@hyperframes/studio 0.6.90 → 0.6.92

package/src/utils/rdpSimplify.ts

@@ -97,7 +97,7 @@ function simplifyTimeSeries(
 export function simplifyGestureSamples(
   samples: Array<{ time: number; properties: Record<string, number> }>,
   totalDuration: number,
-  epsilon: number,
+  epsilon: number | ((key: string) => number),
 ): Map<number, Record<string, number>> {
   if (samples.length === 0) return new Map();
   if (totalDuration <= 0) return new Map();
@@ -120,7 +120,8 @@ export function simplifyGestureSamples(
         series.push({ time: s.time, value: s.properties[key] });
       }
     }
-    const simplified = simplifyTimeSeries(series, epsilon);
+    const keyEpsilon = typeof epsilon === "function" ? epsilon(key) : epsilon;
+    const simplified = simplifyTimeSeries(series, keyEpsilon);
     for (const pt of simplified) {
       survivingTimes.add(pt.time);
     }

package/src/utils/timelineElementSplit.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from "vitest";
+import { SPLIT_BOUNDARY_EPSILON_S, isSplitTimeWithinBounds } from "./timelineElementSplit";
+
+describe("isSplitTimeWithinBounds", () => {
+  const start = 1;
+  const duration = 4;
+  const end = start + duration;
+
+  it("accepts the exact lower clamp boundary", () => {
+    // The timeline canvas clamps an edge click to exactly
+    // start + SPLIT_BOUNDARY_EPSILON_S, so that value must be splittable.
+    expect(isSplitTimeWithinBounds(start + SPLIT_BOUNDARY_EPSILON_S, start, duration)).toBe(true);
+  });
+
+  it("accepts the exact upper clamp boundary", () => {
+    expect(
+      isSplitTimeWithinBounds(start + duration - SPLIT_BOUNDARY_EPSILON_S, start, duration),
+    ).toBe(true);
+  });
+
+  it("accepts an interior split time", () => {
+    expect(isSplitTimeWithinBounds(3, start, duration)).toBe(true);
+  });
+
+  it("rejects times at or outside the clip edges", () => {
+    expect(isSplitTimeWithinBounds(start, start, duration)).toBe(false);
+    expect(isSplitTimeWithinBounds(end, start, duration)).toBe(false);
+    expect(isSplitTimeWithinBounds(start - 1, start, duration)).toBe(false);
+    expect(isSplitTimeWithinBounds(end + 1, start, duration)).toBe(false);
+  });
+
+  it("rejects times inside the epsilon margins", () => {
+    expect(isSplitTimeWithinBounds(start + SPLIT_BOUNDARY_EPSILON_S / 2, start, duration)).toBe(
+      false,
+    );
+    expect(isSplitTimeWithinBounds(end - SPLIT_BOUNDARY_EPSILON_S / 2, start, duration)).toBe(
+      false,
+    );
+  });
+
+  it("rejects every time on a clip shorter than two epsilons", () => {
+    // Math.max(min, Math.min(max, t)) collapses to min when the clip is too
+    // short for the clamp range; that collapsed value must still be rejected.
+    const shortDuration = SPLIT_BOUNDARY_EPSILON_S;
+    expect(isSplitTimeWithinBounds(start + SPLIT_BOUNDARY_EPSILON_S, start, shortDuration)).toBe(
+      false,
+    );
+    expect(isSplitTimeWithinBounds(start + shortDuration / 2, start, shortDuration)).toBe(false);
+  });
+});

package/src/utils/timelineElementSplit.ts

@@ -0,0 +1,32 @@
+import type { TimelineElement } from "../player/store/playerStore";
+
+export { buildPatchTarget, readFileContent } from "../hooks/timelineEditingHelpers";
+
+/** Minimum distance (seconds) from clip boundaries to allow a split. */
+export const SPLIT_BOUNDARY_EPSILON_S = 0.03;
+
+/**
+ * True when splitTime leaves at least SPLIT_BOUNDARY_EPSILON_S on both sides
+ * of the cut. Inclusive at the epsilon offsets: the timeline canvas clamps
+ * edge clicks to exactly start/end ± epsilon, so the clamped value must pass.
+ */
+export function isSplitTimeWithinBounds(
+  splitTime: number,
+  clipStart: number,
+  clipDuration: number,
+): boolean {
+  return (
+    splitTime >= clipStart + SPLIT_BOUNDARY_EPSILON_S &&
+    splitTime <= clipStart + clipDuration - SPLIT_BOUNDARY_EPSILON_S
+  );
+}
+
+export function canSplitElement(el: TimelineElement): boolean {
+  return (
+    !el.timelineLocked &&
+    el.timingSource !== "implicit" &&
+    !el.compositionSrc &&
+    !!el.duration &&
+    Number.isFinite(el.duration)
+  );
+}