@weasel-js/core 1.9.4 → 1.10.1

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

@@ -0,0 +1,66 @@
+import { closeGesture as e, runBehaviorCancel as t } from "../gestureLifecycle.js";
+import { inPlane as n, selectionLayer as r } from "../planeInput.js";
+import { recordTransform as i } from "../transform-again/memory.js";
+import { commitResize as a } from "./commit.js";
+import { nextFrame as o } from "./frame.js";
+import { beginResize as s } from "./session.js";
+import { unitsOfBox as c } from "./replay.js";
+//#region src/interactions/actions/resize/action.ts
+var l = n({
+	id: "resize",
+	label: "Resize",
+	eligible: { capability: "transforms-selection" },
+	requires: [
+		"selection",
+		"scene",
+		"resizePolicy",
+		"poseDescriptor",
+		"applyOps",
+		"geometryProjection",
+		"view"
+	],
+	invoker: {
+		timing: "ongoing",
+		start(n, r) {
+			let l = s(n);
+			if (!l) return {};
+			let { session: u, readers: d } = l, f = [...n.deps.selection?.get() ?? []], p = u.scene.overrides.hold(), m = { previews: /* @__PURE__ */ new Map() };
+			return u.lifecycle.start(u.writeIds), {
+				kind: "resize",
+				onMove(e) {
+					e.drag && (m = o(u, d, e), p.set(m.previews));
+				},
+				onEnd(n, r) {
+					let o = !1;
+					try {
+						if (r === "commit") {
+							if (o = a(u, m), o && m.proposed) {
+								let e = c(u.box.bounds, m.proposed);
+								i(u.scene, {
+									kind: "scale",
+									to: e,
+									anchor: u.box.anchor
+								}, f);
+							}
+						} else t(u.constraints, u.gestureCtx);
+					} finally {
+						e({
+							hold: p,
+							previews: m.previews,
+							behaviors: u.constraints,
+							ctx: u.gestureCtx,
+							lifecycle: u.lifecycle
+						}, o);
+					}
+				},
+				previewIds: () => m.previews.keys(),
+				previewPose: (e) => m.previews.get(e) ?? null
+			};
+		}
+	},
+	enabled: () => !0
+}, r);
+//#endregion
+export { l as resizeAction };
+
+//# sourceMappingURL=action.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","names":["resizeAction","inPlane","begun","beginResize","ctx","subject","hold","session","frame","moveCtx","nextFrame","readers","committed","reason","commitResize","to","unitsOfBox","id","selectionLayer"],"sources":["../../../../src/interactions/actions/resize/action.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { NodeId } from 'core/scene/types';\nimport { closeGesture, runBehaviorCancel } from '../gestureLifecycle';\nimport { inPlane, selectionLayer } from '../planeInput';\nimport { commitResize } from './commit';\nimport { nextFrame } from './frame';\nimport { beginResize, type ResizeFrame } from './session';\nimport { unitsOfBox } from './replay';\nimport { recordTransform } from '../transform-again/memory';\n\n/**\n * @experimental\n * Anchor-relative drag resize, committed as one batch on release. It needs\n * `InvocationCtx.drag.affordance` with a `handle:*` kind.\n *\n * The optional `resizePolicy` dep carries the constraints, point snaps, and\n * `expandIds`; absent, the invoker falls back to the kit's default\n * constraints, no snap, and `ids => ids` expansion.\n */\nexport const resizeAction: Action & { requires: string[] } = inPlane({\n  id: 'resize',\n  label: 'Resize',\n  // No default binding: a bare `{ kind: 'drag' }` claims every drag at ambient\n  // scope. The resize handles bind it (`selectionResizeBindings`).\n  eligible: { capability: 'transforms-selection' },\n  requires: ['selection', 'scene', 'resizePolicy', 'poseDescriptor', 'applyOps', 'geometryProjection', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, _opts): OngoingHandle {\n      const begun = beginResize(ctx);\n      if (!begun) return {};\n      const { session, readers } = begun;\n      const subject = [...(ctx.deps.selection?.get() ?? [])] as string[];\n      const hold = session.scene.overrides.hold();\n      let frame: ResizeFrame = { previews: new Map() };\n      session.lifecycle.start(session.writeIds as readonly string[]);\n      return {\n        kind: 'resize',\n        onMove(moveCtx: InvocationCtx): void {\n          if (!moveCtx.drag) return;\n          frame = nextFrame(session, readers, moveCtx);\n          hold.set(frame.previews);\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          try {\n            if (reason === 'commit') {\n              committed = commitResize(session, frame);\n              if (committed && frame.proposed) {\n                const to = unitsOfBox(session.box.bounds, frame.proposed);\n                recordTransform(session.scene, { kind: 'scale', to, anchor: session.box.anchor }, subject);\n              }\n            } else runBehaviorCancel(session.constraints, session.gestureCtx);\n          } finally {\n            closeGesture({ hold, previews: frame.previews, behaviors: session.constraints, ctx: session.gestureCtx, lifecycle: session.lifecycle }, committed);\n          }\n        },\n        previewIds: () => frame.previews.keys(),\n        previewPose: (id: string) => frame.previews.get(id as NodeId) ?? null,\n      };\n    },\n  },\n  /**\n   * Always enabled: the dispatcher treats anything `!== true` as \"skip and\n   * try the next match\", so a disabled reason here makes the resize binding\n   * silently lose to lower-specificity matches (e.g. ambient `insertAction`).\n   */\n  enabled: () => true,\n}, selectionLayer);\n"],"mappings":";;;;;;;;AAoBA,IAAaA,IAAgDC,EAAQ;CACnE,IAAI;CACJ,OAAO;CAGP,UAAU,EAAE,YAAY,uBAAuB;CAC/C,UAAU;EAAC;EAAa;EAAS;EAAgB;EAAkB;EAAY;EAAsB;CAAM;CAC3G,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAsB;GAC9C,IAAMC,IAAQC,EAAYC,CAAG;GAC7B,IAAI,CAACF,GAAO,OAAO,CAAC;GACpB,IAAM,EAAE,YAAS,eAAYA,GACvBG,IAAU,CAAC,GAAID,EAAI,KAAK,WAAW,IAAI,KAAK,CAAC,CAAE,GAC/CE,IAAOC,EAAQ,MAAM,UAAU,KAAK,GACtCC,IAAqB,EAAE,0BAAU,IAAI,IAAI,EAAE;GAE/C,OADAD,EAAQ,UAAU,MAAMA,EAAQ,QAA6B,GACtD;IACL,MAAM;IACN,OAAO,GAA8B;KACnC,AAAKE,EAAQ,SACb,IAAQC,EAAUH,GAASI,GAASF,CAAO,GAC3CH,EAAK,IAAIE,EAAM,QAAQ;IACzB;IACA,MAAM,GAAwB,GAAmC;KAC/D,IAAII,IAAY;KAChB,IAAI;MACF,IAAIC,MAAW,UAEb;WADA,IAAYC,EAAaP,GAASC,CAAK,GACnCI,KAAaJ,EAAM,UAAU;QAC/B,IAAMO,IAAKC,EAAWT,EAAQ,IAAI,QAAQC,EAAM,QAAQ;QACxD,EAAgBD,EAAQ,OAAO;SAAE,MAAM;SAAS;SAAI,QAAQA,EAAQ,IAAI;QAAO,GAAGF,CAAO;OAC3F;aACK,EAAkBE,EAAQ,aAAaA,EAAQ,UAAU;KAClE,UAAU;MACR,EAAa;OAAE;OAAM,UAAUC,EAAM;OAAU,WAAWD,EAAQ;OAAa,KAAKA,EAAQ;OAAY,WAAWA,EAAQ;MAAU,GAAGK,CAAS;KACnJ;IACF;IACA,kBAAkBJ,EAAM,SAAS,KAAK;IACtC,cAAc,MAAeA,EAAM,SAAS,IAAIS,CAAY,KAAK;GACnE;EACF;CACF;CAMA,eAAe;AACjB,GAAGC,CAAc"}

package/dist/interactions/actions/resize/behaviors/lockAspect.js.map

