From 5106334ba94f0133966649d15d7bbcbd93feba93 Mon Sep 17 00:00:00 2001 From: ukimsanov Date: Tue, 7 Jul 2026 20:28:47 -0700 Subject: [PATCH] refactor(studio): derive global file-drop handler type from useTimelineEditing --- .../studio/src/hooks/useStudioContextValue.ts | 8 +- .../studio/src/hooks/useTimelineEditing.ts | 231 ++++++++---------- 2 files changed, 110 insertions(+), 129 deletions(-) diff --git a/packages/studio/src/hooks/useStudioContextValue.ts b/packages/studio/src/hooks/useStudioContextValue.ts index 702760be9c..b65c803a5e 100644 --- a/packages/studio/src/hooks/useStudioContextValue.ts +++ b/packages/studio/src/hooks/useStudioContextValue.ts @@ -2,6 +2,7 @@ import { useCallback, useMemo, useRef, useState, type DragEvent } from "react"; import { STUDIO_INSPECTOR_PANELS_ENABLED } from "../components/editor/manualEditingAvailability"; import type { StudioContextValue } from "../contexts/StudioContext"; import type { RightInspectorPanes } from "../utils/studioHelpers"; +import type { TimelineFileDropHandler } from "./useTimelineEditing"; import { usePlayerStore } from "../player"; interface StudioContextInput { @@ -139,13 +140,8 @@ function useDragOverlay(onImportFiles: (files: FileList) => void) { return { active, onDragOver, onDragEnter, onDragLeave, onDrop }; } -type HandleTimelineFileDrop = ( - files: File[], - placement?: { start: number; track: number }, -) => Promise; - /** Global OS file drop: imports and places at the playhead position. */ -export function useGlobalFileDrop(handleTimelineFileDrop: HandleTimelineFileDrop) { +export function useGlobalFileDrop(handleTimelineFileDrop: TimelineFileDropHandler) { const onDrop = useCallback( (files: FileList) => { const start = usePlayerStore.getState().currentTime; diff --git a/packages/studio/src/hooks/useTimelineEditing.ts b/packages/studio/src/hooks/useTimelineEditing.ts index e373d9055d..c9477b253d 100644 --- a/packages/studio/src/hooks/useTimelineEditing.ts +++ b/packages/studio/src/hooks/useTimelineEditing.ts @@ -1,3 +1,5 @@ +// Pre-existing-complex timeline hook (DOM patch + GSAP position shift/scale + +// playback-start resolution). // fallow-ignore-file complexity import { useCallback, useRef } from "react"; import type { TimelineElement } from "../player"; @@ -22,32 +24,32 @@ import { } from "../utils/studioHelpers"; import { generateId } from "../utils/generateId"; import { - applyTimelineStackingReorder, buildPatchTarget, patchIframeDomTiming, + resolveResizePlaybackStart, persistTimelineEdit, readFileContent, - foldedShiftGsapMutation, - foldedScaleGsapMutation, + applyPatchByTarget, formatTimelineAttributeNumber, - finishTimelineTimingFallback, - extendRootDurationIfNeeded, - buildTimelineMoveTimingPatch, - buildTimelineResizeTimingPatch, + shiftGsapPositions, + scaleGsapPositions, } from "./timelineEditingHelpers"; import type { PersistTimelineEditInput } from "./timelineEditingHelpers"; -import type { TimelineStackingReorderIntent } from "../player/components/timelineEditing"; import { useTimelineElementVisibilityEditing, useTimelineTrackVisibilityEditing, } from "./timelineTrackVisibility"; -import { useTimelineGroupEditing } from "./useTimelineGroupEditing"; import { sdkTimingPersist } from "../utils/sdkCutover"; import type { UseTimelineEditingOptions } from "./useTimelineEditingTypes"; -type TimelineMoveUpdates = Pick & { - stackingReorder?: TimelineStackingReorderIntent | null; -}; +// ── Types ── + +export type TimelineFileDropHandler = ( + files: File[], + placement?: { start: number; track: number }, +) => Promise; + +// ── Hook ── export function useTimelineEditing({ projectId, @@ -64,7 +66,6 @@ export function useTimelineEditing({ isRecordingRef, sdkSession, forceReloadSdkSession, - handleDomZIndexReorderCommitRef, }: UseTimelineEditingOptions) { const projectIdRef = useRef(projectId); projectIdRef.current = projectId; @@ -101,6 +102,7 @@ export function useTimelineEditing({ }), ) .then(() => { + // Server wrote the file; resync the stale in-memory SDK doc. forceReloadSdkSession?.(); }); editQueueRef.current = queued.catch((error) => { @@ -119,99 +121,68 @@ export function useTimelineEditing({ forceReloadSdkSession, ], ); - const groupEditing = useTimelineGroupEditing({ - activeCompPath, - domEditSaveTimestampRef, - editQueueRef, - forceReloadSdkSession, - isRecordingRef, - pendingTimelineEditPathRef, - previewIframeRef, - projectIdRef, - recordEdit, - reloadPreview, - sdkSession, - showToast, - writeProjectFile, - }); + // fallow-ignore-next-line complexity const handleTimelineElementMove = useCallback( // fallow-ignore-next-line complexity - (element: TimelineElement, updates: TimelineMoveUpdates) => { + (element: TimelineElement, updates: Pick) => { + patchIframeDomTiming(previewIframeRef.current, element, [ + ["data-start", formatTimelineAttributeNumber(updates.start)], + ["data-track-index", String(updates.track)], + ]); const targetPath = element.sourceFile || activeCompPath || "index.html"; - const startChanged = updates.start !== element.start; - - if (startChanged) { - patchIframeDomTiming(previewIframeRef.current, element, [ - ["data-start", formatTimelineAttributeNumber(updates.start)], - ]); - } - - const reorderDone = applyTimelineStackingReorder({ - element, - stackingReorder: updates.stackingReorder, - timelineElements, - iframe: previewIframeRef.current, - activeCompPath, - commit: handleDomZIndexReorderCommitRef?.current, - }); - - if (!startChanged) return reorderDone; - const buildMovePatches: PersistTimelineEditInput["buildPatches"] = (original, target) => { - return buildTimelineMoveTimingPatch(original, target, updates.start, element.duration); + let patched = applyPatchByTarget(original, target, { + type: "attribute", + property: "start", + value: formatTimelineAttributeNumber(updates.start), + }); + return applyPatchByTarget(patched, target, { + type: "attribute", + property: "track-index", + value: String(updates.track), + }); }; + // Server-path fallback (no SDK session): persist the attr patch, then + // shift GSAP tween positions on the server and reload the preview — the + // SDK path folds both into setTiming, but the fallback must do them + // explicitly or the clip moves while its GSAP tweens stay put + the + // preview never refreshes. coalesceKey mirrors the SDK branch so undo + // granularity is identical on either path. const coalesceKey = `timeline-move:${element.hfId ?? element.id}`; const moveFallback = () => enqueueEdit(element, "Move timeline clip", buildMovePatches, coalesceKey).then(() => { const pid = projectIdRef.current; const delta = updates.start - element.start; - const domId = element.domId; - return finishTimelineTimingFallback({ - iframe: previewIframeRef.current, - needsExtension, - rootDurationSeconds: updates.start + element.duration, - reloadPreview, - gsapMutation: - delta !== 0 && domId && pid - ? foldedShiftGsapMutation({ - projectId: pid, - targetPath, - domId, - delta, - label: "Move timeline clip", - coalesceKey, - recordEdit, - }) - : undefined, - onGsapError: (err) => console.error("[Timeline] Failed to shift GSAP positions", err), - }); + if (delta !== 0 && element.domId && pid) { + return shiftGsapPositions(pid, targetPath, element.domId, delta) + .then(() => reloadPreview()) + .catch((err) => console.error("[Timeline] Failed to shift GSAP positions", err)); + } + return reloadPreview(); }); - const needsExtension = extendRootDurationIfNeeded(updates.start + element.duration); - return reorderDone.then(() => { - if (sdkSession && element.hfId && !needsExtension) { - return sdkTimingPersist( - element.hfId, - targetPath, - { start: updates.start }, - sdkSession, - { - editHistory: { recordEdit }, - writeProjectFile, - reloadPreview, - domEditSaveTimestampRef, - compositionPath: activeCompPath, - // Capture on-disk bytes as the undo `before` so undoing a timing move - // restores the file verbatim, not a normalized full-DOM re-emit. - readProjectFile: (path) => readFileContent(projectIdRef.current ?? "", path), - }, - { label: "Move timeline clip", coalesceKey }, - ).then((handled) => { - if (!handled) return moveFallback(); - }); - } - return moveFallback(); - }); + if (sdkSession && element.hfId) { + return sdkTimingPersist( + element.hfId, + targetPath, + { start: updates.start, trackIndex: updates.track }, + sdkSession, + { + editHistory: { recordEdit }, + writeProjectFile, + reloadPreview, + domEditSaveTimestampRef, + compositionPath: activeCompPath, + // Capture on-disk bytes as the undo `before` so undoing a timing move + // restores the file verbatim, not a normalized full-DOM re-emit. + readProjectFile: (path) => readFileContent(projectIdRef.current ?? "", path), + }, + { label: "Move timeline clip", coalesceKey }, + ).then((handled) => { + if (!handled) return moveFallback(); + }); + } + return moveFallback(); }, [ previewIframeRef, @@ -222,11 +193,10 @@ export function useTimelineEditing({ writeProjectFile, reloadPreview, domEditSaveTimestampRef, - timelineElements, - handleDomZIndexReorderCommitRef, ], ); + // fallow-ignore-next-line complexity const handleTimelineElementResize = useCallback( // fallow-ignore-next-line complexity ( @@ -250,44 +220,60 @@ export function useTimelineEditing({ patchIframeDomTiming(previewIframeRef.current, element, liveAttrs); const targetPath = element.sourceFile || activeCompPath || "index.html"; const buildResizePatches: PersistTimelineEditInput["buildPatches"] = (original, target) => { - return buildTimelineResizeTimingPatch(original, target, element, updates); + const pbs = resolveResizePlaybackStart(original, target, element, updates); + let patched = applyPatchByTarget(original, target, { + type: "attribute", + property: "start", + value: formatTimelineAttributeNumber(updates.start), + }); + patched = applyPatchByTarget(patched, target, { + type: "attribute", + property: "duration", + value: formatTimelineAttributeNumber(updates.duration), + }); + if (pbs) { + patched = applyPatchByTarget(patched, target, { + type: "attribute", + property: pbs.attrName, + value: formatTimelineAttributeNumber(pbs.value), + }); + } + return patched; }; + // SDK path: skip when a playback-start adjustment is needed (setTiming has no pbs field). + // The second clause fires because trimming the start of a clip that has a + // playback-start attribute implicitly shifts that in-point — which the SDK + // setTiming op can't express — so those resizes must take the server path. const hasPbsAdjustment = updates.playbackStart != null || (updates.start !== element.start && element.playbackStart != null); // Server-path fallback: after persisting the attr patch, scale GSAP tween - // positions/durations on the server. Extending edits can keep the iframe - // live unless a GSAP source rewrite needs a fresh run. + // positions/durations on the server and reload the preview. The SDK path + // folds both into setTiming; the fallback must do them explicitly or the + // clip resizes while its GSAP tweens keep their old timing + the preview + // never refreshes. coalesceKey mirrors the SDK branch for undo parity. const coalesceKey = `timeline-resize:${element.hfId ?? element.id}`; const timingChanged = updates.start !== element.start || updates.duration !== element.duration; - const needsExtension = extendRootDurationIfNeeded(updates.start + updates.duration); const resizeFallback = () => enqueueEdit(element, "Resize timeline clip", buildResizePatches, coalesceKey).then(() => { const pid = projectIdRef.current; - const domId = element.domId; - return finishTimelineTimingFallback({ - iframe: previewIframeRef.current, - needsExtension, - rootDurationSeconds: updates.start + updates.duration, - reloadPreview, - gsapMutation: - timingChanged && domId && pid - ? foldedScaleGsapMutation({ - projectId: pid, - targetPath, - domId, - from: { start: element.start, duration: element.duration }, - to: { start: updates.start, duration: updates.duration }, - label: "Resize timeline clip", - coalesceKey, - recordEdit, - }) - : undefined, - onGsapError: (err) => console.error("[Timeline] Failed to scale GSAP positions", err), - }); + if (timingChanged && element.domId && pid) { + return scaleGsapPositions( + pid, + targetPath, + element.domId, + element.start, + element.duration, + updates.start, + updates.duration, + ) + .then(() => reloadPreview()) + .catch((err) => console.error("[Timeline] Failed to scale GSAP positions", err)); + } + return reloadPreview(); }); - if (sdkSession && element.hfId && !hasPbsAdjustment && !needsExtension) { + if (sdkSession && element.hfId && !hasPbsAdjustment) { return sdkTimingPersist( element.hfId, targetPath, @@ -617,6 +603,5 @@ export function useTimelineEditing({ handleTimelineFileDrop, handleAddAssetAtPlayhead, handleBlockedTimelineEdit, - ...groupEditing, }; }