refactor: move track pruning into a post-command reactor

3 files changed, 209 insertions, 228 deletions

diff --git a/apps/web/src/lib/commands/timeline/element/delete-elements.ts b/apps/web/src/lib/commands/timeline/element/delete-elements.ts
index 26277f95..9177a3f8 100644
--- a/apps/web/src/lib/commands/timeline/element/delete-elements.ts
+++ b/apps/web/src/lib/commands/timeline/element/delete-elements.ts
@@ -1,84 +1,81 @@
-import { Command, type CommandResult } from "@/lib/commands/base-command";

-import type { TimelineTrack } from "@/lib/timeline";

-import { EditorCore } from "@/core";

-import { rippleShiftElements } from "@/lib/timeline";

-import { isMainTrack } from "@/lib/timeline/placement";

-

-export class DeleteElementsCommand extends Command {

-	private savedState: TimelineTrack[] | null = null;

-	private readonly elements: { trackId: string; elementId: string }[];

-	private readonly rippleEnabled: boolean;

-

-	constructor({

-		elements,

-		rippleEnabled = false,

-	}: {

-		elements: { trackId: string; elementId: string }[];

-		rippleEnabled?: boolean;

-	}) {

-		super();

-		this.elements = elements;

-		this.rippleEnabled = rippleEnabled;

-	}

-

-	execute(): CommandResult {

-		const editor = EditorCore.getInstance();

-		this.savedState = editor.timeline.getTracks();

-

-		const updatedTracks = this.savedState

-			.map((track) => {

-				const elementsToDeleteOnTrack = this.elements.filter(

-					(target) => target.trackId === track.id,

-				);

-				const hasElementsToDelete = elementsToDeleteOnTrack.length > 0;

-

-				if (!hasElementsToDelete) {

-					return track;

-				}

-

-				const deletedElementInfos = elementsToDeleteOnTrack

-					.map((target) =>

-						track.elements.find((element) => element.id === target.elementId),

-					)

-					.filter((element): element is NonNullable<typeof element> => element !== undefined)

-					.map((element) => ({ startTime: element.startTime, duration: element.duration }));

-

-				let elements = track.elements.filter(

-					(element) =>

-						!this.elements.some(

-							(target) =>

-								target.trackId === track.id && target.elementId === element.id,

-						),

-				);

-

-				if (this.rippleEnabled && deletedElementInfos.length > 0) {

-					const sortedByStartDesc = [...deletedElementInfos].sort(

-						(a, b) => b.startTime - a.startTime,

-					);

-					for (const { startTime, duration } of sortedByStartDesc) {

-						elements = rippleShiftElements({

-							elements,

-							afterTime: startTime,

-							shiftAmount: duration,

-						});

-					}

-				}

-

-				return { ...track, elements } as typeof track;

-			})

-			.filter((track) => track.elements.length > 0 || isMainTrack(track));

-

-		editor.timeline.updateTracks(updatedTracks);

-

-		return {

-			select: [],

-		};

-	}

-

-	undo(): void {

-		if (this.savedState) {

-			const editor = EditorCore.getInstance();

-			editor.timeline.updateTracks(this.savedState);

-		}

-	}

-}

+import { Command, type CommandResult } from "@/lib/commands/base-command";
+import type { TimelineTrack } from "@/lib/timeline";
+import { EditorCore } from "@/core";
+import { rippleShiftElements } from "@/lib/timeline";
+
+export class DeleteElementsCommand extends Command {
+	private savedState: TimelineTrack[] | null = null;
+	private readonly elements: { trackId: string; elementId: string }[];
+	private readonly rippleEnabled: boolean;
+
+	constructor({
+		elements,
+		rippleEnabled = false,
+	}: {
+		elements: { trackId: string; elementId: string }[];
+		rippleEnabled?: boolean;
+	}) {
+		super();
+		this.elements = elements;
+		this.rippleEnabled = rippleEnabled;
+	}
+
+	execute(): CommandResult {
+		const editor = EditorCore.getInstance();
+		this.savedState = editor.timeline.getTracks();
+
+		const updatedTracks = this.savedState.map((track) => {
+				const elementsToDeleteOnTrack = this.elements.filter(
+					(target) => target.trackId === track.id,
+				);
+				const hasElementsToDelete = elementsToDeleteOnTrack.length > 0;
+
+				if (!hasElementsToDelete) {
+					return track;
+				}
+
+				const deletedElementInfos = elementsToDeleteOnTrack
+					.map((target) =>
+						track.elements.find((element) => element.id === target.elementId),
+					)
+					.filter((element): element is NonNullable<typeof element> => element !== undefined)
+					.map((element) => ({ startTime: element.startTime, duration: element.duration }));
+
+				let elements = track.elements.filter(
+					(element) =>
+						!this.elements.some(
+							(target) =>
+								target.trackId === track.id && target.elementId === element.id,
+						),
+				);
+
+				if (this.rippleEnabled && deletedElementInfos.length > 0) {
+					const sortedByStartDesc = [...deletedElementInfos].sort(
+						(a, b) => b.startTime - a.startTime,
+					);
+					for (const { startTime, duration } of sortedByStartDesc) {
+						elements = rippleShiftElements({
+							elements,
+							afterTime: startTime,
+							shiftAmount: duration,
+						});
+					}
+				}
+
+				return { ...track, elements } as typeof track;
+			});
+
+		editor.timeline.updateTracks(updatedTracks);
+
+		return {
+			select: [],
+		};
+	}
+
+	undo(): void {
+		if (this.savedState) {
+			const editor = EditorCore.getInstance();
+			editor.timeline.updateTracks(this.savedState);
+		}
+	}
+}
diff --git a/apps/web/src/lib/commands/timeline/element/duplicate-elements.ts b/apps/web/src/lib/commands/timeline/element/duplicate-elements.ts
index df3531eb..ad31ae9c 100644
--- a/apps/web/src/lib/commands/timeline/element/duplicate-elements.ts
+++ b/apps/web/src/lib/commands/timeline/element/duplicate-elements.ts
@@ -1,127 +1,127 @@
-import { Command, type CommandResult } from "@/lib/commands/base-command";

