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 <noreply@anthropic.com>

* 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 <noreply@anthropic.com>

* 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 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
James Russo
2026-11-13 17:01:16 +00:00
committed by GitHub
co-authored by Claude Opus 5.5
parent d77731aab5
commit 87c4a07dc9
17 changed files with 768 additions and 30 deletions
@@ -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 } },
@@ -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 {
@@ -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 = `<div id="card" style="${style}"></div>`;
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 });
});
});
+133
View File
@@ -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<Element, Before>();
/** "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 };
}
@@ -73,6 +73,7 @@ describe("createEditingPortClient", () => {
"query",
"geometry",
"layers",
"draft",
],
});
} finally {
+42
View File
@@ -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<string, never>;
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<K extends EditingRequestKind> = EditingRequests[K]["params"];
export type EditingResult<K extends EditingRequestKind> = 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<K> | 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. */
@@ -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);
});
};
}
@@ -41,6 +41,7 @@ export {
restoreStudioBoxSize,
restoreStudioRotation,
restoreStudioPathOffset,
restoreStudioPathOffsetStyles,
clearStudioPathOffset,
clearStudioRotation,
clearStudioBoxSize,
@@ -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");
@@ -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<string, number | string>) => 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");
@@ -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<Element, { inline: string; px: Point }>();
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 {
@@ -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<typeof import("../../player/lib/previewChannel")>();
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 = `<main data-composition-id="main"><div id="card" style="width: 200px; height: 100px"></div><div id="chip" style="translate: 30px 0px"></div><div id="centred" style="width: 200px; height: 100px; translate: -50% -50%"></div><div id="moved" data-hf-studio-original-inline-translate="" style="translate: 10px 20px"></div></main>`;
});
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<string, unknown> = {};
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<HTMLElement> {
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);
});
});
@@ -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<string, Drawn>;
sending: boolean;
}
const standIns = new WeakMap<Element, { iframe: HTMLIFrameElement; handle: string }>();
const queues = new WeakMap<HTMLIFrameElement, Queue>();
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<Drawn>): 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);
}
@@ -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<EditingPortClient, Map<string, HTMLElement>>();
const standInHandles = new WeakMap<Element, string>();
const standInAncestors = new WeakMap<Element, string[]>();
@@ -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);
@@ -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<typeof elementCornerOverlayPoints>;
@@ -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,
@@ -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");
+1 -1
View File
@@ -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 {