@weasel-js/core 1.10.1 → 1.11.1

package/dist/interactions/actions/resize/cornerHandles.js.map

@@ -1 +1 @@
-{"version":3,"file":"cornerHandles.js","names":["CORNER_ANCHORS","cornerPoint","entry","bounds","cornerResizeHandles","p","c","hitCornerHandle","px","handle","radius","py","fixedCornerOf","anchor"],"sources":["../../../../src/interactions/actions/resize/cornerHandles.ts"],"sourcesContent":["import type { ResizeAnchor } from '../../gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** Corner resize-handle: world-space center plus the anchor that pins the opposite corner during resize. */\nexport interface CornerHandle {\n  cx: number;\n  cy: number;\n  anchor: ResizeAnchor;\n}\n\n/** Which AABB edge a corner sits on, per axis. `'min'` = the x/y origin\n *  edge; `'max'` = the origin + extent edge. */\nexport type CornerEdge = 'min' | 'max';\n\n/** One entry of the canonical 4-corner resize layout. The single source of\n *  truth for \"which corner maps to which anchor / handle-kind\". */\nexport interface CornerAnchor {\n  /** Which x-edge the corner sits on (`'min'` = left, `'max'` = right). */\n  xEdge: CornerEdge;\n  /** Which y-edge the corner sits on (`'min'` = top, `'max'` = bottom). */\n  yEdge: CornerEdge;\n  /** Anchor that pins the diagonally-opposite (fixed) corner. Always the\n   *  axis-wise opposite of `{xEdge, yEdge}`. */\n  anchor: ResizeAnchor;\n  /** Affordance/handle discriminator string for this corner. */\n  kind: string;\n  /** Short positional tag (`'<xEdge>-<yEdge>'`), e.g. `'min-max'`. */\n  tag: string;\n}\n\n/**\n * The single ordered corner→anchor table. Order is **load-bearing**: every\n * consumer iterates it in this sequence (TL, TR, BL, BR) so positional\n * meaning (the i-th handle / `kind` / `tag`) stays consistent across the\n * resize-handle affordance, the affordance-hit classifier, and\n * `cornerResizeHandles`. Each corner's `anchor` names the diagonally\n * opposite corner, so dragging the corner scales the box from that fixed\n * point.\n */\nexport const CORNER_ANCHORS: readonly CornerAnchor[] = [\n  { xEdge: 'min', yEdge: 'min', anchor: { x: 'max', y: 'max' }, kind: 'handle:top-left',     tag: 'min-min' },\n  { xEdge: 'max', yEdge: 'min', anchor: { x: 'min', y: 'max' }, kind: 'handle:top-right',    tag: 'max-min' },\n  { xEdge: 'min', yEdge: 'max', anchor: { x: 'max', y: 'min' }, kind: 'handle:bottom-left',  tag: 'min-max' },\n  { xEdge: 'max', yEdge: 'max', anchor: { x: 'min', y: 'min' }, kind: 'handle:bottom-right', tag: 'max-max' },\n];\n\n/** Resolve a corner's world-space position for the given bounds. `xEdge`\n *  `'max'` → `x + width`; `yEdge` `'max'` → `y + height`. */\nexport function cornerPoint(\n  bounds: Bounds,\n  entry: Pick<CornerAnchor, 'xEdge' | 'yEdge'>,\n): { x: number; y: number } {\n  return {\n    x: entry.xEdge === 'max' ? bounds.x + bounds.width : bounds.x,\n    y: entry.yEdge === 'max' ? bounds.y + bounds.height : bounds.y,\n  };\n}\n\n/** Standard 4-corner resize-handle layout: each corner pins the opposite\n *  corner via an anchor of `{x: 'min'|'max', y: 'min'|'max'}` so dragging it\n *  scales the box from the fixed opposite corner. Decodes {@link CORNER_ANCHORS}\n *  against `bounds`. */\nexport function cornerResizeHandles(bounds: Bounds): CornerHandle[] {\n  return CORNER_ANCHORS.map((c) => {\n    const p = cornerPoint(bounds, c);\n    return { cx: p.x, cy: p.y, anchor: c.anchor };\n  });\n}\n\n/** Square hit-test for a handle: returns true if `(px, py)` is within\n *  `radius` of the handle center on both axes. */\nexport function hitCornerHandle(\n  handle: CornerHandle,\n  px: number,\n  py: number,\n  radius: number,\n): boolean {\n  return Math.abs(px - handle.cx) <= radius\n    && Math.abs(py - handle.cy) <= radius;\n}\n\n/** The corner that does NOT move under a resize gesture with the given\n *  anchor. Used by the rotated-resize math to pin a world-space invariant.\n *\n *  Convention: `anchor.x === 'min'` means the min-x (left) edge is the\n *  fixed anchor, so the fixed corner sits at `x = bounds.x` (min-x).\n *  `anchor.x === 'max'` means the max-x (right) edge is fixed, so the\n *  fixed corner sits at `x = bounds.x + bounds.width`. `'free'` on an\n *  axis means that axis doesn't move; the fixed coord is the bounds\n *  origin on that axis. */\nexport function fixedCornerOf(\n  bounds: Bounds,\n  anchor: ResizeAnchor,\n): { x: number; y: number } {\n  return {\n    x: anchor.x === 'max' ? bounds.x + bounds.width : bounds.x,\n    y: anchor.y === 'max' ? bounds.y + bounds.height : bounds.y,\n  };\n}\n"],"mappings":";AAuCA,IAAaA,IAA0C;CACrD;EAAE,OAAO;EAAO,OAAO;EAAO,QAAQ;GAAE,GAAG;GAAO,GAAG;EAAM;EAAG,MAAM;EAAuB,KAAK;CAAU;CAC1G;EAAE,OAAO;EAAO,OAAO;EAAO,QAAQ;GAAE,GAAG;GAAO,GAAG;EAAM;EAAG,MAAM;EAAuB,KAAK;CAAU;CAC1G;EAAE,OAAO;EAAO,OAAO;EAAO,QAAQ;GAAE,GAAG;GAAO,GAAG;EAAM;EAAG,MAAM;EAAuB,KAAK;CAAU;CAC1G;EAAE,OAAO;EAAO,OAAO;EAAO,QAAQ;GAAE,GAAG;GAAO,GAAG;EAAM;EAAG,MAAM;EAAuB,KAAK;CAAU;AAC5G;AAIA,SAAgBC,EACd,GACA,GAC0B;CAC1B,OAAO;EACL,GAAGC,EAAM,UAAU,QAAQC,EAAO,IAAIA,EAAO,QAAQA,EAAO;EAC5D,GAAGD,EAAM,UAAU,QAAQC,EAAO,IAAIA,EAAO,SAASA,EAAO;CAC/D;AACF;AAMA,SAAgBC,EAAoB,GAAgC;CAClE,OAAOJ,EAAe,KAAK,MAAM;EAC/B,IAAMK,IAAIJ,EAAYE,GAAQG,CAAC;EAC/B,OAAO;GAAE,IAAID,EAAE;GAAG,IAAIA,EAAE;GAAG,QAAQC,EAAE;EAAO;CAC9C,CAAC;AACH;AAIA,SAAgBC,EACd,GACA,GACA,GACA,GACS;CACT,OAAO,KAAK,IAAIC,IAAKC,EAAO,EAAE,KAAKC,KAC9B,KAAK,IAAIC,IAAKF,EAAO,EAAE,KAAKC;AACnC;AAWA,SAAgBE,EACd,GACA,GAC0B;CAC1B,OAAO;EACL,GAAGC,EAAO,MAAM,QAAQV,EAAO,IAAIA,EAAO,QAAQA,EAAO;EACzD,GAAGU,EAAO,MAAM,QAAQV,EAAO,IAAIA,EAAO,SAASA,EAAO;CAC5D;AACF"}
+{"version":3,"file":"cornerHandles.js","names":[],"sources":["../../../../src/interactions/actions/resize/cornerHandles.ts"],"sourcesContent":["import type { ResizeAnchor } from '../../gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { pxExtentIn, type TargetTransform } from 'core/geometry/targetFrame';\n\n/** Corner resize-handle: world-space center plus the anchor that pins the opposite corner during resize. */\nexport interface CornerHandle {\n  cx: number;\n  cy: number;\n  anchor: ResizeAnchor;\n}\n\n/** Which AABB edge a corner sits on, per axis. `'min'` = the x/y origin\n *  edge; `'max'` = the origin + extent edge. */\nexport type CornerEdge = 'min' | 'max';\n\n/** Where a resize handle sits on one axis: on an edge (`CornerEdge`), or\n *  `'mid'`way between them, which is what makes a handle an edge handle. */\nexport type HandleEdge = CornerEdge | 'mid';\n\n/** One entry of the canonical resize-handle layout: where the handle sits,\n *  which edges it pins, and what a press on it reports. */\nexport interface ResizeHandleAnchor {\n  /** Where the handle sits on x (`'min'` = left, `'mid'` = centered, `'max'` = right). */\n  xEdge: HandleEdge;\n  /** Where the handle sits on y (`'min'` = top, `'mid'` = centered, `'max'` = bottom). */\n  yEdge: HandleEdge;\n  /** Anchor that pins the opposite side: the axis-wise opposite of each\n   *  edge the handle sits on, and `'free'` on an axis it sits mid-way along,\n   *  which the drag leaves alone. */\n  anchor: ResizeAnchor;\n  /** Affordance/handle discriminator string for this handle. */\n  kind: string;\n  /** Short positional tag (`'<xEdge>-<yEdge>'`), e.g. `'min-max'`. */\n  tag: string;\n}\n\n/** A corner entry of {@link RESIZE_HANDLE_ANCHORS}. */\nexport interface CornerAnchor extends ResizeHandleAnchor {\n  /** Which x-edge the corner sits on (`'min'` = left, `'max'` = right). */\n  xEdge: CornerEdge;\n  /** Which y-edge the corner sits on (`'min'` = top, `'max'` = bottom). */\n  yEdge: CornerEdge;\n}\n\n/**\n * The single ordered resize-handle table: the four corners (TL, TR, BL, BR),\n * then the four edge midpoints (top, right, bottom, left). Order is\n * **load-bearing**: the resize-handle affordance, the selection overlay and\n * `cornerResizeHandles` all iterate it in this sequence, so the i-th handle\n * means the same thing to each. A corner pins the diagonally opposite corner;\n * an edge pins the opposite edge and leaves the other axis free.\n */\nexport const RESIZE_HANDLE_ANCHORS: readonly ResizeHandleAnchor[] = [\n  { xEdge: 'min', yEdge: 'min', anchor: { x: 'max', y: 'max' }, kind: 'handle:top-left',     tag: 'min-min' },\n  { xEdge: 'max', yEdge: 'min', anchor: { x: 'min', y: 'max' }, kind: 'handle:top-right',    tag: 'max-min' },\n  { xEdge: 'min', yEdge: 'max', anchor: { x: 'max', y: 'min' }, kind: 'handle:bottom-left',  tag: 'min-max' },\n  { xEdge: 'max', yEdge: 'max', anchor: { x: 'min', y: 'min' }, kind: 'handle:bottom-right', tag: 'max-max' },\n  { xEdge: 'mid', yEdge: 'min', anchor: { x: 'free', y: 'max' }, kind: 'handle:top',         tag: 'mid-min' },\n  { xEdge: 'max', yEdge: 'mid', anchor: { x: 'min', y: 'free' }, kind: 'handle:right',       tag: 'max-mid' },\n  { xEdge: 'mid', yEdge: 'max', anchor: { x: 'free', y: 'min' }, kind: 'handle:bottom',      tag: 'mid-max' },\n  { xEdge: 'min', yEdge: 'mid', anchor: { x: 'max', y: 'free' }, kind: 'handle:left',        tag: 'min-mid' },\n];\n\n/** True for a corner entry of {@link RESIZE_HANDLE_ANCHORS}. */\nexport function isCornerHandle(entry: ResizeHandleAnchor): entry is CornerAnchor {\n  return entry.xEdge !== 'mid' && entry.yEdge !== 'mid';\n}\n\n/** The corner entries of {@link RESIZE_HANDLE_ANCHORS}, in its order. */\nexport const CORNER_ANCHORS: readonly CornerAnchor[] = RESIZE_HANDLE_ANCHORS.filter(isCornerHandle);\n\n/** An edge handle sits this many hit radii on screen from each corner of the\n *  side it is on, at least: under that, it would crowd the corners and leave\n *  the body too little room to be grabbed. At the default 8 px radius, a\n *  side must span 48 px. */\nexport const EDGE_HANDLE_MIN_RADII = 6;\n\n/** Whether a body this size, in its own frame `xf`, has room for edge\n *  handles on screen: each side spans {@link EDGE_HANDLE_MIN_RADII} times\n *  `radiusPx`. Both sides, because a short side puts the two handles across\n *  it over the middle of the body. */\nexport function edgeHandlesFit(\n  body: { width: number; height: number },\n  xf: TargetTransform,\n  scale: { x: number; y: number },\n  radiusPx: number,\n): boolean {\n  const floor = pxExtentIn(EDGE_HANDLE_MIN_RADII * radiusPx, scale, xf);\n  return Math.abs(body.width) >= floor.x && Math.abs(body.height) >= floor.y;\n}\n\n/** How a canvas lays out its resize handles. `hitRadiusPx` is the one size\n *  the edge-handle decision keys on, because a handle exists to be grabbed:\n *  paint and hit-test both read it, so no handle is drawn that cannot be\n *  grabbed or grabbable where none is drawn. */\nexport interface ResizeHandleLayout {\n  /** Whether the edge midpoints get handles at all. */\n  edges: boolean;\n  /** The handles' hit radius, screen px. */\n  hitRadiusPx: number;\n}\n\n/** The handles a body gets in `layout`: every corner, then the edge\n *  midpoints when the layout has them and {@link edgeHandlesFit} at its hit\n *  radius. The answer the selection overlay paints; the hit-test reaches the\n *  same one through the regions' `edgeOf`. */\nexport function resizeHandlesFor(\n  layout: ResizeHandleLayout,\n  body: { width: number; height: number },\n  xf: TargetTransform,\n  scale: { x: number; y: number },\n): readonly ResizeHandleAnchor[] {\n  return layout.edges && edgeHandlesFit(body, xf, scale, layout.hitRadiusPx)\n    ? RESIZE_HANDLE_ANCHORS\n    : CORNER_ANCHORS;\n}\n\n/** Resolve a handle's position for the given bounds, in the bounds' frame:\n *  `'min'` → the origin edge, `'max'` → origin + extent, `'mid'` → between. */\nexport function handlePoint(\n  bounds: Bounds,\n  entry: Pick<ResizeHandleAnchor, 'xEdge' | 'yEdge'>,\n): { x: number; y: number } {\n  return {\n    x: bounds.x + bounds.width * EDGE_FRACTION[entry.xEdge],\n    y: bounds.y + bounds.height * EDGE_FRACTION[entry.yEdge],\n  };\n}\n\nconst EDGE_FRACTION: Record<HandleEdge, number> = { min: 0, mid: 0.5, max: 1 };\n\n/** @deprecated Use {@link handlePoint}, which also places edge handles. */\nexport const cornerPoint: (\n  bounds: Bounds,\n  entry: Pick<CornerAnchor, 'xEdge' | 'yEdge'>,\n) => { x: number; y: number } = handlePoint;\n\n/** Standard 4-corner resize-handle layout: each corner pins the opposite\n *  corner via an anchor of `{x: 'min'|'max', y: 'min'|'max'}` so dragging it\n *  scales the box from the fixed opposite corner. Decodes {@link CORNER_ANCHORS}\n *  against `bounds`; edge handles are the affordance's, which knows the view. */\nexport function cornerResizeHandles(bounds: Bounds): CornerHandle[] {\n  return CORNER_ANCHORS.map((c) => {\n    const p = handlePoint(bounds, c);\n    return { cx: p.x, cy: p.y, anchor: c.anchor };\n  });\n}\n\n/** Square hit-test for a handle: returns true if `(px, py)` is within\n *  `radius` of the handle center on both axes. */\nexport function hitCornerHandle(\n  handle: CornerHandle,\n  px: number,\n  py: number,\n  radius: number,\n): boolean {\n  return Math.abs(px - handle.cx) <= radius\n    && Math.abs(py - handle.cy) <= radius;\n}\n\n/** The corner that does NOT move under a resize gesture with the given\n *  anchor. Used by the rotated-resize math to pin a world-space invariant.\n *\n *  Convention: `anchor.x === 'min'` means the min-x (left) edge is the\n *  fixed anchor, so the fixed corner sits at `x = bounds.x` (min-x).\n *  `anchor.x === 'max'` means the max-x (right) edge is fixed, so the\n *  fixed corner sits at `x = bounds.x + bounds.width`. `'free'` on an\n *  axis (an edge handle's other axis) pins the bounds' center on it: a drag\n *  leaves that extent alone, and an aspect lock grows it about the center. */\nexport function fixedCornerOf(\n  bounds: Bounds,\n  anchor: ResizeAnchor,\n): { x: number; y: number } {\n  return handlePoint(bounds, { xEdge: PINNED[anchor.x], yEdge: PINNED[anchor.y] });\n}\n\nconst PINNED: Record<ResizeAnchor['x'], HandleEdge> = { min: 'min', max: 'max', free: 'mid' };\n\n/** The corner or edge midpoint of `bounds` a resize pinning `anchor` moves. */\nexport function movingPoint(bounds: Bounds, anchor: ResizeAnchor): { x: number; y: number } {\n  return handlePoint(bounds, { xEdge: MOVING[anchor.x], yEdge: MOVING[anchor.y] });\n}\n\nconst MOVING: Record<ResizeAnchor['x'], HandleEdge> = { min: 'max', max: 'min', free: 'mid' };\n\n/** `bounds` with the edges `anchor` leaves free moved by `(dx, dy)`, in its own axes. */\nexport function movedEdges(bounds: Bounds, anchor: ResizeAnchor, dx: number, dy: number): Bounds {\n  let { x, y, width, height } = bounds;\n  if (anchor.x === 'min') width += dx;\n  else if (anchor.x === 'max') { x += dx; width -= dx; }\n  if (anchor.y === 'min') height += dy;\n  else if (anchor.y === 'max') { y += dy; height -= dy; }\n  return { x, y, width, height };\n}\n"],"mappings":"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"}