@@ -1 +1 @@
-{"version":3,"file":"lockAspect.js","names":["lockAspectWithModifier","opts","ctx","key","origin","ratio","dw","pose","dh","nw","nh","anchor","nx","ny"],"sources":["../../../../../src/interactions/actions/resize/behaviors/lockAspect.ts"],"sourcesContent":["import type {\n  ModifierState,\n  BoundsConstraint,\n} from '../../../gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\ntype ModKey = keyof ModifierState;\n\n/** Aspect-ratio lock: drag a corner/edge with `key` (default `'shift'`) held\n *  to keep the resized bounds at the start-pose's `width / height` ratio.\n *\n *  Strategy:\n *  - Compute the proposed deltas in width and height (signed, relative to\n *    origin). Whichever axis has the larger absolute delta \"wins\"; the other\n *    is recomputed from `(originW / originH) * winnerDelta`.\n *  - The opposite corner/edge stays anchored — for the corner case we infer\n *    the anchor from the proposed bounds; for an edge handle we resize the\n *    orthogonal axis symmetrically around the dragged edge's anchor (the\n *    handle's own line stays put, the orthogonal axis grows/shrinks centered\n *    on the un-dragged edge — see notes below).\n *  - No-op when the modifier is not held, when the origin has zero width or\n *    height (no defined ratio), or when the proposed pose hasn't moved.\n *\n *  Edge-handle handling: with `anchor.x !== 'free' && anchor.y === 'free'`\n *  (an `e` or `w` handle), only the width was driven by the pointer. We pick\n *  the new height as `width / ratio` and pin it to the un-dragged y axis by\n *  anchoring at the origin's top edge (`y` stays at `origin.y`). Symmetric\n *  for `n` / `s`.\n */\nexport function lockAspectWithModifier<TPose extends Bounds>(opts: {\n  key?: ModKey;\n} = {}): BoundsConstraint<TPose> {\n  const { key = 'shift' } = opts;\n\n  return {\n    onMove(ctx, { pose, anchor }) {\n      if (!ctx.modifiers[key]) return;\n      const origin = ctx.origin.get(ctx.draggedIds[0]) as Bounds | undefined;\n      if (!origin) return;\n      if (origin.width === 0 || origin.height === 0) return;\n      const ratio = origin.width / origin.height; // w / h\n\n      // Signed deltas relative to origin. Negative deltas mean the user has\n      // dragged through the anchor and flipped the rect; we preserve sign on\n      // the recomputed axis so the flipped quadrant stays consistent.\n      const dw = pose.width - origin.width;\n      const dh = pose.height - origin.height;\n\n      let nw: number;\n      let nh: number;\n\n      if (anchor.x === 'free' && anchor.y === 'free') {\n        // No driven axis — nothing to lock against.\n        return;\n      } else if (anchor.x === 'free') {\n        // Edge handle: n or s. height is driven; width follows.\n        nh = pose.height;\n        nw = nh * ratio;\n        // sign-preserve width if the original height delta caused a flip.\n        // (height-driven only; width direction follows ratio absolutely.)\n        if (nw < 0) nw = -nw;\n      } else if (anchor.y === 'free') {\n        // Edge handle: e or w. width is driven; height follows.\n        nw = pose.width;\n        nh = nw / ratio;\n        if (nh < 0) nh = -nh;\n      } else {\n        // Corner handle. Pick the dominant axis by absolute delta.\n        if (Math.abs(dw) >= Math.abs(dh)) {\n          nw = pose.width;\n          // Match height sign to width sign so the rect stays in the same\n          // quadrant the pointer chose.\n          nh = (Math.abs(nw) / ratio) * Math.sign(pose.height || 1);\n        } else {\n          nh = pose.height;\n          nw = (Math.abs(nh) * ratio) * Math.sign(pose.width || 1);\n        }\n      }\n\n      // Recompute x/y from the anchor (the un-dragged edge stays pinned).\n      let nx = pose.x;\n      let ny = pose.y;\n      if (anchor.x === 'min') {\n        // West edge anchored at origin.x.\n        nx = origin.x;\n      } else if (anchor.x === 'max') {\n        // East edge anchored at origin.x + origin.width.\n        nx = origin.x + origin.width - nw;\n      } else {\n        // Edge handle (n/s): width grew/shrunk via ratio. Center horizontally\n        // about the origin's center so the rect stays visually centered on\n        // the dragged edge's midline.\n        nx = origin.x + origin.width / 2 - nw / 2;\n      }\n      if (anchor.y === 'min') {\n        ny = origin.y;\n      } else if (anchor.y === 'max') {\n        ny = origin.y + origin.height - nh;\n      } else {\n        ny = origin.y + origin.height / 2 - nh / 2;\n      }\n\n      return {\n        pose: { ...pose, x: nx, y: ny, width: nw, height: nh },\n      };\n    },\n  };\n}\n"],"mappings":";AA6BA,SAAgBA,EAA6C,IAEzD,CAAC,GAA4B;CAC/B,IAAM,EAAE,SAAM,YAAYC;CAE1B,OAAO,EACL,OAAO,GAAK,EAAE,SAAM,aAAU;EAC5B,IAAI,CAACC,EAAI,UAAUC,IAAM;EACzB,IAAMC,IAASF,EAAI,OAAO,IAAIA,EAAI,WAAW,EAAE;EAE/C,IADI,CAACE,KACDA,EAAO,UAAU,KAAKA,EAAO,WAAW,GAAG;EAC/C,IAAMC,IAAQD,EAAO,QAAQA,EAAO,QAK9BE,IAAKC,EAAK,QAAQH,EAAO,OACzBI,IAAKD,EAAK,SAASH,EAAO,QAE5BK,GACAC;EAEJ,IAAIC,EAAO,MAAM,UAAUA,EAAO,MAAM,QAEtC;EACK,AAAIA,EAAO,MAAM,UAEtB,IAAKJ,EAAK,QACV,IAAKG,IAAKL,GAGNI,IAAK,MAAG,IAAK,CAACA,MACTE,EAAO,MAAM,UAEtB,IAAKJ,EAAK,OACV,IAAKE,IAAKJ,GACNK,IAAK,MAAG,IAAK,CAACA,MAGd,KAAK,IAAIJ,CAAE,KAAK,KAAK,IAAIE,CAAE,KAC7B,IAAKD,EAAK,OAGV,IAAM,KAAK,IAAIE,CAAE,IAAIJ,IAAS,KAAK,KAAKE,EAAK,UAAU,CAAC,MAExD,IAAKA,EAAK,QACV,IAAM,KAAK,IAAIG,CAAE,IAAIL,IAAS,KAAK,KAAKE,EAAK,SAAS,CAAC;EAK3D,IAAIK,IAAKL,EAAK,GACVM,IAAKN,EAAK;EAqBd,OApBA,AAUEK,IAVED,EAAO,MAAM,QAEVP,EAAO,IACHO,EAAO,MAAM,QAEjBP,EAAO,IAAIA,EAAO,QAAQK,IAK1BL,EAAO,IAAIA,EAAO,QAAQ,IAAIK,IAAK,GAE1C,AAKEI,IALEF,EAAO,MAAM,QACVP,EAAO,IACHO,EAAO,MAAM,QACjBP,EAAO,IAAIA,EAAO,SAASM,IAE3BN,EAAO,IAAIA,EAAO,SAAS,IAAIM,IAAK,GAGpC,EACL,MAAM;GAAE,GAAGH;GAAM,GAAGK;GAAI,GAAGC;GAAI,OAAOJ;GAAI,QAAQC;EAAG,EACvD;CACF,EACF;AACF"}
+{"version":3,"file":"lockAspect.js","names":["lockAspectWithModifier","opts","ctx","key","origin","ratio","dw","pose","dh","nw","nh","anchor","nx","ny"],"sources":["../../../../../src/interactions/actions/resize/behaviors/lockAspect.ts"],"sourcesContent":["import type {\n  ModifierState,\n  BoundsConstraint,\n} from '../../../gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\ntype ModKey = keyof ModifierState;\n\n/** Aspect-ratio lock: drag a corner/edge with `key` (default `'shift'`) held\n *  to keep the resized bounds at the start-pose's `width / height` ratio.\n *\n *  On a corner handle the axis with the larger absolute delta wins and the\n *  other follows from the ratio, with the opposite corner anchored. On an\n *  edge handle the driven axis sets the other, which stays centered on the\n *  origin. No-op when the origin has zero width or height.\n */\nexport function lockAspectWithModifier<TPose extends Bounds>(opts: {\n  key?: ModKey;\n} = {}): BoundsConstraint<TPose> {\n  const { key = 'shift' } = opts;\n\n  return {\n    onMove(ctx, { pose, anchor }) {\n      if (!ctx.modifiers[key]) return;\n      const origin = ctx.origin.get(ctx.draggedIds[0]) as Bounds | undefined;\n      if (!origin) return;\n      if (origin.width === 0 || origin.height === 0) return;\n      const ratio = origin.width / origin.height; // w / h\n\n      const dw = pose.width - origin.width;\n      const dh = pose.height - origin.height;\n\n      let nw: number;\n      let nh: number;\n\n      if (anchor.x === 'free' && anchor.y === 'free') {\n        // No driven axis — nothing to lock against.\n        return;\n      } else if (anchor.x === 'free') {\n        // Edge handle: n or s. height is driven; width follows.\n        nh = pose.height;\n        nw = nh * ratio;\n        if (nw < 0) nw = -nw;\n      } else if (anchor.y === 'free') {\n        // Edge handle: e or w. width is driven; height follows.\n        nw = pose.width;\n        nh = nw / ratio;\n        if (nh < 0) nh = -nh;\n      } else {\n        // Corner handle. Pick the dominant axis by absolute delta.\n        if (Math.abs(dw) >= Math.abs(dh)) {\n          nw = pose.width;\n          // Match height sign to width sign so the rect stays in the same\n          // quadrant the pointer chose.\n          nh = (Math.abs(nw) / ratio) * Math.sign(pose.height || 1);\n        } else {\n          nh = pose.height;\n          nw = (Math.abs(nh) * ratio) * Math.sign(pose.width || 1);\n        }\n      }\n\n      // Recompute x/y from the anchor (the un-dragged edge stays pinned).\n      let nx = pose.x;\n      let ny = pose.y;\n      if (anchor.x === 'min') {\n        // West edge anchored at origin.x.\n        nx = origin.x;\n      } else if (anchor.x === 'max') {\n        // East edge anchored at origin.x + origin.width.\n        nx = origin.x + origin.width - nw;\n      } else {\n        // Edge handle (n/s): center horizontally about the origin's center.\n        nx = origin.x + origin.width / 2 - nw / 2;\n      }\n      if (anchor.y === 'min') {\n        ny = origin.y;\n      } else if (anchor.y === 'max') {\n        ny = origin.y + origin.height - nh;\n      } else {\n        ny = origin.y + origin.height / 2 - nh / 2;\n      }\n\n      return {\n        pose: { ...pose, x: nx, y: ny, width: nw, height: nh },\n      };\n    },\n  };\n}\n"],"mappings":";AAgBA,SAAgBA,EAA6C,IAEzD,CAAC,GAA4B;CAC/B,IAAM,EAAE,SAAM,YAAYC;CAE1B,OAAO,EACL,OAAO,GAAK,EAAE,SAAM,aAAU;EAC5B,IAAI,CAACC,EAAI,UAAUC,IAAM;EACzB,IAAMC,IAASF,EAAI,OAAO,IAAIA,EAAI,WAAW,EAAE;EAE/C,IADI,CAACE,KACDA,EAAO,UAAU,KAAKA,EAAO,WAAW,GAAG;EAC/C,IAAMC,IAAQD,EAAO,QAAQA,EAAO,QAE9BE,IAAKC,EAAK,QAAQH,EAAO,OACzBI,IAAKD,EAAK,SAASH,EAAO,QAE5BK,GACAC;EAEJ,IAAIC,EAAO,MAAM,UAAUA,EAAO,MAAM,QAEtC;EACK,AAAIA,EAAO,MAAM,UAEtB,IAAKJ,EAAK,QACV,IAAKG,IAAKL,GACNI,IAAK,MAAG,IAAK,CAACA,MACTE,EAAO,MAAM,UAEtB,IAAKJ,EAAK,OACV,IAAKE,IAAKJ,GACNK,IAAK,MAAG,IAAK,CAACA,MAGd,KAAK,IAAIJ,CAAE,KAAK,KAAK,IAAIE,CAAE,KAC7B,IAAKD,EAAK,OAGV,IAAM,KAAK,IAAIE,CAAE,IAAIJ,IAAS,KAAK,KAAKE,EAAK,UAAU,CAAC,MAExD,IAAKA,EAAK,QACV,IAAM,KAAK,IAAIG,CAAE,IAAIL,IAAS,KAAK,KAAKE,EAAK,SAAS,CAAC;EAK3D,IAAIK,IAAKL,EAAK,GACVM,IAAKN,EAAK;EAmBd,OAlBA,AAQEK,IARED,EAAO,MAAM,QAEVP,EAAO,IACHO,EAAO,MAAM,QAEjBP,EAAO,IAAIA,EAAO,QAAQK,IAG1BL,EAAO,IAAIA,EAAO,QAAQ,IAAIK,IAAK,GAE1C,AAKEI,IALEF,EAAO,MAAM,QACVP,EAAO,IACHO,EAAO,MAAM,QACjBP,EAAO,IAAIA,EAAO,SAASM,IAE3BN,EAAO,IAAIA,EAAO,SAAS,IAAIM,IAAK,GAGpC,EACL,MAAM;GAAE,GAAGH;GAAM,GAAGK;GAAI,GAAGC;GAAI,OAAOJ;GAAI,QAAQC;EAAG,EACvD;CACF,EACF;AACF"}

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

