Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

16.5 KB
Raw Blame
import { describe, expect, it } from "vitest";
import {
	areEditSpecsEquivalent,
	areTimelineStatesEquivalent,
	composeEditSpecs,
	createIdentityEditSpec,
	createTimelineHistory,
	createTimelineState,
	deleteSelectedTimelineSegment,
	deleteTimelineRanges,
	dragTimelineDisplaySplitPoint,
	findNextPlayableTime,
	findNextPlayableTimeInRanges,
	findPlayableRangeIndex,
	getTimelineDisplayDuration,
	getTimelineDisplaySegments,
	getTimelineDisplaySplitPoints,
	getTimelineKeepRanges,
	getTimelineSegments,
	mapOutputTimeToSourceTime,
	mapSourceTimeToOutputTime,
	mapTimelineDisplayTimeToSourceTime,
	mapTimelineSourceTimeToDisplayTime,
	normalizeKeepRanges,
	pushTimelineHistory,
	redoTimelineHistory,
	remapCurrentOutputTimeThroughEdit,
	removeSplitPoint,
	removeTimelineDisplaySplitPoint,
	selectTimelineSegment,
	splitTimelineAt,
	trimTimelineClipEdge,
	undoTimelineHistory,
} from "@/lib/video-edits";

describe("video edit specs", () => {
	it("normalizes keep ranges", () => {
		const spec = normalizeKeepRanges(
			[
				{ start: 8, end: 12 },
				{ start: 2, end: 4 },
				{ start: 3.5, end: 5 },
				{ start: Number.NaN, end: 0.01 },
			],
			10,
		);

		expect(spec).toEqual({
			version: 1,
			sourceDuration: 10,
			keepRanges: [
				{ start: 2, end: 5 },
				{ start: 8, end: 10 },
			],
		});
	});

	it("maps source and output timestamps", () => {
		const spec = normalizeKeepRanges(
			[
				{ start: 1, end: 3 },
				{ start: 5, end: 8 },
			],
			10,
		);

		expect(mapSourceTimeToOutputTime(2, spec)).toBe(1);
		expect(mapSourceTimeToOutputTime(4, spec)).toBeNull();
		expect(mapOutputTimeToSourceTime(3, spec)).toBe(6);
	});

	it("composes repeated edits through the retained source", () => {
		const previousSpec = normalizeKeepRanges(
			[
				{ start: 0, end: 4 },
				{ start: 6, end: 10 },
			],
			10,
		);
		const nextOutputSpec = normalizeKeepRanges([{ start: 1, end: 6 }], 8);
		const composed = composeEditSpecs(previousSpec, nextOutputSpec);

		expect(composed.keepRanges).toEqual([
			{ start: 1, end: 4 },
			{ start: 6, end: 8 },
		]);
		expect(remapCurrentOutputTimeThroughEdit(5, previousSpec, composed)).toBe(
			4,
		);
		expect(
			remapCurrentOutputTimeThroughEdit(7, previousSpec, composed),
		).toBeNull();
	});

	it("creates an identity edit spec", () => {
		expect(createIdentityEditSpec(4.2)).toEqual({
			version: 1,
			sourceDuration: 4.2,
			keepRanges: [{ start: 0, end: 4.2 }],
		});
	});

	it("detects normalized no-op edit specs", () => {
		expect(
			areEditSpecsEquivalent(
				{
					version: 1,
					sourceDuration: 10,
					keepRanges: [{ start: 0, end: 10 }],
				},
				{
					version: 1,
					sourceDuration: 10,
					keepRanges: [
						{ start: 0, end: 4 },
						{ start: 4, end: 10 },
					],
				},
			),
		).toBe(true);

		expect(
			areEditSpecsEquivalent(
				createIdentityEditSpec(10),
				normalizeKeepRanges([{ start: 1, end: 10 }], 10),
			),
		).toBe(false);
	});
});