package/dist/interactions/actions/resize/frame.js

@@ -1,88 +1,155 @@
-import { remapRotatedLeaf as e, translatePoseViaDescriptor as t } from "../../../core/geometry/poseDescriptor.js";
-import { localToWorld as n, worldDeltaToLocal as r } from "../../../core/geometry/targetFrame.js";
-import { fixedCornerOf as i } from "./cornerHandles.js";
-import { carryPose as a, planeOf as o } from "../planeInput.js";
-import { pointerStateOf as s } from "../pointerState.js";
-import { boxFrame as c } from "./boxFrame.js";
-import { boundsForRules as l } from "./ruleBounds.js";
-import { snapPose as u } from "./pointSnap.js";
-import { poseFrameOf as d } from "@weasel-js/geom";
+import { remapRotatedLeaf, translatePoseViaDescriptor } from "../../../core/geometry/poseDescriptor.js";
+import { localToWorld, worldDeltaToLocal } from "../../../core/geometry/targetFrame.js";
+import { insetBox, outsetBox } from "../../../core/geometry/inkExtents.js";
+import { fixedCornerOf, movedEdges } from "./cornerHandles.js";
+import { carryPose, planeOf } from "../planeInput.js";
+import { pointerStateOf } from "../pointerState.js";
+import { snapMods } from "../../../features/snap/roles.js";
+import { boundsForRules } from "./ruleBounds.js";
+import { boxFrame } from "./boxFrame.js";
+import { clampToMinSize } from "./behaviors/clampMinSize.js";
+import { edgeAspect, onDiagonal } from "./aspect.js";
+import { poseFrameOf } from "@weasel-js/geom";
+
 //#region src/interactions/actions/resize/frame.ts