@@ -0,0 +1,16 @@
+import { targetTransformOf as e } from "../../../core/geometry/targetFrame.js";
+//#region src/interactions/actions/resize/boxFrame.ts
+function t(t, n) {
+	return e({
+		x: n.x,
+		y: n.y,
+		width: n.width,
+		height: n.height,
+		rotation: t.rotation,
+		transform: t.transform
+	});
+}
+//#endregion
+export { t as boxFrame };
+
+//# sourceMappingURL=boxFrame.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boxFrame.js","names":["boxFrame","targetTransformOf","bounds","box"],"sources":["../../../../src/interactions/actions/resize/boxFrame.ts"],"sourcesContent":["import type { PoseLinear } from '@weasel-js/geom';\nimport { targetTransformOf, type TargetTransform } from 'core/geometry/targetFrame';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** The frame `bounds` is drawn in while a box with this rotation and\n *  `transform` is resized: both about `bounds`' own center, which moves as\n *  the box does. */\nexport function boxFrame(\n  box: { readonly rotation: number; readonly transform?: PoseLinear },\n  bounds: Bounds,\n): TargetTransform {\n  return targetTransformOf({\n    x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height,\n    rotation: box.rotation, transform: box.transform,\n  });\n}\n"],"mappings":";;AAOA,SAAgBA,EACd,GACA,GACiB;CACjB,OAAOC,EAAkB;EACvB,GAAGC,EAAO;EAAG,GAAGA,EAAO;EAAG,OAAOA,EAAO;EAAO,QAAQA,EAAO;EAC9D,UAAUC,EAAI;EAAU,WAAWA,EAAI;CACzC,CAAC;AACH"}

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

