Skip to content

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

5.9 KB
Raw Blame
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";

interface ClipRange {
    oldStart: number;
    oldEnd: number;
    newStart: number;
    newEnd: number;
    trimShift: 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,
            trimShift: newClip.trimStart - oldClip.trimStart,
        });
    }

    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 - containing.trimShift;
    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 || r.trimShift !== 0)
        || 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,
    };
}