-function f(e, t, n, i, a) {
-	let { x: o, y: s } = r(a, n, i) ?? {
+/** `ob` with the edges `anchor` leaves free moved by the drag delta, which is
+*  taken into the axes of the frame the box is drawn in first. A frame nothing
+*  maps back through moves no edge. */
+function computeProposedBounds(ob, anchor, worldDx, worldDy, frame) {
+	const { x: dx, y: dy } = worldDeltaToLocal(frame, worldDx, worldDy) ?? {
 		x: 0,
 		y: 0
-	}, c = e.x, l = e.y, u = e.width, d = e.height;
-	return t.x === "min" ? u = e.width + o : t.x === "max" && (c = e.x + o, u = e.width - o), t.y === "min" ? d = e.height + s : t.y === "max" && (l = e.y + s, d = e.height - s), {
-		x: c,
-		y: l,
-		width: u,
-		height: d
 	};
+	return movedEdges(ob, anchor, dx, dy);
 }
-function p(e, t, n, r) {
-	let i = r;
-	for (let r of e) {
-		let e = r.onMove?.(t, {
-			pose: i,
-			anchor: n
-		});
-		e && e.pose !== void 0 && (i = {
-			x: e.pose.x,
-			y: e.pose.y,
-			width: e.pose.width,
-			height: e.pose.height
+/** `proposed` as the constraints rewrite it, each seeing the one before's. */
+function constrain(constraints, gctx, anchor, proposed) {
+	let bounds = proposed;
+	for (const b of constraints) {
+		const r = b.onMove?.(gctx, {
+			pose: bounds,
+			anchor
 		});
+		if (!r) continue;
+		if (r.pose !== void 0) bounds = {
+			x: r.pose.x,
+			y: r.pose.y,
+			width: r.pose.width,
+			height: r.pose.height
+		};
 	}
-	return i;
+	return bounds;
 }
-function m(t, n, r, i, a) {
-	return a && d(n) !== null ? e(n, r, i) : t.remapBounds(n, r, i);
+/** One write id's world pose with the box taken from `src` to `dst`.
+*
+*  A turned or skewed leaf resized with others needs its own frame: `src`/`dst`
+*  are world-frame there, unlike the lone path where the drag delta
+*  was already projected into the leaf's frame, so the naive affine
+*  scales the wrong pair of extents. See `remapRotatedLeaf`. */
+function leafPose(g, start, src, dst, sharedBox) {
+	if (sharedBox && poseFrameOf(start) !== null) return remapRotatedLeaf(start, src, dst);
+	return g.remapBounds(start, src, dst);
 }
-function h(e, r, a, o) {
-	let s = c(a, o);
-	if (s.identity) return r;
-	let l = i(o, a.anchor), u = n(s, l.x, l.y);
-	return t(r, a.fixedWorld.x - u.x, a.fixedWorld.y - u.y, e);
+/** `pose` shifted so the corner opposite the dragged one stays where the
+*  press found it, which resizing a box whose frame is about its center moves. */
+function pinFixedCorner(g, pose, box, proposed) {
+	const frame = boxFrame(box, proposed);
+	if (frame.identity) return pose;
+	const newFixedLocal = fixedCornerOf(proposed, box.anchor);
+	const newFixedWorld = localToWorld(frame, newFixedLocal.x, newFixedLocal.y);
+	return translatePoseViaDescriptor(pose, box.fixedWorld.x - newFixedWorld.x, box.fixedWorld.y - newFixedWorld.y, g);
 }
-function g(e, t, n) {
-	let r = e.scene.get(t)?.layer;
-	return e.poseFrame.local(t, a(e.geometryOf(t), n, r === void 0 ? null : o(e.view, r)));
+/** A world result for `id`, as stored. */
+function storedPose(place, id, world) {
+	const layer = place.scene.get(id)?.layer;
+	return place.poseFrame.local(id, carryPose(place.geometryOf(id), world, layer === void 0 ? null : planeOf(place.view, layer)));
 }
-function _(e, t, n = (e, t) => t) {
-	let { box: r } = e, i = /* @__PURE__ */ new Map(), a = (n) => {
-		let i = e.startWorlds.get(n);
-		if (i !== void 0) return m(e.geometryOf(n), i, r.bounds, t, e.sharedBox);
+/** Every write id's stored pose with the box taken from where the press found
+*  it to `asked`, held to the place's minimum. A lone target is also pinned at
+*  the fixed corner, and comes back with its world pose. `proposed` is the box
+*  they were put in. */
+function posesInBox(place, asked) {
+	const { box } = place;
+	const proposed = (place.minimum && clampToMinSize(asked, box.anchor, place.minimum)) ?? asked;
+	const previews = /* @__PURE__ */ new Map();
+	const worldOf = (id) => {
+		const start = place.startWorlds.get(id);
+		if (start === void 0) return void 0;
+		return leafPose(place.geometryOf(id), start, box.bounds, proposed, place.sharedBox);
 	};
-	if (e.sharedBox) {
-		for (let t of e.writeIds) {
-			let n = a(t);
-			n !== void 0 && i.set(t, g(e, t, n));
+	if (place.sharedBox) {
+		for (const id of place.writeIds) {
+			const next = worldOf(id);
+			if (next === void 0) continue;
+			previews.set(id, storedPose(place, id, next));
 		}
-		return { previews: i };
+		return {
+			previews,
+			proposed
+		};
 	}
-	let o = e.writeIds[0], s = e.geometryOf(o), c = a(o);
-	if (c === void 0) return { previews: i };
-	let l = n(s, h(s, c, r, t));
-	return i.set(o, g(e, o, l)), {
-		previews: i,
+	const id = place.writeIds[0];
+	const g = place.geometryOf(id);
+	const remapped = worldOf(id);
+	if (remapped === void 0) return {
+		previews,
+		proposed
+	};
+	const world = pinFixedCorner(g, remapped, box, proposed);
+	previews.set(id, storedPose(place, id, world));
+	return {
+		previews,
+		proposed,
 		lone: {
-			id: o,
-			g: s,
-			world: l
+			id,
+			g,
+			world
 		}
 	};
 }
-function v(e, t, n) {
-	let r = n.drag.current, { box: i, gestureCtx: a } = e;
-	a.modifiers = { ...n.modifiers }, a.pointer = s(r, n), a.view = t.view(), a.plane = t.plane();
-	let o = p(e.constraints, a, i.anchor, f(i.bounds, i.anchor, r.x - e.startWorld.x, r.y - e.startWorld.y, c(i, i.bounds))), { previews: d, lone: m } = _(e, o, (t, n) => u(e.pointSnap, t, n, i, i.anchor, a.modifiers, a.plane ?? null));
-	return m && (a.current = /* @__PURE__ */ new Map([[m.id, l(m.g, m.world)]])), {
-		previews: d,
-		proposed: o
+/** The pointer put on the box's diagonal, for an aspect-locked corner: the
+*  session's input subspace then leaves it where it is, and a target still
+*  lands it where the diagonal meets the target. */
+function aspectPointer(session, frame, drawn, raw) {
+	const { startWorld: o, box } = session;
+	const local = worldDeltaToLocal(frame, raw.x - o.x, raw.y - o.y);
+	const d = local && onDiagonal(local, drawn, box.anchor);
+	if (!d) return raw;
+	const zero = localToWorld(frame, 0, 0);
+	const w = localToWorld(frame, d.x, d.y);
+	return {
+		x: o.x + w.x - zero.x,
+		y: o.y + w.y - zero.y
+	};
+}
+/** One move's previews: the box as the snapped drag and the constraints
+*  leave it, and every write id's stored pose inside it. A lone target also
+*  gets the rotated-resize pin; a shared box, resized in the AABB frame, does
+*  not.
+*  `moveCtx` must carry a drag. */
+function nextFrame(session, readers, moveCtx) {
+	const raw = moveCtx.drag.current;
+	const { box, gestureCtx: gctx } = session;
+	gctx.modifiers = { ...moveCtx.modifiers };
+	gctx.pointer = pointerStateOf(raw, moveCtx);
+	gctx.view = readers.view();
+	gctx.plane = readers.plane();
+	const mods = snapMods(moveCtx);
+	const frame = boxFrame(box, box.bounds);
+	const drawnStart = outsetBox(box.bounds, box.extents);
+	const pointer = mods.constrain ? aspectPointer(session, frame, drawnStart, raw) : raw;
+	const at = session.snap.at(pointer, mods).point;
+	const moved = computeProposedBounds(box.bounds, box.anchor, at.x - session.startWorld.x, at.y - session.startWorld.y, frame);
+	const drawn = outsetBox(moved, box.extents);
+	const shaped = mods.constrain ? edgeAspect(drawn, drawnStart, box.anchor) : drawn;
+	const { previews, proposed, lone } = posesInBox(session, insetBox(constrain(session.constraints, gctx, box.anchor, shaped), box.extents));
+	if (lone) gctx.current = /* @__PURE__ */ new Map([[lone.id, outsetBox(boundsForRules(lone.g, lone.world), box.extents)]]);
+	return {
+		previews,
+		proposed
 	};
 }
-//#endregion
-export { v as nextFrame, _ as posesInBox };
 
+//#endregion
+export { nextFrame, posesInBox };
 //# sourceMappingURL=frame.js.map

package/dist/interactions/actions/resize/frame.js.map

@@ -1 +1 @@
-{"version":3,"file":"frame.js","names":["computeProposedBounds","dx","dy","worldDeltaToLocal","frame","worldDx","worldDy","nx","ob","ny","nw","nh","anchor","constrain","bounds","proposed","b","constraints","r","gctx","leafPose","sharedBox","poseFrameOf","start","remapRotatedLeaf","src","dst","g","pinFixedCorner","boxFrame","box","pose","newFixedLocal","fixedCornerOf","newFixedWorld","localToWorld","translatePoseViaDescriptor","storedPose","layer","place","id","carryPose","world","planeOf","posesInBox","previews","worldOf","next","remapped","snap","nextFrame","at","moveCtx","session","pointerStateOf","readers","snapPose","lone","boundsForRules"],"sources":["../../../../src/interactions/actions/resize/frame.ts"],"sourcesContent":["import { poseFrameOf } from '@weasel-js/geom';\nimport type { InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport { localToWorld, worldDeltaToLocal, type TargetTransform } from 'core/geometry/targetFrame';\nimport type { NodeId } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { BoundsConstraint, GestureContext, ResizeAnchor, RotatedPose } from '../../gestures/types';\nimport { carryPose, planeOf } from '../planeInput';\nimport { fixedCornerOf } from './cornerHandles';\nimport { remapRotatedLeaf, translatePoseViaDescriptor, type PoseDescriptor } from './geometry';\nimport { snapPose } from './pointSnap';\nimport { boundsForRules } from './ruleBounds';\nimport { boxFrame } from './boxFrame';\nimport type { ResizeBox, ResizeFrame, ResizeSession } from './session';\n\n/** `ob` with the edges `anchor` leaves free moved by the drag delta, which is\n *  taken into the axes of the frame the box is drawn in first. A frame nothing\n *  maps back through moves no edge. */\nfunction computeProposedBounds(\n  ob: Bounds,\n  anchor: ResizeAnchor,\n  worldDx: number,\n  worldDy: number,\n  frame: TargetTransform,\n): Bounds {\n  const { x: dx, y: dy } = worldDeltaToLocal(frame, worldDx, worldDy) ?? { x: 0, y: 0 };\n  let nx = ob.x;\n  let ny = ob.y;\n  let nw = ob.width;\n  let nh = ob.height;\n  if (anchor.x === 'min') {\n    nw = ob.width + dx;\n  } else if (anchor.x === 'max') {\n    nx = ob.x + dx;\n    nw = ob.width - dx;\n  }\n  if (anchor.y === 'min') {\n    nh = ob.height + dy;\n  } else if (anchor.y === 'max') {\n    ny = ob.y + dy;\n    nh = ob.height - dy;\n  }\n  return { x: nx, y: ny, width: nw, height: nh };\n}\n\n/** `proposed` as the constraints rewrite it, each seeing the one before's. */\nfunction constrain(\n  constraints: readonly BoundsConstraint<Bounds>[],\n  gctx: GestureContext<Bounds>,\n  anchor: ResizeAnchor,\n  proposed: Bounds,\n): Bounds {\n  let bounds = proposed;\n  for (const b of constraints) {\n    const r = b.onMove?.(gctx, { pose: bounds, anchor });\n    if (!r) continue;\n    if (r.pose !== undefined) {\n      bounds = { x: r.pose.x, y: r.pose.y, width: r.pose.width, height: r.pose.height };\n    }\n  }\n  return bounds;\n}\n\n/** One write id's world pose with the box taken from `src` to `dst`.\n *\n *  A turned or skewed leaf resized with others needs its own frame: `src`/`dst`\n *  are world-frame there, unlike the lone path where the drag delta\n *  was already projected into the leaf's frame, so the naive affine\n *  scales the wrong pair of extents. See `remapRotatedLeaf`. */\nfunction leafPose(\n  g: PoseDescriptor<unknown>,\n  start: unknown,\n  src: Bounds,\n  dst: Bounds,\n  sharedBox: boolean,\n): unknown {\n  if (sharedBox && poseFrameOf(start) !== null) {\n    return remapRotatedLeaf(start as RotatedPose, src, dst);\n  }\n  return g.remapBounds(start, src, dst);\n}\n\n/** `pose` shifted so the corner opposite the dragged one stays where the\n *  press found it, which resizing a box whose frame is about its center moves. */\nfunction pinFixedCorner(\n  g: PoseDescriptor<unknown>,\n  pose: unknown,\n  box: Pick<ResizeBox, 'anchor' | 'rotation' | 'transform' | 'fixedWorld'>,\n  proposed: Bounds,\n): unknown {\n  const frame = boxFrame(box, proposed);\n  if (frame.identity) return pose;\n  const newFixedLocal = fixedCornerOf(proposed, box.anchor);\n  const newFixedWorld = localToWorld(frame, newFixedLocal.x, newFixedLocal.y);\n  return translatePoseViaDescriptor(\n    pose,\n    box.fixedWorld.x - newFixedWorld.x,\n    box.fixedWorld.y - newFixedWorld.y,\n    g,\n  );\n}\n\n/** A world result for `id`, as stored. */\nfunction storedPose(\n  place: Pick<ResizeSession, 'scene' | 'poseFrame' | 'view' | 'geometryOf'>,\n  id: NodeId,\n  world: unknown,\n): unknown {\n  const layer = place.scene.get(id)?.layer;\n  return place.poseFrame.local(\n    id,\n    carryPose(place.geometryOf(id), world, layer === undefined ? null : planeOf(place.view, layer)),\n  );\n}\n\n/** Every write id's stored pose with the box taken from where the press found\n *  it to `proposed`. A lone target is also pinned at the fixed corner and run\n *  through `snap`, and comes back with its world pose. */\nexport function posesInBox(\n  place: Pick<ResizeSession, 'scene' | 'poseFrame' | 'view' | 'geometryOf' | 'writeIds' | 'startWorlds' | 'box' | 'sharedBox'>,\n  proposed: Bounds,\n  snap: (g: PoseDescriptor<unknown>, world: unknown) => unknown = (_g, world) => world,\n): { previews: Map<NodeId, unknown>; lone?: { id: NodeId; g: PoseDescriptor<unknown>; world: unknown } } {\n  const { box } = place;\n  const previews = new Map<NodeId, unknown>();\n  const worldOf = (id: NodeId): unknown => {\n    const start = place.startWorlds.get(id);\n    if (start === undefined) return undefined;\n    return leafPose(place.geometryOf(id), start, box.bounds, proposed, place.sharedBox);\n  };\n\n  if (place.sharedBox) {\n    for (const id of place.writeIds) {\n      const next = worldOf(id);\n      if (next === undefined) continue;\n      previews.set(id, storedPose(place, id, next));\n    }\n    return { previews };\n  }\n\n  const id = place.writeIds[0];\n  const g = place.geometryOf(id);\n  const remapped = worldOf(id);\n  if (remapped === undefined) return { previews };\n  const world = snap(g, pinFixedCorner(g, remapped, box, proposed));\n  previews.set(id, storedPose(place, id, world));\n  return { previews, lone: { id, g, world } };\n}\n\n/** One move's previews: the box as the drag and the constraints leave it,\n *  and every write id's stored pose inside it. A lone target also gets the\n *  rotated-resize pin and the point snaps, which a shared box, resized in the\n *  AABB frame, does not. `moveCtx` must carry a drag. */\nexport function nextFrame(session: ResizeSession, readers: GestureReaders, moveCtx: InvocationCtx): ResizeFrame {\n  const at = moveCtx.drag!.current;\n  const { box, gestureCtx: gctx } = session;\n  gctx.modifiers = { ...moveCtx.modifiers };\n  gctx.pointer = pointerStateOf(at, moveCtx);\n  gctx.view = readers.view();\n  gctx.plane = readers.plane();\n\n  const proposed = constrain(\n    session.constraints,\n    gctx,\n    box.anchor,\n    computeProposedBounds(box.bounds, box.anchor, at.x - session.startWorld.x, at.y - session.startWorld.y, boxFrame(box, box.bounds)),\n  );\n\n  const { previews, lone } = posesInBox(session, proposed, (g, world) => snapPose(\n    session.pointSnap, g, world, box, box.anchor, gctx.modifiers, gctx.plane ?? null,\n  ));\n  if (lone) gctx.current = new Map<string, Bounds>([[lone.id as string, boundsForRules(lone.g, lone.world)]]);\n  return { previews, proposed };\n}\n"],"mappings":"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"}
+{"version":3,"file":"frame.js","names":[],"sources":["../../../../src/interactions/actions/resize/frame.ts"],"sourcesContent":["import { poseFrameOf } from '@weasel-js/geom';\nimport type { InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport { localToWorld, worldDeltaToLocal, type TargetTransform } from 'core/geometry/targetFrame';\nimport type { NodeId } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { BoundsConstraint, GestureContext, ResizeAnchor, RotatedPose } from '../../gestures/types';\nimport { carryPose, planeOf } from '../planeInput';\nimport { fixedCornerOf, movedEdges } from './cornerHandles';\nimport { remapRotatedLeaf, translatePoseViaDescriptor, type PoseDescriptor } from './geometry';\nimport { boundsForRules } from './ruleBounds';\nimport { boxFrame } from './boxFrame';\nimport { insetBox, outsetBox } from 'core/geometry/inkExtents';\nimport type { ResizeBox, ResizeFrame, ResizeSession } from './session';\nimport { clampToMinSize } from './behaviors/clampMinSize';\nimport { edgeAspect, onDiagonal } from './aspect';\nimport { snapMods } from 'features/snap/roles';\n\n/** `ob` with the edges `anchor` leaves free moved by the drag delta, which is\n *  taken into the axes of the frame the box is drawn in first. A frame nothing\n *  maps back through moves no edge. */\nfunction computeProposedBounds(\n  ob: Bounds,\n  anchor: ResizeAnchor,\n  worldDx: number,\n  worldDy: number,\n  frame: TargetTransform,\n): Bounds {\n  const { x: dx, y: dy } = worldDeltaToLocal(frame, worldDx, worldDy) ?? { x: 0, y: 0 };\n  return movedEdges(ob, anchor, dx, dy);\n}\n\n/** `proposed` as the constraints rewrite it, each seeing the one before's. */\nfunction constrain(\n  constraints: readonly BoundsConstraint<Bounds>[],\n  gctx: GestureContext<Bounds>,\n  anchor: ResizeAnchor,\n  proposed: Bounds,\n): Bounds {\n  let bounds = proposed;\n  for (const b of constraints) {\n    const r = b.onMove?.(gctx, { pose: bounds, anchor });\n    if (!r) continue;\n    if (r.pose !== undefined) {\n      bounds = { x: r.pose.x, y: r.pose.y, width: r.pose.width, height: r.pose.height };\n    }\n  }\n  return bounds;\n}\n\n/** One write id's world pose with the box taken from `src` to `dst`.\n *\n *  A turned or skewed leaf resized with others needs its own frame: `src`/`dst`\n *  are world-frame there, unlike the lone path where the drag delta\n *  was already projected into the leaf's frame, so the naive affine\n *  scales the wrong pair of extents. See `remapRotatedLeaf`. */\nfunction leafPose(\n  g: PoseDescriptor<unknown>,\n  start: unknown,\n  src: Bounds,\n  dst: Bounds,\n  sharedBox: boolean,\n): unknown {\n  if (sharedBox && poseFrameOf(start) !== null) {\n    return remapRotatedLeaf(start as RotatedPose, src, dst);\n  }\n  return g.remapBounds(start, src, dst);\n}\n\n/** `pose` shifted so the corner opposite the dragged one stays where the\n *  press found it, which resizing a box whose frame is about its center moves. */\nfunction pinFixedCorner(\n  g: PoseDescriptor<unknown>,\n  pose: unknown,\n  box: Pick<ResizeBox, 'anchor' | 'rotation' | 'transform' | 'fixedWorld'>,\n  proposed: Bounds,\n): unknown {\n  const frame = boxFrame(box, proposed);\n  if (frame.identity) return pose;\n  const newFixedLocal = fixedCornerOf(proposed, box.anchor);\n  const newFixedWorld = localToWorld(frame, newFixedLocal.x, newFixedLocal.y);\n  return translatePoseViaDescriptor(\n    pose,\n    box.fixedWorld.x - newFixedWorld.x,\n    box.fixedWorld.y - newFixedWorld.y,\n    g,\n  );\n}\n\n/** A world result for `id`, as stored. */\nfunction storedPose(\n  place: Pick<ResizeSession, 'scene' | 'poseFrame' | 'view' | 'geometryOf'>,\n  id: NodeId,\n  world: unknown,\n): unknown {\n  const layer = place.scene.get(id)?.layer;\n  return place.poseFrame.local(\n    id,\n    carryPose(place.geometryOf(id), world, layer === undefined ? null : planeOf(place.view, layer)),\n  );\n}\n\n/** Every write id's stored pose with the box taken from where the press found\n *  it to `asked`, held to the place's minimum. A lone target is also pinned at\n *  the fixed corner, and comes back with its world pose. `proposed` is the box\n *  they were put in. */\nexport function posesInBox(\n  place: Pick<ResizeSession, 'scene' | 'poseFrame' | 'view' | 'geometryOf' | 'writeIds' | 'startWorlds' | 'box' | 'sharedBox' | 'minimum'>,\n  asked: Bounds,\n): { previews: Map<NodeId, unknown>; proposed: Bounds; lone?: { id: NodeId; g: PoseDescriptor<unknown>; world: unknown } } {\n  const { box } = place;\n  const proposed = (place.minimum && clampToMinSize(asked, box.anchor, place.minimum)) ?? asked;\n  const previews = new Map<NodeId, unknown>();\n  const worldOf = (id: NodeId): unknown => {\n    const start = place.startWorlds.get(id);\n    if (start === undefined) return undefined;\n    return leafPose(place.geometryOf(id), start, box.bounds, proposed, place.sharedBox);\n  };\n\n  if (place.sharedBox) {\n    for (const id of place.writeIds) {\n      const next = worldOf(id);\n      if (next === undefined) continue;\n      previews.set(id, storedPose(place, id, next));\n    }\n    return { previews, proposed };\n  }\n\n  const id = place.writeIds[0];\n  const g = place.geometryOf(id);\n  const remapped = worldOf(id);\n  if (remapped === undefined) return { previews, proposed };\n  const world = pinFixedCorner(g, remapped, box, proposed);\n  previews.set(id, storedPose(place, id, world));\n  return { previews, proposed, lone: { id, g, world } };\n}\n\n/** The pointer put on the box's diagonal, for an aspect-locked corner: the\n *  session's input subspace then leaves it where it is, and a target still\n *  lands it where the diagonal meets the target. */\nfunction aspectPointer(session: ResizeSession, frame: TargetTransform, drawn: Bounds, raw: { x: number; y: number }): { x: number; y: number } {\n  const { startWorld: o, box } = session;\n  const local = worldDeltaToLocal(frame, raw.x - o.x, raw.y - o.y);\n  const d = local && onDiagonal(local, drawn, box.anchor);\n  if (!d) return raw;\n  const zero = localToWorld(frame, 0, 0);\n  const w = localToWorld(frame, d.x, d.y);\n  return { x: o.x + w.x - zero.x, y: o.y + w.y - zero.y };\n}\n\n/** One move's previews: the box as the snapped drag and the constraints\n *  leave it, and every write id's stored pose inside it. A lone target also\n *  gets the rotated-resize pin; a shared box, resized in the AABB frame, does\n *  not.\n *  `moveCtx` must carry a drag. */\nexport function nextFrame(session: ResizeSession, readers: GestureReaders, moveCtx: InvocationCtx): ResizeFrame {\n  const raw = moveCtx.drag!.current;\n  const { box, gestureCtx: gctx } = session;\n  gctx.modifiers = { ...moveCtx.modifiers };\n  gctx.pointer = pointerStateOf(raw, moveCtx);\n  gctx.view = readers.view();\n  gctx.plane = readers.plane();\n\n  const mods = snapMods(moveCtx);\n  const frame = boxFrame(box, box.bounds);\n  const drawnStart = outsetBox(box.bounds, box.extents);\n  const pointer = mods.constrain ? aspectPointer(session, frame, drawnStart, raw) : raw;\n  const snapped = session.snap.at(pointer, mods);\n  const at = snapped.point;\n  // The constraints see the box as drawn; the stroke keeps its width, so the\n  // extents come back off what they leave.\n  const moved = computeProposedBounds(box.bounds, box.anchor, at.x - session.startWorld.x, at.y - session.startWorld.y, frame);\n  const drawn = outsetBox(moved, box.extents);\n  const shaped = mods.constrain ? edgeAspect(drawn, drawnStart, box.anchor) : drawn;\n  const constrained = insetBox(constrain(session.constraints, gctx, box.anchor, shaped), box.extents);\n\n  const { previews, proposed, lone } = posesInBox(session, constrained);\n  if (lone) gctx.current = new Map<string, Bounds>([[lone.id as string, outsetBox(boundsForRules(lone.g, lone.world), box.extents)]]);\n  return { previews, proposed };\n}\n"],"mappings":"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"}

package/dist/interactions/actions/resize/minimum.js

@@ -0,0 +1,35 @@
+import { minSizeOf } from "../../../core/scene/minSize.js";
+import { poseFrameOf } from "@weasel-js/geom";
+
+//#region src/interactions/actions/resize/minimum.ts
+/**
+* The smallest the resized box may go, from each written node's
+* `data.minSize`: a lone target's own, or, for a box several share, the box
+* at which the first of them reaches its own. A turned member is held on
+* both axes by the larger of its two ratios, since the box's axes are not
+* its own. `null` when nothing written has a minimum.
+*/
+function boxMinimum(scene, writeIds, leafBounds, startWorlds, box, sharedBox) {
+	if (!sharedBox) return minSizeOf(scene.get(writeIds[0])?.data);
+	let sx = 0;
+	let sy = 0;
+	writeIds.forEach((id, i) => {
+		const min = minSizeOf(scene.get(id)?.data);
+		const leaf = leafBounds[i];
+		if (!min || !leaf) return;
+		const rx = leaf.width > 0 ? min.width / leaf.width : 0;
+		const ry = leaf.height > 0 ? min.height / leaf.height : 0;
+		const turned = poseFrameOf(startWorlds.get(id)) !== null;
+		sx = Math.max(sx, turned ? Math.max(rx, ry) : rx);
+		sy = Math.max(sy, turned ? Math.max(rx, ry) : ry);
+	});
+	if (sx === 0 && sy === 0) return null;
+	return {
+		width: sx * box.width,
+		height: sy * box.height
+	};
+}
+
+//#endregion
+export { boxMinimum };
+//# sourceMappingURL=minimum.js.map

package/dist/interactions/actions/resize/minimum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimum.js","names":[],"sources":["../../../../src/interactions/actions/resize/minimum.ts"],"sourcesContent":["import { poseFrameOf } from '@weasel-js/geom';\nimport { minSizeOf, type MinSize } from 'core/scene/minSize';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/**\n * The smallest the resized box may go, from each written node's\n * `data.minSize`: a lone target's own, or, for a box several share, the box\n * at which the first of them reaches its own. A turned member is held on\n * both axes by the larger of its two ratios, since the box's axes are not\n * its own. `null` when nothing written has a minimum.\n */\nexport function boxMinimum(\n  scene: Scene<unknown, string, unknown>,\n  writeIds: readonly NodeId[],\n  leafBounds: readonly Bounds[],\n  startWorlds: ReadonlyMap<NodeId, unknown>,\n  box: Bounds,\n  sharedBox: boolean,\n): MinSize | null {\n  if (!sharedBox) return minSizeOf(scene.get(writeIds[0])?.data);\n  let sx = 0;\n  let sy = 0;\n  writeIds.forEach((id, i) => {\n    const min = minSizeOf(scene.get(id)?.data);\n    const leaf = leafBounds[i];\n    if (!min || !leaf) return;\n    const rx = leaf.width > 0 ? min.width / leaf.width : 0;\n    const ry = leaf.height > 0 ? min.height / leaf.height : 0;\n    const turned = poseFrameOf(startWorlds.get(id)) !== null;\n    sx = Math.max(sx, turned ? Math.max(rx, ry) : rx);\n    sy = Math.max(sy, turned ? Math.max(rx, ry) : ry);\n  });\n  if (sx === 0 && sy === 0) return null;\n  return { width: sx * box.width, height: sy * box.height };\n}\n"],"mappings":";;;;;;;;;;;AAYA,SAAgB,WACd,OACA,UACA,YACA,aACA,KACA,WACgB;CAChB,IAAI,CAAC,WAAW,OAAO,UAAU,MAAM,IAAI,SAAS,EAAE,CAAC,EAAE,IAAI;CAC7D,IAAI,KAAK;CACT,IAAI,KAAK;CACT,SAAS,SAAS,IAAI,MAAM;EAC1B,MAAM,MAAM,UAAU,MAAM,IAAI,EAAE,CAAC,EAAE,IAAI;EACzC,MAAM,OAAO,WAAW;EACxB,IAAI,CAAC,OAAO,CAAC,MAAM;EACnB,MAAM,KAAK,KAAK,QAAQ,IAAI,IAAI,QAAQ,KAAK,QAAQ;EACrD,MAAM,KAAK,KAAK,SAAS,IAAI,IAAI,SAAS,KAAK,SAAS;EACxD,MAAM,SAAS,YAAY,YAAY,IAAI,EAAE,CAAC,MAAM;EACpD,KAAK,KAAK,IAAI,IAAI,SAAS,KAAK,IAAI,IAAI,EAAE,IAAI,EAAE;EAChD,KAAK,KAAK,IAAI,IAAI,SAAS,KAAK,IAAI,IAAI,EAAE,IAAI,EAAE;CAClD,CAAC;CACD,IAAI,OAAO,KAAK,OAAO,GAAG,OAAO;CACjC,OAAO;EAAE,OAAO,KAAK,IAAI;EAAO,QAAQ,KAAK,IAAI;CAAO;AAC1D"}

package/dist/interactions/actions/resize/replay.js

@@ -1,47 +1,57 @@
-import { resizeOps as e } from "./commit.js";
-import { posesInBox as t } from "./frame.js";
-import { captureResize as n } from "./session.js";
+import { resizeOps } from "./commit.js";
+import { posesInBox } from "./frame.js";
+import { captureResize } from "./session.js";
+
 //#region src/interactions/actions/resize/replay.ts
-function r(e, t) {
+/** `to`, given in units of `from` (`{ x: 0, y: 0, width: 1, height: 1 }` is
+*  `from` itself), in `from`'s own coordinates. */
+function boxInUnits(from, to) {
 	return {
-		x: e.x + t.x * e.width,
-		y: e.y + t.y * e.height,
-		width: t.width * e.width,
-		height: t.height * e.height
+		x: from.x + to.x * from.width,
+		y: from.y + to.y * from.height,
+		width: to.width * from.width,
+		height: to.height * from.height
 	};
 }
-function i(e, t) {
-	let n = e.width === 0 ? {
+/** `to` in units of `from`: the inverse of `boxInUnits`. A zero extent
+*  reads as unscaled on that axis. */
+function unitsOfBox(from, to) {
+	const ux = from.width === 0 ? {
 		x: 0,
 		width: 1
 	} : {
-		x: (t.x - e.x) / e.width,
-		width: t.width / e.width
-	}, r = e.height === 0 ? {
+		x: (to.x - from.x) / from.width,
+		width: to.width / from.width
+	};
+	const uy = from.height === 0 ? {
 		y: 0,
 		height: 1
 	} : {
-		y: (t.y - e.y) / e.height,
-		height: t.height / e.height
+		y: (to.y - from.y) / from.height,
+		height: to.height / from.height
 	};
 	return {
-		x: n.x,
-		y: r.y,
-		width: n.width,
-		height: r.height
+		x: ux.x,
+		y: uy.y,
+		width: ux.width,
+		height: uy.height
 	};
 }
-function a(i, a, o, s, c, l) {
-	if (a.length === 0) return [];
-	let u = n(i, a, o, c);
-	if (!u) return [];
-	let { place: d } = u, { previews: f } = t(d, r(d.box.bounds, s));
-	return e({
-		...d,
-		geometryProjection: c.geometryProjection
-	}, f, l);
+/** The ops that resize `selected` the way a handle drag would, taking the box
+*  it would resize to `units` of itself. The resize policy's expansion
+*  applies; its constraints and point snaps, which shape a pointer, do not. */
+function resizeSelectionOps(scene, selected, anchor, units, deps, label) {
+	if (selected.length === 0) return [];
+	const captured = captureResize(scene, selected, anchor, deps);
+	if (!captured) return [];
+	const { place } = captured;
+	const { previews } = posesInBox(place, boxInUnits(place.box.bounds, units));
+	return resizeOps({
+		...place,
+		geometryProjection: deps.geometryProjection
+	}, previews, label);
 }
-//#endregion
-export { r as boxInUnits, a as resizeSelectionOps, i as unitsOfBox };
 
+//#endregion
+export { boxInUnits, resizeSelectionOps, unitsOfBox };
 //# sourceMappingURL=replay.js.map

package/dist/interactions/actions/resize/replay.js.map

@@ -1 +1 @@
-{"version":3,"file":"replay.js","names":["boxInUnits","from","to","unitsOfBox","ux","uy","resizeSelectionOps","selected","captured","captureResize","scene","anchor","deps","posesInBox","place","units","resizeOps","previews","label"],"sources":["../../../../src/interactions/actions/resize/replay.ts"],"sourcesContent":["import type { ActionDeps, ResizeAnchor } from '@weasel-js/routing';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { resizeOps } from './commit';\nimport { posesInBox } from './frame';\nimport { captureResize } from './session';\n\n/** `to`, given in units of `from` (`{ x: 0, y: 0, width: 1, height: 1 }` is\n *  `from` itself), in `from`'s own coordinates. */\nexport function boxInUnits(from: Bounds, to: Bounds): Bounds {\n  return {\n    x: from.x + to.x * from.width,\n    y: from.y + to.y * from.height,\n    width: to.width * from.width,\n    height: to.height * from.height,\n  };\n}\n\n/** `to` in units of `from`: the inverse of `boxInUnits`. A zero extent\n *  reads as unscaled on that axis. */\nexport function unitsOfBox(from: Bounds, to: Bounds): Bounds {\n  const ux = from.width === 0 ? { x: 0, width: 1 } : { x: (to.x - from.x) / from.width, width: to.width / from.width };\n  const uy = from.height === 0 ? { y: 0, height: 1 } : { y: (to.y - from.y) / from.height, height: to.height / from.height };\n  return { x: ux.x, y: uy.y, width: ux.width, height: uy.height };\n}\n\n/** The ops that resize `selected` the way a handle drag would, taking the box\n *  it would resize to `units` of itself. The resize policy's expansion\n *  applies; its constraints and point snaps, which shape a pointer, do not. */\nexport function resizeSelectionOps(\n  scene: Scene<unknown, string, unknown>,\n  selected: readonly string[],\n  anchor: ResizeAnchor,\n  units: Bounds,\n  deps: Pick<ActionDeps, 'poseDescriptor' | 'resizePolicy' | 'view' | 'geometryProjection'>,\n  label: string,\n): Op[] {\n  if (selected.length === 0) return [];\n  const captured = captureResize(scene, selected as NodeId[], anchor, deps);\n  if (!captured) return [];\n  const { place } = captured;\n  const { previews } = posesInBox(place, boxInUnits(place.box.bounds, units));\n  return resizeOps({ ...place, geometryProjection: deps.geometryProjection }, previews, label);\n}\n"],"mappings":";;;;AAUA,SAAgBA,EAAW,GAAc,GAAoB;CAC3D,OAAO;EACL,GAAGC,EAAK,IAAIC,EAAG,IAAID,EAAK;EACxB,GAAGA,EAAK,IAAIC,EAAG,IAAID,EAAK;EACxB,OAAOC,EAAG,QAAQD,EAAK;EACvB,QAAQC,EAAG,SAASD,EAAK;CAC3B;AACF;AAIA,SAAgBE,EAAW,GAAc,GAAoB;CAC3D,IAAMC,IAAKH,EAAK,UAAU,IAAI;EAAE,GAAG;EAAG,OAAO;CAAE,IAAI;EAAE,IAAIC,EAAG,IAAID,EAAK,KAAKA,EAAK;EAAO,OAAOC,EAAG,QAAQD,EAAK;CAAM,GAC7GI,IAAKJ,EAAK,WAAW,IAAI;EAAE,GAAG;EAAG,QAAQ;CAAE,IAAI;EAAE,IAAIC,EAAG,IAAID,EAAK,KAAKA,EAAK;EAAQ,QAAQC,EAAG,SAASD,EAAK;CAAO;CACzH,OAAO;EAAE,GAAGG,EAAG;EAAG,GAAGC,EAAG;EAAG,OAAOD,EAAG;EAAO,QAAQC,EAAG;CAAO;AAChE;AAKA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GACA,GACM;CACN,IAAIC,EAAS,WAAW,GAAG,OAAO,CAAC;CACnC,IAAMC,IAAWC,EAAcC,GAAOH,GAAsBI,GAAQC,CAAI;CACxE,IAAI,CAACJ,GAAU,OAAO,CAAC;CACvB,IAAM,EAAE,aAAUA,GACZ,EAAE,gBAAaK,EAAWC,GAAOd,EAAWc,EAAM,IAAI,QAAQC,CAAK,CAAC;CAC1E,OAAOC,EAAU;EAAE,GAAGF;EAAO,oBAAoBF,EAAK;CAAmB,GAAGK,GAAUC,CAAK;AAC7F"}
+{"version":3,"file":"replay.js","names":[],"sources":["../../../../src/interactions/actions/resize/replay.ts"],"sourcesContent":["import type { ActionDeps, ResizeAnchor } from '@weasel-js/routing';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { resizeOps } from './commit';\nimport { posesInBox } from './frame';\nimport { captureResize } from './session';\n\n/** `to`, given in units of `from` (`{ x: 0, y: 0, width: 1, height: 1 }` is\n *  `from` itself), in `from`'s own coordinates. */\nexport function boxInUnits(from: Bounds, to: Bounds): Bounds {\n  return {\n    x: from.x + to.x * from.width,\n    y: from.y + to.y * from.height,\n    width: to.width * from.width,\n    height: to.height * from.height,\n  };\n}\n\n/** `to` in units of `from`: the inverse of `boxInUnits`. A zero extent\n *  reads as unscaled on that axis. */\nexport function unitsOfBox(from: Bounds, to: Bounds): Bounds {\n  const ux = from.width === 0 ? { x: 0, width: 1 } : { x: (to.x - from.x) / from.width, width: to.width / from.width };\n  const uy = from.height === 0 ? { y: 0, height: 1 } : { y: (to.y - from.y) / from.height, height: to.height / from.height };\n  return { x: ux.x, y: uy.y, width: ux.width, height: uy.height };\n}\n\n/** The ops that resize `selected` the way a handle drag would, taking the box\n *  it would resize to `units` of itself. The resize policy's expansion\n *  applies; its constraints and point snaps, which shape a pointer, do not. */\nexport function resizeSelectionOps(\n  scene: Scene<unknown, string, unknown>,\n  selected: readonly string[],\n  anchor: ResizeAnchor,\n  units: Bounds,\n  deps: Pick<ActionDeps, 'poseDescriptor' | 'resizePolicy' | 'view' | 'geometryProjection'>,\n  label: string,\n): Op[] {\n  if (selected.length === 0) return [];\n  const captured = captureResize(scene, selected as NodeId[], anchor, deps);\n  if (!captured) return [];\n  const { place } = captured;\n  const { previews } = posesInBox(place, boxInUnits(place.box.bounds, units));\n  return resizeOps({ ...place, geometryProjection: deps.geometryProjection }, previews, label);\n}\n"],"mappings":";;;;;;;AAUA,SAAgB,WAAW,MAAc,IAAoB;CAC3D,OAAO;EACL,GAAG,KAAK,IAAI,GAAG,IAAI,KAAK;EACxB,GAAG,KAAK,IAAI,GAAG,IAAI,KAAK;EACxB,OAAO,GAAG,QAAQ,KAAK;EACvB,QAAQ,GAAG,SAAS,KAAK;CAC3B;AACF;;;AAIA,SAAgB,WAAW,MAAc,IAAoB;CAC3D,MAAM,KAAK,KAAK,UAAU,IAAI;EAAE,GAAG;EAAG,OAAO;CAAE,IAAI;EAAE,IAAI,GAAG,IAAI,KAAK,KAAK,KAAK;EAAO,OAAO,GAAG,QAAQ,KAAK;CAAM;CACnH,MAAM,KAAK,KAAK,WAAW,IAAI;EAAE,GAAG;EAAG,QAAQ;CAAE,IAAI;EAAE,IAAI,GAAG,IAAI,KAAK,KAAK,KAAK;EAAQ,QAAQ,GAAG,SAAS,KAAK;CAAO;CACzH,OAAO;EAAE,GAAG,GAAG;EAAG,GAAG,GAAG;EAAG,OAAO,GAAG;EAAO,QAAQ,GAAG;CAAO;AAChE;;;;AAKA,SAAgB,mBACd,OACA,UACA,QACA,OACA,MACA,OACM;CACN,IAAI,SAAS,WAAW,GAAG,OAAO,CAAC;CACnC,MAAM,WAAW,cAAc,OAAO,UAAsB,QAAQ,IAAI;CACxE,IAAI,CAAC,UAAU,OAAO,CAAC;CACvB,MAAM,EAAE,UAAU;CAClB,MAAM,EAAE,aAAa,WAAW,OAAO,WAAW,MAAM,IAAI,QAAQ,KAAK,CAAC;CAC1E,OAAO,UAAU;EAAE,GAAG;EAAO,oBAAoB,KAAK;CAAmB,GAAG,UAAU,KAAK;AAC7F"}

package/dist/interactions/actions/resize/ruleBounds.js

@@ -1,9 +1,12 @@
-import { isRectPose as e } from "../../../core/geometry/autoPoseDescriptor.js";
+import { isRectPose } from "../../../core/geometry/autoPoseDescriptor.js";
+
 //#region src/interactions/actions/resize/ruleBounds.ts
-function t(t, n) {
-	return e(n) ? n : t.getBounds(n);
+/** `pose` as the bounds a constraint or a point snap reads. A pose that is
+*  already a box goes through whole, so a `rotation` on it rides along. */
+function boundsForRules(geometry, pose) {
+	return isRectPose(pose) ? pose : geometry.getBounds(pose);
 }
-//#endregion
-export { t as boundsForRules };
 
+//#endregion
+export { boundsForRules };
 //# sourceMappingURL=ruleBounds.js.map

package/dist/interactions/actions/resize/ruleBounds.js.map

@@ -1 +1 @@
-{"version":3,"file":"ruleBounds.js","names":["boundsForRules","isRectPose","pose","geometry"],"sources":["../../../../src/interactions/actions/resize/ruleBounds.ts"],"sourcesContent":["import { isRectPose } from 'core/geometry/autoPoseDescriptor';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { PoseDescriptor } from './geometry';\n\n/** `pose` as the bounds a constraint or a point snap reads. A pose that is\n *  already a box goes through whole, so a `rotation` on it rides along. */\nexport function boundsForRules(geometry: PoseDescriptor<unknown>, pose: unknown): Bounds {\n  return isRectPose(pose) ? pose : geometry.getBounds(pose);\n}\n"],"mappings":";;AAMA,SAAgBA,EAAe,GAAmC,GAAuB;CACvF,OAAOC,EAAWC,CAAI,IAAIA,IAAOC,EAAS,UAAUD,CAAI;AAC1D"}
+{"version":3,"file":"ruleBounds.js","names":[],"sources":["../../../../src/interactions/actions/resize/ruleBounds.ts"],"sourcesContent":["import { isRectPose } from 'core/geometry/autoPoseDescriptor';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { PoseDescriptor } from './geometry';\n\n/** `pose` as the bounds a constraint or a point snap reads. A pose that is\n *  already a box goes through whole, so a `rotation` on it rides along. */\nexport function boundsForRules(geometry: PoseDescriptor<unknown>, pose: unknown): Bounds {\n  return isRectPose(pose) ? pose : geometry.getBounds(pose);\n}\n"],"mappings":";;;;;AAMA,SAAgB,eAAe,UAAmC,MAAuB;CACvF,OAAO,WAAW,IAAI,IAAI,OAAO,SAAS,UAAU,IAAI;AAC1D"}