-import type { TimelineElement, TimelineTrack } from "@/lib/timeline";

-import { generateUUID } from "@/utils/id";

-import { EditorCore } from "@/core";

-import { applyPlacement, resolveTrackPlacement } from "@/lib/timeline/placement";

-import { cloneAnimations } from "@/lib/animation";

-

-interface DuplicateElementsParams {

-	elements: { trackId: string; elementId: string }[];

-}

-

-export class DuplicateElementsCommand extends Command {

-	private duplicatedElements: { trackId: string; elementId: string }[] = [];

-	private savedState: TimelineTrack[] | null = null;

-	private elements: DuplicateElementsParams["elements"];

-

-	constructor({ elements }: DuplicateElementsParams) {

-		super();

-		this.elements = elements;

-	}

-

-	execute(): CommandResult | undefined {

-		const editor = EditorCore.getInstance();

-		this.savedState = editor.timeline.getTracks();

-		this.duplicatedElements = [];

-

-		let updatedTracks = [...this.savedState];

-

-		for (const track of this.savedState) {

-			const elementsToDuplicate = this.elements.filter(

-				(elementEntry) => elementEntry.trackId === track.id,

-			);

-

-			if (elementsToDuplicate.length === 0) {

-				continue;

-			}

-

-			const elementIdsToDuplicate = new Set(

-				elementsToDuplicate.map((element) => element.elementId),

-			);

-			const newTrackElements: TimelineElement[] = [];

-

-			for (const element of track.elements) {

-				if (!elementIdsToDuplicate.has(element.id)) {

-					continue;

-				}

-

-				const newId = generateUUID();

-				newTrackElements.push(

-					buildDuplicateElement({

-						element,

-						id: newId,

-						startTime: element.startTime,

-					}),

-				);

-			}

-

-			const placementResult = resolveTrackPlacement({

-				tracks: updatedTracks,

-				trackType: track.type,

-				timeSpans: [],

-				strategy: { type: "alwaysNew", position: "highest" },

-			});

-			if (!placementResult || placementResult.kind !== "newTrack") {

-				continue;

-			}

-

-			const applied = applyPlacement({

-				tracks: updatedTracks,

-				placementResult,

-				elements: newTrackElements,

-			});

-			if (!applied) {

-				continue;

-			}

-

-			updatedTracks = applied.updatedTracks;

-

-			for (const element of newTrackElements) {

-				this.duplicatedElements.push({

-					trackId: applied.targetTrackId,

-					elementId: element.id,

-				});

-			}

-		}

-

-		editor.timeline.updateTracks(updatedTracks);

-

-		if (this.duplicatedElements.length > 0) {

-			return {

-				select: this.duplicatedElements,

-			};

-		}

-	}

-

-	undo(): void {

-		if (this.savedState) {

-			const editor = EditorCore.getInstance();

-			editor.timeline.updateTracks(this.savedState);

-		}

-	}

-

-	getDuplicatedElements(): { trackId: string; elementId: string }[] {

-		return this.duplicatedElements;

-	}

-}

-

-function buildDuplicateElement({

-	element,

-	id,

-	startTime,

-}: {

-	element: TimelineElement;

-	id: string;

-	startTime: number;

-}): TimelineElement {

-	return {

-		...element,

-		id,

-		name: `${element.name} (copy)`,

-		startTime,

-		animations: cloneAnimations({

-			animations: element.animations,

-			shouldRegenerateKeyframeIds: true,

-		}),

-	};

-}

