Skip to content

Commit 0a036dc

Browse files
committed
fix(studio-server): previewAdapter getElementTimings ignores relative data-start refs
Same bug class as the SDK's getElementTimings fix (#2092): data-start can be a relative-reference expression ("intro", "intro + 2"), not just an absolute number. The old code did a raw parseFloat on it, so any reference silently resolved to undefined instead of an actual time. Also: this function never read data-duration at all (only data-start/data-end literally), so a reference to a duration-authored (not end-authored) clip was unresolvable regardless of the parseFloat bug — resolving a reference needs the target's END, which for a duration-authored clip requires start+duration. Both fixed together via the shared parseStartExpression grammar parser (@hyperframes/core/runtime/start-expression), with the same cycle-guard pattern as the SDK fix. Reference resolution against other elements is scoped to this file's existing findById (bare data-hf-id lookup). 6 new tests: duration-based end resolution, relative reference (with and without offset), missing target, and a mutual-cycle termination check.
1 parent 5a48321 commit 0a036dc

2 files changed

Lines changed: 112 additions & 8 deletions

File tree

‎packages/studio-server/src/helpers/previewAdapter.test.ts‎

Lines changed: 55 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -253,5 +253,60 @@ describe("T10 — PreviewAdapter contract (spec for R7)", () => {
253253
expect(timings["hf-notimed"].start).toBeUndefined();
254254
expect(timings["hf-notimed"].end).toBeUndefined();
255255
});
256+
257+
it("resolves data-duration into end when there is no data-end (never worked before)", () => {
258+
make("div", { "data-hf-id": "hf-t1", "data-start": "1", "data-duration": "3" });
259+
const adapter = adapterWith(() => null);
260+
const timings = adapter.getElementTimings();
261+
expect(timings["hf-t1"]).toEqual({ start: 1, end: 4 });
262+
});
263+
264+
it("resolves a relative data-start reference ('ref + offset') instead of returning undefined", () => {
265+
make("div", { "data-hf-id": "hf-intro", "data-start": "1", "data-duration": "3" });
266+
make("div", { "data-hf-id": "hf-outro", "data-start": "hf-intro + 2", "data-duration": "1" });
267+
const adapter = adapterWith(() => null);
268+
const timings = adapter.getElementTimings();
269+
// hf-intro ends at 4 (1 + 3); hf-outro starts 2s after that = 6.
270+
expect(timings["hf-outro"]).toEqual({ start: 6, end: 7 });
271+
});
272+
273+
it("resolves a bare reference (no offset) to the referenced element's end", () => {
274+
make("div", { "data-hf-id": "hf-intro", "data-start": "1", "data-end": "4" });
275+
make("div", {
276+
"data-hf-id": "hf-right-after",
277+
"data-start": "hf-intro",
278+
"data-duration": "1",
279+
});
280+
const adapter = adapterWith(() => null);
281+
const timings = adapter.getElementTimings();
282+
expect(timings["hf-right-after"]).toEqual({ start: 4, end: 5 });
283+
});
284+
285+
it("returns undefined start (not NaN) when the reference target doesn't exist", () => {
286+
make("div", {
287+
"data-hf-id": "hf-orphan",
288+
"data-start": "hf-nonexistent + 5",
289+
"data-duration": "2",
290+
});
291+
const adapter = adapterWith(() => null);
292+
const timings = adapter.getElementTimings();
293+
expect(timings["hf-orphan"].start).toBeUndefined();
294+
});
295+
296+
it("terminates (not an infinite loop) on a mutual A <-> B reference cycle", () => {
297+
make("div", { "data-hf-id": "hf-a", "data-start": "hf-b", "data-duration": "2" });
298+
make("div", { "data-hf-id": "hf-b", "data-start": "hf-a", "data-duration": "3" });
299+
const adapter = adapterWith(() => null);
300+
// Unlike the SDK's static resolver (which fails safe to 0 and lets real
301+
// durations propagate outward into arbitrary-but-finite numbers), this
302+
// simpler resolver has no 0-fallback — an unresolvable `sv` poisons
303+
// `resolveEnd` (it requires a finite start to add duration), so the whole
304+
// cycle correctly reports "no defined timing" rather than a fabricated
305+
// number. The guard's job is just termination; this call must return
306+
// synchronously instead of hanging.
307+
const timings = adapter.getElementTimings();
308+
expect(timings["hf-a"].start).toBeUndefined();
309+
expect(timings["hf-b"].start).toBeUndefined();
310+
});
256311
});
257312
});

