fix(studio): a sealed preview moves and saves a layer its animation moves (#8105)

* test(studio): a sealed preview moves and saves a layer its animation moves

* fix(studio): a sealed preview moves and saves a layer its animation moves

* test(studio): a sealed drag of a moving layer saves nothing when the preview's tweens can't be read

* fix(studio): a sealed drag of a moving layer saves nothing without the preview's tweens

* refactor(studio): keep the drag stamp's writer beside its reader

* style(studio): keep the drag stamp reader's comment on the reader
This commit is contained in:
Miguel Ángel
2026-11-17 22:02:42 +00:00
committed by GitHub
parent d872853874
commit 7a9d78e69a
12 changed files with 320 additions and 58 deletions
@@ -35,7 +35,6 @@ import {
type UseDomEditOverlayGesturesOptions,
} from "./domEditOverlayGestures";
import { collectSnapContext, buildExcludeElements, type SnapContext } from "./snapTargetCollection";
import { MOVING_LAYER_UNREADABLE } from "./plainTranslate";
import type { PreviewGestureStart } from "./previewGestureStartRead";
import { editsPlainCss } from "../../hooks/gsapRuntimeKeyframes";
import { logResize, resetResizeMoveLog } from "../../utils/resizeDebug";
@@ -68,14 +67,6 @@ export function startGroupDrag(
notifyBlockedPress(e, opts, blockedSelection);
return false;
}
const moving = items.find((item) => item.start?.gsap?.moving)?.selection;
if (moving) {
e.preventDefault();
e.stopPropagation();
opts.onBlockedMoveRef.current(moving, MOVING_LAYER_UNREADABLE);
return false;
}
opts.onManualDragStartRef.current?.();
const dragItems = filterNestedDomEditGroupItems(items);
const members: ManualOffsetDragMember[] = [];
@@ -212,11 +203,6 @@ export function startGesture(
let pathOffsetMember: ManualOffsetDragMember | undefined;
if (kind === "drag") {
if (start?.gsap?.moving) {
opts.onBlockedMoveRef.current(sel, MOVING_LAYER_UNREADABLE);
e.preventDefault();
return false;
}
opts.onManualDragStartRef.current?.();
const result = createManualOffsetDragMember({
key: selectionCacheKey(sel),
@@ -6,11 +6,8 @@ import {
} from "./manualEdits";
import { readTranslatePx } from "./plainTranslate";
import { drawPreviewDraft } from "./previewDrafts";
import {
getOffsetDragGsap,
stampGestureBase,
type ManualOffsetDragMember,
} from "./manualOffsetDrag";
import { getOffsetDragGsap, type ManualOffsetDragMember } from "./manualOffsetDrag";
import { stampGestureBase } from "../../hooks/draggedGsapPosition";
import type { StudioEditRevert } from "../../utils/studioPendingEdits";
interface MemberPosition {
@@ -49,7 +46,7 @@ function showMemberPosition(member: ManualOffsetDragMember, position: MemberPosi
if (position.gsap) getOffsetDragGsap(member.element)?.set(member.element, { ...position.gsap });
// The restore drops the gesture's base stamps; its save still reads them.
if (!member.plainTranslate)
stampGestureBase(member.element, member.initialOffset, member.baseGsap);
stampGestureBase(member.element, member.initialOffset, member.baseGsap, !!member.moving);
}
function redrawMemberOnFrame(member: ManualOffsetDragMember): void {
@@ -0,0 +1,267 @@
// @vitest-environment happy-dom
import { gsap } from "gsap";
import { parseGsapScriptAcorn } from "@hyperframes/parsers/gsap-parser-acorn";
import { afterEach, expect, it, vi } from "vitest";
// The frame's real runtime agent, serving the opaque frame from this document.
import { installMarkedEditingAgent } from "../../../../core/src/runtime/editingAgent.test-helpers";
import { makeSelection } from "../../hooks/domSelectionTestHarness";
import { freezeDragStamp } from "../../hooks/draggedGsapPosition";
import { settleGsapSnapshot } from "../../hooks/gsapFrameSnapshot";
import { tryGsapDragIntercept } from "../../hooks/gsapRuntimeBridge";
import { watchPreviewFrame } from "../../player/lib/bridgePlayback";
import { describePreviewElements, queryPreviewElements } from "../../player/lib/previewElements";
import { detachedFakeIframe } from "../../player/hooks/timelinePlayerTestHarness";
import { usePlayerStore } from "../../player/store/playerStore";
import type { UseDomEditOverlayGesturesOptions } from "./domEditOverlayGestures";
import { startGesture } from "./domEditOverlayStartGesture";
import {
applyManualOffsetDragCommit,
applyManualOffsetDragDraft,
endManualOffsetDragMembers,
} from "./manualOffsetDrag";
import { measurePreviewGestureStart } from "./previewGestureStartRead";
import { standInFor } from "./previewSelection";
const timeline = (tweens: string) => `var tl = gsap.timeline({ paused: true });
${tweens}
window.__timelines["main"] = tl;`;
const MOVES_BOX = `tl.to("#box", { x: 200, y: 80, duration: 1, ease: "none" }, 0);`;
const SCRIPT = timeline(MOVES_BOX);
// Split-text output: more tween targets than the frame's GSAP snapshot carries, so Studio gets none.
const SPLIT_TEXT = `tl.to(".c", { opacity: 0, stagger: 0.001 }, 0);`;
const SPANS = '<span class="c"></span>'.repeat(600);
/** Frame px of a translate the draft drew, e.g. "calc(0px + 20px) calc(0px + 0px)". */
const drawnTranslate = (box: HTMLElement) =>
box.style.translate
.split(/ (?![^(]*\))/)
.map((axis) =>
[...axis.matchAll(/-?[\d.]+px/g)].reduce((sum, [px]) => sum + Number.parseFloat(px), 0),
);
/** Where the box is drawn in the frame: the translate GSAP's transform starts with, plus any translate on top. */
function drawnAt(box: HTMLElement) {
const [tx = 0, ty = 0] = drawnTranslate(box);
const [gx = 0, gy = 0] = (/translate(?:3d)?\(([^)]*)\)/.exec(box.style.transform)?.[1] ?? "")
.split(",")
.map((part) => Number.parseFloat(part) || 0);
return { x: gx + tx, y: gy + ty };
}
const mainTimeline = () =>
(window as unknown as { __timelines?: Record<string, gsap.core.Timeline> }).__timelines?.main;
const closers: Array<() => void> = [];
function mount(script: string, extra = "") {
document.body.innerHTML = `<div data-composition-id="main" data-width="1920" data-height="1080"><div id="box"></div>${extra}</div>`;
const box = document.getElementById("box")!;
box.getBoundingClientRect = () => {
const { x, y } = drawnAt(box);
return {
x: 300 + x,
y: 200 + y,
width: 100,
height: 50,
left: 300 + x,
top: 200 + y,
} as DOMRect;
};
Object.defineProperty(box, "offsetWidth", { value: 100 });
Object.defineProperty(box, "offsetHeight", { value: 50 });
Object.assign(window, { gsap, __timelines: {} });
new Function("gsap", "window", script)(gsap, window);
// The preview paused half way through the tween: GSAP has the box at 100, 40.
mainTimeline()?.seek(0.5);
usePlayerStore.setState({ currentTime: 0.5, isPlaying: false, autoKeyframeEnabled: true });
}
afterEach(() => {
closers.splice(0).forEach((close) => close());
mainTimeline()?.kill();
document.body.innerHTML = "";
for (const name of ["gsap", "__timelines"]) Reflect.deleteProperty(window, name);
usePlayerStore.setState({ currentTime: 0, isPlaying: false });
});
function sized<T extends Element>(element: T, [x, y, width, height]: number[]): T {
element.getBoundingClientRect = () =>
({ x, y, width, height, left: x, top: y, right: x + width, bottom: y + height }) as DOMRect;
return element;
}
/** A frame Studio cannot read, whose runtime is the real editing agent over this document. */
function opaqueFrame() {
const frame: Record<string, unknown> = {};
const iframe = sized(detachedFakeIframe(frame), [100, 50, 960, 540]) as HTMLIFrameElement;
Object.defineProperty(iframe, "contentDocument", { value: null });
Object.defineProperty(frame, "document", {
get: () => {
throw new DOMException("blocked", "SecurityError");
},
});
const parent = {
postMessage: (data: unknown, _origin: string, ports: MessagePort[]) =>
window.dispatchEvent(
new MessageEvent("message", { source: frame as unknown as Window, data, ports }),
),
} as unknown as Window;
const agent = installMarkedEditingAgent(parent);
frame.postMessage = (data: unknown) =>
window.dispatchEvent(new MessageEvent("message", { source: parent, data }));
closers.push(() => agent.dispose());
watchPreviewFrame(iframe);
window.dispatchEvent(
new MessageEvent("message", {
source: frame as unknown as Window,
origin: window.location.origin,
data: { source: "hf-preview", type: "stage-size", width: 1920, height: 1080 },
}),
);
return iframe;
}
function gestureOpts(iframe: HTMLIFrameElement) {
const ref = <T>(current: T) => ({ current });
const overlayEl = sized(document.createElement("div"), [20, 10, 1200, 800]);
return {
selectionRef: ref(null),
overlayRectRef: ref(null),
boxRef: ref(document.createElement("div")),
overlayRef: ref(overlayEl),
iframeRef: ref(iframe),
gestureRef: ref(null),
groupGestureRef: ref(null),
groupOverlayItemsRef: ref([]),
rafPausedRef: ref(false),
onManualDragStartRef: ref(vi.fn()),
onBlockedMoveRef: ref(vi.fn()),
} as unknown as UseDomEditOverlayGesturesOptions;
}
const press = () =>
({
clientX: 10,
clientY: 10,
pointerId: 1,
button: 0,
preventDefault() {},
stopPropagation() {},
currentTarget: { setPointerCapture() {} },
}) as unknown as React.PointerEvent<HTMLElement>;
/** Presses the box on a sealed frame, drags it 10 page px right and lets go, as the overlay does. */
async function dragBoxOnSealedFrame(
script: string,
beforePress?: (iframe: HTMLIFrameElement) => void,
) {
const box = document.getElementById("box")!;
const iframe = opaqueFrame();
beforePress?.(iframe);
const handle = (await queryPreviewElements(iframe, "#box"))!.matches[0]!.handle;
const standIn = standInFor(iframe, (await describePreviewElements(iframe, [handle]))![0]!);
const selection = { ...makeSelection("box", standIn), id: "box", handle };
const opts = gestureOpts(iframe);
const read = await measurePreviewGestureStart(iframe, opts.overlayRef.current!, [handle]);
const { rect, start } = read!.elements[0]!;
const started = startGesture("drag", press(), opts, { selection, rect, start, snap: read!.snap });
expect(opts.onBlockedMoveRef.current).not.toHaveBeenCalled();
const member = opts.gestureRef.current!.pathOffsetMember!;
// A page px is two frame px: the frame shows 1920 px in 960.
applyManualOffsetDragDraft(member, 10, 0);
await vi.waitFor(() => expect(drawnAt(box)).toEqual({ x: 120, y: 40 }));
const offset = applyManualOffsetDragCommit(member, 10, 0);
const commit = vi.fn(async () => undefined);
const [anim] = parseGsapScriptAcorn(script).animations;
const outcome = await tryGsapDragIntercept(
selection,
offset,
[anim!],
iframe,
commit,
undefined,
{
stamp: freezeDragStamp(standIn),
},
);
endManualOffsetDragMembers([member]);
return { started, start, anim: anim!, outcome, commit };
}
// fails without the fix: a sealed preview refused to drag a layer its animation moves.
it("drags a layer its tween moves in a sealed preview: it moves live and saves a keyframe there", async () => {
mount(SCRIPT);
const { started, start, anim, outcome, commit } = await dragBoxOnSealedFrame(SCRIPT);
expect(start.gsap).toEqual({ x: 100, y: 40, moving: true });
expect(started).toBe(true);
expect(outcome).toEqual({ status: "persisted" });
expect(commit).toHaveBeenCalledTimes(1);
// The keyframe a same-origin preview writes for the same move: GSAP's 100, 40 plus the drag's 20.
expect(commit.mock.calls[0]![1]).toEqual({
type: "replace-with-keyframes",
animationId: anim.id,
targetSelector: "#box",
position: 0,
duration: 1,
keyframes: [
{ percentage: 50, properties: { x: 120, y: 40 } },
{ percentage: 100, properties: { x: 200, y: 80 } },
],
easeEach: "none",
});
});
it("saves the keyframe of a drag pressed right after two quick seeks", async () => {
mount(SCRIPT);
const seek = (time: number) => {
mainTimeline()?.seek(time);
usePlayerStore.setState({ currentTime: time });
};
const { outcome, commit } = await dragBoxOnSealedFrame(SCRIPT, (iframe) => {
seek(0.3);
void settleGsapSnapshot(iframe);
seek(0.4);
seek(0.5);
});
expect(outcome).toEqual({ status: "persisted" });
expect(commit.mock.calls.map(([, mutation]) => mutation)).toMatchObject([
{
type: "replace-with-keyframes",
keyframes: [{ percentage: 50, properties: { x: 120, y: 40 } }, {}],
},
]);
});
it("saves nothing for a moving layer when the sealed preview's tweens can't be read", async () => {
const script = timeline(`${MOVES_BOX}\n${SPLIT_TEXT}`);
mount(script, SPANS);
const { start, outcome, commit } = await dragBoxOnSealedFrame(script);
expect(start.gsap).toEqual({ x: 100, y: 40, moving: true });
// Routed without the frame's tweens, the move would save a `set` that pins the layer.
expect(outcome).toEqual({
status: "blocked",
reason: "source-uneditable",
detail: "frame-tweens-unreadable",
});
expect(commit).not.toHaveBeenCalled();
});
it("still saves a layer GSAP only holds when the sealed preview's tweens can't be read", async () => {
const script = timeline(`tl.set("#box", { x: 100, y: 40 }, 0);\n${SPLIT_TEXT}`);
mount(script, SPANS);
const { start, outcome, commit } = await dragBoxOnSealedFrame(script);
expect(start.gsap).toEqual({ x: 100, y: 40, moving: false });
expect(outcome).toEqual({ status: "persisted" });
expect(commit).toHaveBeenCalledTimes(1);
// The hold's own `set` takes the new place, as when the frame's tweens are read.
expect(commit.mock.calls[0]![1]).toEqual({
type: "update-properties",
animationId: "#box-set-0-position",
properties: { x: 120, y: 40 },
});
});
@@ -37,6 +37,7 @@ import {
STUDIO_ROTATION_DRAFT_ATTR,
} from "./manualEditsTypes";
import { endPreviewDraft } from "./previewDrafts";
import { DRAG_MOVING_ATTR } from "../../hooks/draggedGsapPosition";
import type {
StudioBoxSizeSnapshot,
StudioRotationSnapshot,
@@ -218,6 +219,7 @@ export function restoreStudioPathOffsetStyles(
}
element.removeAttribute("data-hf-drag-gsap-base-x");
element.removeAttribute("data-hf-drag-gsap-base-y");
element.removeAttribute(DRAG_MOVING_ATTR);
}
}
@@ -14,7 +14,11 @@ import {
type StudioPathOffsetSnapshot,
} from "./manualEdits";
import type { EditMoment } from "./manualEditsTypes";
import { computeDraggedGsapPosition } from "../../hooks/draggedGsapPosition";
import {
computeDraggedGsapPosition,
DRAG_MOVING_ATTR,
stampGestureBase,
} from "../../hooks/draggedGsapPosition";
import { editsPlainCss } from "../../hooks/gsapRuntimeKeyframes";
import { readTranslatePx, UNREADABLE_TRANSLATE, writeTranslatePx } from "./plainTranslate";
import { drawPreviewDraft, endPreviewDraft } from "./previewDrafts";
@@ -94,6 +98,8 @@ export interface ManualOffsetDragMember {
* making the element accelerate away ("flies"). See applyOffsetDragDraftViaGsap.
*/
baseGsap: { x: number; y: number };
/** The sealed preview's gesture start reported a tween moving it. */
moving?: true;
initialPathOffset: StudioPathOffsetSnapshot;
gestureToken: string;
screenToOffset: ManualOffsetDragMatrix;
@@ -344,7 +350,8 @@ export function createManualOffsetDragMember(input: {
const gsapX = (!plainTranslate && win?.gsap?.getProperty?.(input.element, "x")) || 0;
const gsapY = (!plainTranslate && win?.gsap?.getProperty?.(input.element, "y")) || 0;
const baseGsap = start?.gsap ? { x: start.gsap.x, y: start.gsap.y } : { x: gsapX, y: gsapY };
if (!plainTranslate) stampGestureBase(input.element, initialOffset, baseGsap);
const moving = start?.gsap?.moving === true;
if (!plainTranslate) stampGestureBase(input.element, initialOffset, baseGsap, moving);
if (win?.__timelines) {
const paused: string[] = [];
@@ -390,6 +397,7 @@ export function createManualOffsetDragMember(input: {
initialOffset,
plainTranslate,
baseGsap,
...(moving && { moving }),
initialPathOffset,
gestureToken,
screenToOffset: start?.screenToOffset ?? { a: w / scaleX, b: 0, c: 0, d: w / scaleY },
@@ -407,6 +415,7 @@ export function createManualOffsetDragMember(input: {
initialOffset,
plainTranslate,
baseGsap,
...(moving && { moving }),
initialPathOffset,
gestureToken,
screenToOffset: measured.matrix,
@@ -452,27 +461,12 @@ export function applyManualOffsetDragDraft(
return offset;
}
/**
* Re-stamp the STABLE gesture-start base/offset before the source commit reads
* them. A mid-gesture re-render can wipe these attrs; the commit converts the
* drop offset → gsap x/y via computeDraggedGsapPosition, which without the base
* falls back to the live (already-dragged) transform and re-adds the delta — so
* the element flies off-screen the instant you drop it. The member holds the
* true gesture-start values in JS, immune to the re-render.
*/
export function stampGestureBase(el: HTMLElement, initialOffset: Point, baseGsap: Point): void {
el.setAttribute("data-hf-drag-gsap-base-x", String(baseGsap.x));
el.setAttribute("data-hf-drag-gsap-base-y", String(baseGsap.y));
el.setAttribute("data-hf-drag-initial-offset-x", String(initialOffset.x));
el.setAttribute("data-hf-drag-initial-offset-y", String(initialOffset.y));
}
function applyManualOffsetCommitValue(
member: ManualOffsetDragMember,
offset: { x: number; y: number },
): { x: number; y: number } {
if (!member.plainTranslate)
stampGestureBase(member.element, member.initialOffset, member.baseGsap);
stampGestureBase(member.element, member.initialOffset, member.baseGsap, !!member.moving);
drawMemberOffset(member, offset, true);
return offset;
}
@@ -552,6 +546,7 @@ export function endManualOffsetDragMembers(members: ManualOffsetDragMember[]): v
member.element.removeAttribute("data-hf-drag-initial-offset-y");
member.element.removeAttribute("data-hf-drag-gsap-base-x");
member.element.removeAttribute("data-hf-drag-gsap-base-y");
member.element.removeAttribute(DRAG_MOVING_ATTR);
// Do NOT clearProps:"transform" — that nukes the committed GSAP position
// and causes a visual snap-back before the soft reload re-applies it.
const gsapOwnsPosition = !member.plainTranslate && Boolean(getOffsetDragGsap(member.element));
@@ -128,8 +128,6 @@ export function readTranslatePxLeavingPercent(el: HTMLElement): Point {
export const UNREADABLE_TRANSLATE =
"Studio can't read this layer's translate. Move it in the Code tab.";
export const MOVING_LAYER_UNREADABLE =
"This preview can't save a move of a layer its animation moves yet. Move it in the Code tab.";
/** Plain px only: GSAP's CSSPlugin splits `translate` on spaces and drops a calc(). */
function formatTranslatePx(p: Point): string {
@@ -15,7 +15,6 @@ import {
createManualOffsetDragMember,
restoreManualOffsetDragMembers,
} from "./manualOffsetDrag";
import { MOVING_LAYER_UNREADABLE } from "./plainTranslate";
import { measurePreviewGestureStart, type PreviewGestureStart } from "./previewGestureStartRead";
import { standInFor } from "./previewSelection";
import { collectSnapContext } from "./snapTargetCollection";
@@ -242,16 +241,6 @@ describe("starting a gesture from what an opaque frame read", () => {
restoreManualOffsetDragMembers(g.pathOffsetMember ? [g.pathOffsetMember] : []);
});
it("refuses a drag of a layer a tween moves, which this preview cannot save yet", () => {
const element = document.createElement("div");
const selection = makeSelection("card", element);
const opts = gestureOpts(selection);
const moving = { ...START, gsap: { x: 0, y: 0, moving: true } };
expect(startGesture("drag", press(), opts, { start: moving })).toBe(false);
expect(opts.onBlockedMoveRef.current).toHaveBeenCalledWith(selection, MOVING_LAYER_UNREADABLE);
expect(opts.gestureRef.current).toBeNull();
});
it("drags a group from each member's GSAP position, snapping with the targets it read", () => {
const items = ["a", "b"].map((key, i) => {
const element = document.createElement("div");
@@ -37,6 +37,8 @@ export function readCssRotation(element: HTMLElement, withRotate = true): number
}
}
export const DRAG_MOVING_ATTR = "data-hf-drag-gsap-moving";
export interface DragStamp {
origX: number;
origY: number;
@@ -44,6 +46,23 @@ export interface DragStamp {
baseY: number;
at?: EditMoment;
frozen?: boolean;
moving?: true;
}
/** Writes the gesture-start stamp `readDragStamp` reads. The member's JS values are re-stamped before the commit
* because a mid-gesture re-render can wipe these attributes, and without the base the drop re-adds the drag. */
export function stampGestureBase(
el: HTMLElement,
initialOffset: { x: number; y: number },
baseGsap: { x: number; y: number },
moving = false,
): void {
if (moving) el.setAttribute(DRAG_MOVING_ATTR, "");
else el.removeAttribute(DRAG_MOVING_ATTR);
el.setAttribute("data-hf-drag-gsap-base-x", String(baseGsap.x));
el.setAttribute("data-hf-drag-gsap-base-y", String(baseGsap.y));
el.setAttribute("data-hf-drag-initial-offset-x", String(initialOffset.x));
el.setAttribute("data-hf-drag-initial-offset-y", String(initialOffset.y));
}
/** The drag-start attributes as they are now; NaN for an absent base. */
@@ -55,6 +74,7 @@ export function readDragStamp(element: HTMLElement): DragStamp {
baseX: read("data-hf-drag-gsap-base-x"),
baseY: read("data-hf-drag-gsap-base-y"),
at: readEditMoment(element),
...(element.getAttribute(DRAG_MOVING_ATTR) !== null && { moving: true }),
};
}
@@ -27,6 +27,7 @@ export type GsapEditBlockDetail =
| "live-rotation-no-source-tween"
| "live-resize-no-source-tween"
| "zero-duration-tween"
| "frame-tweens-unreadable"
| PlayheadEditRefusal;
/** Why an edit at the playhead could not be written as keyframes of the file's tween. */
@@ -90,6 +91,8 @@ const GSAP_EDIT_DETAIL_COPY: Partial<Record<GsapEditBlockDetail, string>> = {
"array-step-computed": `${STEP_LIST} whose value comes from code, which Studio can't keep while it edits them. ${IN_CODE}`,
"array-step-relative": `${STEP_LIST} with a relative value (like "+=40"), which an edit would apply again. ${IN_CODE}`,
"array-step-random": `${STEP_LIST} with a random() value, which an edit would roll again. ${IN_CODE}`,
"frame-tweens-unreadable":
"This preview couldn't read the layer's animation, so Studio can't save the move. Move it in the Code tab.",
};
export function gsapEditBlockMessage(
@@ -43,11 +43,11 @@ afterEach(() => {
usePlayerStore.setState({ currentTime: 0, isPlaying: false });
});
async function readReply(reply: unknown) {
async function readReply(reply: unknown, holds = true) {
usePlayerStore.setState({ currentTime: 0.5, isPlaying: false });
request.mockResolvedValue(reply);
const iframe = document.createElement("iframe");
await expect(settleGsapSnapshot(iframe)).resolves.toBeUndefined();
await expect(settleGsapSnapshot(iframe)).resolves.toBe(holds);
return iframe;
}
@@ -78,7 +78,7 @@ it.each([
["an id past the text bound", snapshot({ targets: [{ ...target, id: "b".repeat(4_097) }] })],
["a reply that is not a record", "gsap"],
])("refuses %s and holds nothing", async (_name, reply) => {
const iframe = await readReply(reply);
const iframe = await readReply(reply, false);
expect(frameTimelines(iframe)).toBeNull();
expect(frameDocument(iframe)).toBeNull();
@@ -75,15 +75,16 @@ function refreshGsapSnapshot(iframe: HTMLIFrameElement): Promise<void> {
return pending;
}
/** Reads the frame again unless the held read is at the paused playhead, for async callers. */
export async function settleGsapSnapshot(iframe: HTMLIFrameElement | null): Promise<void> {
if (!iframe || !previewFrameOpaque(iframe)) return;
/** Reads the frame again unless the held read is at the paused playhead; false if an opaque frame holds none. */
export async function settleGsapSnapshot(iframe: HTMLIFrameElement | null): Promise<boolean> {
if (!iframe || !previewFrameOpaque(iframe)) return true;
const client = previewEditingClient(iframe);
for (let reads = 0; reads < 2; reads++) {
const snapshot = held.get(client);
if (snapshot && fresh(snapshot)) return;
if (snapshot && fresh(snapshot)) return true;
await refreshGsapSnapshot(iframe);
}
return held.has(client);
}
async function read(iframe: HTMLIFrameElement, client: EditingPortClient): Promise<void> {
@@ -33,6 +33,7 @@ import { roundTo3 } from "../utils/rounding";
import type { GsapDragCommitCallbacks } from "./gsapDragCommit";
import { readDragStamp, type DragStamp } from "./draggedGsapPosition";
import { editMoment } from "./editMoment";
import { settleGsapSnapshot } from "./gsapFrameSnapshot";
import type { EditMoment } from "../components/editor/manualEditsTypes";
import { isInstantHold, selectorFromSelection, writeTargetSelector } from "./gsapShared";
import {
@@ -261,6 +262,9 @@ export async function tryGsapDragIntercept(
const stamp = options?.stamp ?? readDragStamp(selection.element);
const moment = editMoment(stamp);
const time = moment.time;
if (!(await settleGsapSnapshot(iframe)) && stamp.moving) {
return { status: "blocked", reason: "source-uneditable", detail: "frame-tweens-unreadable" };
}
if (!options?.preflightPassed) {
const preflight = await preflightGsapDragIntercept(
selection,