@@ -0,0 +1,85 @@
+import { unionAABB as e, unionBounds as t } from "../../../core/geometry/unionBounds.js";
+import { visualBoundsViaDescriptor as n } from "../../../core/geometry/poseDescriptor.js";
+import { localToWorld as r } from "../../../core/geometry/targetFrame.js";
+import { fixedCornerOf as i } from "./cornerHandles.js";
+import { carryPose as a, invertPlane as o, planeOf as s } from "../planeInput.js";
+import { shapeSources as c } from "../selectionSubtree.js";
+import { pointerStateOf as l } from "../pointerState.js";
+import { sceneGestureFrames as u } from "../gestureFrames.js";
+import { boxFrame as d } from "./boxFrame.js";
+import { boundsForRules as f } from "./ruleBounds.js";
+import { DEFAULT_RESIZE_BEHAVIORS as p } from "./behaviors/index.js";
+import { poseLinearOf as m } from "@weasel-js/geom";
+//#region src/interactions/actions/resize/capture.ts
+var h = (e) => e, g = [];
+function _(e) {
+	return e ? {
+		constraints: e.constraints,
+		pointSnap: e.pointSnap,
+		expandIds: e.expandIds
+	} : {
+		constraints: p,
+		pointSnap: g,
+		expandIds: h
+	};
+}
+function v(e, t, n) {
+	let r = c(e, n(t));
+	if (r.length === 0) return null;
+	let i = t.length === 1 && (r.length !== 1 || r[0] !== t[0]);
+	return {
+		writeIds: i || t.length > 1 ? r : t,
+		isGroupPath: i
+	};
+}
+function y(e, t, r, i, c) {
+	let l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), d = [], f = [];
+	for (let p of t) {
+		let t = e.get(p);
+		if (!t) continue;
+		l.set(p, t.pose);
+		let m = r(p), h = a(m, i.world(p), o(s(c, t.layer)));
+		u.set(p, h), d.push(m.getBounds(h)), f.push(n(h, m));
+	}
+	return {
+		startPoses: l,
+		startWorlds: u,
+		leafBounds: d,
+		drawnBounds: f
+	};
+}
+function b(n, a, o, s, c, l) {
+	let { leafBounds: u, drawnBounds: p } = n, h = u.length === 1 ? u[0] : o ? t(u) : e(p), g = !o && a.length === 1, _ = g ? n.startWorlds.get(a[0]) : h, v = g ? l(a[0]) : c, y = o ? 0 : v.getRotation?.(_) ?? 0, b = g && m(_) || void 0, x = i(h, s);
+	return {
+		box: {
+			bounds: h,
+			anchor: s,
+			rotation: y,
+			transform: b,
+			fixedWorld: r(d({
+				rotation: y,
+				transform: b
+			}, h), x.x, x.y)
+		},
+		ruleOrigin: f(v, _)
+	};
+}
+function x(e, t, n, r, i) {
+	return {
+		draggedIds: t,
+		origin: /* @__PURE__ */ new Map([[t[0], n]]),
+		current: /* @__PURE__ */ new Map([[t[0], n]]),
+		snap: null,
+		modifiers: { ...e.modifiers },
+		pointer: l(r, e),
+		view: i.view(),
+		plane: i.plane(),
+		...e.deps.scene ? { frames: u(e.deps.scene, e.deps.view) } : {},
+		adapter: void 0,
+		scratch: {}
+	};
+}
+//#endregion
+export { x as buildGestureContext, b as captureBox, y as captureStarts, v as captureTargets, _ as resolvePolicy };
+
+//# sourceMappingURL=capture.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"capture.js","names":["IDENTITY_EXPAND","ids","EMPTY_POINT_SNAP","resolvePolicy","dep","DEFAULT_RESIZE_BEHAVIORS","captureTargets","expanded","shapeSources","scene","expandIds","isGroupPath","captureStarts","startPoses","startWorlds","leafBounds","drawnBounds","id","writeIds","node","g","geometryOf","world","carryPose","poseFrame","invertPlane","planeOf","view","visualBoundsViaDescriptor","captureBox","starts","bounds","unionBounds","unionAABB","lone","originPose","originGeometry","geometry","rotation","transform","poseLinearOf","fixedLocal","fixedCornerOf","anchor","localToWorld","boxFrame","boundsForRules","buildGestureContext","ruleOrigin","ctx","pointerStateOf","startWorld","readers","sceneGestureFrames"],"sources":["../../../../src/interactions/actions/resize/capture.ts"],"sourcesContent":["import { poseLinearOf } from '@weasel-js/geom';\nimport type { InvocationCtx } from '@weasel-js/routing';\nimport { localToWorld } from 'core/geometry/targetFrame';\nimport { pointerStateOf } from '../pointerState';\nimport { sceneGestureFrames } from '../gestureFrames';\nimport { unionAABB, unionBounds } from 'core/geometry/unionBounds';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { BoundsConstraint, GestureContext, PointSnapBehavior, ResizeAnchor } from '../../gestures/types';\nimport type { ResizePolicy } from '../depSchema';\nimport { carryPose, invertPlane, planeOf } from '../planeInput';\nimport type { PoseFrame } from '../poseFrame';\nimport { shapeSources } from '../selectionSubtree';\nimport { DEFAULT_RESIZE_BEHAVIORS } from './behaviors';\nimport { fixedCornerOf } from './cornerHandles';\nimport { visualBoundsViaDescriptor, type PoseDescriptor } from './geometry';\nimport { boundsForRules } from './ruleBounds';\nimport { boxFrame } from './boxFrame';\nimport type { ResizeBox } from './session';\n\nconst IDENTITY_EXPAND = (ids: string[]) => ids;\nconst EMPTY_POINT_SNAP: PointSnapBehavior<Bounds>[] = [];\n\n/** The `resizePolicy` dep's rules, or the defaults when it is unsourced. */\nexport function resolvePolicy(dep: ResizePolicy<unknown> | undefined): {\n  constraints: BoundsConstraint<Bounds>[];\n  pointSnap: PointSnapBehavior<Bounds>[];\n  expandIds: (ids: string[]) => string[];\n} {\n  if (!dep) {\n    return {\n      // Standard kit behaviors (shift = aspect lock) apply even with no\n      // policy wired; consumers opt out via an explicit `constraints: []`.\n      constraints: DEFAULT_RESIZE_BEHAVIORS as BoundsConstraint<Bounds>[],\n      pointSnap: EMPTY_POINT_SNAP,\n      expandIds: IDENTITY_EXPAND,\n    };\n  }\n  return {\n    constraints: dep.constraints as unknown as BoundsConstraint<Bounds>[],\n    pointSnap: dep.pointSnap as unknown as PointSnapBehavior<Bounds>[],\n    expandIds: dep.expandIds,\n  };\n}\n\n/** The ids the gesture writes, and whether one selected id stands for them.\n *  A lone id the policy expands into a different set is the group path:\n *  every leaf is written, against the union of their bounds. Otherwise the\n *  selected ids are written directly. A group whose pose derives from its\n *  children is resized by resizing them, whatever the policy expanded to.\n *  Null when there is nothing to write. */\nexport function captureTargets(\n  scene: Scene<unknown, string, unknown>,\n  ids: readonly NodeId[],\n  expandIds: (ids: string[]) => string[],\n): { writeIds: NodeId[]; isGroupPath: boolean } | null {\n  const expanded = shapeSources(scene, expandIds(ids as unknown as string[]));\n  if (expanded.length === 0) return null;\n  const isGroupPath =\n    ids.length === 1 && (expanded.length !== 1 || expanded[0] !== (ids[0] as string));\n  const writeIds = (isGroupPath || ids.length > 1 ? expanded : (ids as unknown as string[])) as NodeId[];\n  return { writeIds, isGroupPath };\n}\n\nexport interface ResizeStarts {\n  /** As stored. */\n  startPoses: Map<NodeId, unknown>;\n  /** In world, carried into the plane the edit is measured in. */\n  startWorlds: Map<NodeId, unknown>;\n  leafBounds: Bounds[];\n  drawnBounds: Bounds[];\n}\n\nexport function captureStarts(\n  scene: Scene<unknown, string, unknown>,\n  writeIds: readonly NodeId[],\n  geometryOf: (id: NodeId) => PoseDescriptor<unknown>,\n  poseFrame: PoseFrame<unknown>,\n  view: unknown,\n): ResizeStarts {\n  const startPoses = new Map<NodeId, unknown>();\n  const startWorlds = new Map<NodeId, unknown>();\n  const leafBounds: Bounds[] = [];\n  const drawnBounds: Bounds[] = [];\n  for (const id of writeIds) {\n    const node = scene.get(id);\n    if (!node) continue;\n    startPoses.set(id, node.pose);\n    const g = geometryOf(id);\n    const world = carryPose(g, poseFrame.world(id), invertPlane(planeOf(view, node.layer)));\n    startWorlds.set(id, world);\n    leafBounds.push(g.getBounds(world));\n    drawnBounds.push(visualBoundsViaDescriptor(world, g));\n  }\n  return { startPoses, startWorlds, leafBounds, drawnBounds };\n}\n\n/** The box the drag resizes, and that box as the constraints read it.\n *  `starts` must hold at least one pose. */\nexport function captureBox(\n  starts: Pick<ResizeStarts, 'startWorlds' | 'leafBounds' | 'drawnBounds'>,\n  writeIds: readonly NodeId[],\n  isGroupPath: boolean,\n  anchor: ResizeAnchor,\n  geometry: PoseDescriptor<unknown>,\n  geometryOf: (id: NodeId) => PoseDescriptor<unknown>,\n): { box: ResizeBox; ruleOrigin: Bounds } {\n  const { leafBounds, drawnBounds } = starts;\n  // A multi-selection's handles sit on the union of what is drawn, so that\n  // is the box its drag resizes.\n  const bounds = leafBounds.length === 1\n    ? leafBounds[0]\n    : isGroupPath ? unionBounds(leafBounds)! : unionAABB(drawnBounds)!;\n\n  // Rotation captured only for the single-write-id path; group-resize\n  // takes the AABB-frame (unrotated) path even if leaves have rotation.\n  const lone = !isGroupPath && writeIds.length === 1;\n  const originPose = lone ? starts.startWorlds.get(writeIds[0]) : (bounds as unknown);\n  // A lone target is read as its own shape; a shared box is a plain rect.\n  const originGeometry = lone ? geometryOf(writeIds[0]) : geometry;\n  const rotation = !isGroupPath ? (originGeometry.getRotation?.(originPose) ?? 0) : 0;\n  const transform = (lone && poseLinearOf(originPose)) || undefined;\n\n  const fixedLocal = fixedCornerOf(bounds, anchor);\n  const fixedWorld = localToWorld(boxFrame({ rotation, transform }, bounds), fixedLocal.x, fixedLocal.y);\n  return {\n    box: { bounds, anchor, rotation, transform, fixedWorld },\n    ruleOrigin: boundsForRules(originGeometry, originPose),\n  };\n}\n\n/** The context the constraints read. `draggedIds` is the selection, not the\n *  ids written, and the one pose it tracks is keyed by the first selected id. */\nexport function buildGestureContext(\n  ctx: InvocationCtx,\n  ids: readonly NodeId[],\n  ruleOrigin: Bounds,\n  startWorld: { x: number; y: number },\n  readers: GestureReaders,\n): GestureContext<Bounds> {\n  return {\n    draggedIds: ids as unknown as string[],\n    origin: new Map<string, Bounds>([[ids[0] as string, ruleOrigin]]),\n    current: new Map<string, Bounds>([[ids[0] as string, ruleOrigin]]),\n    snap: null,\n    modifiers: { ...ctx.modifiers },\n    pointer: pointerStateOf(startWorld, ctx),\n    view: readers.view(),\n    plane: readers.plane(),\n    ...(ctx.deps.scene\n      ? { frames: sceneGestureFrames(ctx.deps.scene, ctx.deps.view) as GestureContext<Bounds>['frames'] }\n      : {}),\n    // `adapter` is unused by the kit's behaviors; cast to satisfy the type.\n    adapter: undefined as unknown as GestureContext<Bounds>['adapter'],\n    scratch: {},\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAqBA,IAAMA,KAAmB,MAAkBC,GACrCC,IAAgD,CAAC;AAGvD,SAAgBC,EAAc,GAI5B;CAUA,OATKC,IASE;EACL,aAAaA,EAAI;EACjB,WAAWA,EAAI;EACf,WAAWA,EAAI;CACjB,IAZS;EAGL,aAAaC;EACb,WAAWH;EACX,WAAWF;CACb;AAOJ;AAQA,SAAgBM,EACd,GACA,GACA,GACqD;CACrD,IAAMC,IAAWC,EAAaC,GAAOC,EAAUT,CAA0B,CAAC;CAC1E,IAAIM,EAAS,WAAW,GAAG,OAAO;CAClC,IAAMI,IACJV,EAAI,WAAW,MAAMM,EAAS,WAAW,KAAKA,EAAS,OAAQN,EAAI;CAErE,OAAO;EAAE,UADSU,KAAeV,EAAI,SAAS,IAAIM,IAAYN;EAC3C;CAAY;AACjC;AAWA,SAAgBW,EACd,GACA,GACA,GACA,GACA,GACc;CACd,IAAMC,oBAAa,IAAI,IAAqB,GACtCC,oBAAc,IAAI,IAAqB,GACvCC,IAAuB,CAAC,GACxBC,IAAwB,CAAC;CAC/B,KAAK,IAAMC,KAAMC,GAAU;EACzB,IAAMC,IAAOV,EAAM,IAAIQ,CAAE;EACzB,IAAI,CAACE,GAAM;EACX,EAAW,IAAIF,GAAIE,EAAK,IAAI;EAC5B,IAAMC,IAAIC,EAAWJ,CAAE,GACjBK,IAAQC,EAAUH,GAAGI,EAAU,MAAMP,CAAE,GAAGQ,EAAYC,EAAQC,GAAMR,EAAK,KAAK,CAAC,CAAC;EAGtF,AAFAL,EAAY,IAAIG,GAAIK,CAAK,GACzBP,EAAW,KAAKK,EAAE,UAAUE,CAAK,CAAC,GAClCN,EAAY,KAAKY,EAA0BN,GAAOF,CAAC,CAAC;CACtD;CACA,OAAO;EAAE;EAAY;EAAa;EAAY;CAAY;AAC5D;AAIA,SAAgBS,EACd,GACA,GACA,GACA,GACA,GACA,GACwC;CACxC,IAAM,EAAE,eAAY,mBAAgBC,GAG9BC,IAAShB,EAAW,WAAW,IACjCA,EAAW,KACXJ,IAAcqB,EAAYjB,CAAU,IAAKkB,EAAUjB,CAAW,GAI5DkB,IAAO,CAACvB,KAAeO,EAAS,WAAW,GAC3CiB,IAAaD,IAAOJ,EAAO,YAAY,IAAIZ,EAAS,EAAE,IAAKa,GAE3DK,IAAiBF,IAAOb,EAAWH,EAAS,EAAE,IAAImB,GAClDC,IAAY3B,IAAgE,IAAjDyB,EAAe,cAAcD,CAAU,KAAK,GACvEI,IAAaL,KAAQM,EAAaL,CAAU,KAAM,KAAA,GAElDM,IAAaC,EAAcX,GAAQY,CAAM;CAE/C,OAAO;EACL,KAAK;GAAE;GAAQ;GAAQ;GAAU;GAAW,YAF3BC,EAAaC,EAAS;IAAE;IAAU;GAAU,GAAGd,CAAM,GAAGU,EAAW,GAAGA,EAAW,CAEtD;EAAW;EACvD,YAAYK,EAAeV,GAAgBD,CAAU;CACvD;AACF;AAIA,SAAgBY,EACd,GACA,GACA,GACA,GACA,GACwB;CACxB,OAAO;EACL,YAAY9C;EACZ,wBAAQ,IAAI,IAAoB,CAAC,CAACA,EAAI,IAAc+C,CAAU,CAAC,CAAC;EAChE,yBAAS,IAAI,IAAoB,CAAC,CAAC/C,EAAI,IAAc+C,CAAU,CAAC,CAAC;EACjE,MAAM;EACN,WAAW,EAAE,GAAGC,EAAI,UAAU;EAC9B,SAASC,EAAeC,GAAYF,CAAG;EACvC,MAAMG,EAAQ,KAAK;EACnB,OAAOA,EAAQ,MAAM;EACrB,GAAIH,EAAI,KAAK,QACT,EAAE,QAAQI,EAAmBJ,EAAI,KAAK,OAAOA,EAAI,KAAK,IAAI,EAAsC,IAChG,CAAC;EAEL,SAAS,KAAA;EACT,SAAS,CAAC;CACZ;AACF"}

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