‎packages/studio-server/src/helpers/previewAdapter.ts‎

Lines changed: 57 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@ import {
55
STUDIO_HEIGHT_PROP,
66
STUDIO_MANUAL_EDIT_GESTURE_ATTR,
77
} from "./draftMarkers.js";
8+
import { parseStartExpression } from "@hyperframes/core/runtime/start-expression";
89

910
export type DraftPayload =
1011
| { type: "move"; hfId: string; dx: number; dy: number }
@@ -138,18 +139,66 @@ export function createPreviewAdapter(
138139
},
139140

140141
getElementTimings() {
142+
// data-start can be a relative-reference expression ("intro", "intro + 2" —
143+
// parseStartExpression's grammar), not just an absolute number. A raw
144+
// parseFloat on it (the old behavior) silently resolves any reference to
145+
// undefined. Resolve references recursively against the target's own
146+
// resolved end (data-end, or data-start + data-duration when the target
147+
// has no data-end) — this function never read data-duration before either,
148+
// so a reference to a duration-authored (not end-authored) clip used to be
149+
// unresolvable regardless of the parseFloat bug.
150+
const startCache = new Map<Element, number | undefined>();
151+
const visiting = new Set<Element>();
152+
153+
const resolveEnd = (el: Element): number | undefined => {
154+
const endAttr = el.getAttribute("data-end");
155+
if (endAttr !== null) {
156+
const ev = parseFloat(endAttr);
157+
if (Number.isFinite(ev)) return ev;
158+
}
159+
const durationAttr = el.getAttribute("data-duration");
160+
const dv = durationAttr !== null ? parseFloat(durationAttr) : NaN;
161+
const sv = resolveStart(el);
162+
if (Number.isFinite(dv) && sv !== undefined) return sv + dv;
163+
return undefined;
164+
};
165+
166+
// Split out of resolveStart so its own branching stays low — mirrors the
167+
// SDK's getElementTimings resolver split (resolveReferenceStart).
168+
const resolveReferenceStart = (refId: string, offset: number): number | undefined => {
169+
const target = findById(refId);
170+
const targetEnd = target ? resolveEnd(target) : undefined;
171+
return targetEnd !== undefined ? Math.max(0, targetEnd + offset) : undefined;
172+
};
173+
174+
const resolveStart = (el: Element): number | undefined => {
175+
if (startCache.has(el)) return startCache.get(el);
176+
if (visiting.has(el)) return undefined; // reference cycle — fail safe, don't loop
177+
visiting.add(el);
178+
let resolved: number | undefined;
179+
try {
180+
const startStr = el.getAttribute("data-start");
181+
const expr = parseStartExpression(startStr);
182+
if (expr?.kind === "reference") {
183+
resolved = resolveReferenceStart(expr.refId, expr.offset);
184+
} else if (expr?.kind === "absolute") {
185+
resolved = expr.value;
186+
} else {
187+
const sv = startStr !== null ? parseFloat(startStr) : NaN;
188+
resolved = Number.isFinite(sv) ? sv : undefined;
189+
}
190+
} finally {
191+
visiting.delete(el);
192+
}
193+
startCache.set(el, resolved);
194+
return resolved;
195+
};
196+
141197
const result: Record<string, { start?: number; end?: number }> = {};
142198
for (const el of doc.querySelectorAll("[data-hf-id]")) {
143199
const hfId = el.getAttribute("data-hf-id");
144200
if (!hfId) continue;
145-
const s = el.getAttribute("data-start");
146-
const e = el.getAttribute("data-end");
147-
const sv = s !== null ? parseFloat(s) : NaN;
148-
const ev = e !== null ? parseFloat(e) : NaN;
149-
result[hfId] = {
150-
start: Number.isFinite(sv) ? sv : undefined,
151-
end: Number.isFinite(ev) ? ev : undefined,
152-
};
201+
result[hfId] = { start: resolveStart(el), end: resolveEnd(el) };
153202
}
154203
return result;
155204
},

0 commit comments

Comments
 (0)