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 {