+import { Command, type CommandResult } from "@/lib/commands/base-command";
+import type { TimelineElement, TimelineTrack } from "@/lib/timeline";
+import { generateUUID } from "@/utils/id";
+import { EditorCore } from "@/core";
+import { applyPlacement, resolveTrackPlacement } from "@/lib/timeline/placement";
+import { cloneAnimations } from "@/lib/animation";
+
+interface DuplicateElementsParams {
+	elements: { trackId: string; elementId: string }[];
+}
+
+export class DuplicateElementsCommand extends Command {
+	private duplicatedElements: { trackId: string; elementId: string }[] = [];
+	private savedState: TimelineTrack[] | null = null;
+	private elements: DuplicateElementsParams["elements"];
+
+	constructor({ elements }: DuplicateElementsParams) {
+		super();
+		this.elements = elements;
+	}
+
+	execute(): CommandResult | undefined {
+		const editor = EditorCore.getInstance();
+		this.savedState = editor.timeline.getTracks();
+		this.duplicatedElements = [];
+
+		let updatedTracks = [...this.savedState];
+
+		for (const track of this.savedState) {
+			const elementsToDuplicate = this.elements.filter(
+				(elementEntry) => elementEntry.trackId === track.id,
+			);
+
+			if (elementsToDuplicate.length === 0) {
+				continue;
+			}
+
+			const elementIdsToDuplicate = new Set(
+				elementsToDuplicate.map((element) => element.elementId),
+			);
+			const newTrackElements: TimelineElement[] = [];
+
+			for (const element of track.elements) {
+				if (!elementIdsToDuplicate.has(element.id)) {
+					continue;
+				}
+
+				const newId = generateUUID();
+				newTrackElements.push(
+					buildDuplicateElement({
+						element,
+						id: newId,
+						startTime: element.startTime,
+					}),
+				);
+			}
+
+			const placementResult = resolveTrackPlacement({
+				tracks: updatedTracks,
+				trackType: track.type,
+				timeSpans: [],
+				strategy: { type: "alwaysNew", position: "highest" },
+			});
+			if (!placementResult || placementResult.kind !== "newTrack") {
+				continue;
+			}
+
+			const applied = applyPlacement({
+				tracks: updatedTracks,
+				placementResult,
+				elements: newTrackElements,
+			});
+			if (!applied) {
+				continue;
+			}
+
+			updatedTracks = applied.updatedTracks;
+
+			for (const element of newTrackElements) {
+				this.duplicatedElements.push({
+					trackId: applied.targetTrackId,
+					elementId: element.id,
+				});
+			}
+		}
+
+		editor.timeline.updateTracks(updatedTracks);
+
+		if (this.duplicatedElements.length > 0) {
+			return {
+				select: this.duplicatedElements,
+			};
+		}
+	}
+
+	undo(): void {
+		if (this.savedState) {
+			const editor = EditorCore.getInstance();
+			editor.timeline.updateTracks(this.savedState);
+		}
+	}
+
+	getDuplicatedElements(): { trackId: string; elementId: string }[] {
+		return this.duplicatedElements;
+	}
+}
+
+function buildDuplicateElement({
+	element,
+	id,
+	startTime,
+}: {
+	element: TimelineElement;
+	id: string;
+	startTime: number;
+}): TimelineElement {
+	return {
+		...element,
+		id,
+		name: `${element.name} (copy)`,
+		startTime,
+		animations: cloneAnimations({
+			animations: element.animations,
+			shouldRegenerateKeyframeIds: true,
+		}),
+	};
+}
diff --git a/apps/web/src/lib/commands/timeline/element/move-elements.ts b/apps/web/src/lib/commands/timeline/element/move-elements.ts
index 73d07bff..6d400964 100644
--- a/apps/web/src/lib/commands/timeline/element/move-elements.ts
+++ b/apps/web/src/lib/commands/timeline/element/move-elements.ts
@@ -7,7 +7,6 @@ import type {
 } from "@/lib/timeline";

 import {

 	buildEmptyTrack,

-	isMainTrack,

 	validateElementTrackCompatibility,

 	enforceMainTrackStart,

 } from "@/lib/timeline/placement";

@@ -100,7 +99,7 @@ export class MoveElementCommand extends Command {
 

 		const isSameTrack = this.sourceTrackId === this.targetTrackId;

 

-		let updatedTracks = tracksToUpdate.map((track): TimelineTrack => {

+		const updatedTracks = tracksToUpdate.map((track): TimelineTrack => {

 			if (isSameTrack && track.id === this.sourceTrackId) {

 				return {

 					...track,

@@ -134,21 +133,6 @@ export class MoveElementCommand extends Command {
 			return track;

 		});

 

-		if (!isSameTrack) {

-			const sourceTrackAfterMove = updatedTracks.find(

-				(track) => track.id === this.sourceTrackId,

-			);

-			if (

-				sourceTrackAfterMove &&

-				sourceTrackAfterMove.elements.length === 0 &&

-				!isMainTrack(sourceTrackAfterMove)

-			) {

-				updatedTracks = updatedTracks.filter(

-					(track) => track.id !== this.sourceTrackId,

-				);

-			}

-		}

-

 		editor.timeline.updateTracks(updatedTracks);

 	}