Skip to content

Create professional demos and 3D mockups in seconds, directly in your browser

feat: implement magnetic snapping for timeline elements

CristianOlivera122672671730e
diff --git a/app/[locale]/(editor)/editor/page.tsx b/app/[locale]/(editor)/editor/page.tsx
index c6289af..7f0a4ab 100644
--- a/app/[locale]/(editor)/editor/page.tsx
+++ b/app/[locale]/(editor)/editor/page.tsx
@@ -6,7 +6,7 @@ import { motion, AnimatePresence } from "framer-motion";
import { loadVideoFromIndexedDB, deleteRecordedVideo } from "@/hooks/useScreenRecording";
import { useVideoUpload } from "@/hooks/useVideoUpload";
import { useImageProjects } from "@/hooks/useImageProjects";
-import { getUploadedVideo, deleteUploadedVideo, saveVideoTrack, getVideoTrack, clearVideoTrack } from "@/lib/video-upload-cache";
+import { getUploadedVideo, deleteUploadedVideo, getVideoTrack, clearVideoTrack } from "@/lib/video-upload-cache";
import { saveVideoProject, cleanupOrphanAudios, getVideoProject, saveCameraBlob, getCameraBlob, clearVideoProjectAndAudios } from "@/lib/video-project-cache";
import { getUploadedImage, deleteUploadedImage } from "@/lib/image-upload-cache";
import { useEditorMode } from "@/hooks/useEditorMode";
@@ -17,7 +17,8 @@ import { useVideoThumbnails, type VideoThumbnail } from "@/hooks/useVideoThumbna
import { useUndoRedo } from "@/hooks/useUndoRedo";
import { clearAllThumbnailCache } from "@/lib/thumbnail-cache";
import { addVideoToLibrary, addVideoToLibraryWithMetadata, getLibraryVideoCount, getLibraryVideo, findExistingVideo } from "@/lib/videos-library";
-import { calculateTotalDuration, clampClipToRealDuration, findNextClipPosition, getClipAtTime, probeMediaDuration, resequenceClips, splitClipAtTime, type VideoTrackClip } from "@/types/video-track.types";
+import { calculateTotalDuration, clampClipToRealDuration, findNextClipPosition, getClipAtTime, probeMediaDuration, resequenceClips, reorderVideoClipAt, splitClipAtTime, type VideoTrackClip } from "@/types/video-track.types";
+import { remapOverlaysAfterClipChange } from "@/lib/timeline-overlay-remap";
import type { ExportQuality, BackgroundTab, VideoCanvasHandle, BackgroundColorConfig, AspectRatio, CropArea } from "@/types";
import type { TrimRange } from "@/types/timeline.types";
import type { MockupConfig, MenuPage } from "@/types/mockup.types";
@@ -262,7 +263,7 @@ export default function Editor() {
const [cameraUrl, setCameraUrl] = useState<string | null>(null);
const [activeTool, setActiveTool] = useActiveTool();
- const lastCopyActionRef = useRef<'element' | 'zoom' | 'motion' | null>(null);
+ const lastCopyActionRef = useRef<'element' | 'zoom' | 'motion' | 'audio' | null>(null);
useEffect(() => {
const handleWindowFocus = () => { lastCopyActionRef.current = null; };
window.addEventListener('focus', handleWindowFocus);
@@ -331,10 +332,11 @@ export default function Editor() {
audioElementsRef, syncAudioPlayback,
handleAudioUpload, handleAudioDelete, handleAddAudioTrack,
handleUpdateAudioTrack, handleDeleteAudioTrack,
+ copySelectedAudioTrack, pasteAudioTrack, copiedAudioTrack,
handleToggleMuteOriginalAudio, handleMasterVolumeChange,
autoTrimModalOpen, pendingAudioUpload, confirmAudioTrim, cancelAudioTrim,
restoreAudios,
- } = useAudioTracks({ videoDuration, isExportingRef });
+ } = useAudioTracks({ videoDuration, isExportingRef, selectedAudioTrackId, setSelectedAudioTrackId, lastCopyActionRef });
const handleCameraConfigChange = useCallback((partial: Partial<CameraConfig>) => {
setCameraConfig((prev) => (prev ? { ...prev, ...partial } : prev));
@@ -1375,18 +1377,46 @@ export default function Editor() {
}, [selectedZoomFragment, videoClips, videoDimensions]);
const handleUpdateVideoClip = useCallback((clipId: string, updates: Partial<VideoTrackClip>) => {
+ const oldClips = videoClipsRef.current;
setVideoClips(prev => {
- const newClips = prev.map(clip =>
+ let newClips = prev.map(clip =>
clip.id === clipId ? { ...clip, ...updates } : clip
);
if (updates.startTime !== undefined || updates.trimEnd !== undefined || updates.trimStart !== undefined) {
+ // Magnetic behavior: when a clip is dragged (only startTime changed, no trim),
+ // re-sequence all clips to close gaps. Trim operations don't resequence.
+ const isDragOnly = updates.startTime !== undefined
+ && updates.trimStart === undefined
+ && updates.trimEnd === undefined;
+ if (isDragOnly) {
+ // Sort by startTime before resequencing so the dragged clip
+ // lands in its new temporal position. resequenceClips itself
+ // no longer sorts (it must preserve array order for reorders).
+ newClips = resequenceClips(
+ [...newClips].sort((a, b) => a.startTime - b.startTime)
+ ).clips;
+ }
const newDuration = calculateTotalDuration(newClips);
setVideoDuration(newDuration);
setTrimRange({ start: 0, end: newDuration });
+ // Remap all overlays (zoom, audio, elements, motion) to the new clip layout.
+ const remapped = remapOverlaysAfterClipChange({
+ oldClips, newClips,
+ zoomFragments: zoomFragmentsRef.current,
+ zoomMovements,
+ audioTracks,
+ canvasElements,
+ motionFragments: mockupMotionFragments,
+ });
+ setZoomFragments(remapped.zoomFragments);
+ setZoomMovements(remapped.zoomMovements);
+ setAudioTracks(remapped.audioTracks);
+ setCanvasElements(remapped.canvasElements);
+ setMockupMotionFragments(remapped.motionFragments);
}
return newClips;
});
- }, []);
+ }, [zoomMovements, audioTracks, canvasElements, mockupMotionFragments, setZoomFragments, setZoomMovements, setAudioTracks, setCanvasElements, setMockupMotionFragments]);
const handleDeleteVideoClip = useCallback((clipId: string) => {
const deletedClip = videoClipsRef.current.find(c => c.id === clipId);
@@ -1427,32 +1457,56 @@ export default function Editor() {
return newClips;
});
- // Remap zoom fragments: remove those within the deleted clip's range,
- // shift those after it by the deleted clip's duration.
+ // Remap all overlays (zoom, audio, elements, motion) to the new clip layout.
if (deletedClip) {
- const deletedStart = deletedClip.startTime;
- const deletedDuration = deletedClip.trimEnd - deletedClip.trimStart;
- const deletedEnd = deletedStart + deletedDuration;
- setZoomFragments(prevFrags =>
- prevFrags
- .filter(f => !(f.startTime >= deletedStart && f.endTime <= deletedEnd))
- .map(f => {
- if (f.startTime >= deletedEnd) {
- return {
- ...f,
- startTime: f.startTime - deletedDuration,
- endTime: f.endTime - deletedDuration,
- };
- }
- return f;
- })
- );
+ const oldClips = videoClipsRef.current;
+ const newClips = resequenceClips(oldClips.filter(c => c.id !== clipId)).clips;
+ const remapped = remapOverlaysAfterClipChange({
+ oldClips, newClips,
+ zoomFragments: zoomFragmentsRef.current,
+ zoomMovements,
+ audioTracks,
+ canvasElements,
+ motionFragments: mockupMotionFragments,
+ });
+ setZoomFragments(remapped.zoomFragments);
+ setZoomMovements(remapped.zoomMovements);
+ setAudioTracks(remapped.audioTracks);
+ setCanvasElements(remapped.canvasElements);
+ setMockupMotionFragments(remapped.motionFragments);
}
if (selectedVideoClipId === clipId) {
setSelectedVideoClipId(null);
}
- }, [selectedVideoClipId, setZoomFragments]);
+ }, [selectedVideoClipId, zoomMovements, audioTracks, canvasElements, mockupMotionFragments, setZoomFragments, setZoomMovements, setAudioTracks, setCanvasElements, setMockupMotionFragments]);
+
+ // Reorder clips: swap or insert dragged clip before/after target, then re-sequence.
+ const handleReorderVideoClip = useCallback((draggedId: string, targetId: string, placeAfter: boolean) => {
+ const oldClips = videoClipsRef.current;
+ const { clips: newClips, offsetMap } = reorderVideoClipAt(oldClips, draggedId, targetId, placeAfter);
+ if (offsetMap.size === 0) return;
+
+ setVideoClips(newClips);
+ const newDuration = calculateTotalDuration(newClips);
+ setVideoDuration(newDuration);
+ setTrimRange({ start: 0, end: newDuration });
+
+ // Remap all overlays to the new clip layout.
+ const remapped = remapOverlaysAfterClipChange({
+ oldClips, newClips,
+ zoomFragments: zoomFragmentsRef.current,
+ zoomMovements,
+ audioTracks,
+ canvasElements,
+ motionFragments: mockupMotionFragments,
+ });
+ setZoomFragments(remapped.zoomFragments);
+ setZoomMovements(remapped.zoomMovements);
+ setAudioTracks(remapped.audioTracks);
+ setCanvasElements(remapped.canvasElements);
+ setMockupMotionFragments(remapped.motionFragments);
+ }, [zoomMovements, audioTracks, canvasElements, mockupMotionFragments, setZoomFragments, setZoomMovements, setAudioTracks, setCanvasElements, setMockupMotionFragments]);
const handleSplitVideoClip = useCallback(() => {
const clips = videoClipsRef.current;
@@ -2578,6 +2632,7 @@ export default function Editor() {
deleteCanvasElement, copySelectedElement, copiedElements, pasteElement,
selectedVideoClipId, setSelectedVideoClipId, handleDeleteVideoClip,
selectedAudioTrackId, setSelectedAudioTrackId, handleDeleteAudioTrack,
+ copySelectedAudioTrack, copiedAudioTrack, pasteAudioTrack,
selectedZoomFragmentId, setSelectedZoomFragmentId, handleDeleteZoomFragment,
copySelectedZoomFragment, copiedZoomFragment, pasteZoomFragment,
selectedZoomMovementId, setSelectedZoomMovementId, handleDeleteZoomMovement,
@@ -3039,6 +3094,7 @@ export default function Editor() {
onSelectVideoClip={handleSelectVideoClip}
onUpdateVideoClip={handleUpdateVideoClip}
onDeleteVideoClip={handleDeleteVideoClip}
+ onReorderVideoClip={handleReorderVideoClip}
zoomFragments={zoomFragments}
selectedZoomFragmentId={selectedZoomFragmentId}
onSelectZoomFragment={handleSelectZoomFragment}
diff --git a/app/components/ui/editor/AudioFragmentTrackItem.tsx b/app/components/ui/editor/AudioFragmentTrackItem.tsx
index 24495d3..4143b35 100644
--- a/app/components/ui/editor/AudioFragmentTrackItem.tsx
+++ b/app/components/ui/editor/AudioFragmentTrackItem.tsx
@@ -2,6 +2,7 @@
import { useState, useRef, useCallback, useMemo, useEffect } from "react";
import { motion, useMotionValue } from "framer-motion";
import { AudioFragmentTrackItemProps, MIN_FRAGMENT_DURATION, MIN_VISUAL_WIDTH_PX } from "@/types/audio.types";
+import { collectSnapPoints, findSnap } from "@/lib/timeline-snapping";
export function AudioFragmentTrackItem({
track, audio, isSelected, contentWidth, videoDuration, contentDuration,
@@ -10,7 +11,9 @@ export function AudioFragmentTrackItem({
lane = 0,
laneHeight = 55,
laneCount = 1,
-}: AudioFragmentTrackItemProps) {
+ currentTime = 0,
+ clipEdges = [],
+}: AudioFragmentTrackItemProps & { currentTime?: number; clipEdges?: Array<{ start: number; end: number }> }) {
const [isDragging, setIsDragging] = useState(false);
const [isResizing, setIsResizing] = useState<'start' | 'end' | null>(null);
const containerRef = useRef<HTMLDivElement>(null);
@@ -65,12 +68,29 @@ export function AudioFragmentTrackItem({
const minX = timeToPixels(boundaries.minStart);
const maxX = timeToPixels(boundaries.maxEnd - track.duration);
newX = Math.max(minX, Math.min(maxX, newX));
+
+ // Magnetic snapping: snap track start/end to clip edges, other tracks, playhead, zero.
+ const snapThresholdPx = 8;
+ const newStartTime = pixelsToTime(newX);
+ const newEndTime = newStartTime + track.duration;
+ const audioEdges = otherTracks.map(t => ({ start: t.startTime, end: t.startTime + t.duration }));
+ const snapPoints = collectSnapPoints({ clipEdges, audioEdges, playhead: currentTime });
+ const snapStart = findSnap(newStartTime, snapPoints, timeToPixels, snapThresholdPx);
+ if (snapStart.offsetPx !== 0) {
+ newX = timeToPixels(snapStart.time);
+ } else {
+ const snapEnd = findSnap(newEndTime, snapPoints, timeToPixels, snapThresholdPx);
+ if (snapEnd.offsetPx !== 0) {
+ newX = timeToPixels(snapEnd.time - track.duration);
+ }
+ }
+ newX = Math.max(minX, Math.min(maxX, newX));
fragmentX.set(newX);
const currentY = fragmentY.get();
const newY = Math.max(laneHeight * 0.05, Math.min(maxLaneY, currentY + info.delta.y));
fragmentY.set(newY);
- }, [contentWidth, videoDuration, fragmentX, fragmentY, track.duration, boundaries, timeToPixels, maxLaneY, laneHeight]);
+ }, [contentWidth, videoDuration, fragmentX, fragmentY, track.duration, boundaries, timeToPixels, pixelsToTime, otherTracks, clipEdges, currentTime, maxLaneY, laneHeight]);
const handleDragStart = useCallback(() => {
setIsDragging(true);
diff --git a/app/components/ui/editor/Timeline.tsx b/app/components/ui/editor/Timeline.tsx
index 1e62ba0..bef8480 100644
--- a/app/components/ui/editor/Timeline.tsx
+++ b/app/components/ui/editor/Timeline.tsx
@@ -17,6 +17,7 @@ import { assignElementLanes } from "@/lib/canvas-elements-timeline.utils";
import { ElementFragmentTrackItem } from "./ElementFragmentTrackItem";
import { findValidFragmentPosition, findValidMovementPosition, getFragmentHoldBounds } from "@/types/zoom.types";
import { ZoomMovementTrackItem, MIN_MOVEMENT_TRACK_DURATION } from "./ZoomMovementTrackItem";
+import { collectSnapPoints, findSnap } from "@/lib/timeline-snapping";
export function Timeline({
videoDuration,
@@ -34,6 +35,7 @@ export function Timeline({
onSelectVideoClip,
onUpdateVideoClip,
onDeleteVideoClip,
+ onReorderVideoClip,
zoomFragments = [],
selectedZoomFragmentId,
onSelectZoomFragment,
@@ -268,7 +270,34 @@ export function Timeline({
if (contentWidth === 0 || scaledDuration === 0) return;
const maxX = videoClips.length > 0 ? timelineWidth : trimEndPosition;
const minX = videoClips.length > 0 ? 0 : trimStartPosition;
- const newX = Math.max(minX, Math.min(maxX, playheadX.get() + info.delta.x));
+ let newX = Math.max(minX, Math.min(maxX, playheadX.get() + info.delta.x));
+
+ // Magnetic snapping: snap playhead to clip edges, fragment edges, and zero.
+ const timeToPx = (t: number) => (t / scaledDuration) * contentWidth;
+ const pxToTime = (px: number) => (px / contentWidth) * scaledDuration;
+ const clipEdges = videoClips.map(c => ({
+ start: c.startTime,
+ end: c.startTime + (c.trimEnd - c.trimStart),
+ }));
+ const fragmentEdges = zoomFragments.map(f => ({
+ start: f.startTime,
+ end: f.endTime,
+ }));
+ const audioEdges = audioTracks.map(t => ({
+ start: t.startTime,
+ end: t.startTime + t.duration,
+ }));
+ const snapPoints = collectSnapPoints({
+ clipEdges,
+ fragmentEdges,
+ audioEdges,
+ });
+ const rawTime = pxToTime(newX);
+ const snap = findSnap(rawTime, snapPoints, timeToPx, 8);
+ if (snap.offsetPx !== 0) {
+ newX = timeToPx(snap.time);
+ }
+
playheadX.set(newX);
const newTime = (newX / contentWidth) * scaledDuration;
pendingSeekRef.current = newTime;
@@ -281,7 +310,7 @@ export function Timeline({
isSeekingRef.current = false;
});
}
- }, [contentWidth, scaledDuration, timelineWidth, onSeek, playheadX, trimStartPosition, trimEndPosition, videoClips]);
+ }, [contentWidth, scaledDuration, timelineWidth, onSeek, playheadX, trimStartPosition, trimEndPosition, videoClips, zoomFragments, audioTracks]);
const handleDragStart = useCallback(() => {
setIsDragging(true);
@@ -601,6 +630,7 @@ export function Timeline({
onSelect={() => onSelectVideoClip?.(clip.id)}
onUpdate={(updates) => onUpdateVideoClip?.(clip.id, updates)}
onDelete={() => onDeleteVideoClip?.(clip.id)}
+ onReorder={(draggedId, targetId, placeAfter) => onReorderVideoClip?.(draggedId, targetId, placeAfter)}
onDragStateChange={setIsDraggingVideoClip}
zoomLevel={zoomLevel}
/>
@@ -724,6 +754,8 @@ export function Timeline({
videoDuration={scaledDuration}
contentDuration={validDuration}
speed={speed}
+ currentTime={currentTime}
+ clipEdges={videoClips.map(c => ({ start: c.startTime, end: c.startTime + (c.trimEnd - c.trimStart) }))}
otherFragments={zoomFragments.filter(f => f.id !== fragment.id)}
onSelect={() => {
onSelectZoomFragment?.(fragment.id);
@@ -923,6 +955,8 @@ export function Timeline({
lane={trackLane}
laneHeight={ELEMENT_ROW_HEIGHT}
laneCount={audioLaneCount}
+ currentTime={currentTime}
+ clipEdges={videoClips.map(c => ({ start: c.startTime, end: c.startTime + (c.trimEnd - c.trimStart) }))}
otherTracks={sameLaneOtherTracks}
onSelect={() => onSelectAudioTrack?.(track.id)}
onUpdate={(updates) => onUpdateAudioTrack?.(track.id, updates)}
diff --git a/app/components/ui/editor/VideoClipTrackItem.tsx b/app/components/ui/editor/VideoClipTrackItem.tsx
index b28c1c3..b44a70c 100644
--- a/app/components/ui/editor/VideoClipTrackItem.tsx
+++ b/app/components/ui/editor/VideoClipTrackItem.tsx
@@ -5,6 +5,7 @@ import { motion, useMotionValue, useTransform } from "framer-motion";
import type { VideoTrackClip } from "@/types/video-track.types";
import { Icon } from "@iconify/react";
import type { MotionValue } from "framer-motion";
+import { collectSnapPoints, findSnap } from "@/lib/timeline-snapping";
const MIN_CLIP_DURATION = 0.1;
@@ -19,6 +20,7 @@ interface VideoClipTrackItemProps {
onUpdate: (updates: Partial<VideoTrackClip>) => void;
onDelete?: () => void;
onDragStateChange?: (isDragging: boolean) => void;
+ onReorder?: (draggedId: string, targetId: string, placeAfter: boolean) => void;
zoomLevel: number;
playheadX: MotionValue<number>;
speed?: number;
@@ -35,6 +37,7 @@ export function VideoClipTrackItem({
onUpdate,
onDelete,
onDragStateChange,
+ onReorder,
zoomLevel,
playheadX,
speed = 1,
@@ -107,15 +110,16 @@ export function VideoClipTrackItem({
const handleDrag = useCallback((_e: MouseEvent | TouchEvent | PointerEvent, info: { delta: { x: number } }) => {
if (contentWidth === 0 || totalDuration === 0) return;
- const currentX = clipX.get();
- let newX = currentX + info.delta.x;
+ // Free drag with per-frame delta (same pattern as other track items).
+ // Snapping is applied only on drop, not during drag, for smooth control.
+ let newX = clipX.get() + info.delta.x;
- const minX = timeToPixels(boundaries.minStart);
- const maxX = timeToPixels(boundaries.maxEnd - clipDuration);
+ // Clamp to timeline bounds [0, totalDuration].
+ const minX = 0;
+ const maxX = timeToPixels(totalDuration - clipDuration);
newX = Math.max(minX, Math.min(maxX, newX));
-
clipX.set(newX);
- }, [contentWidth, totalDuration, clipX, clipDuration, boundaries, timeToPixels]);
+ }, [contentWidth, totalDuration, clipX, clipDuration, timeToPixels]);
const handleDragStart = useCallback(() => {
setIsDragging(true);
@@ -126,11 +130,51 @@ export function VideoClipTrackItem({
setIsDragging(false);
onDragStateChange?.(false);
- const newStartTime = pixelsToTime(clipX.get());
- onUpdate({
- startTime: Math.max(0, newStartTime),
+ // Detect if the clip was dropped onto another clip (>=50% overlap).
+ // If so, trigger a reorder instead of a free-drag position update.
+ const draggedCenterPx = clipX.get() + clipWidth.get() / 2;
+ const target = otherClips.find(other => {
+ const otherStartPx = timeToPixels(other.startTime);
+ const otherDur = other.trimEnd - other.trimStart;
+ const otherEndPx = timeToPixels(other.startTime + otherDur);
+ return draggedCenterPx >= otherStartPx && draggedCenterPx <= otherEndPx;
});
- }, [clipX, pixelsToTime, onUpdate, onDragStateChange]);
+
+ if (target && onReorder) {
+ // Determine whether to place before or after the target based on
+ // the dragged clip's center relative to the target's center.
+ const targetCenterPx = timeToPixels(target.startTime) + timeToPixels(target.trimEnd - target.trimStart) / 2;
+ const placeAfter = draggedCenterPx > targetCenterPx;
+ onReorder(clip.id, target.id, placeAfter);
+ } else {
+ // Apply magnetic snapping on drop (not during drag) for smooth control.
+ let finalX = clipX.get();
+ const snapThresholdPx = 8;
+ const finalStartTime = pixelsToTime(finalX);
+ const finalEndTime = finalStartTime + clipDuration;
+ const clipEdges = otherClips.map(c => ({
+ start: c.startTime,
+ end: c.startTime + (c.trimEnd - c.trimStart),
+ }));
+ const snapPoints = collectSnapPoints({
+ clipEdges,
+ playhead: currentTime,
+ });
+ const snapStart = findSnap(finalStartTime, snapPoints, timeToPixels, snapThresholdPx);
+ if (snapStart.offsetPx !== 0) {
+ finalX = timeToPixels(snapStart.time);
+ } else {
+ const snapEnd = findSnap(finalEndTime, snapPoints, timeToPixels, snapThresholdPx);
+ if (snapEnd.offsetPx !== 0) {
+ finalX = timeToPixels(snapEnd.time - clipDuration);
+ }
+ }
+ const newStartTime = pixelsToTime(finalX);
+ onUpdate({
+ startTime: Math.max(0, newStartTime),
+ });
+ }
+ }, [clipX, clipWidth, pixelsToTime, onUpdate, onDragStateChange, otherClips, timeToPixels, onReorder, clip.id, clipDuration, currentTime]);
const handleResizeStartDrag = useCallback((_e: MouseEvent | TouchEvent | PointerEvent, info: { delta: { x: number } }) => {
if (contentWidth === 0 || totalDuration === 0) return;
@@ -229,7 +273,7 @@ export function VideoClipTrackItem({
: '1px solid rgba(52, 168, 83, 0.4)',
}}
drag="x"
- dragConstraints={{ left: 0, right: contentWidth / speed }}
+ dragConstraints={false}
dragElastic={0}
dragMomentum={false}
onDrag={handleDrag}
diff --git a/app/components/ui/editor/ZoomFragmentTrackItem.tsx b/app/components/ui/editor/ZoomFragmentTrackItem.tsx
index d2fef0b..d3f8f7b 100644
--- a/app/components/ui/editor/ZoomFragmentTrackItem.tsx
+++ b/app/components/ui/editor/ZoomFragmentTrackItem.tsx
@@ -5,6 +5,7 @@ import { motion, useMotionValue } from "framer-motion";
import type { ZoomFragment } from "@/types/zoom.types";
import { zoomLevelToFactor, speedToTransitionMs } from "@/types/zoom.types";
import { MIN_MOVEMENT_TRACK_DURATION } from "./ZoomMovementTrackItem";
+import { collectSnapPoints, findSnap } from "@/lib/timeline-snapping";
const MIN_FRAGMENT_DURATION = 0.5;
@@ -21,6 +22,8 @@ interface ZoomFragmentTrackItemProps {
onMouseEnter?: () => void;
onMouseLeave?: () => void;
speed?: number;
+ currentTime?: number;
+ clipEdges?: Array<{ start: number; end: number }>;
}
export function ZoomFragmentTrackItem({
@@ -36,6 +39,8 @@ export function ZoomFragmentTrackItem({
onMouseEnter,
onMouseLeave,
speed = 1,
+ currentTime = 0,
+ clipEdges = [],
}: ZoomFragmentTrackItemProps) {
const [isDragging, setIsDragging] = useState(false);
const [isResizing, setIsResizing] = useState<'start' | 'end' | null>(null);
@@ -104,8 +109,25 @@ export function ZoomFragmentTrackItem({
const maxX = timeToPixels(boundaries.maxEnd - duration);
newX = Math.max(minX, Math.min(maxX, newX));
+ // Magnetic snapping: snap fragment start/end to clip edges, other fragments, playhead, zero.
+ const snapThresholdPx = 8;
+ const newStartTime = pixelsToTime(newX);
+ const newEndTime = newStartTime + duration;
+ const fragmentEdges = otherFragments.map(f => ({ start: f.startTime, end: f.endTime }));
+ const snapPoints = collectSnapPoints({ clipEdges, fragmentEdges, playhead: currentTime });
+ const snapStart = findSnap(newStartTime, snapPoints, timeToPixels, snapThresholdPx);
+ if (snapStart.offsetPx !== 0) {
+ newX = timeToPixels(snapStart.time);
+ } else {
+ const snapEnd = findSnap(newEndTime, snapPoints, timeToPixels, snapThresholdPx);
+ if (snapEnd.offsetPx !== 0) {
+ newX = timeToPixels(snapEnd.time - duration);
+ }
+ }
+ newX = Math.max(minX, Math.min(maxX, newX));
+
fragmentX.set(newX);
- }, [contentWidth, videoDuration, fragmentX, fragment, boundaries, timeToPixels]);
+ }, [contentWidth, videoDuration, fragmentX, fragment, boundaries, timeToPixels, pixelsToTime, otherFragments, clipEdges, currentTime]);
const handleDragStart = useCallback(() => {
setIsDragging(true);
diff --git a/app/components/ui/editor/mockups-3d/Mockup3DFrame.tsx b/app/components/ui/editor/mockups-3d/Mockup3DFrame.tsx
index c8b1e19..c3341ed 100644
--- a/app/components/ui/editor/mockups-3d/Mockup3DFrame.tsx
+++ b/app/components/ui/editor/mockups-3d/Mockup3DFrame.tsx
@@ -74,7 +74,8 @@ interface FrameProps extends Mockup3DStageProps {
export function Mockup3DFrame({ device, rootRef: externalRootRef, ...stageProps }: FrameProps) {
const layout = DEVICE_LAYOUT[device];
- const rootRef = externalRootRef ?? useRef<THREE.Group | null>(null);
+ const internalRootRef = useRef<THREE.Group | null>(null);
+ const rootRef = externalRootRef ?? internalRootRef;
const cameraRef = useRef<THREE.PerspectiveCamera | null>(null);
const canvasElRef = useRef<HTMLCanvasElement | null>(null);
const raycasterRef = useRef(new THREE.Raycaster());
@@ -133,10 +134,10 @@ export function Mockup3DFrame({ device, rootRef: externalRootRef, ...stageProps
: layout.overlay.kind === "fixed"
? { position: "absolute", left: 0, top: 0, width: layout.width, height: layout.height, zIndex: 2, overflow: "visible" }
: {
- position: "absolute", top: "50%", left: "50%",
- width: layout.overlay.size, height: layout.overlay.size,
- transform: "translate(-50%, -50%)", zIndex: 2, overflow: "visible",
- };
+ position: "absolute", top: "50%", left: "50%",
+ width: layout.overlay.size, height: layout.overlay.size,
+ transform: "translate(-50%, -50%)", zIndex: 2, overflow: "visible",
+ };
return (
<div
diff --git a/hooks/useAudioTracks.ts b/hooks/useAudioTracks.ts
index bcc6b15..a537910 100644
--- a/hooks/useAudioTracks.ts
+++ b/hooks/useAudioTracks.ts
@@ -8,9 +8,12 @@ const MAX_AUDIO_TRACKS = 8;
interface UseAudioTracksParams {
videoDuration: number;
isExportingRef: React.MutableRefObject<boolean>;
+ selectedAudioTrackId?: string | null;
+ setSelectedAudioTrackId?: (id: string | null) => void;
+ lastCopyActionRef?: React.MutableRefObject<'element' | 'zoom' | 'motion' | 'audio' | null>;
}
-export function useAudioTracks({ videoDuration, isExportingRef }: UseAudioTracksParams) {
+export function useAudioTracks({ videoDuration, isExportingRef, selectedAudioTrackId, setSelectedAudioTrackId, lastCopyActionRef }: UseAudioTracksParams) {
const [uploadedAudios, setUploadedAudios] = useState<UploadedAudio[]>([]);
const [audioTracks, setAudioTracks] = useState<AudioTrack[]>([]);
const [muteOriginalAudio, setMuteOriginalAudio] = useState<boolean>(false);
@@ -151,6 +154,36 @@ export function useAudioTracks({ videoDuration, isExportingRef }: UseAudioTracks
});
}, []);
+ // Copy / Paste audio tracks
+ const [copiedAudioTrack, setCopiedAudioTrack] = useState<Omit<AudioTrack, 'id' | 'startTime'> | null>(null);
+
+ const copySelectedAudioTrack = useCallback(() => {
+ const track = audioTracks.find(t => t.id === selectedAudioTrackId);
+ if (!track) return;
+ const { id: _id, startTime: _st, ...config } = track;
+ setCopiedAudioTrack(config);
+ if (lastCopyActionRef) lastCopyActionRef.current = 'audio';
+ }, [audioTracks, selectedAudioTrackId, lastCopyActionRef]);
+
+ const pasteAudioTrack = useCallback(() => {
+ if (!copiedAudioTrack) return;
+ const audio = uploadedAudios.find(a => a.id === copiedAudioTrack.audioId);
+ if (!audio) return;
+ if (audioTracks.length >= MAX_AUDIO_TRACKS) {
+ alert(`Maximum of ${MAX_AUDIO_TRACKS} audio tracks allowed.`);
+ return;
+ }
+ const lastTrackEnd = audioTracks.reduce((max, t) => Math.max(max, t.startTime + t.duration), 0);
+ const startTime = Math.min(lastTrackEnd, videoDuration);
+ const newTrack: AudioTrack = {
+ ...copiedAudioTrack,
+ id: `track-${crypto.randomUUID()}`,
+ startTime,
+ };
+ setAudioTracks(prev => [...prev, newTrack]);
+ setSelectedAudioTrackId?.(newTrack.id);
+ }, [copiedAudioTrack, uploadedAudios, audioTracks, videoDuration, setSelectedAudioTrackId]);
+
const handleToggleMuteOriginalAudio = useCallback(() => setMuteOriginalAudio(prev => !prev), []);
const handleMasterVolumeChange = useCallback((volume: number) => setMasterVolume(volume), []);
@@ -214,6 +247,7 @@ export function useAudioTracks({ videoDuration, isExportingRef }: UseAudioTracks
audioElementsRef, syncAudioPlayback,
handleAudioUpload, handleAudioDelete, handleAddAudioTrack,
handleUpdateAudioTrack, handleDeleteAudioTrack,
+ copySelectedAudioTrack, pasteAudioTrack, copiedAudioTrack,
handleToggleMuteOriginalAudio, handleMasterVolumeChange,
autoTrimModalOpen, pendingAudioUpload, confirmAudioTrim, cancelAudioTrim,
restoreAudios,
diff --git a/hooks/useCanvasElements.ts b/hooks/useCanvasElements.ts
index 5686fb1..6ff31bb 100644
--- a/hooks/useCanvasElements.ts
+++ b/hooks/useCanvasElements.ts
@@ -10,7 +10,7 @@ interface UseCanvasElementsParams {
setSelectedElementId: (id: string | null) => void;
setMultiSelectedElementIds: (ids: string[]) => void;
setActiveTool: (tool: Tool) => void;
- lastCopyActionRef: React.MutableRefObject<'element' | 'zoom' | 'motion' | null>;
+ lastCopyActionRef: React.MutableRefObject<'element' | 'zoom' | 'motion' | 'audio' | null>;
}
export function useCanvasElements({
diff --git a/hooks/useEditorShortcuts.ts b/hooks/useEditorShortcuts.ts
index fb805e1..0a08094 100644
--- a/hooks/useEditorShortcuts.ts
+++ b/hooks/useEditorShortcuts.ts
@@ -30,6 +30,9 @@ interface UseEditorShortcutsParams {
selectedAudioTrackId: string | null;
setSelectedAudioTrackId: (id: string | null) => void;
handleDeleteAudioTrack: (id: string) => void;
+ copySelectedAudioTrack: () => void;
+ copiedAudioTrack: unknown;
+ pasteAudioTrack: () => void;
selectedZoomFragmentId: string | null;
setSelectedZoomFragmentId: (id: string | null) => void;
@@ -49,7 +52,7 @@ interface UseEditorShortcutsParams {
copiedMockupMotionFragment: unknown;
pasteMockupMotionFragment: () => void;
- lastCopyActionRef: React.MutableRefObject<'element' | 'zoom' | 'motion' | null>;
+ lastCopyActionRef: React.MutableRefObject<'element' | 'zoom' | 'motion' | 'audio' | null>;
handleImageUploadToCanvas: (file: File) => void | Promise<void>;
handleVideoUpload: (file: File, options?: { forceReplace?: boolean }) => Promise<void>;
@@ -77,6 +80,9 @@ export function useEditorShortcuts({
selectedAudioTrackId,
setSelectedAudioTrackId,
handleDeleteAudioTrack,
+ copySelectedAudioTrack,
+ copiedAudioTrack,
+ pasteAudioTrack,
selectedZoomFragmentId,
setSelectedZoomFragmentId,
handleDeleteZoomFragment,
@@ -165,6 +171,11 @@ export function useEditorShortcuts({
pasteMockupMotionFragment();
return;
}
+ if (copiedAudioTrack) {
+ e.preventDefault();
+ pasteAudioTrack();
+ return;
+ }
if (copiedElements.length > 0) {
e.preventDefault();
pasteElement();
@@ -176,6 +187,7 @@ export function useEditorShortcuts({
isPhotoMode, handleImageUploadToCanvas, handleVideoUpload, activeTool,
copiedZoomFragment, pasteZoomFragment, copiedElements, pasteElement,
copiedMockupMotionFragment, pasteMockupMotionFragment, lastCopyActionRef,
+ copiedAudioTrack, pasteAudioTrack,
]);
useEffect(() => {
@@ -207,6 +219,11 @@ export function useEditorShortcuts({
copySelectedMockupMotionFragment();
return;
}
+ if (selectedAudioTrackId) {
+ e.preventDefault();
+ copySelectedAudioTrack();
+ return;
+ }
}
if ((e.key === "Delete" || e.key === "Backspace") && (selectedElementId || multiSelectedElementIds.length > 0)) {
@@ -271,6 +288,7 @@ export function useEditorShortcuts({
deleteCanvasElement, handleDeleteZoomFragment, handleDeleteZoomMovement,
handleDeleteAudioTrack, handleDeleteVideoClip, handleDeleteMockupMotionFragment,
copySelectedElement, textToolActive, copySelectedZoomFragment, copySelectedMockupMotionFragment,
+ copySelectedAudioTrack,
setTextToolActive, setSelectedElementId, setSelectedVideoClipId, setSelectedAudioTrackId,
setSelectedZoomMovementId, setSelectedZoomFragmentId, setSelectedMockupMotionFragmentId,
]);
diff --git a/hooks/useMockupMotionFragments.ts b/hooks/useMockupMotionFragments.ts
index a8207fb..8cde45f 100644
--- a/hooks/useMockupMotionFragments.ts
+++ b/hooks/useMockupMotionFragments.ts
@@ -14,7 +14,7 @@ interface UseMockupMotionFragmentsParams {
currentTime: number;
videoDuration: number;
setActiveTool: (tool: Tool) => void;
- lastCopyActionRef: React.MutableRefObject<'element' | 'zoom' | 'motion' | null>;
+ lastCopyActionRef: React.MutableRefObject<'element' | 'zoom' | 'motion' | 'audio' | null>;
selectedMockupMotionFragmentId: string | null;
setSelectedMockupMotionFragmentId: React.Dispatch<React.SetStateAction<string | null>>;
/** Current active motion mode — when this changes, orphan fragments from
diff --git a/hooks/useZoomFragments.ts b/hooks/useZoomFragments.ts
index 80def90..10cf8b2 100644
--- a/hooks/useZoomFragments.ts
+++ b/hooks/useZoomFragments.ts
@@ -14,7 +14,7 @@ interface UseZoomFragmentsParams {
currentTime: number;
videoDuration: number;
setActiveTool: (tool: Tool) => void;
- lastCopyActionRef: React.MutableRefObject<'element' | 'zoom' | 'motion' | null>;
+ lastCopyActionRef: React.MutableRefObject<'element' | 'zoom' | 'motion' | 'audio' | null>;
selectedZoomFragmentId: string | null;
setSelectedZoomFragmentId: React.Dispatch<React.SetStateAction<string | null>>;
selectedZoomMovementId: string | null;
diff --git a/lib/timeline-overlay-remap.ts b/lib/timeline-overlay-remap.ts
new file mode 100644
index 0000000..f3c47b2
--- /dev/null
+++ b/lib/timeline-overlay-remap.ts
@@ -0,0 +1,179 @@
+import type { VideoTrackClip } from "@/types/video-track.types";
+import type { ZoomFragment, ZoomMovement } from "@/types/zoom.types";
+import type { AudioTrack } from "@/types/audio.types";
+import type { CanvasElement } from "@/types/canvas-elements.types";
+import type { MockupMotionFragment } from "@/lib/mockup-motion";
+
+/**
+ * Keeps timeline overlays (zoom fragments, audio tracks, canvas elements,
+ * motion fragments) in sync when the video clip layout changes (clip deleted,
+ * trimmed, or reordered).
+ *
+ * Overlays are stored in absolute timeline time. When clips move, shrink, or
+ * disappear, each overlay interval is mapped through the clip that contains
+ * it: shifted by that clip's new offset, clamped to its new bounds, and
+ * dropped entirely when its containing clip was removed.
+ */
+
+interface ClipRange {
+ oldStart: number;
+ oldEnd: number;
+ newStart: number;
+ newEnd: number;
+}
+
+function buildClipRanges(oldClips: VideoTrackClip[], newClips: VideoTrackClip[]): ClipRange[] {
+ const newById = new Map(newClips.map(c => [c.id, c]));
+ const ranges: ClipRange[] = [];
+
+ for (const oldClip of oldClips) {
+ const oldDuration = oldClip.trimEnd - oldClip.trimStart;
+ const newClip = newById.get(oldClip.id);
+ if (!newClip) continue; // removed — overlays on it get dropped
+ const newDuration = newClip.trimEnd - newClip.trimStart;
+ ranges.push({
+ oldStart: oldClip.startTime,
+ oldEnd: oldClip.startTime + oldDuration,
+ newStart: newClip.startTime,
+ newEnd: newClip.startTime + newDuration,
+ });
+ }
+
+ return ranges.sort((a, b) => a.oldStart - b.oldStart);
+}
+
+/**
+ * Maps an overlay interval through the clip layout change.
+ * Returns null when the overlay should be dropped.
+ */
+function mapInterval(
+ start: number,
+ end: number,
+ ranges: ClipRange[]
+): { start: number; end: number } | null {
+ if (end <= start) return null;
+
+ // Find the clip that contains the overlay's midpoint (falling back to the
+ // clip that contains its start). Overlays sitting in a gap keep their
+ // absolute position — there is no clip to anchor them to.
+ const mid = (start + end) / 2;
+ const containing =
+ ranges.find(r => mid >= r.oldStart && mid < r.oldEnd) ??
+ ranges.find(r => start >= r.oldStart && start < r.oldEnd);
+
+ if (!containing) {
+ return { start, end };
+ }
+
+ const offset = containing.newStart - containing.oldStart;
+ let newStart = start + offset;
+ let newEnd = end + offset;
+
+ // Clamp to the clip's new bounds; drop if nothing visible remains.
+ const clampedStart = Math.max(newStart, containing.newStart);
+ const clampedEnd = Math.min(newEnd, containing.newEnd);
+ if (clampedEnd - clampedStart <= 0.01) return null;
+
+ newStart = clampedStart;
+ newEnd = clampedEnd;
+
+ return { start: newStart, end: newEnd };
+}
+
+export interface RemapOverlaysInput {
+ oldClips: VideoTrackClip[];
+ newClips: VideoTrackClip[];
+ zoomFragments: ZoomFragment[];
+ zoomMovements: ZoomMovement[];
+ audioTracks: AudioTrack[];
+ canvasElements: CanvasElement[];
+ motionFragments: MockupMotionFragment[];
+}
+
+export interface RemapOverlaysResult {
+ zoomFragments: ZoomFragment[];
+ zoomMovements: ZoomMovement[];
+ audioTracks: AudioTrack[];
+ canvasElements: CanvasElement[];
+ motionFragments: MockupMotionFragment[];
+ /** Zoom fragment ids that were dropped (their movements are removed too). */
+ droppedFragmentIds: Set<string>;
+}
+
+export function remapOverlaysAfterClipChange(input: RemapOverlaysInput): RemapOverlaysResult {
+ const { oldClips, newClips } = input;
+ const ranges = buildClipRanges(oldClips, newClips);
+
+ // Skip all work when nothing relevant changed (pure selection updates etc.)
+ const layoutChanged = ranges.some(r => r.newStart !== r.oldStart || r.newEnd !== r.oldEnd)
+ || newClips.length !== oldClips.length;
+ if (!layoutChanged) {
+ return {
+ zoomFragments: input.zoomFragments,
+ zoomMovements: input.zoomMovements,
+ audioTracks: input.audioTracks,
+ canvasElements: input.canvasElements,
+ motionFragments: input.motionFragments,
+ droppedFragmentIds: new Set(),
+ };
+ }
+
+ const zoomFragments: ZoomFragment[] = [];
+ const droppedFragmentIds = new Set<string>();
+
+ for (const fragment of input.zoomFragments) {
+ const mapped = mapInterval(fragment.startTime, fragment.endTime, ranges);
+ if (!mapped) {
+ droppedFragmentIds.add(fragment.id);
+ continue;
+ }
+ zoomFragments.push({ ...fragment, startTime: mapped.start, endTime: mapped.end });
+ }
+
+ const zoomMovements = input.zoomMovements.filter(
+ m => !droppedFragmentIds.has(m.zoomFragmentId)
+ );
+
+ const audioTracks: AudioTrack[] = [];
+ for (const track of input.audioTracks) {
+ const mapped = mapInterval(track.startTime, track.startTime + track.duration, ranges);
+ if (!mapped) continue;
+ const duration = mapped.end - mapped.start;
+ audioTracks.push({ ...track, startTime: mapped.start, duration });
+ }
+
+ const canvasElements: CanvasElement[] = [];
+ for (const element of input.canvasElements) {
+ const start = element.startTime ?? 0;
+ const end = element.endTime;
+ // Elements without an endTime span the whole timeline — only shift them
+ // when they have a bounded interval.
+ if (end === undefined) {
+ canvasElements.push(element);
+ continue;
+ }
+ const mapped = mapInterval(start, end, ranges);
+ if (!mapped) continue;
+ canvasElements.push({
+ ...element,
+ startTime: mapped.start,
+ endTime: mapped.end,
+ } as CanvasElement);
+ }
+
+ const motionFragments: MockupMotionFragment[] = [];
+ for (const fragment of input.motionFragments) {
+ const mapped = mapInterval(fragment.startTime, fragment.endTime, ranges);
+ if (!mapped) continue;
+ motionFragments.push({ ...fragment, startTime: mapped.start, endTime: mapped.end });
+ }
+
+ return {
+ zoomFragments,
+ zoomMovements,
+ audioTracks,
+ canvasElements,
+ motionFragments,
+ droppedFragmentIds,
+ };
+}
diff --git a/lib/timeline-snapping.ts b/lib/timeline-snapping.ts
new file mode 100644
index 0000000..a746f4a
--- /dev/null
+++ b/lib/timeline-snapping.ts
@@ -0,0 +1,101 @@
+/**
+ * Snapping helpers for the timeline.
+ *
+ * Collects all "snap points" (clip edges, fragment edges, playhead, zero) and
+ * finds the nearest one within a pixel threshold. Used by drag handlers for
+ * clips, fragments, and the playhead to implement magnetic snapping.
+ */
+
+export interface SnapPoint {
+ time: number;
+ label?: string;
+}
+
+export interface SnapResult {
+ /** The snapped time, or null if no snap point was within range. */
+ time: number;
+ /** The pixel offset that was applied (for rendering snap indicators). */
+ offsetPx: number;
+}
+
+/**
+ * Collects snap points from all timeline entities.
+ * De-duplicates and sorts them.
+ */
+export function collectSnapPoints(opts: {
+ clipEdges?: Array<{ start: number; end: number }>;
+ fragmentEdges?: Array<{ start: number; end: number }>;
+ audioEdges?: Array<{ start: number; end: number }>;
+ elementEdges?: Array<{ start: number; end: number }>;
+ motionEdges?: Array<{ start: number; end: number }>;
+ playhead?: number;
+ zero?: boolean;
+}): SnapPoint[] {
+ const points: SnapPoint[] = [];
+ const add = (t: number) => points.push({ time: Math.max(0, t) });
+
+ if (opts.zero !== false) add(0);
+
+ for (const e of opts.clipEdges ?? []) {
+ add(e.start);
+ add(e.end);
+ }
+ for (const e of opts.fragmentEdges ?? []) {
+ add(e.start);
+ add(e.end);
+ }
+ for (const e of opts.audioEdges ?? []) {
+ add(e.start);
+ add(e.end);
+ }
+ for (const e of opts.elementEdges ?? []) {
+ add(e.start);
+ if (e.end !== undefined) add(e.end);
+ }
+ for (const e of opts.motionEdges ?? []) {
+ add(e.start);
+ add(e.end);
+ }
+ if (opts.playhead !== undefined) add(opts.playhead);
+
+ // De-duplicate within 1ms
+ const sorted = points.sort((a, b) => a.time - b.time);
+ const deduped: SnapPoint[] = [];
+ for (const p of sorted) {
+ if (deduped.length === 0 || Math.abs(p.time - deduped[deduped.length - 1].time) > 0.001) {
+ deduped.push(p);
+ }
+ }
+ return deduped;
+}
+
+/**
+ * Finds the nearest snap point to `time` within `thresholdPx` pixels.
+ * Returns the snapped time (unchanged if no snap), and the pixel offset.
+ */
+export function findSnap(
+ time: number,
+ snapPoints: SnapPoint[],
+ timeToPx: (t: number) => number,
+ thresholdPx: number,
+): SnapResult {
+ let bestTime = time;
+ let bestDist = thresholdPx;
+ let found = false;
+
+ for (const p of snapPoints) {
+ const distPx = Math.abs(timeToPx(p.time) - timeToPx(time));
+ if (distPx <= bestDist) {
+ bestDist = distPx;
+ bestTime = p.time;
+ found = true;
+ }
+ }
+
+ if (!found) {
+ return { time, offsetPx: 0 };
+ }
+
+ const offsetPx = timeToPx(bestTime) - timeToPx(time);
+ return { time: bestTime, offsetPx };
+}
diff --git a/types/timeline.types.ts b/types/timeline.types.ts
index 6bc5e2b..5b1ef92 100644
--- a/types/timeline.types.ts
+++ b/types/timeline.types.ts
@@ -26,6 +26,7 @@ export interface TimelineProps {
onSelectVideoClip?: (clipId: string | null) => void;
onUpdateVideoClip?: (clipId: string, updates: Partial<VideoTrackClip>) => void;
onDeleteVideoClip?: (clipId: string) => void;
+ onReorderVideoClip?: (draggedId: string, targetId: string, placeAfter: boolean) => void;
// Zoom props
zoomFragments?: ZoomFragment[];
selectedZoomFragmentId?: string | null;
diff --git a/types/video-track.types.ts b/types/video-track.types.ts
index afe82fb..c480393 100644
--- a/types/video-track.types.ts
+++ b/types/video-track.types.ts
@@ -95,10 +95,13 @@ export function resequenceClips(clips: VideoTrackClip[]): {
clips: VideoTrackClip[];
offsetMap: Map<string, number>;
} {
- const sorted = [...clips].sort((a, b) => a.startTime - b.startTime);
+ // Preserve the array order instead of sorting by startTime. Callers that
+ // need a specific order (e.g. reorderVideoClipAt) build the array in the
+ // desired order; sorting here would undo the reorder because clips still
+ // carry their old startTime values.
const offsetMap = new Map<string, number>();
let cursor = 0;
- const resequenced = sorted.map(clip => {
+ const resequenced = clips.map(clip => {
const duration = clip.trimEnd - clip.trimStart;
const offset = cursor - clip.startTime;
if (offset !== 0) offsetMap.set(clip.id, offset);
@@ -108,3 +111,40 @@ export function resequenceClips(clips: VideoTrackClip[]): {
});
return { clips: resequenced, offsetMap };
}
+
+/**
+ * Moves `draggedId` to the position of `targetId` (before or after it) and
+ * re-sequences every clip so the track stays contiguous — the magnetic
+ * reorder used by editors like CapCut. Returns the offset each clip moved
+ * by (used to remap timeline overlays).
+ */
+export function reorderVideoClipAt(
+ clips: VideoTrackClip[],
+ draggedId: string,
+ targetId: string,
+ placeAfter: boolean
+): {
+ clips: VideoTrackClip[];
+ offsetMap: Map<string, number>;
+} {
+ const dragged = clips.find(c => c.id === draggedId);
+ const target = clips.find(c => c.id === targetId);
+ if (!dragged || !target || draggedId === targetId) {
+ return { clips, offsetMap: new Map() };
+ }
+
+ const withoutDragged = clips.filter(c => c.id !== draggedId);
+ const targetIndex = withoutDragged.findIndex(c => c.id === targetId);
+ if (targetIndex === -1) {
+ return { clips, offsetMap: new Map() };
+ }
+
+ const insertAt = placeAfter ? targetIndex + 1 : targetIndex;
+ const reordered = [
+ ...withoutDragged.slice(0, insertAt),
+ dragged,
+ ...withoutDragged.slice(insertAt),
+ ];
+
+ return resequenceClips(reordered);
+}