describe("timeline editing", () => {
	it("deletes transcript ranges as one normalized timeline change", () => {
		const nextState = deleteTimelineRanges(createTimelineState(10), [
			{ start: 1.02, end: 1.35 },
			{ start: 4.1, end: 4.4 },
			{ start: 4.35, end: 4.7 },
		]);

		expect(getTimelineKeepRanges(nextState)).toEqual([
			{ start: 0, end: 1.02 },
			{ start: 1.35, end: 4.1 },
			{ start: 4.7, end: 10 },
		]);
		expect(nextState.splitPoints).toEqual([1.02, 1.35, 4.1, 4.7]);
	});

	it("does not allow transcript deletion to remove all playable video", () => {
		const state = createTimelineState(10);
		expect(deleteTimelineRanges(state, [{ start: 0, end: 10 }])).toEqual(state);
	});

	it("stores a batch transcript deletion as one undoable history entry", () => {
		const initialState = createTimelineState(10);
		const history = createTimelineHistory(initialState);
		const deleted = deleteTimelineRanges(initialState, [
			{ start: 1, end: 1.3 },
			{ start: 3, end: 3.4 },
		]);
		const changedHistory = pushTimelineHistory(history, deleted);

		expect(changedHistory.entries).toHaveLength(2);
		expect(
			getTimelineKeepRanges(changedHistory.entries[1] ?? initialState),
		).toEqual([
			{ start: 0, end: 1 },
			{ start: 1.3, end: 3 },
			{ start: 3.4, end: 10 },
		]);
		expect(undoTimelineHistory(changedHistory).index).toBe(0);
	});

	it("splits, selects, and deletes a segment", () => {
		const splitState = splitTimelineAt(createTimelineState(10), 4);
		const firstSegment = getTimelineSegments(splitState)[0];
		expect(firstSegment).toBeDefined();

		const selected = selectTimelineSegment(splitState, firstSegment?.id ?? "");
		const deleted = deleteSelectedTimelineSegment(selected);

		expect(getTimelineKeepRanges(deleted)).toEqual([{ start: 4, end: 10 }]);
	});

	it("collapses deleted segments out of the displayed timeline", () => {
		const splitState = splitTimelineAt(
			splitTimelineAt(createTimelineState(10), 3),
			7,
		);
		const middleSegment = getTimelineSegments(splitState)[1];
		expect(middleSegment).toBeDefined();
		if (!middleSegment) throw new Error("Expected middle segment");

		const deleted = deleteSelectedTimelineSegment(
			selectTimelineSegment(splitState, middleSegment.id),
		);

		expect(getTimelineKeepRanges(deleted)).toEqual([
			{ start: 0, end: 3 },
			{ start: 7, end: 10 },
		]);
		expect(getTimelineDisplayDuration(deleted)).toBe(6);
		expect(
			getTimelineDisplaySegments(deleted).map(
				({ start, end, displayStart, displayEnd }) => ({
					start,
					end,
					displayStart,
					displayEnd,
				}),
			),
		).toEqual([
			{ start: 0, end: 3, displayStart: 0, displayEnd: 3 },
			{ start: 7, end: 10, displayStart: 3, displayEnd: 6 },
		]);
		expect(
			getTimelineDisplaySplitPoints(deleted).map(
				({ time, sourceTimes, splitIndices }) => ({
					time,
					sourceTimes,
					splitIndices,
				}),
			),
		).toEqual([{ time: 3, sourceTimes: [3, 7], splitIndices: [0, 1] }]);
		expect(mapTimelineSourceTimeToDisplayTime(deleted, 7)).toBe(3);
		expect(mapTimelineDisplayTimeToSourceTime(deleted, 3)).toBe(3);
	});

	it("preserves display offsets and split indices across trimmed deletions", () => {
		const state = {
			...createTimelineState(20),
			trimStart: 2,
			trimEnd: 18,
			splitPoints: [17, 14, 12, 10, 9, 8, 7, 6, 4, 3],
			deletedRanges: [
				{ start: 17, end: 19 },
				{ start: 10, end: 12 },
				{ start: 6, end: 8 },
				{ start: 1, end: 3 },
			],
			selectedSegmentId: "8:9",
		};

		expect(
			getTimelineDisplaySegments(state).map(
				({ start, end, displayStart, displayEnd, selected }) => ({
					start,
					end,
					displayStart,
					displayEnd,
					selected,
				}),
			),
		).toEqual([
			{ start: 3, end: 4, displayStart: 1, displayEnd: 2, selected: false },
			{ start: 4, end: 6, displayStart: 2, displayEnd: 4, selected: false },
			{ start: 8, end: 9, displayStart: 4, displayEnd: 5, selected: true },
			{ start: 9, end: 10, displayStart: 5, displayEnd: 6, selected: false },
			{ start: 12, end: 14, displayStart: 6, displayEnd: 8, selected: false },
			{ start: 14, end: 17, displayStart: 8, displayEnd: 11, selected: false },
		]);
		expect(
			getTimelineDisplaySplitPoints(state).map(
				({ time, sourceTimes, splitIndices }) => ({
					time,
					sourceTimes,
					splitIndices,
				}),
			),
		).toEqual([
			{ time: 2, sourceTimes: [4], splitIndices: [1] },
			{ time: 4, sourceTimes: [6, 8], splitIndices: [2, 3] },
			{ time: 5, sourceTimes: [9], splitIndices: [4] },
			{ time: 6, sourceTimes: [10, 12], splitIndices: [5, 6] },
			{ time: 8, sourceTimes: [14], splitIndices: [7] },
		]);
	});

	it("retains nearby split indices when a subminimum segment is omitted", () => {
		const state = {
			...createTimelineState(10),
			splitPoints: [1, 1.001, 2, 3, 7, 8],
			deletedRanges: [{ start: 3, end: 7 }],
		};

		expect(
			getTimelineDisplaySplitPoints(state).map(
				({ time, sourceTimes, splitIndices }) => ({
					time,
					sourceTimes,
					splitIndices,
				}),
			),
		).toEqual([
			{ time: 1, sourceTimes: [1], splitIndices: [0, 1] },
			{ time: 2, sourceTimes: [2], splitIndices: [2] },
			{ time: 3, sourceTimes: [3, 7], splitIndices: [3, 4] },
			{ time: 4, sourceTimes: [8], splitIndices: [5] },
		]);
	});

	it("removes a collapsed display split by restoring the deleted segment", () => {
		const splitState = splitTimelineAt(
			splitTimelineAt(createTimelineState(10), 3),
			7,
		);
		const middleSegment = getTimelineSegments(splitState)[1];
		expect(middleSegment).toBeDefined();
		if (!middleSegment) throw new Error("Expected middle segment");

		const deleted = deleteSelectedTimelineSegment(
			selectTimelineSegment(splitState, middleSegment.id),
		);
		const restored = removeTimelineDisplaySplitPoint(deleted, 0);

		expect(getTimelineKeepRanges(restored)).toEqual([{ start: 0, end: 10 }]);
		expect(getTimelineDisplaySplitPoints(restored)).toEqual([]);
	});

	it("drags a collapsed display split to shrink either adjacent clip", () => {
		const splitState = splitTimelineAt(
			splitTimelineAt(createTimelineState(10), 3),
			7,
		);
		const middleSegment = getTimelineSegments(splitState)[1];
		expect(middleSegment).toBeDefined();
		if (!middleSegment) throw new Error("Expected middle segment");

		const deleted = deleteSelectedTimelineSegment(
			selectTimelineSegment(splitState, middleSegment.id),
		);
		const leftShrunk = dragTimelineDisplaySplitPoint(deleted, 0, "center", 2);
		const rightShrunk = dragTimelineDisplaySplitPoint(deleted, 0, "center", 8);

		expect(getTimelineKeepRanges(leftShrunk)).toEqual([
			{ start: 0, end: 2 },
			{ start: 7, end: 10 },
		]);
		expect(getTimelineDisplaySplitPoints(leftShrunk)[0]?.sourceTimes).toEqual([
			2, 7,
		]);
		expect(getTimelineKeepRanges(rightShrunk)).toEqual([
			{ start: 0, end: 3 },
			{ start: 8, end: 10 },
		]);
		expect(getTimelineDisplaySplitPoints(rightShrunk)[0]?.sourceTimes).toEqual([
			3, 8,
		]);
	});

	it("restores a deleted segment when removing its split boundary", () => {
		const splitState = splitTimelineAt(
			splitTimelineAt(createTimelineState(10), 3),
			7,
		);
		const middleSegment = getTimelineSegments(splitState)[1];
		expect(middleSegment).toBeDefined();
		if (!middleSegment) throw new Error("Expected middle segment");

		const deleted = deleteSelectedTimelineSegment(
			selectTimelineSegment(splitState, middleSegment.id),
		);
		expect(getTimelineKeepRanges(deleted)).toEqual([
			{ start: 0, end: 3 },
			{ start: 7, end: 10 },
		]);

		const afterFirstSplitRemoved = removeSplitPoint(deleted, 0);
		expect(
			getTimelineSegments(afterFirstSplitRemoved).map(
				({ start, end, deleted }) => ({
					start,
					end,
					deleted,
				}),
			),
		).toEqual([
			{ start: 0, end: 7, deleted: false },
			{ start: 7, end: 10, deleted: false },
		]);

		const afterSecondSplitRemoved = removeSplitPoint(afterFirstSplitRemoved, 0);
		expect(
			getTimelineSegments(afterSecondSplitRemoved).map(
				({ start, end, deleted }) => ({
					start,
					end,
					deleted,
				}),
			),
		).toEqual([{ start: 0, end: 10, deleted: false }]);
		expect(getTimelineKeepRanges(afterSecondSplitRemoved)).toEqual([
			{ start: 0, end: 10 },
		]);
	});

	it("trims an inner clip from either edge without touching its neighbours", () => {
		const splitState = splitTimelineAt(createTimelineState(10), 4);
		const [firstClip, secondClip] = getTimelineDisplaySegments(splitState);
		if (!firstClip || !secondClip) throw new Error("Expected two clips");

		const secondTrimmedLeft = trimTimelineClipEdge(
			splitState,
			secondClip.id,
			"start",
			6,
		);
		expect(getTimelineKeepRanges(secondTrimmedLeft)).toEqual([
			{ start: 0, end: 4 },
			{ start: 6, end: 10 },
		]);

		const firstTrimmedRight = trimTimelineClipEdge(
			splitState,
			firstClip.id,
			"end",
			3,
		);
		expect(getTimelineKeepRanges(firstTrimmedRight)).toEqual([
			{ start: 0, end: 3 },
			{ start: 4, end: 10 },
		]);
	});

	it("never lets a clip edge carve into the adjacent clip", () => {
		const splitState = splitTimelineAt(createTimelineState(10), 4);
		const [firstClip, secondClip] = getTimelineDisplaySegments(splitState);
		if (!firstClip || !secondClip) throw new Error("Expected two clips");

		// First clip's right edge dragged past its own end stops at the boundary.
		expect(
			getTimelineKeepRanges(
				trimTimelineClipEdge(splitState, firstClip.id, "end", 8),
			),
		).toEqual([{ start: 0, end: 10 }]);

		// Second clip's left edge dragged before its own start stops at the boundary.
		expect(
			getTimelineKeepRanges(
				trimTimelineClipEdge(splitState, secondClip.id, "start", 1),
			),
		).toEqual([{ start: 0, end: 10 }]);
	});

	it("carves (does not un-collapse) when the outer clip already has trimmed-off footage", () => {
		// Front: delete [0,2] so the first visible clip is source 2-10.
		const frontDeleted = deleteSelectedTimelineSegment(
			selectTimelineSegment(
				splitTimelineAt(createTimelineState(10), 2),
				getTimelineSegments(splitTimelineAt(createTimelineState(10), 2))[0]
					?.id ?? "",
			),
		);
		const frontClip = getTimelineDisplaySegments(frontDeleted)[0];
		if (!frontClip) throw new Error("Expected a leading clip");
		const frontTrimmed = trimTimelineClipEdge(
			frontDeleted,
			frontClip.id,
			"start",
			4,
		);
		expect(getTimelineKeepRanges(frontTrimmed)).toEqual([
			{ start: 4, end: 10 },
		]);
		// Display stays collapsed (6s), not ballooned back to 10s.
		expect(getTimelineDisplayDuration(frontTrimmed)).toBe(6);

		// Back: delete [8,10] so the last visible clip is source 0-8.
		const backDeleted = deleteSelectedTimelineSegment(
			selectTimelineSegment(
				splitTimelineAt(createTimelineState(10), 8),
				getTimelineSegments(splitTimelineAt(createTimelineState(10), 8))[1]
					?.id ?? "",
			),
		);
		const backSegments = getTimelineDisplaySegments(backDeleted);
		const backClip = backSegments[backSegments.length - 1];
		if (!backClip) throw new Error("Expected a trailing clip");
		const backTrimmed = trimTimelineClipEdge(
			backDeleted,
			backClip.id,
			"end",
			6,
		);
		expect(getTimelineKeepRanges(backTrimmed)).toEqual([{ start: 0, end: 6 }]);
		expect(getTimelineDisplayDuration(backTrimmed)).toBe(6);
	});

	it("moves the global in/out point from the outermost clip edges", () => {
		const splitState = splitTimelineAt(createTimelineState(10), 4);
		const [firstClip, secondClip] = getTimelineDisplaySegments(splitState);
		if (!firstClip || !secondClip) throw new Error("Expected two clips");

		expect(
			getTimelineKeepRanges(
				trimTimelineClipEdge(splitState, firstClip.id, "start", 2),
			),
		).toEqual([{ start: 2, end: 10 }]);
		expect(
			getTimelineKeepRanges(
				trimTimelineClipEdge(splitState, secondClip.id, "end", 8),
			),
		).toEqual([{ start: 0, end: 8 }]);
	});

	it("tracks undo and redo state", () => {
		const initial = createTimelineState(10);
		const history = createTimelineHistory(initial);
		const nextHistory = pushTimelineHistory(
			history,
			splitTimelineAt(initial, 5),
		);
		const undone = undoTimelineHistory(nextHistory);
		const redone = redoTimelineHistory(undone);

		expect(
			getTimelineSegments(undone.entries[undone.index] ?? initial),
		).toHaveLength(1);
		expect(
			getTimelineSegments(redone.entries[redone.index] ?? initial),
		).toHaveLength(2);
	});

	it("detects timeline draft changes independently from output changes", () => {
		const initial = createTimelineState(10);
		const split = splitTimelineAt(initial, 5);
		const initialSegment = getTimelineSegments(initial)[0];
		expect(initialSegment).toBeDefined();
		if (!initialSegment) throw new Error("Expected initial segment");
		const selected = selectTimelineSegment(initial, initialSegment.id);

		expect(areTimelineStatesEquivalent(initial, split)).toBe(false);
		expect(areTimelineStatesEquivalent(initial, selected)).toBe(true);
		expect(
			areEditSpecsEquivalent(
				normalizeKeepRanges(getTimelineKeepRanges(initial), initial.duration),
				normalizeKeepRanges(getTimelineKeepRanges(split), split.duration),
			),
		).toBe(true);
	});

	it("finds preview skip targets", () => {
		const spec = normalizeKeepRanges(
			[
				{ start: 0, end: 2 },
				{ start: 5, end: 8 },
			],
			10,
		);

		expect(findNextPlayableTime(1, spec)).toBe(1);
		expect(findNextPlayableTime(3, spec)).toBe(5);
		expect(findNextPlayableTime(8.1, spec)).toBeNull();
	});

	it("finds preview skip targets in normalized ranges without rescanning them", () => {
		const ranges = Array.from({ length: 1000 }, (_, index) => ({
			start: index * 2,
			end: index * 2 + 1,
		}));

		expect(findNextPlayableTimeInRanges(998.5, ranges)).toBe(998.5);
		expect(findNextPlayableTimeInRanges(999, ranges)).toBe(1000);
		expect(findNextPlayableTimeInRanges(1999, ranges)).toBeNull();
		expect(findNextPlayableTimeInRanges(Number.NaN, ranges)).toBeNull();
		expect(findPlayableRangeIndex(998.5, ranges)).toBe(499);
		expect(findPlayableRangeIndex(999, ranges)).toBe(-1);
	});
});