@@ -0,0 +1,69 @@
+import { commitGestureOps as e, reduceBehaviorEnd as t } from "../gestureLifecycle.js";
+import { createTransformOp as n } from "../../../core/ops/transform.js";
+import { geometryDataOp as r } from "../geometryProjection.js";
+import { defaultCommitAdapter as i } from "../defaultCommitAdapter.js";
+import { boxToBox as a } from "@weasel-js/geom";
+//#region src/interactions/actions/resize/commit.ts
+function o(e, t, n, i, o, s) {
+	let c = t.getBounds(i), l = t.getBounds(o), u = a(c.x, c.y, c.width, c.height, l.x, l.y, l.width, l.height), d = r(e, {
+		id: n.id,
+		data: n.data,
+		pose: i
+	}, u, s);
+	if (!d) return null;
+	if (!(l.width < 0 || l.height < 0)) return {
+		dataOp: d,
+		pose: o
+	};
+	let f = {
+		...l,
+		x: l.width < 0 ? l.x + l.width : l.x,
+		y: l.height < 0 ? l.y + l.height : l.y,
+		width: Math.abs(l.width),
+		height: Math.abs(l.height)
+	};
+	return {
+		dataOp: d,
+		pose: t.remapBounds(o, l, f)
+	};
+}
+function s(e, t, r) {
+	let i = [];
+	for (let a of e.writeIds) {
+		let s = t.get(a);
+		if (s === void 0) continue;
+		let c = e.startPoses.get(a);
+		if (c === void 0) continue;
+		let l = s, u = e.geometryProjection ? e.scene.get(a) : void 0;
+		if (e.geometryProjection && u) {
+			let t = o(e.geometryProjection, e.geometryOf(a), {
+				id: a,
+				data: u.data
+			}, c, s, r);
+			t && (i.push(t.dataOp), l = t.pose);
+		}
+		i.push(n({
+			id: a,
+			from: c,
+			to: l,
+			label: r
+		}));
+	}
+	return i;
+}
+function c(n, r) {
+	let { lifecycle: a } = n, o = {
+		scene: n.scene,
+		applyOps: n.applyOps,
+		adapter: i(n.scene, n.selectionMethods)
+	}, c = t(n.constraints, n.gestureCtx);
+	if (c === null) return !1;
+	if (c !== void 0) return e(o, a, c);
+	if (r.previews.size === 0) return !1;
+	let l = s(n, r.previews, a.label);
+	return l.length !== 0 && e(o, a, l);
+}
+//#endregion
+export { c as commitResize, s as resizeOps };
+
+//# sourceMappingURL=commit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"commit.js","names":["projectedGeometry","sb","g","from","db","next","m","boxToBox","dataOp","geometryDataOp","projection","node","label","nb","resizeOps","ops","id","leaves","previews","to","projected","createTransformOp","commitResize","session","target","defaultCommitAdapter","r","reduceBehaviorEnd","commitGestureOps","lifecycle","frame"],"sources":["../../../../src/interactions/actions/resize/commit.ts"],"sourcesContent":["import { boxToBox, type Affine } from '@weasel-js/geom';\nimport type { Op } from 'core/ops/types';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { NodeId } from 'core/scene/types';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { geometryDataOp, type GeometryProjection } from '../geometryProjection';\nimport { commitGestureOps, reduceBehaviorEnd } from '../gestureLifecycle';\nimport type { PoseDescriptor } from './geometry';\nimport type { ResizeFrame, ResizeSession } from './session';\n\n/** The op mapping a leaf's data-held geometry by the box→box affine its pose\n *  underwent, and the pose to commit beside it. Null when the projection\n *  leaves this node's data alone. */\nfunction projectedGeometry(\n  projection: GeometryProjection,\n  g: PoseDescriptor<unknown>,\n  node: { id: string; data: unknown },\n  from: unknown,\n  next: unknown,\n  label: string,\n): { dataOp: Op; pose: unknown } | null {\n  const sb = g.getBounds(from);\n  const db = g.getBounds(next);\n  const m: Affine = boxToBox(\n    sb.x, sb.y, sb.width, sb.height,\n    db.x, db.y, db.width, db.height,\n  );\n  const dataOp = geometryDataOp(projection, { id: node.id, data: node.data, pose: from }, m, label);\n  if (!dataOp) return null;\n  // The data absorbed the affine — including any mirror from a\n  // drag past the opposite edge — so the pose must commit as a\n  // normalized AABB. Leaving signed extents on the pose makes\n  // the node unhittable (hit-testing assumes normalized boxes).\n  // Without the seam the signed pose is kept: a bare-AABB pose\n  // is the only carrier of the flip there.\n  if (!(db.width < 0 || db.height < 0)) return { dataOp, pose: next };\n  const nb = {\n    ...db,\n    x: db.width < 0 ? db.x + db.width : db.x,\n    y: db.height < 0 ? db.y + db.height : db.y,\n    width: Math.abs(db.width),\n    height: Math.abs(db.height),\n  };\n  return { dataOp, pose: g.remapBounds(next, db, nb) };\n}\n\n/** One transform op per write id, `from` the pose stored at press and `to`\n *  its preview, each preceded by its data op when the geometry projection\n *  answers for the node. */\nexport function resizeOps(\n  leaves: Pick<ResizeSession, 'scene' | 'writeIds' | 'startPoses' | 'geometryOf' | 'geometryProjection'>,\n  previews: ReadonlyMap<NodeId, unknown>,\n  label: string,\n): Op[] {\n  const ops: Op[] = [];\n  for (const id of leaves.writeIds) {\n    const next = previews.get(id);\n    if (next === undefined) continue;\n    const from = leaves.startPoses.get(id);\n    if (from === undefined) continue;\n    let to: unknown = next;\n    const node = leaves.geometryProjection ? leaves.scene.get(id) : undefined;\n    if (leaves.geometryProjection && node) {\n      const projected = projectedGeometry(\n        leaves.geometryProjection, leaves.geometryOf(id), { id: id as string, data: node.data }, from, next, label,\n      );\n      if (projected) {\n        ops.push(projected.dataOp);\n        to = projected.pose;\n      }\n    }\n    ops.push(createTransformOp<unknown>({ id: id as string, from, to, label }));\n  }\n  return ops;\n}\n\n/** Commit the drag as one batch, so one undo entry. Returns whether anything\n *  reached the document. */\nexport function commitResize(session: ResizeSession, frame: ResizeFrame): boolean {\n  const { lifecycle } = session;\n  const target = {\n    scene: session.scene,\n    applyOps: session.applyOps,\n    adapter: defaultCommitAdapter(session.scene, session.selectionMethods),\n  };\n  const r = reduceBehaviorEnd(session.constraints, session.gestureCtx);\n  if (r === null) return false;\n  if (r !== undefined) return commitGestureOps(target, lifecycle, r);\n\n  if (frame.previews.size === 0) return false;\n  const ops = resizeOps(session, frame.previews, lifecycle.label);\n  if (ops.length === 0) return false;\n  return commitGestureOps(target, lifecycle, ops);\n}\n"],"mappings":";;;;;;AAaA,SAASA,EACP,GACA,GACA,GACA,GACA,GACA,GACsC;CACtC,IAAMC,IAAKC,EAAE,UAAUC,CAAI,GACrBC,IAAKF,EAAE,UAAUG,CAAI,GACrBC,IAAYC,EAChBN,EAAG,GAAGA,EAAG,GAAGA,EAAG,OAAOA,EAAG,QACzBG,EAAG,GAAGA,EAAG,GAAGA,EAAG,OAAOA,EAAG,MAC3B,GACMI,IAASC,EAAeC,GAAY;EAAE,IAAIC,EAAK;EAAI,MAAMA,EAAK;EAAM,MAAMR;CAAK,GAAGG,GAAGM,CAAK;CAChG,IAAI,CAACJ,GAAQ,OAAO;CAOpB,IAAI,EAAEJ,EAAG,QAAQ,KAAKA,EAAG,SAAS,IAAI,OAAO;EAAE;EAAQ,MAAMC;CAAK;CAClE,IAAMQ,IAAK;EACT,GAAGT;EACH,GAAGA,EAAG,QAAQ,IAAIA,EAAG,IAAIA,EAAG,QAAQA,EAAG;EACvC,GAAGA,EAAG,SAAS,IAAIA,EAAG,IAAIA,EAAG,SAASA,EAAG;EACzC,OAAO,KAAK,IAAIA,EAAG,KAAK;EACxB,QAAQ,KAAK,IAAIA,EAAG,MAAM;CAC5B;CACA,OAAO;EAAE;EAAQ,MAAMF,EAAE,YAAYG,GAAMD,GAAIS,CAAE;CAAE;AACrD;AAKA,SAAgBC,EACd,GACA,GACA,GACM;CACN,IAAMC,IAAY,CAAC;CACnB,KAAK,IAAMC,KAAMC,EAAO,UAAU;EAChC,IAAMZ,IAAOa,EAAS,IAAIF,CAAE;EAC5B,IAAIX,MAAS,KAAA,GAAW;EACxB,IAAMF,IAAOc,EAAO,WAAW,IAAID,CAAE;EACrC,IAAIb,MAAS,KAAA,GAAW;EACxB,IAAIgB,IAAcd,GACZM,IAAOM,EAAO,qBAAqBA,EAAO,MAAM,IAAID,CAAE,IAAI,KAAA;EAChE,IAAIC,EAAO,sBAAsBN,GAAM;GACrC,IAAMS,IAAYpB,EAChBiB,EAAO,oBAAoBA,EAAO,WAAWD,CAAE,GAAG;IAAM;IAAc,MAAML,EAAK;GAAK,GAAGR,GAAME,GAAMO,CACvG;GACA,AAAIQ,MACFL,EAAI,KAAKK,EAAU,MAAM,GACzB,IAAKA,EAAU;EAEnB;EACA,EAAI,KAAKC,EAA2B;GAAM;GAAc;GAAM;GAAI;EAAM,CAAC,CAAC;CAC5E;CACA,OAAON;AACT;AAIA,SAAgBO,EAAa,GAAwB,GAA6B;CAChF,IAAM,EAAE,iBAAcC,GAChBC,IAAS;EACb,OAAOD,EAAQ;EACf,UAAUA,EAAQ;EAClB,SAASE,EAAqBF,EAAQ,OAAOA,EAAQ,gBAAgB;CACvE,GACMG,IAAIC,EAAkBJ,EAAQ,aAAaA,EAAQ,UAAU;CACnE,IAAIG,MAAM,MAAM,OAAO;CACvB,IAAIA,MAAM,KAAA,GAAW,OAAOE,EAAiBJ,GAAQK,GAAWH,CAAC;CAEjE,IAAII,EAAM,SAAS,SAAS,GAAG,OAAO;CACtC,IAAMf,IAAMD,EAAUS,GAASO,EAAM,UAAUD,EAAU,KAAK;CAE9D,OADId,EAAI,WAAW,KACZa,EAAiBJ,GAAQK,GAAWd,CAAG;AAChD"}

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

