Open source CapCut alternative.
TypeScript
feat(site): trim a whole multi-selection from one handle
David Le66da5d77649b
diff --git a/site/src/cut/lib/laneTracks.test.ts b/site/src/cut/lib/laneTracks.test.tsindex d66d92cb..978030d9 100644--- a/site/src/cut/lib/laneTracks.test.ts+++ b/site/src/cut/lib/laneTracks.test.ts@@ -1,5 +1,5 @@import { beforeEach, describe, expect, test } from "bun:test";-import { commitRow, landOnRow, NEW_ROW_PX, partAround, resolveRow } from "./laneTracks";+import { commitRow, groupTrimEdges, landOnRow, NEW_ROW_PX, partAround, resolveRow } from "./laneTracks";import { clipLen, useEditor } from "./store";import { emptySubtitles } from "./types";import type { AudioClip, VideoClip } from "./types";@@ -251,3 +251,25 @@ describe("a cross-row move keeps the lane sound", () => {expect(clipById(resident.id).start).toBeCloseTo(3.2);});});++describe("groupTrimEdges", () => {+ // Three right edges at 10, 12 and 8, each with its own room.+ const edges = [+ { at: 10, lo: 6, hi: 14 },+ { at: 12, lo: 9, hi: 13 },+ { at: 8, lo: 4, hi: 20 },+ ];++ test("every edge travels with the grabbed one", () => {+ expect(groupTrimEdges(edges, 0, 2)).toEqual({ travel: 2, at: [12, 13, 10] });+ });++ test("the grabbed edge's own room holds the whole travel", () => {+ expect(groupTrimEdges(edges, 0, 9)).toEqual({ travel: 4, at: [14, 13, 12] });+ expect(groupTrimEdges(edges, 0, -9)).toEqual({ travel: -4, at: [6, 9, 4] });+ });++ test("a member out of room stops at its wall while the rest keep going", () => {+ expect(groupTrimEdges(edges, 2, 5)).toEqual({ travel: 5, at: [14, 13, 13] });+ });+});diff --git a/site/src/cut/lib/laneTracks.ts b/site/src/cut/lib/laneTracks.tsindex 83b5e5ea..272a92a5 100644--- a/site/src/cut/lib/laneTracks.ts+++ b/site/src/cut/lib/laneTracks.ts@@ -560,6 +560,41 @@ const memberOf = (s: S, sel: NonNullable<Selection>): GroupMember | null => {return null;};+/** The set a grab on `id` carries when the item sits in a multi-selection:+ * every selected lane item, and the unselected peers of any grouped overlay+ * among them, so a group never tears apart. Null when the grab is on its+ * own. */+function selectedMembers(+ s: S,+ kind: LaneKind,+ id: string+): { grabbed: GroupMember; members: GroupMember[] } | null {+ const selKind = laneSelectionKind(kind);+ if (+ s.multiSelection.length < 2 ||+ !s.multiSelection.some((m) => m?.kind === selKind && m.id === id)+ )+ return null;+ const seen = new Set<string>();+ const members: GroupMember[] = [];+ const admit = (m: GroupMember | null) => {+ if (!m) return;+ const key = `${m.kind}:${m.id}`;+ if (seen.has(key)) return;+ seen.add(key);+ members.push(m);+ };+ for (const sel of s.multiSelection) if (sel) admit(memberOf(s, sel));+ for (const m of [...members]) {+ const gid = m.kind === "overlay" ? (m.raw as Overlay).groupId : undefined;+ if (!gid) continue;+ for (const peer of s.overlays.filter((o) => o.groupId === gid))+ admit(memberOf(s, { kind: "overlay", id: peer.id }));+ }+ const grabbed = members.find((m) => m.kind === kind && m.id === id) ?? members.find((m) => m.id === id);+ return grabbed && members.length > 1 ? { grabbed, members } : null;+}+/*** Drag a whole multi-selection as one rigid set: every member shifts by the* same delta, so the arrangement — a title over its clip, a sound effect on@@ -846,34 +881,11 @@ export function startLaneMove(e: React.PointerEvent, kind: LaneKind, id: string,return;}// A grab on one member of a multi-selection drags the whole selection as a- // rigid set. Grouped overlays ride too: unselected peers sharing a groupId- // join the set, so a group never tears apart under a multi-drag.- const selKind = laneSelectionKind(kind);- if (- s.multiSelection.length > 1 &&- s.multiSelection.some((m) => m?.kind === selKind && m.id === id)- ) {- const seen = new Set<string>();- const members: GroupMember[] = [];- const admit = (m: GroupMember | null) => {- if (!m) return;- const key = `${m.kind}:${m.id}`;- if (seen.has(key)) return;- seen.add(key);- members.push(m);- };- for (const sel of s.multiSelection) if (sel) admit(memberOf(s, sel));- for (const m of [...members]) {- const gid = m.kind === "overlay" ? (m.raw as Overlay).groupId : undefined;- if (!gid) continue;- for (const peer of s.overlays.filter((o) => o.groupId === gid))- admit(memberOf(s, { kind: "overlay", id: peer.id }));- }- const grabbed = members.find((m) => m.kind === kind && m.id === id) ?? members.find((m) => m.id === id);- if (grabbed && members.length > 1) {- startGroupMove(e, grabbed, members, ui);- return;- }+ // rigid set.+ const group = selectedMembers(s, kind, id);+ if (group) {+ startGroupMove(e, group.grabbed, group.members, ui);+ return;}const ad = ADAPTERS[kind];const raw0 = ad.raws(s).find((r) => ad.view(r).id === id);@@ -1182,6 +1194,13 @@ export function startLaneTrim(const bar = (e.currentTarget as HTMLElement).parentElement;const s = useEditor.getState();if (s.readOnly) return;+ // A handle on one member of a multi-selection trims the same edge of+ // every member together.+ const group = selectedMembers(s, kind, id);+ if (group) {+ startGroupTrim(e, group.grabbed, group.members, side, ui);+ return;+ }const ad = ADAPTERS[kind];const raw0 = ad.raws(s).find((r) => ad.view(r).id === id);if (!raw0) return;@@ -1443,3 +1462,101 @@ export function startLaneTrim(},});}++/** One edge of every member of a group trim. The grabbed edge's travel,+ * held within its own room, is the travel every member's edge takes; a+ * member with less room stops at its own wall while the rest keep going, so+ * the arrangement holds wherever it can. */+export function groupTrimEdges(+ edges: { at: number; lo: number; hi: number }[],+ grabbed: number,+ travel: number+): { travel: number; at: number[] } {+ const clamp = (e: { at: number; lo: number; hi: number }, t: number) =>+ Math.min(e.hi, Math.max(e.lo, e.at + t));+ const g = edges[grabbed];+ const held = clamp(g, travel) - g.at;+ return { travel: held, at: edges.map((e) => clamp(e, held)) };+}++/**+ * Trim the same edge of a whole multi-selection with one handle: every+ * member's edge moves with the grabbed one, snapping where the grabbed edge+ * snaps. Each member keeps to its own room — the item's minimum length, its+ * source bound, and the nearest item on its lane — so the document stays+ * overlap-free at every instant and nothing else moves. One undo step.+ */+function startGroupTrim(+ e: React.PointerEvent,+ grabbed: GroupMember,+ members: GroupMember[],+ side: "l" | "r",+ ui: LaneTrimUI+) {+ const s = useEditor.getState();+ // The grab keeps the multi-selection and makes the grabbed item primary.+ useEditor.setState({+ selection: { kind: laneSelectionKind(grabbed.kind), id: grabbed.id },+ selectedKey: null,+ });+ if (s.playing) s.setPlaying(false);+ s.pushHistory();+ const memberKeys = new Set(members.map((m) => `${m.kind}:${m.id}`));+ const targets = snapTargetsExcluding(s, memberKeys, true);+ const tol = SNAP_PX / ui.pps;+ // Each member's edge and its room: the far edge less the minimum length+ // on one side, the source bound or the nearest item on the lane on the+ // other. Members count as neighbors too, since a trim leaves every other+ // edge where it is.+ const edges = members.map((m) => {+ const ad = ADAPTERS[m.kind];+ const lane = ad+ .raws(s)+ .map((r) => ad.view(r))+ .filter((v) => v.id !== m.id && v.lane === m.lane);+ const end = m.start + m.len;+ if (side === "l") {+ const prevEnd = lane+ .filter((v) => v.start + v.len <= m.start + 1e-6)+ .reduce((x, v) => Math.max(x, v.start + v.len), 0);+ return { at: m.start, lo: Math.max(prevEnd, ad.leftFloor(s, m.raw)), hi: end - ad.minLen };+ }+ const nextStart = lane+ .filter((v) => v.start >= end - 1e-6)+ .reduce((x, v) => Math.min(x, v.start), Infinity);+ return { at: end, lo: m.start + ad.minLen, hi: Math.min(nextStart, m.start + ad.maxLen(s, m.raw)) };+ });+ const gi = members.indexOf(grabbed);+ const clips0 = members.some((m) => m.kind === "video") ? s.clips : null;+ const apply = (at: number[]) => {+ const buckets = new Map<LaneKind, Patch<LaneRaw>[]>();+ members.forEach((m, i) => {+ const ad = ADAPTERS[m.kind];+ const list = buckets.get(m.kind) ?? [];+ list.push(side === "l" ? ad.trimLeftPatch(m.raw, at[i]) : ad.trimRightPatch(m.raw, at[i]));+ buckets.set(m.kind, list);+ });+ for (const [k, patches] of buckets) ADAPTERS[k].apply(patches);+ };+ startDrag(e, {+ onMove: (dx, _dy, ev) => {+ settleSnapBack();+ const g = edges[gi];+ let { travel, at } = groupTrimEdges(edges, gi, dx / ui.pps);+ const hit = snapHeldOff(ev) ? null : nearestSnap(g.at + travel, targets, tol);+ if (hit !== null && hit >= g.lo && hit <= g.hi) {+ ({ travel, at } = groupTrimEdges(edges, gi, hit - g.at));+ ui.onSnap(side === "l" ? leftGuide(hit, ui.pps) : rightGuide(hit, ui.pps));+ } else ui.onSnap(null);+ apply(at);+ },+ onUp: () => {+ ui.onSnap(null);+ // Transition bars re-seat onto the cuts the trim moved.+ if (!clips0) return;+ const st = useEditor.getState();+ if (st.transitions.length)+ useEditor.setState({ transitions: reanchorTransitions(clips0, st.clips, st.transitions) });+ },+ });+}