Skip to content

Commit eb4ab7f

Browse files
committed
fix(studio): a dropped nested clip stops at its host's start before snapping
1 parent 6e25218 commit eb4ab7f

7 files changed

Lines changed: 109 additions & 30 deletions

File tree

‎packages/studio/src/player/components/timelineClipDragPreview.test.ts‎

Lines changed: 70 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@ import {
77
type DragPreviewContext,
88
} from "./timelineClipDragPreview";
99
import type { DraggedClipState } from "./timelineClipDragTypes";
10-
import { commitDraggedClipMove } from "./timelineClipDragCommit";
10+
import { commitDraggedClipMove, persistMoveEdits } from "./timelineClipDragCommit";
1111
import { LANE_H, RULER_H, TRACKS_TOP_PAD, TRACK_H } from "./timelineLayout";
1212

1313
// ─────────────────────────────────────────────────────────────────────────────
@@ -466,3 +466,72 @@ describe("computeDragPreview — the ghost start is the committed start", () =>
466466
}
467467
});
468468
});
469+
470+
describe("a nested clip's drop stops at its host's start in the preview", () => {
471+
// Host at 2 s: the clip may not start before 2 unless it was authored there.
472+
const logo: TimelineElement = { ...clip("logo", 0, 5, 5, 0, "div"), parentCompositionStart: 2 };
473+
const saved = async (element: TimelineElement, start: number) => {
474+
const updateElement = vi.fn();
475+
await persistMoveEdits([{ element, updates: { start, track: element.track } }], {
476+
elements: [element],
477+
trackOrder: [0, 1, 2],
478+
updateElement,
479+
onMoveElements: vi.fn(async () => {}),
480+
});
481+
return updateElement.mock.calls[0]?.[1]?.start;
482+
};
483+
484+
it("holds a drop that snapping would put before the host, and saves the same start", async () => {
485+
const { drag, clientX, clientY } = horizontalDrag(logo, 0.5, -3.9);
486+
const next = computeDragPreview(drag, clientX, clientY, {
487+
...ctx(undefined, [logo]),
488+
buildSnapTargets: () => [{ time: 1.9, type: "beat" }],
489+
});
490+
expect(next.previewStart).toBe(2);
491+
expect(next.snapTime).toBeNull();
492+
expect(await saved(logo, next.previewStart)).toBe(2);
493+
});
494+
495+
it("snaps from the floor, so an edge just past the host's start still catches", () => {
496+
const { drag, clientX, clientY } = horizontalDrag(logo, 0.5, -3.9);
497+
const next = computeDragPreview(drag, clientX, clientY, {
498+
...ctx(undefined, [logo]),
499+
buildSnapTargets: () => [{ time: 2.1, type: "beat" }],
500+
});
501+
expect(next).toMatchObject({ previewStart: 2.1, snapTime: 2.1 });
502+
});
503+
504+
it("keeps a mixed group's spacing when the nested member meets its floor", () => {
505+
// Grab the top-level member: only the group clamp knows the nested one's floor.
506+
const outro = clip("outro", 1, 8, 2, 0, "div");
507+
const { drag, clientX, clientY } = horizontalDrag(outro, 1.5, -7);
508+
const next = computeDragPreview(drag, clientX, clientY, {
509+
...ctx(undefined, [logo, outro]),
510+
selectedKeys: new Set(["logo", "outro"]),
511+
});
512+
expect(next.previewStart).toBe(5);
513+
});
514+
515+
it("leaves a clip authored before its host's start in place when grabbed", async () => {
516+
const early: TimelineElement = { ...logo, id: "early", key: "early", domId: "early", start: 1 };
517+
const { drag, clientX, clientY } = horizontalDrag(early, 0.5, 0);
518+
expect(computeDragPreview(drag, clientX, clientY, ctx(undefined, [early])).previewStart).toBe(
519+
1,
520+
);
521+
const trim = computeResizePreview(
522+
{
523+
element: early,
524+
edge: "start",
525+
originClientX: 0,
526+
previewStart: 1,
527+
previewDuration: 5,
528+
started: true,
529+
pointerId: 0,
530+
},
531+
0,
532+
{ scroll: fakeScroll(), pps: PPS, buildSnapTargets: () => [] },
533+
);
534+
expect(trim).toMatchObject({ previewStart: 1, previewDuration: 5 });
535+
expect(await saved(early, 1)).toBe(1);
536+
});
537+
});

‎packages/studio/src/player/components/timelineClipDragPreview.ts‎