@@ -0,0 +1,88 @@
+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";
+//#region src/interactions/actions/resize/frame.ts
+function f(e, t, n, i, a) {
+	let { x: o, y: s } = r(a, n, i) ?? {
+		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
+	};
+}
+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
+		});
+	}
+	return i;
+}
+function m(t, n, r, i, a) {
+	return a && d(n) !== null ? e(n, r, i) : t.remapBounds(n, r, i);
+}
+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);
+}
+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)));
+}
+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);
+	};
+	if (e.sharedBox) {
+		for (let t of e.writeIds) {
+			let n = a(t);
+			n !== void 0 && i.set(t, g(e, t, n));
+		}
+		return { previews: i };
+	}
+	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,
+		lone: {
+			id: o,
+			g: s,
+			world: l
+		}
+	};
+}
+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
+	};
+}
+//#endregion
+export { v as nextFrame, _ as posesInBox };
+
+//# sourceMappingURL=frame.js.map

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

@@ -0,0 +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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"}

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

@@ -0,0 +1,111 @@
+import { fromPlane as e, toPlane as t } from "../../../core/viewport/parallax.js";
+import { isRectPose as n } from "../../../core/geometry/autoPoseDescriptor.js";
+import { targetCorners as r, worldDeltaToLocal as i } from "../../../core/geometry/targetFrame.js";
+import { boxFrame as a } from "./boxFrame.js";
+import { boundsForRules as o } from "./ruleBounds.js";
+//#region src/interactions/actions/resize/pointSnap.ts
+function s(e, t, n, i, a) {
+	let o = e.x + e.width / 2, s = e.y + e.height / 2, [c, l, u, d] = r(e, t), f = null, p = null;
+	if (i.x !== "free" && i.y !== "free") {
+		let e = i.x === "min" && i.y === "min" ? c : i.x === "max" && i.y === "min" ? l : i.x === "max" && i.y === "max" ? u : d, t = i.x === "min" && i.y === "min" ? u : i.x === "max" && i.y === "min" ? d : i.x === "max" && i.y === "max" ? c : l;
+		p = {
+			worldX: e.x,
+			worldY: e.y
+		}, f = {
+			worldX: t.x,
+			worldY: t.y
+		};
+	}
+	return {
+		draggedCorner: f,
+		fixedCorner: p,
+		center: {
+			worldX: o,
+			worldY: s
+		},
+		origin: {
+			worldX: c.x,
+			worldY: c.y
+		},
+		rotation: n,
+		anchor: i,
+		proposed: e,
+		modifiers: a
+	};
+}
+function c(e, t, n, r) {
+	if (n.frame === "center") {
+		let t = n.worldX - r.center.worldX, i = n.worldY - r.center.worldY;
+		return {
+			...e,
+			x: e.x + t,
+			y: e.y + i
+		};
+	}
+	if (n.frame === "origin") {
+		let t = n.worldX - r.origin.worldX, i = n.worldY - r.origin.worldY;
+		return {
+			...e,
+			x: e.x + t,
+			y: e.y + i
+		};
+	}
+	let a = n.frame === "dragged-corner" ? r.fixedCorner : r.draggedCorner;
+	if (!a) return e;
+	let o = i(t, n.worldX - a.worldX, n.worldY - a.worldY);
+	if (!o) return e;
+	let s = Math.abs(o.x), c = Math.abs(o.y), l = (a.worldX + n.worldX) / 2, u = (a.worldY + n.worldY) / 2;
+	return {
+		...e,
+		x: l - s / 2,
+		y: u - c / 2,
+		width: s,
+		height: c
+	};
+}
+function l(t, n) {
+	let r = (t) => {
+		let r = e(n, {
+			x: t.worldX,
+			y: t.worldY
+		});
+		return {
+			worldX: r.x,
+			worldY: r.y
+		};
+	};
+	return {
+		...t,
+		draggedCorner: t.draggedCorner && r(t.draggedCorner),
+		fixedCorner: t.fixedCorner && r(t.fixedCorner),
+		center: r(t.center),
+		origin: r(t.origin)
+	};
+}
+function u(e, n) {
+	if (!e) return e;
+	let r = t(n, {
+		x: e.worldX,
+		y: e.worldY
+	});
+	return {
+		...e,
+		worldX: r.x,
+		worldY: r.y
+	};
+}
+function d(e, t, r, i, d, f, p) {
+	if (e.length === 0) return r;
+	let m = o(t, r), h = a(i, m), g = s(m, h, i.rotation, d, f);
+	for (let i of e) {
+		let e = p ? u(i.onMove(l(g, p)), p) : i.onMove(g);
+		if (!e) continue;
+		let a = c(m, h, e, g);
+		return n(r) ? a : t.remapBounds(r, m, a);
+	}
+	return r;
+}
+//#endregion
+export { d as snapPose };
+
+//# sourceMappingURL=pointSnap.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pointSnap.js","names":["buildPointSnapContext","cx","pose","cy","tl","tr","br","bl","targetCorners","frame","draggedCorner","fixedCorner","anchor","fixedPt","draggedPt","applyPointSnap","result","dx","ctx","dy","pin","diagonal","worldDeltaToLocal","newWidth","newHeight","newCx","newCy","pointSnapToCamera","cam","w","fromPlane","m","p","pointSnapFromPlane","r","toPlane","snapPose","rules","poseAsRect","boundsForRules","g","boxFrame","box","psCtx","modifiers","rule","plane","snapped","isRectPose"],"sources":["../../../../src/interactions/actions/resize/pointSnap.ts"],"sourcesContent":["import { isRectPose } from 'core/geometry/autoPoseDescriptor';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { fromPlane, toPlane, type PlaneMap } from 'core/viewport/parallax';\nimport type {\n  ModifierState,\n  PointSnapBehavior,\n  PointSnapContext,\n  PointSnapResult,\n  ResizeAnchor,\n} from '../../gestures/types';\nimport { targetCorners, worldDeltaToLocal, type TargetTransform } from 'core/geometry/targetFrame';\nimport { boxFrame } from './boxFrame';\nimport type { ResizeBox } from './session';\nimport type { PoseDescriptor } from './geometry';\nimport { boundsForRules } from './ruleBounds';\n\nfunction buildPointSnapContext<TPose extends Bounds>(\n  pose: TPose,\n  frame: TargetTransform,\n  rotation: number,\n  anchor: ResizeAnchor,\n  modifiers: ModifierState,\n): PointSnapContext<TPose> {\n  const cx = pose.x + pose.width / 2;\n  const cy = pose.y + pose.height / 2;\n  const [tl, tr, br, bl] = targetCorners(pose, frame);\n\n  let draggedCorner: { worldX: number; worldY: number } | null = null;\n  let fixedCorner: { worldX: number; worldY: number } | null = null;\n\n  if (anchor.x !== 'free' && anchor.y !== 'free') {\n    const fixedPt =\n      anchor.x === 'min' && anchor.y === 'min' ? tl :\n      anchor.x === 'max' && anchor.y === 'min' ? tr :\n      anchor.x === 'max' && anchor.y === 'max' ? br : bl;\n    const draggedPt =\n      anchor.x === 'min' && anchor.y === 'min' ? br :\n      anchor.x === 'max' && anchor.y === 'min' ? bl :\n      anchor.x === 'max' && anchor.y === 'max' ? tl : tr;\n    fixedCorner = { worldX: fixedPt.x, worldY: fixedPt.y };\n    draggedCorner = { worldX: draggedPt.x, worldY: draggedPt.y };\n  }\n\n  return {\n    draggedCorner,\n    fixedCorner,\n    center: { worldX: cx, worldY: cy },\n    origin: { worldX: tl.x, worldY: tl.y },\n    rotation,\n    anchor,\n    proposed: pose,\n    modifiers,\n  };\n}\n\nfunction applyPointSnap<TPose extends Bounds>(\n  pose: TPose,\n  frame: TargetTransform,\n  result: PointSnapResult,\n  ctx: PointSnapContext<TPose>,\n): TPose {\n  if (result.frame === 'center') {\n    const dx = result.worldX - ctx.center.worldX;\n    const dy = result.worldY - ctx.center.worldY;\n    return { ...pose, x: pose.x + dx, y: pose.y + dy };\n  }\n  if (result.frame === 'origin') {\n    const dx = result.worldX - ctx.origin.worldX;\n    const dy = result.worldY - ctx.origin.worldY;\n    return { ...pose, x: pose.x + dx, y: pose.y + dy };\n  }\n  const pin = result.frame === 'dragged-corner' ? ctx.fixedCorner : ctx.draggedCorner;\n  if (!pin) return pose;\n  // The diagonal from the pinned corner, in the box's own axes.\n  const diagonal = worldDeltaToLocal(frame, result.worldX - pin.worldX, result.worldY - pin.worldY);\n  if (!diagonal) return pose;\n  const newWidth = Math.abs(diagonal.x);\n  const newHeight = Math.abs(diagonal.y);\n  const newCx = (pin.worldX + result.worldX) / 2;\n  const newCy = (pin.worldY + result.worldY) / 2;\n  return { ...pose, x: newCx - newWidth / 2, y: newCy - newHeight / 2, width: newWidth, height: newHeight };\n}\n\n/** `ctx`'s points in the camera's world, for a snap rule written against it. */\nfunction pointSnapToCamera<TPose extends Bounds>(\n  ctx: PointSnapContext<TPose>,\n  m: PlaneMap,\n): PointSnapContext<TPose> {\n  const cam = (p: { worldX: number; worldY: number }) => {\n    const w = fromPlane(m, { x: p.worldX, y: p.worldY });\n    return { worldX: w.x, worldY: w.y };\n  };\n  return {\n    ...ctx,\n    draggedCorner: ctx.draggedCorner && cam(ctx.draggedCorner),\n    fixedCorner: ctx.fixedCorner && cam(ctx.fixedCorner),\n    center: cam(ctx.center),\n    origin: cam(ctx.origin),\n  };\n}\n\n/** A snap rule's answer, back in the plane the resize works in. */\nfunction pointSnapFromPlane(\n  r: PointSnapResult | null | undefined,\n  m: PlaneMap,\n): PointSnapResult | null | undefined {\n  if (!r) return r;\n  const p = toPlane(m, { x: r.worldX, y: r.worldY });\n  return { ...r, worldX: p.x, worldY: p.y };\n}\n\n/** `pose` moved so the frame the first answering rule chose lands on its\n *  target; `pose` itself when no rule answers. `plane` is the plane the\n *  resize works in, null in the camera's own world. */\nexport function snapPose(\n  rules: readonly PointSnapBehavior<Bounds>[],\n  g: PoseDescriptor<unknown>,\n  pose: unknown,\n  box: Pick<ResizeBox, 'rotation' | 'transform'>,\n  anchor: ResizeAnchor,\n  modifiers: ModifierState,\n  plane: PlaneMap | null,\n): unknown {\n  if (rules.length === 0) return pose;\n  const poseAsRect = boundsForRules(g, pose);\n  const frame = boxFrame(box, poseAsRect);\n  const psCtx = buildPointSnapContext(poseAsRect, frame, box.rotation, anchor, modifiers);\n  // Point snaps are the surface's rules over the camera's world, so\n  // on a plane their points cross at this boundary.\n  for (const rule of rules) {\n    const result = plane\n      ? pointSnapFromPlane(rule.onMove(pointSnapToCamera(psCtx, plane)), plane)\n      : rule.onMove(psCtx);\n    if (!result) continue;\n    const snapped = applyPointSnap(poseAsRect, frame, result, psCtx);\n    return isRectPose(pose) ? snapped : g.remapBounds(pose, poseAsRect, snapped);\n  }\n  return pose;\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,47 @@
+import { resizeOps as e } from "./commit.js";
+import { posesInBox as t } from "./frame.js";
+import { captureResize as n } from "./session.js";
+//#region src/interactions/actions/resize/replay.ts
+function r(e, t) {
+	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
+	};
+}
+function i(e, t) {
+	let n = e.width === 0 ? {
+		x: 0,
+		width: 1
+	} : {
+		x: (t.x - e.x) / e.width,
+		width: t.width / e.width
+	}, r = e.height === 0 ? {
+		y: 0,
+		height: 1
+	} : {
+		y: (t.y - e.y) / e.height,
+		height: t.height / e.height
+	};
+	return {
+		x: n.x,
+		y: r.y,
+		width: n.width,
+		height: r.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);
+}
+//#endregion
+export { r as boxInUnits, a as resizeSelectionOps, i as unitsOfBox };
+
+//# sourceMappingURL=replay.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,9 @@
+import { isRectPose as e } from "../../../core/geometry/autoPoseDescriptor.js";
+//#region src/interactions/actions/resize/ruleBounds.ts
+function t(t, n) {
+	return e(n) ? n : t.getBounds(n);
+}
+//#endregion
+export { t as boundsForRules };
+
+//# sourceMappingURL=ruleBounds.js.map