From 87c4a07dc99a91e185c02a53090bdf941ff32db2 Mon Sep 17 00:00:00 2001 From: James Russo Date: Fri, 13 Nov 2026 17:01:16 +0000 Subject: [PATCH] feat(studio): drag and resize draw live on an opaque preview over its channel (#7646) * feat(studio): drag and resize draw live on an opaque preview over its channel On a preview frame Studio cannot script, a drag moved only the selection outline: the element stayed put until the save reloaded the preview. A resize threw on every pointer move (it measured the frame's element for the centre pin), saved its size without the centring shift, and then a drag or resize save threw while re-syncing the preview's timeline, which stopped the save queue and paused the preview. The runtime answers a new `draft` request: it adds a gesture's translate to the one the element had and sets its border box, the way the save writes them, and an end either keeps what is drawn (the save landed) or puts back what was there (a cancel, a tap, a failed save). Studio mirrors what a gesture draws on an opaque selection's stand-in to the frame, one request in flight per frame with later moves merged into the next. An opaque resize grows the outline about its centre from the size it wrote rather than measuring the frame. The timeline re-sync after a save reports a frame it cannot reach, so its caller re-seeks or reloads instead of throwing. A stand-in now starts with the inline translate and Studio size and offset of the element it stands for, so a drag on a freshly reloaded preview starts from where the element is. Before, a second drag after a reload saved only its own distance and dropped the first. Same-origin frames do not change: only an opaque selection's stand-in is mirrored, and the re-sync change only catches a read such a frame refuses. Co-Authored-By: Claude Opus 5.5 * fix(core): draft writes test an element by its namespace, not its realm The runtime preview guard bans instanceof HTMLElement/SVGElement in the runtime, since a node from another realm fails it; the draft handler uses isStylableElement from domRealm.ts, as other runtime style writes do. Co-Authored-By: Claude Opus 5.5 * fix(studio): keep the opaque preview's gesture drafts in step with the saved edit - Grabbing a layer again before its last save settles keeps that save's draft on the frame and draws the new gesture from there; the movement probe's restore no longer ends a draft it never drew. - A move on an opaque preview starts from the px the frame renders the translate at (%, em, var(), or a stylesheet translate), records the author's own value for Reset, and refuses a % it cannot size instead of dropping it. The frame's draft base resolves % to px, so a resize can't shift it again. - The stand-in carries Studio's translate marks, so Reset after a reload restores the author's translate. - A resize with no offset member keeps its draft once saved. - An undo painted over a pending move draws the move again when it is put back. Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: Claude Opus 5.5 --- .../core/src/runtime/editingAgent.test.ts | 21 ++ packages/core/src/runtime/editingAgent.ts | 2 + .../core/src/runtime/editingDraft.test.ts | 71 +++++ packages/core/src/runtime/editingDraft.ts | 133 +++++++++ packages/core/src/runtime/editingPort.test.ts | 1 + packages/core/src/runtime/editingPort.ts | 42 +++ .../components/editor/gestureUndoRevert.ts | 19 +- .../src/components/editor/manualEdits.ts | 1 + .../components/editor/manualEditsSnapshot.ts | 10 + .../src/components/editor/manualOffsetDrag.ts | 8 +- .../src/components/editor/plainTranslate.ts | 55 ++-- .../components/editor/previewDrafts.test.ts | 263 ++++++++++++++++++ .../src/components/editor/previewDrafts.ts | 73 +++++ .../src/components/editor/previewSelection.ts | 55 +++- .../src/components/editor/resizeDraft.ts | 38 +++ .../editor/useDomEditOverlayGestures.ts | 4 +- packages/studio/src/utils/gsapSoftReload.ts | 2 +- 17 files changed, 768 insertions(+), 30 deletions(-) create mode 100644 packages/core/src/runtime/editingDraft.test.ts create mode 100644 packages/core/src/runtime/editingDraft.ts create mode 100644 packages/studio/src/components/editor/previewDrafts.test.ts create mode 100644 packages/studio/src/components/editor/previewDrafts.ts diff --git a/packages/core/src/runtime/editingAgent.test.ts b/packages/core/src/runtime/editingAgent.test.ts index 0ab8ad0ce1..42443b28a9 100644 --- a/packages/core/src/runtime/editingAgent.test.ts +++ b/packages/core/src/runtime/editingAgent.test.ts @@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; import { installEditingAgent } from "./editingAgent"; const CONNECT = { source: "hf-parent", type: "editing-connect", v: 1 }; +const H = "0123456789abcdef:1"; function frameWindow(): Window { const iframe = document.createElement("iframe"); @@ -148,6 +149,7 @@ describe("installEditingAgent", () => { "query", "geometry", "layers", + "draft", ], }, }); @@ -331,6 +333,25 @@ describe("installEditingAgent", () => { 130 + index, "invalid-params", ]), + ...[ + {}, + { drafts: [] }, + { drafts: Array(257).fill({ handle: H, end: "keep" }) }, + { drafts: [{ handle: "1", end: "keep" }] }, + { drafts: [{ handle: H, end: "drop" }] }, + { drafts: [{ handle: H, end: "keep", translate: null }] }, + { drafts: [{ handle: H, translate: null }] }, + { drafts: [{ handle: H, translate: { x: 1 }, size: null }] }, + { drafts: [{ handle: H, translate: { x: "1", y: 0 }, size: null }] }, + { drafts: [{ handle: H, translate: { x: Infinity, y: 0 }, size: null }] }, + { drafts: [{ handle: H, translate: { x: 1e6, y: 0 }, size: null }] }, + { drafts: [{ handle: H, translate: null, size: { width: -1, height: 2 } }] }, + { drafts: [{ handle: H, translate: null, size: { width: 1, height: 2, depth: 3 } }] }, + ].map((params, index) => [ + { v: 1, id: 150 + index, kind: "draft", params }, + 150 + index, + "invalid-params", + ]), ...[["--"], ["--a b"], ["--a;b"], ["--a:b"], ["Color"], ["-x"], ["--" + "a".repeat(255)]].map( (properties, index) => [ { v: 1, id: 60 + index, kind: "computed-styles", params: { selector: "p", properties } }, diff --git a/packages/core/src/runtime/editingAgent.ts b/packages/core/src/runtime/editingAgent.ts index ca327d2e31..a21e15ae1e 100644 --- a/packages/core/src/runtime/editingAgent.ts +++ b/packages/core/src/runtime/editingAgent.ts @@ -30,6 +30,7 @@ import { import { elementGeometry } from "./editingGeometry"; import { pointerTargetsAt } from "./editingTargets"; import { layersOf } from "./editingLayers"; +import { drawDrafts } from "./editingDraft"; import { getLogicalOpacity } from "../studioPreviewMark"; type Handlers = { @@ -89,6 +90,7 @@ const HANDLERS: Handlers = { query: ({ selector }) => queryElements(selector), geometry: ({ handles, children }) => elementGeometry(handles, children), layers: ({ group, offset }) => layersOf(group, offset), + draft: ({ drafts }) => drawDrafts(drafts), }; function serve(port: MessagePort): void { diff --git a/packages/core/src/runtime/editingDraft.test.ts b/packages/core/src/runtime/editingDraft.test.ts new file mode 100644 index 0000000000..b4f654f1b4 --- /dev/null +++ b/packages/core/src/runtime/editingDraft.test.ts @@ -0,0 +1,71 @@ +import { afterEach, describe, expect, it } from "vitest"; +import { drawDrafts } from "./editingDraft"; +import { handleFor } from "./editingHandles"; + +afterEach(() => { + document.body.innerHTML = ""; +}); + +function card(style: string): { element: HTMLElement; handle: string } { + document.body.innerHTML = `
`; + const element = document.getElementById("card")!; + return { element, handle: handleFor(element) }; +} + +// The test DOM keeps a calc() unsimplified, so each axis is read back as the sum of its px terms. +const shown = (element: HTMLElement) => + element.style.translate + .split(/ (?![^(]*\))/) + .map((axis) => + [...axis.matchAll(/-?[\d.]+px/g)].reduce((sum, [px]) => sum + parseFloat(px), 0), + ); + +describe("drafts", () => { + it("adds a drag to the translate the element had, and restores it on a cancel", () => { + const { element, handle } = card("translate: 10px 20px; width: 50px"); + expect(drawDrafts([{ handle, translate: { x: 5, y: -4 }, size: null }])).toEqual({ drawn: 1 }); + expect(shown(element)).toEqual([15, 16]); + drawDrafts([{ handle, translate: { x: 30, y: 0 }, size: null }]); + expect(shown(element)).toEqual([40, 20]); + drawDrafts([{ handle, end: "restore" }]); + expect(element.getAttribute("style")).toBe("translate: 10px 20px; width: 50px;"); + }); + + it("draws a resize's box and centring shift, and keeps both once the edit is saved", () => { + const { element, handle } = card("width: 50px; min-width: 40px"); + drawDrafts([{ handle, translate: { x: -25, y: -10 }, size: { width: 100, height: 70 } }]); + expect(shown(element)).toEqual([-25, -10]); + expect(element.style.width).toBe("100px"); + expect(element.style.height).toBe("70px"); + expect(element.style.minWidth).toBe("0px"); + expect(element.style.boxSizing).toBe("border-box"); + drawDrafts([{ handle, end: "keep" }]); + expect(element.style.width).toBe("100px"); + drawDrafts([{ handle, translate: { x: 5, y: 0 }, size: null }]); + expect(shown(element)).toEqual([-20, -10]); + expect(element.style.width).toBe("100px"); + drawDrafts([{ handle, translate: null, size: null }]); + expect(shown(element)).toEqual([-25, -10]); + }); + + it("adds a resize's shift to the px a % translate is at its start, so the new size can't move it", () => { + const { element, handle } = card("width: 200px; height: 100px; translate: -50% -50%"); + drawDrafts([{ handle, translate: { x: -50, y: 0 }, size: { width: 300, height: 100 } }]); + expect(shown(element)).toEqual([-150, -50]); + drawDrafts([{ handle, end: "restore" }]); + expect(element.style.translate).toBe("-50% -50%"); + }); + + it("puts back only the part a draft stops drawing", () => { + const { element, handle } = card("height: 30px"); + drawDrafts([{ handle, translate: { x: 1, y: 2 }, size: { width: 10, height: 10 } }]); + drawDrafts([{ handle, translate: { x: 1, y: 2 }, size: null }]); + expect(element.style.height).toBe("30px"); + expect(element.style.width).toBe(""); + expect(shown(element)).toEqual([1, 2]); + }); + + it("skips a handle this load does not have", () => { + expect(drawDrafts([{ handle: "0123456789abcdef:999", end: "restore" }])).toEqual({ drawn: 0 }); + }); +}); diff --git a/packages/core/src/runtime/editingDraft.ts b/packages/core/src/runtime/editingDraft.ts new file mode 100644 index 0000000000..daf063f892 --- /dev/null +++ b/packages/core/src/runtime/editingDraft.ts @@ -0,0 +1,133 @@ +/** + * Gesture drafts for the editing channel. A parent that cannot script the frame draws a drag or a + * resize here, on the element's inline style, so the preview moves with the pointer. What the + * element had before its first draft is kept until the parent ends the draft or the frame loads again. + */ +import { isStylableElement, type StylableElement as Styled } from "./domRealm"; +import { elementForHandle } from "./editingHandles"; +import type { EditingDraft } from "./editingPort"; + +const SIZE_PROPERTIES = [ + "box-sizing", + "width", + "height", + "min-width", + "min-height", + "max-width", + "max-height", +] as const; +const DRAWN = ["translate", ...SIZE_PROPERTIES] as const; + +interface Before { + inline: Array<[name: string, value: string, priority: string]>; + /** The computed translate, split into its axes with each % as px, that a draft's translate adds to. */ + translate: string[]; +} + +const before = new WeakMap(); + +/** "calc(50% + 2px) 4px" as its top-level parts. */ +function axes(value: string): string[] { + const parts: string[] = []; + let depth = 0; + let part = ""; + for (const char of value.trim()) { + depth += char === "(" ? 1 : char === ")" ? -1 : 0; + if (/\s/.test(char) && depth === 0) { + if (part) parts.push(part); + part = ""; + } else part += char; + } + if (part) parts.push(part); + return parts; +} + +/** The side a translate's % takes a share of: the box `transform-box` names. */ +function percentSide(computed: CSSStyleDeclaration, size: "width" | "height"): number { + const [a, b] = size === "width" ? ["left", "right"] : ["top", "bottom"]; + const n = (name: string) => Number.parseFloat(computed.getPropertyValue(name)) || 0; + const pad = + n(`padding-${a}`) + n(`padding-${b}`) + n(`border-${a}-width`) + n(`border-${b}-width`); + const content = n(size) - (computed.getPropertyValue("box-sizing") === "border-box" ? pad : 0); + const box = computed.getPropertyValue("transform-box"); + return box === "content-box" || box === "fill-box" ? content : content + pad; +} + +/** Each % as the px it is now, so a resize drawn with it does not move the element again. */ +function percentAsPx(axis: string, side: number): string { + return axis.replace( + /(-?\d*\.?\d+(?:e[-+]?\d+)?)%/gi, + (_, n: string) => `${(Number(n) * side) / 100}px`, + ); +} + +function beforeOf(element: Styled): Before { + let saved = before.get(element); + if (!saved) { + const { style } = element; + const computed = getComputedStyle(element); + const translate = computed.getPropertyValue("translate"); + const sides = [percentSide(computed, "width"), percentSide(computed, "height")]; + saved = { + inline: DRAWN.map((name) => [ + name, + style.getPropertyValue(name), + style.getPropertyPriority(name), + ]), + translate: + translate && translate !== "none" + ? axes(translate).map((axis, i) => (i < 2 ? percentAsPx(axis, sides[i]!) : axis)) + : [], + }; + before.set(element, saved); + } + return saved; +} + +function restore(element: Styled, names: readonly string[]): void { + for (const [name, value, priority] of before.get(element)?.inline ?? []) { + if (!names.includes(name)) continue; + if (value) element.style.setProperty(name, value, priority); + else element.style.removeProperty(name); + } +} + +function drawTranslate(element: Styled, offset: { x: number; y: number }): void { + const [x = "0px", y = "0px", z] = beforeOf(element).translate; + const value = `calc(${x} + ${offset.x}px) calc(${y} + ${offset.y}px)${z ? ` ${z}` : ""}`; + element.style.setProperty("translate", value); +} + +function drawSize(element: Styled, size: { width: number; height: number }): void { + beforeOf(element); + const { style } = element; + style.setProperty("box-sizing", "border-box"); + style.setProperty("width", `${size.width}px`); + style.setProperty("height", `${size.height}px`); + for (const name of ["min-width", "min-height"]) style.setProperty(name, "0px"); + for (const name of ["max-width", "max-height"]) style.setProperty(name, "none"); +} + +function apply(element: Styled, draft: EditingDraft): void { + if ("end" in draft) { + if (draft.end === "restore") restore(element, DRAWN); + before.delete(element); + return; + } + if (draft.translate) drawTranslate(element, draft.translate); + else restore(element, ["translate"]); + if (draft.size) drawSize(element, draft.size); + else restore(element, SIZE_PROPERTIES); +} + +/** Applies each draft in order; one for an element this load no longer has is skipped. */ +export function drawDrafts(drafts: readonly EditingDraft[]): { drawn: number } { + let drawn = 0; + for (const draft of drafts) { + const element = elementForHandle(draft.handle); + if (!isStylableElement(element)) continue; + apply(element, draft); + drawn++; + } + return { drawn }; +} diff --git a/packages/core/src/runtime/editingPort.test.ts b/packages/core/src/runtime/editingPort.test.ts index 95cc5c0ea7..69cf7c7b98 100644 --- a/packages/core/src/runtime/editingPort.test.ts +++ b/packages/core/src/runtime/editingPort.test.ts @@ -73,6 +73,7 @@ describe("createEditingPortClient", () => { "query", "geometry", "layers", + "draft", ], }); } finally { diff --git a/packages/core/src/runtime/editingPort.ts b/packages/core/src/runtime/editingPort.ts index 17d9ae9e42..03fe5fed37 100644 --- a/packages/core/src/runtime/editingPort.ts +++ b/packages/core/src/runtime/editingPort.ts @@ -100,6 +100,7 @@ export const EDITING_REQUEST_KINDS = [ "query", "geometry", "layers", + "draft", ] as const; export type EditingRequestKind = (typeof EDITING_REQUEST_KINDS)[number]; @@ -114,6 +115,17 @@ export interface EditingRuntimeSnapshot { clipParents: Array<[string, string]>; } +export const MAX_DRAFT_PX = 100_000; + +/** A gesture's draft on one element: null puts that part back; `end` keeps what is drawn or restores. */ +export type EditingDraft = + | { + handle: EditingElementHandle; + translate: { x: number; y: number } | null; + size: { width: number; height: number } | null; + } + | { handle: EditingElementHandle; end: "keep" | "restore" }; + type NoParams = Record; export interface EditingRequests { hello: { @@ -169,6 +181,8 @@ export interface EditingRequests { params: { group?: EditingElementHandle; offset?: number }; result: { layers: EditingLayer[]; truncated: boolean; missingGroup: boolean }; }; + /** Gesture drafts in order, up to MAX_DESCRIBE_HANDLES; `drawn` counts the elements still here. */ + draft: { params: { drafts: EditingDraft[] }; result: { drawn: number } }; } export type EditingParams = EditingRequests[K]["params"]; export type EditingResult = EditingRequests[K]["result"]; @@ -261,6 +275,33 @@ function layerParams(params: unknown): EditingParams<"layers"> | null { return { ...(isHandle(group) && { group }), ...(isOffset(offset) && { offset }) }; } +const isDraftPx = (value: unknown, min: number): value is number => + Number.isFinite(value) && (value as number) >= min && Math.abs(value as number) <= MAX_DRAFT_PX; + +function draftPart(value: unknown, keys: string, min: number): boolean { + if (value === null) return true; + if (!hasKeys(value, keys)) return false; + return keys.split(",").every((key) => isDraftPx(value[key], min)); +} + +function draftEntry(value: unknown): EditingDraft | null { + if (!isPlainRecord(value) || !isHandle(value.handle)) return null; + const { handle, end, translate, size } = value; + if (hasKeys(value, "end,handle")) + return end === "keep" || end === "restore" ? { handle, end } : null; + if (!hasKeys(value, "handle,size,translate")) return null; + const valid = draftPart(translate, "x,y", -MAX_DRAFT_PX) && draftPart(size, "height,width", 0); + return valid ? (value as EditingDraft) : null; +} + +function draftList(params: unknown): EditingParams<"draft"> | null { + if (!hasKeys(params, "drafts") || !Array.isArray(params.drafts)) return null; + const { drafts } = params; + if (!drafts.length || drafts.length > MAX_DESCRIBE_HANDLES) return null; + const parsed = drafts.map(draftEntry); + return parsed.includes(null) ? null : { drafts: parsed as EditingDraft[] }; +} + const PARAM_PARSERS: { [K in EditingRequestKind]: (params: unknown) => EditingParams | null; } = { @@ -297,6 +338,7 @@ const PARAM_PARSERS: { return isHandle(children) ? { ...list, children } : null; }, layers: (params) => noParams(params) ?? layerParams(params), + draft: draftList, }; /** Validates one request off the wire. Never throws: anything unusable becomes a typed error. */ diff --git a/packages/studio/src/components/editor/gestureUndoRevert.ts b/packages/studio/src/components/editor/gestureUndoRevert.ts index 30bde86bfb..ce5300c701 100644 --- a/packages/studio/src/components/editor/gestureUndoRevert.ts +++ b/packages/studio/src/components/editor/gestureUndoRevert.ts @@ -1,8 +1,11 @@ import { captureStudioPathOffset, + readAppliedStudioPathOffset, restoreStudioPathOffset, type StudioPathOffsetSnapshot, } from "./manualEdits"; +import { readTranslatePx } from "./plainTranslate"; +import { drawPreviewDraft } from "./previewDrafts"; import { getOffsetDragGsap, stampGestureBase, @@ -49,6 +52,16 @@ function showMemberPosition(member: ManualOffsetDragMember, position: MemberPosi stampGestureBase(member.element, member.initialOffset, member.baseGsap); } +function redrawMemberOnFrame(member: ManualOffsetDragMember): void { + const { element, initialOffset } = member; + const offset = member.plainTranslate + ? readTranslatePx(element) + : readAppliedStudioPathOffset(element); + const translate = { x: offset.x - initialOffset.x, y: offset.y - initialOffset.y }; + if (Number.isFinite(translate.x) && Number.isFinite(translate.y) && (translate.x || translate.y)) + drawPreviewDraft(element, { translate }); +} + /** Undo's live revert of a move: its members at gesture start. */ export function manualOffsetMoveRevert(members: ManualOffsetDragMember[]): StudioEditRevert { const startPlacement = members.map((member) => placementOf(member.element)); @@ -61,7 +74,11 @@ export function manualOffsetMoveRevert(members: ManualOffsetDragMember[]): Studi placement: startPlacement[i]!, }), ); - return () => members.forEach((member, i) => showMemberPosition(member, shown[i]!)); + return () => + members.forEach((member, i) => { + showMemberPosition(member, shown[i]!); + redrawMemberOnFrame(member); + }); }; } diff --git a/packages/studio/src/components/editor/manualEdits.ts b/packages/studio/src/components/editor/manualEdits.ts index eb40862046..33ea7d3a21 100644 --- a/packages/studio/src/components/editor/manualEdits.ts +++ b/packages/studio/src/components/editor/manualEdits.ts @@ -41,6 +41,7 @@ export { restoreStudioBoxSize, restoreStudioRotation, restoreStudioPathOffset, + restoreStudioPathOffsetStyles, clearStudioPathOffset, clearStudioRotation, clearStudioBoxSize, diff --git a/packages/studio/src/components/editor/manualEditsSnapshot.ts b/packages/studio/src/components/editor/manualEditsSnapshot.ts index 79042fe118..da7ac853eb 100644 --- a/packages/studio/src/components/editor/manualEditsSnapshot.ts +++ b/packages/studio/src/components/editor/manualEditsSnapshot.ts @@ -36,6 +36,7 @@ import { STUDIO_ORIGINAL_ROTATION_TRANSFORM_ORIGIN_ATTR, STUDIO_ROTATION_DRAFT_ATTR, } from "./manualEditsTypes"; +import { endPreviewDraft } from "./previewDrafts"; import type { StudioBoxSizeSnapshot, StudioRotationSnapshot, @@ -117,6 +118,7 @@ function restoreStyleProperty(element: HTMLElement, property: string, value: str } export function restoreStudioBoxSize(element: HTMLElement, previous: StudioBoxSizeSnapshot): void { + endPreviewDraft(element, "restore"); forgetStudioBoxSizeDraftBase(element); restoreStyleProperty(element, "width", previous.width); restoreStyleProperty(element, "height", previous.height); @@ -176,6 +178,14 @@ export function restoreStudioRotation( export function restoreStudioPathOffset( element: HTMLElement, previous: StudioPathOffsetSnapshot, +): void { + endPreviewDraft(element, "restore"); + restoreStudioPathOffsetStyles(element, previous); +} + +export function restoreStudioPathOffsetStyles( + element: HTMLElement, + previous: StudioPathOffsetSnapshot, ): void { if (previous.translate) element.style.setProperty("translate", previous.translate); else element.style.removeProperty("translate"); diff --git a/packages/studio/src/components/editor/manualOffsetDrag.ts b/packages/studio/src/components/editor/manualOffsetDrag.ts index 70957f361d..892d8e5c71 100644 --- a/packages/studio/src/components/editor/manualOffsetDrag.ts +++ b/packages/studio/src/components/editor/manualOffsetDrag.ts @@ -10,12 +10,14 @@ import { isStudioManualEditGestureCurrent, readAppliedStudioPathOffset, restoreStudioPathOffset, + restoreStudioPathOffsetStyles, type StudioPathOffsetSnapshot, } from "./manualEdits"; import type { EditMoment } from "./manualEditsTypes"; import { computeDraggedGsapPosition } from "../../hooks/draggedGsapPosition"; import { editsPlainCss } from "../../hooks/gsapRuntimeKeyframes"; import { readTranslatePx, UNREADABLE_TRANSLATE, writeTranslatePx } from "./plainTranslate"; +import { drawPreviewDraft, endPreviewDraft } from "./previewDrafts"; interface OffsetDragGsap { set: (el: Element, vars: Record) => void; @@ -289,7 +291,7 @@ export function measureManualOffsetDragScreenToOffsetMatrix( return { ok: true, matrix: screenToOffset }; } finally { - restoreStudioPathOffset(element, snapshot); + restoreStudioPathOffsetStyles(element, snapshot); } } @@ -367,6 +369,7 @@ export function createManualOffsetDragMember(input: { scaleY: input.rect.editScaleY, plainTranslate, }); + endPreviewDraft(input.element, "keep"); if (!measured.ok) { // GSAP transforms can defeat the probe: approximate with the preview scale. The commit // reads GSAP's real position, so only the drag preview is imprecise. @@ -426,6 +429,8 @@ function drawMemberOffset( offset: { x: number; y: number }, commit: boolean, ): void { + const { x, y } = member.initialOffset; + drawPreviewDraft(member.element, { translate: { x: offset.x - x, y: offset.y - y } }); if (member.plainTranslate) writeTranslatePx(member.element, offset); else if (applyOffsetDragDraftViaGsap(member.element, offset, member.baseGsap)) return; else if (commit) applyStudioPathOffset(member.element, offset); @@ -537,6 +542,7 @@ export function endManualOffsetDragMembers(members: ManualOffsetDragMember[]): v for (const member of members) { if (!isStudioManualEditGestureCurrent(member.element, member.gestureToken)) continue; endStudioManualEditGesture(member.element, member.gestureToken); + endPreviewDraft(member.element, "keep"); member.element.removeAttribute("data-hf-drag-initial-offset-x"); member.element.removeAttribute("data-hf-drag-initial-offset-y"); member.element.removeAttribute("data-hf-drag-gsap-base-x"); diff --git a/packages/studio/src/components/editor/plainTranslate.ts b/packages/studio/src/components/editor/plainTranslate.ts index 66dd45ac2f..640aa97ec9 100644 --- a/packages/studio/src/components/editor/plainTranslate.ts +++ b/packages/studio/src/components/editor/plainTranslate.ts @@ -70,34 +70,53 @@ function evaluateLength(value: string, side: number): number { const CONTENT_BOXES = new Set(["content-box", "fill-box"]); +type ComputedRead = (property: string) => string; + +export const TRANSLATE_PX_PROPERTIES = [ + "translate", + "width", + "height", + "box-sizing", + "transform-box", + ...["left", "right", "top", "bottom"].flatMap((s) => [`padding-${s}`, `border-${s}-width`]), +]; + /** The side % resolves against: the box `transform-box` names (fill-box is the content box on HTML). */ -function referenceBox( - cs: CSSStyleDeclaration, - size: "width" | "height", - a: string, - b: string, -): number { - const n = (prop: string) => Number.parseFloat(cs.getPropertyValue(prop)) || 0; +function referenceBox(read: ComputedRead, size: "width" | "height", a: string, b: string): number { + const n = (prop: string) => Number.parseFloat(read(prop)) || 0; const pad = n(`padding-${a}`) + n(`padding-${b}`) + n(`border-${a}-width`) + n(`border-${b}-width`); - const content = n(size) - (cs.boxSizing === "border-box" ? pad : 0); - return CONTENT_BOXES.has(cs.getPropertyValue("transform-box")) ? content : content + pad; + const content = n(size) - (read("box-sizing") === "border-box" ? pad : 0); + return CONTENT_BOXES.has(read("transform-box")) ? content : content + pad; +} + +/** A computed translate in px; with no styles to size the box, a % is NaN rather than 0. */ +export function translatePx(value: string, read?: ComputedRead): Point { + if (value === "none") return { x: 0, y: 0 }; + const [x = "0px", y = "0px"] = splitTopLevelWhitespace(value); + const side = (size: "width" | "height", a: string, b: string) => + read ? referenceBox(read, size, a, b) : Number.NaN; + return { + x: evaluateLength(x, side("width", "left", "right")), + y: evaluateLength(y, side("height", "top", "bottom")), + }; +} + +const frameTranslates = new WeakMap(); + +export function rememberFrameTranslate(el: HTMLElement, px: Point): void { + frameTranslates.set(el, { inline: el.style.getPropertyValue("translate"), px }); } /** The element's CSS `translate` in px, as it renders now. */ // ponytail: a 3-value translate loses its z on the next move; keep z when a fixture needs it. export function readTranslatePx(el: HTMLElement): Point { const cs = el.ownerDocument.defaultView?.getComputedStyle(el); + const inline = el.style.getPropertyValue("translate"); + const frame = cs ? undefined : frameTranslates.get(el); + if (frame?.inline === inline) return frame.px; // Computed first: Chrome resolves em, vw and var() there and leaves only % to work out. - const value = cs?.translate || el.style.getPropertyValue("translate") || "none"; - if (value === "none") return { x: 0, y: 0 }; - const [x = "0px", y = "0px"] = splitTopLevelWhitespace(value); - const side = (size: "width" | "height", a: string, b: string) => - cs ? referenceBox(cs, size, a, b) : 0; - return { - x: evaluateLength(x, side("width", "left", "right")), - y: evaluateLength(y, side("height", "top", "bottom")), - }; + return translatePx(cs?.translate || inline || "none", cs && ((p) => cs.getPropertyValue(p))); } export function readTranslatePxLeavingPercent(el: HTMLElement): Point { diff --git a/packages/studio/src/components/editor/previewDrafts.test.ts b/packages/studio/src/components/editor/previewDrafts.test.ts new file mode 100644 index 0000000000..264b3eb507 --- /dev/null +++ b/packages/studio/src/components/editor/previewDrafts.test.ts @@ -0,0 +1,263 @@ +// @vitest-environment happy-dom + +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; +// The frame's real runtime agent, serving the opaque frame from this document. +import { installEditingAgent } from "../../../../core/src/runtime/editingAgent"; +import { detachedFakeIframe } from "../../player/hooks/timelinePlayerTestHarness"; +import { describePreviewElements, queryPreviewElements } from "../../player/lib/previewElements"; +import { resolvePreviewSelection, standInFor } from "./previewSelection"; +import { manualOffsetMoveRevert } from "./gestureUndoRevert"; +import { writePlainMove } from "./plainTranslate"; +import { + beginStudioManualEditGesture, + captureStudioBoxSize, + restoreStudioBoxSize, +} from "./manualEdits"; +import { STUDIO_ORIGINAL_INLINE_TRANSLATE_ATTR } from "./manualEditsTypes"; +import { + applyManualOffsetDragCommit, + applyManualOffsetDragDraft, + createManualOffsetDragMember, + endManualOffsetDragMembers, + restoreManualOffsetDragMembers, + type ManualOffsetDragMember, +} from "./manualOffsetDrag"; +import { endResizeWithoutMember, resolveResizeDraftRect } from "./resizeDraft"; +import { applySoftReloadFinalization } from "../../utils/gsapSoftReload"; +import type { DomEditSelection } from "./domEditing"; +import type { GestureState } from "./domEditOverlayGestures"; +import { previewRequest } from "../../player/lib/previewChannel"; + +vi.mock("../../player/lib/previewChannel", async (importOriginal) => { + const actual = await importOriginal(); + return { ...actual, previewRequest: vi.fn(actual.previewRequest) }; +}); +const draftRequests = () => + vi.mocked(previewRequest).mock.calls.filter(([, kind]) => kind === "draft"); + +const closers: Array<() => void> = []; +beforeEach(() => { + document.body.innerHTML = `
`; +}); +afterEach(() => { + closers.splice(0).forEach((close) => close()); + document.body.innerHTML = ""; +}); + +/** A frame whose window refuses every read, as a cross-origin one does; its runtime serves this document. */ +function opaqueFrame(): HTMLIFrameElement { + const blocked = () => { + throw new DOMException("blocked", "SecurityError"); + }; + const target: Record = {}; + const frame = new Proxy(target, { + get: (_, key) => (key === "postMessage" ? target.postMessage : blocked()), + }); + const iframe = detachedFakeIframe(frame); + Object.defineProperty(iframe, "contentDocument", { value: null }); + 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 = installEditingAgent(parent); + target.postMessage = (data: unknown) => + window.dispatchEvent(new MessageEvent("message", { source: parent, data })); + closers.push(() => agent.dispose()); + return iframe; +} + +async function described(iframe: HTMLIFrameElement, selector: string) { + const handle = (await queryPreviewElements(iframe, selector))!.matches[0]!.handle; + return (await describePreviewElements(iframe, [handle]))![0]!; +} + +async function standIn(iframe: HTMLIFrameElement, selector: string): Promise { + return standInFor(iframe, await described(iframe, selector)); +} + +const settled = () => new Promise((resolve) => setTimeout(resolve, 20)); + +const RECT = { left: 10, top: 20, width: 100, height: 50, editScaleX: 0.5, editScaleY: 0.5 }; + +function dragMember(element: HTMLElement): ManualOffsetDragMember { + const selection = { element } as DomEditSelection; + const made = createManualOffsetDragMember({ + key: "k", + selection, + element, + rect: RECT, + gesture: "drag", + }); + if (!made.ok) throw new Error(made.reason); + return made.member; +} + +const card = () => document.getElementById("card")!; +/** The test DOM keeps a calc() unsimplified, so each axis is read back as the sum of its px terms. */ +const shown = (element: HTMLElement) => + element.style + .getPropertyValue("translate") + .split(/ (?![^(]*\))/) + .map((axis) => + [...axis.matchAll(/-?[\d.]+px/g)].reduce((sum, [px]) => sum + parseFloat(px), 0), + ); + +describe("gesture drafts on an opaque frame", () => { + it("moves the frame's element with a drag, and puts it back when the drag is cancelled", async () => { + const member = dragMember(await standIn(opaqueFrame(), "#card")); + applyManualOffsetDragDraft(member, 10, 0); + applyManualOffsetDragDraft(member, 40, 20); + await vi.waitFor(() => expect(shown(card())).toEqual([80, 40])); + restoreManualOffsetDragMembers([member]); + await vi.waitFor(() => + expect(card().getAttribute("style")).toBe("width: 200px; height: 100px;"), + ); + }); + + it("holds a saved drag where it was dropped, and the next drag starts from there", async () => { + const element = await standIn(opaqueFrame(), "#card"); + const first = dragMember(element); + applyManualOffsetDragCommit(first, 40, 20); + endManualOffsetDragMembers([first]); + await vi.waitFor(() => expect(shown(card())).toEqual([80, 40])); + const second = dragMember(element); + applyManualOffsetDragDraft(second, -10, 0); + await vi.waitFor(() => expect(shown(card())).toEqual([60, 40])); + }); + + it("draws a drag that grabs the layer again before the last save settles from where that one left it", async () => { + const element = await standIn(opaqueFrame(), "#card"); + const first = dragMember(element); + applyManualOffsetDragCommit(first, 40, 20); + await vi.waitFor(() => expect(shown(card())).toEqual([80, 40])); + const second = dragMember(element); + applyManualOffsetDragDraft(second, 10, 0); + endManualOffsetDragMembers([first]); + await vi.waitFor(() => expect(shown(card())).toEqual([100, 40])); + applyManualOffsetDragCommit(second, 10, 0); + endManualOffsetDragMembers([second]); + await settled(); + expect(shown(card())).toEqual([100, 40]); + }); + + it("puts a move back on the frame when an undo painted over it does not go through", async () => { + const member = dragMember(await standIn(opaqueFrame(), "#card")); + applyManualOffsetDragCommit(member, 40, 20); + await vi.waitFor(() => expect(shown(card())).toEqual([80, 40])); + const putBack = manualOffsetMoveRevert([member])(); + await vi.waitFor(() => + expect(card().getAttribute("style")).toBe("width: 200px; height: 100px;"), + ); + putBack(); + await vi.waitFor(() => expect(shown(card())).toEqual([80, 40])); + }); + + it("moves a % translate from the px the frame renders it at, and keeps the author's value to reset to", async () => { + const iframe = opaqueFrame(); + const options = { activeCompositionPath: "index.html", isMasterView: false }; + const selection = await resolvePreviewSelection( + iframe, + await described(iframe, "#centred"), + options, + ); + const member = dragMember(selection!.element); + expect(member.initialOffset).toEqual({ x: -100, y: -50 }); + const offset = applyManualOffsetDragCommit(member, 40, 0); + expect(offset).toEqual({ x: -20, y: -50 }); + expect(writePlainMove(selection!.element, offset).slice(0, 2)).toEqual([ + { type: "inline-style", property: "translate", value: "-20px -50px" }, + { type: "attribute", property: STUDIO_ORIGINAL_INLINE_TRANSLATE_ATTR, value: "-50% -50%" }, + ]); + const centred = document.getElementById("centred")!; + await vi.waitFor(() => expect(shown(centred)).toEqual([-20, -50])); + }); + + it("refuses to move a % translate it has no rendered px for, rather than drop it", async () => { + const element = await standIn(opaqueFrame(), "#centred"); + const made = createManualOffsetDragMember({ + key: "k", + selection: { element } as DomEditSelection, + element, + rect: RECT, + gesture: "drag", + }); + expect(made.ok).toBe(false); + }); + + it("keeps the translate the author had before Studio moved the layer as the one to reset to", async () => { + const element = await standIn(opaqueFrame(), "#moved"); + applyManualOffsetDragCommit(dragMember(element), 40, 0); + expect(element.getAttribute(STUDIO_ORIGINAL_INLINE_TRANSLATE_ATTR)).toBe(""); + }); + + it("starts a drag on a freshly loaded frame from the translate its element has", async () => { + const member = dragMember(await standIn(opaqueFrame(), "#chip")); + expect(member.initialOffset).toEqual({ x: 30, y: 0 }); + expect(applyManualOffsetDragCommit(member, 40, 0)).toEqual({ x: 110, y: 0 }); + const chip = document.getElementById("chip")!; + await vi.waitFor(() => expect(shown(chip)).toEqual([110, 0])); + }); + + it("sends one request at a time and draws only the latest of the moves that waited", async () => { + const member = dragMember(await standIn(opaqueFrame(), "#card")); + vi.mocked(previewRequest).mockClear(); + for (let dx = 2; dx <= 40; dx += 2) applyManualOffsetDragDraft(member, dx, 0); + await vi.waitFor(() => expect(shown(card())).toEqual([80, 0])); + expect(draftRequests()).toHaveLength(2); + }); + + it("grows a resized box about its centre without measuring the frame, and draws it there", async () => { + const iframe = opaqueFrame(); + const element = await standIn(iframe, "#card"); + const g = { + ...{ originLeft: 10, originTop: 20, originWidth: 100, originHeight: 50 }, + ...{ actualWidth: 200, actualHeight: 100, editScaleX: 0.5, editScaleY: 0.5 }, + actualRotation: 0, + pathOffsetMember: dragMember(element), + } as GestureState; + const size = { width: 300, height: 140 }; + const rect = resolveResizeDraftRect(g, element, null, iframe, () => null, { + wanted: size, + written: size, + }); + expect(rect).toMatchObject({ left: -15, top: 10, width: 150, height: 70, angle: 0 }); + expect(g.lastResizeAnchor).toEqual({ dx: -25, dy: -10 }); + await vi.waitFor(() => expect(card().style.width).toBe("300px")); + expect(card().style.height).toBe("140px"); + expect(shown(card())).toEqual([-50, -20]); + }); + + it("keeps a saved resize with no offset member on the frame when a later restore runs", async () => { + const iframe = opaqueFrame(); + const element = await standIn(iframe, "#card"); + const before = captureStudioBoxSize(element); + const token = beginStudioManualEditGesture(element, "resize"); + const g = { + ...{ originLeft: 10, originTop: 20, originWidth: 100, originHeight: 50 }, + ...{ actualWidth: 200, actualHeight: 100, editScaleX: 0.5, editScaleY: 0.5 }, + actualRotation: 0, + } as GestureState; + const size = { width: 300, height: 140 }; + resolveResizeDraftRect(g, element, null, iframe, () => null, { wanted: size, written: size }); + await vi.waitFor(() => expect(card().style.width).toBe("300px")); + endResizeWithoutMember(element, token); + restoreStudioBoxSize(element, before); + await settled(); + expect(card().style.width).toBe("300px"); + }); + + it("leaves elements of a frame Studio scripts to the gesture alone", async () => { + vi.mocked(previewRequest).mockClear(); + const member = dragMember(document.getElementById("chip")!); + applyManualOffsetDragDraft(member, 40, 20); + restoreManualOffsetDragMembers([member]); + await new Promise((resolve) => setTimeout(resolve, 20)); + expect(draftRequests()).toHaveLength(0); + }); + + it("reports a timeline rebind it cannot reach, so the caller syncs the preview another way", () => { + expect(applySoftReloadFinalization(opaqueFrame(), 1)).toBe(false); + }); +}); diff --git a/packages/studio/src/components/editor/previewDrafts.ts b/packages/studio/src/components/editor/previewDrafts.ts new file mode 100644 index 0000000000..3a67e74048 --- /dev/null +++ b/packages/studio/src/components/editor/previewDrafts.ts @@ -0,0 +1,73 @@ +/** + * A gesture on a preview frame Studio cannot script edits the selection's stand-in element. What the + * gesture draws on the stand-in is drawn on the frame's own element too, over the frame's channel, + * so the preview follows the pointer. One request is in flight per frame; later draws wait and merge. + */ +import { MAX_DESCRIBE_HANDLES, type EditingDraft } from "@hyperframes/core/runtime/editing-port"; +import { previewRequest } from "../../player/lib/previewChannel"; + +type Drawn = { + translate: { x: number; y: number } | null; + size: { width: number; height: number } | null; +}; + +interface Queue { + ops: EditingDraft[]; + drawn: Map; + sending: boolean; +} + +const standIns = new WeakMap(); +const queues = new WeakMap(); + +export function registerPreviewStandIn( + standIn: Element, + iframe: HTMLIFrameElement, + handle: string, +): void { + standIns.set(standIn, { iframe, handle }); +} + +function queueFor(iframe: HTMLIFrameElement): Queue { + let queue = queues.get(iframe); + if (!queue) { + queue = { ops: [], drawn: new Map(), sending: false }; + queues.set(iframe, queue); + } + return queue; +} + +function send(iframe: HTMLIFrameElement, queue: Queue): void { + if (queue.sending || !queue.ops.length) return; + const drafts = queue.ops.splice(0, MAX_DESCRIBE_HANDLES); + queue.sending = true; + void previewRequest(iframe, "draft", { drafts }).finally(() => { + queue.sending = false; + send(iframe, queue); + }); +} + +/** Draws `part` of the stand-in's draft on its frame element; any other element is left alone. */ +export function drawPreviewDraft(element: Element, part: Partial): void { + const target = standIns.get(element); + if (!target) return; + const queue = queueFor(target.iframe); + const drawn = { translate: null, size: null, ...queue.drawn.get(target.handle), ...part }; + queue.drawn.set(target.handle, drawn); + const op = { handle: target.handle, ...drawn }; + const last = queue.ops.map((queued) => queued.handle).lastIndexOf(target.handle); + const waiting = queue.ops[last]; + if (waiting && !("end" in waiting)) queue.ops[last] = op; + else queue.ops.push(op); + send(target.iframe, queue); +} + +/** Ends the stand-in's draft on its frame: "keep" once saved or regrabbed mid-save, else "restore". */ +export function endPreviewDraft(element: Element, end: "keep" | "restore"): void { + const target = standIns.get(element); + if (!target) return; + const queue = queueFor(target.iframe); + if (!queue.drawn.delete(target.handle)) return; + queue.ops.push({ handle: target.handle, end }); + send(target.iframe, queue); +} diff --git a/packages/studio/src/components/editor/previewSelection.ts b/packages/studio/src/components/editor/previewSelection.ts index a91aab65ff..b6ff896f67 100644 --- a/packages/studio/src/components/editor/previewSelection.ts +++ b/packages/studio/src/components/editor/previewSelection.ts @@ -3,10 +3,11 @@ * descriptions. Which element a selection lands on comes from `domEditSelectionRules.ts`, the * rules a scriptable frame's selections use, so both kinds of frame select the same element. * - * Such a selection's `element` is a stand-in: an element with only the target's tag, in a - * document with no window, the same one for a handle for the whole frame load. Nothing in it - * loads, runs or renders, and nothing from the frame is copied into it. The frame's element is - * the selection's `handle`. + * Such a selection's `element` is a stand-in: an element with the target's tag, in a document + * with no window, the same one for a handle for the whole frame load. Nothing in it loads, runs or + * renders; from the frame it takes only the inline translate, box and Studio marks a gesture starts + * from, and the px the frame renders that translate as. The frame's element is the selection's + * `handle`. */ import { resolveEditingAffordances } from "@hyperframes/core/editing"; import { @@ -60,6 +61,17 @@ import { getPreviewTargetFromPointer, } from "../../utils/studioPreviewHelpers"; import { isVideoAudible } from "../../player/lib/timelineElementHelpers"; +import { registerPreviewStandIn } from "./previewDrafts"; +import { + STUDIO_HEIGHT_PROP, + STUDIO_OFFSET_X_PROP, + STUDIO_OFFSET_Y_PROP, + STUDIO_ORIGINAL_INLINE_TRANSLATE_ATTR, + STUDIO_ORIGINAL_TRANSLATE_ATTR, + STUDIO_PATH_OFFSET_ATTR, + STUDIO_WIDTH_PROP, +} from "./manualEditsTypes"; +import { rememberFrameTranslate, TRANSLATE_PX_PROPERTIES, translatePx } from "./plainTranslate"; let inertDocument: Document | undefined; const inert = () => (inertDocument ??= document.implementation.createHTMLDocument("")); @@ -72,6 +84,18 @@ function inertElement(tag: string): HTMLElement { } } +const GESTURE_START_STYLES = [ + "translate", + STUDIO_OFFSET_X_PROP, + STUDIO_OFFSET_Y_PROP, + STUDIO_WIDTH_PROP, + STUDIO_HEIGHT_PROP, +]; +const GESTURE_START_ATTRS = [ + STUDIO_PATH_OFFSET_ATTR, + STUDIO_ORIGINAL_TRANSLATE_ATTR, + STUDIO_ORIGINAL_INLINE_TRANSLATE_ATTR, +]; const standIns = new WeakMap>(); const standInHandles = new WeakMap(); const standInAncestors = new WeakMap(); @@ -83,8 +107,17 @@ export function standInFor(iframe: HTMLIFrameElement, element: PreviewElement): let standIn = byHandle.get(element.handle); if (!standIn) { standIn = inertElement(element.tag); + for (const name of GESTURE_START_STYLES) { + const value = element.inlineStyles[name]; + if (value && !mayBeCut(value)) standIn.style.setProperty(name, value); + } + for (const name of GESTURE_START_ATTRS) { + const value = attr(element, name); + if (value !== null && !mayBeCut(value)) standIn.setAttribute(name, value); + } byHandle.set(element.handle, standIn); standInHandles.set(standIn, element.handle); + registerPreviewStandIn(standIn, iframe, element.handle); } return standIn; } @@ -316,10 +349,18 @@ export async function resolvePreviewSelection( const compositionSrc = compositionSourceOf(current); const probe = readable(current); const inlineStyles = getInlineStyles(probe); - const computedStyles = await previewComputedStyles(iframe, current, [ - ...CURATED_STYLE_PROPERTIES, + const styles = await previewComputedStyles(iframe, current, [ + ...new Set([...CURATED_STYLE_PROPERTIES, ...TRANSLATE_PX_PROPERTIES]), ]); - if (!computedStyles) return null; + if (!styles) return null; + // The stand-in has no box to size a % or em against: a move starts from what the frame renders. + rememberFrameTranslate( + element, + translatePx(styles.translate ?? "none", (p) => styles[p] ?? ""), + ); + const computedStyles = Object.fromEntries( + CURATED_STYLE_PROPERTIES.flatMap((p) => (p in styles ? [[p, styles[p]!]] : [])), + ); const isCompositionRoot = await isPreviewCompositionRoot(iframe, chain, index, computedStyles); if (isCompositionRoot === null) return null; const isInsideLocked = chainLocked(chain, chainReader(chain), index); diff --git a/packages/studio/src/components/editor/resizeDraft.ts b/packages/studio/src/components/editor/resizeDraft.ts index 3ca46c7f7c..d631875ab7 100644 --- a/packages/studio/src/components/editor/resizeDraft.ts +++ b/packages/studio/src/components/editor/resizeDraft.ts @@ -9,6 +9,9 @@ import { import { computeNextResizeAnchor, resizeRemainderShift } from "./domEditResizeLocal"; import type { ResizeDraftSizes } from "./domEditResizeLocal"; import { applyManualOffsetDragDraft } from "./manualOffsetDrag"; +import { endStudioManualEditGesture, isStudioManualEditGestureCurrent } from "./manualEdits"; +import { drawPreviewDraft, endPreviewDraft } from "./previewDrafts"; +import { previewFrameOpaque } from "../../player/lib/previewChannel"; type Corners = ReturnType; @@ -80,6 +83,40 @@ function resolveAnchoredResizeDraft( ); } +/** A frame Studio cannot measure: the box grows about its centre by the size the draft wrote. */ +function resolveUnmeasuredResizeDraft( + g: GestureState, + element: HTMLElement, + { written }: ResizeDraftSizes, +): OverlayRect { + const width = (g.originWidth * written.width) / g.actualWidth; + const height = (g.originHeight * written.height) / g.actualHeight; + if (g.pathOffsetMember) { + const anchor = { + dx: ((g.actualWidth - written.width) / 2) * g.editScaleX, + dy: ((g.actualHeight - written.height) / 2) * g.editScaleY, + }; + g.lastResizeAnchor = anchor; + applyManualOffsetDragDraft(g.pathOffsetMember, anchor.dx, anchor.dy); + } + drawPreviewDraft(element, { size: written }); + return { + left: g.originLeft + (g.originWidth - width) / 2, + top: g.originTop + (g.originHeight - height) / 2, + width, + height, + editScaleX: g.editScaleX, + editScaleY: g.editScaleY, + angle: g.actualRotation, + }; +} + +/** Ends a settled resize that has no offset member; a frame it drew on keeps the new size. */ +export function endResizeWithoutMember(element: HTMLElement, token: string | undefined): void { + if (!token || isStudioManualEditGestureCurrent(element, token)) endPreviewDraft(element, "keep"); + endStudioManualEditGesture(element, token); +} + /** The overlay rect to paint for the current resize pointer-move frame. */ export function resolveResizeDraftRect( g: GestureState, @@ -89,6 +126,7 @@ export function resolveResizeDraftRect( measureOrientedRect: () => OverlayRect | null, sizes: ResizeDraftSizes, ): OverlayRect { + if (iframe && previewFrameOpaque(iframe)) return resolveUnmeasuredResizeDraft(g, element, sizes); if (g.pathOffsetMember) { return resolveAnchoredResizeDraft( g, diff --git a/packages/studio/src/components/editor/useDomEditOverlayGestures.ts b/packages/studio/src/components/editor/useDomEditOverlayGestures.ts index 3ee28a45be..e4cce7ed7a 100644 --- a/packages/studio/src/components/editor/useDomEditOverlayGestures.ts +++ b/packages/studio/src/components/editor/useDomEditOverlayGestures.ts @@ -45,7 +45,7 @@ import { resolveDomEditRotationGesture, } from "./domEditOverlayGestures"; import { resolveCenterResizeSize } from "./domEditResizeLocal"; -import { resolveResizeDraftRect } from "./resizeDraft"; +import { endResizeWithoutMember, resolveResizeDraftRect } from "./resizeDraft"; import { notifyBlockedPress } from "./domEditOverlayStartGesture"; import { hugRectForElement } from "./domEditOverlayCrop"; import { @@ -530,7 +530,7 @@ export function createDomEditOverlayGestureHandlers(opts: UseDomEditOverlayGestu }) .finally(() => { if (member) endManualOffsetDragMembers([member]); - else endStudioManualEditGesture(sel.element, g.manualEditDragToken); + else endResizeWithoutMember(sel.element, g.manualEditDragToken); }); edit.settle(saved); logResizeSettle(sel.element, "post-release"); diff --git a/packages/studio/src/utils/gsapSoftReload.ts b/packages/studio/src/utils/gsapSoftReload.ts index 1e7678725d..e43482abb4 100644 --- a/packages/studio/src/utils/gsapSoftReload.ts +++ b/packages/studio/src/utils/gsapSoftReload.ts @@ -286,8 +286,8 @@ export function applySoftReloadFinalization( currentTime: number, ): boolean { const win = iframe?.contentWindow as IframeWindow | null; - if (!win?.__hfForceTimelineRebind) return false; try { + if (!win?.__hfForceTimelineRebind) return false; if (win.__hfSuppressSceneMutations) { win.__hfSuppressSceneMutations(() => finalizeSoftReload(win, currentTime)); } else {