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 {