Lines changed: 11 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -81,10 +81,10 @@ function resolveDragMaxStart(scroll: HTMLDivElement | null, pps: number, duratio
8181
/**
8282
* Rigid group move: when the grabbed clip is part of a multi-selection, the
8383
* WHOLE formation shifts by its delta on commit (see timelineClipDragCommit).
84-
* Clamp that delta here — against every selected member's start — so the
85-
* grabbed clip can't out-run the group: it STOPS the instant any member would
86-
* cross 0, exactly as it lands on commit. Lane changes still apply to the
87-
* grabbed clip only, so only the start (x) is constrained.
84+
* Clamp that delta here, and a lone clip's as a group of one, so the grabbed
85+
* clip STOPS the instant any member would cross its floor (clampToHostStart),
86+
* exactly as it lands on commit. Lane changes still apply to the grabbed clip
87+
* only, so only the start (x) is constrained.
8888
*/
8989
function resolveGroupClampedStart(
9090
snapStart: number,
@@ -93,10 +93,10 @@ function resolveGroupClampedStart(
9393
elements: TimelineElement[],
9494
selectedKeys: ReadonlySet<string>,
9595
): number {
96-
if (selectedKeys.size <= 1 || !selectedKeys.has(dragKey)) return snapStart;
97-
const memberStarts = elements.filter((e) => selectedKeys.has(e.key ?? e.id)).map((e) => e.start);
98-
const clampedDelta = clampGroupMoveDelta(snapStart - element.start, memberStarts);
99-
return element.start + clampedDelta;
96+
const inGroup = selectedKeys.size > 1 && selectedKeys.has(dragKey);
97+
const members = inGroup ? elements.filter((e) => selectedKeys.has(e.key ?? e.id)) : [element];
98+
const floors = members.map((e) => ({ start: e.start, minStart: clampToHostStart(e, 0) }));
99+
return element.start + clampGroupMoveDelta(snapStart - element.start, floors);
100100
}
101101

102102
/**
@@ -174,6 +174,7 @@ export function computeDragPreview(
174174
originScrollLeft: drag.originScrollLeft,
175175
currentScrollLeft: scroll?.scrollLeft ?? drag.originScrollLeft,
176176
pixelsPerSecond: pps,
177+
minStart: clampToHostStart(drag.element, 0),
177178
maxStart: dragMaxStart,
178179
trackOrder,
179180
},
@@ -227,8 +228,8 @@ export function computeDragPreview(
227228
// deliberate vertical lane change from a horizontal drag merely bumped sideways.
228229
desiredTrack: nextMove.track,
229230
insertRow,
230-
snapTime: snap.snapTime,
231-
snapType: snap.snapType,
231+
snapTime: previewStart === snap.start ? snap.snapTime : null,
232+
snapType: previewStart === snap.start ? snap.snapType : null,
232233
};
233234
}
234235

‎packages/studio/src/player/components/timelineEditing.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,7 @@ export interface TimelineMoveInput {
5151
originScrollLeft?: number;
5252
currentScrollLeft?: number;
5353
pixelsPerSecond: number;
54+
minStart?: number;
5455
maxStart: number;
5556
trackOrder: number[];
5657
layerOrder?: TimelineLayerId[];
@@ -127,7 +128,7 @@ export function resolveTimelineMove(
127128
const deltaTrack = Math.round(trackDeltaRaw);
128129
const nextStart = clamp(
129130
roundToCentiseconds(input.start + deltaTime),
130-
0,
131+
input.minStart ?? 0,
131132
Math.max(0, input.maxStart),
132133
);
133134

‎packages/studio/src/player/components/timelineGroupEditing.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -109,7 +109,7 @@ function clampTimelineGroupMoveDelta(
109109
members: readonly TimelineGroupTimingMember[],
110110
): number {
111111
if (members.length === 0) return 0;
112-
const minDelta = Math.max(...members.map((member) => -member.start));
112+
const minDelta = Math.max(...members.map((member) => -(member.start - (member.minStart ?? 0))));
113113
return roundTimelineTime(Math.max(rawDelta, minDelta));
114114
}
115115

‎packages/studio/src/player/components/timelineMultiDragPreview.test.ts‎

Lines changed: 10 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,8 @@ const base = (over: Partial<MultiDragPreviewInput> = {}): MultiDragPreviewInput
1717
...over,
1818
});
1919

20+
const starts = (...values: number[]) => values.map((start) => ({ start }));
21+
2022
describe("isMultiDragActive", () => {
2123
it("is active when a started drag's clip is part of a 2+ selection", () => {
2224
expect(isMultiDragActive(base())).toBe(true);
@@ -94,34 +96,34 @@ describe("multiDragPassengerOffsetPx (rigid: every passenger shares the delta)",
9496

9597
describe("clampGroupMoveDelta (rigid group move)", () => {
9698
it("passes a rightward delta through unchanged (no right wall)", () => {
97-
expect(clampGroupMoveDelta(3, [2, 5, 9])).toBe(3);
98-
expect(clampGroupMoveDelta(1000, [0, 4])).toBe(1000);
99+
expect(clampGroupMoveDelta(3, starts(2, 5, 9))).toBe(3);
100+
expect(clampGroupMoveDelta(1000, starts(0, 4))).toBe(1000);
99101
});
100102

101103
it("passes a leftward delta through when no member would cross 0", () => {
102104
// Leftmost member at 5, moving left by 3 → 2 ≥ 0, so unclamped.
103-
expect(clampGroupMoveDelta(-3, [5, 8, 12])).toBe(-3);
105+
expect(clampGroupMoveDelta(-3, starts(5, 8, 12))).toBe(-3);
104106
});
105107

106108
it("clamps a leftward delta so the leftmost member stops exactly at 0", () => {
107109
// Leftmost at 2 → the furthest left the group can move is -2 (that member → 0).
108110
// A pointer asking for -5 is clamped to -2: the grabbed clip stops with the
109111
// formation instead of out-running it.
110-
expect(clampGroupMoveDelta(-5, [2, 6, 10])).toBe(-2);
112+
expect(clampGroupMoveDelta(-5, starts(2, 6, 10))).toBe(-2);
111113
});
112114

113115
it("is bounded by the MOST-constrained (leftmost) member, not the grabbed one", () => {
114116
// Grabbed clip is at 10; a passenger at 1 is the constraint. Max left = -1.
115-
expect(clampGroupMoveDelta(-8, [10, 1, 4])).toBe(-1);
117+
expect(clampGroupMoveDelta(-8, starts(10, 1, 4))).toBe(-1);
116118
});
117119

118120
it("already-at-0 member forbids any leftward move", () => {
119-
expect(clampGroupMoveDelta(-4, [0, 3, 7])).toBe(0);
121+
expect(clampGroupMoveDelta(-4, starts(0, 3, 7))).toBe(0);
120122
// rightward still allowed
121-
expect(clampGroupMoveDelta(2, [0, 3, 7])).toBe(2);
123+
expect(clampGroupMoveDelta(2, starts(0, 3, 7))).toBe(2);
122124
});
123125

124126
it("returns the raw delta for an empty formation", () => {
125-
expect(clampGroupMoveDelta(-9, [])).toBe(-9);
127+
expect(clampGroupMoveDelta(-9, starts())).toBe(-9);
126128
});
127129
});

‎packages/studio/src/player/components/timelineMultiDragPreview.ts‎

Lines changed: 8 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -97,10 +97,13 @@ export function multiDragPassengerOffsetPx(
9797
* included). Only the lower bound (start ≥ 0) constrains a move; the timeline has
9898
* no fixed right wall (the composition grows on commit).
9999
*/
100-
export function clampGroupMoveDelta(rawDelta: number, memberStarts: readonly number[]): number {
101-
if (memberStarts.length === 0) return rawDelta;
102-
// Leftmost member sets the floor: delta ≥ -min(start) keeps every start ≥ 0.
103-
const minStart = Math.min(...memberStarts);
104-
const minDelta = minStart === 0 ? 0 : -minStart; // avoid -0
100+
export function clampGroupMoveDelta(
101+
rawDelta: number,
102+
members: readonly { start: number; minStart?: number }[],
103+
): number {
104+
if (members.length === 0) return rawDelta;
105+
// The member nearest its own floor bounds the move: delta ≥ -(start - minStart) for each.
106+
const room = Math.min(...members.map((m) => m.start - (m.minStart ?? 0)));
107+
const minDelta = room === 0 ? 0 : -room; // avoid -0
105108
return rawDelta < minDelta ? minDelta : rawDelta;
106109
}

‎packages/studio/src/player/store/timelineElement.ts‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -94,18 +94,21 @@ export interface TimelineElement {
9494
expandedHostKey?: string;
9595
}
9696

97-
type RowClock = Pick<TimelineElement, "parentCompositionStart" | "authoredStartIsMasterTime">;
97+
type RowClock = Pick<
98+
TimelineElement,
99+
"start" | "parentCompositionStart" | "authoredStartIsMasterTime"
100+
>;
98101
const authoredOffset = (element: RowClock) =>
99102
element.authoredStartIsMasterTime ? 0 : (element.parentCompositionStart ?? 0);
100103

101-
/** The earliest master start this row can be written at: its host's start. */
104+
/** The earliest master start this row can take: its host's start, or its own if already earlier. */
102105
export function clampToHostStart(element: RowClock, masterTime: number): number {
103-
return Math.max(authoredOffset(element), masterTime);
106+
return Math.max(Math.min(authoredOffset(element), element.start), masterTime);
104107
}
105108

106109
/** A master-time position on this row, as the `data-start` its source file stores. */
107110
export function toAuthoredStart(element: RowClock, masterTime: number): number {
108-
return clampToHostStart(element, masterTime) - authoredOffset(element);
111+
return Math.max(0, clampToHostStart(element, masterTime) - authoredOffset(element));
109112
}
110113

111114
/** A master-time position on the clock this row's tweens run on. */

0 commit comments

Comments
 (0)