@weasel-js/core 1.7.0 → 1.7.1

package/dist/interactions/actions/resize/behaviors/clampMinSize.js

@@ -0,0 +1,18 @@
+//#region src/interactions/actions/resize/behaviors/clampMinSize.ts
+function e(e) {
+	let { minWidth: t, minHeight: n } = e;
+	return { onMove(e, { pose: r, anchor: i }) {
+		let { x: a, y: o, width: s, height: c } = r, l = !1;
+		if (i.x !== "free" && s < t && (i.x === "min" || (a = a + s - t), s = t, l = !0), i.y !== "free" && c < n && (i.y === "min" || (o = o + c - n), c = n, l = !0), l) return { pose: {
+			...r,
+			x: a,
+			y: o,
+			width: s,
+			height: c
+		} };
+	} };
+}
+//#endregion
+export { e as clampMinSize };
+
+//# sourceMappingURL=clampMinSize.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clampMinSize.js","names":["clampMinSize","args","pose","changed","anchor","width","minWidth","x","height","minHeight","y"],"sources":["../../../../../src/interactions/actions/resize/behaviors/clampMinSize.ts"],"sourcesContent":["import type { BoundsConstraint } from '../../../gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** Resize constraint that stops a node shrinking past a minimum. The anchored\n *  edge stays put, so clamping pushes the dragged edge back rather than moving\n *  the node. */\nexport function clampMinSize<TPose extends Bounds>(args: {\n  minWidth: number;\n  minHeight: number;\n}): BoundsConstraint<TPose> {\n  const { minWidth, minHeight } = args;\n  return {\n    onMove(_ctx, { pose, anchor }) {\n      let { x, y, width, height } = pose;\n      let changed = false;\n      if (anchor.x !== 'free' && width < minWidth) {\n        if (anchor.x === 'min') {\n          // West edge is anchor; east edge was dragged. Hold x; widen to min.\n          width = minWidth;\n        } else {\n          // East edge is anchor at originalRight = x + width. Hold the right;\n          // shift x left so width = minWidth.\n          const right = x + width;\n          x = right - minWidth;\n          width = minWidth;\n        }\n        changed = true;\n      }\n      if (anchor.y !== 'free' && height < minHeight) {\n        if (anchor.y === 'min') {\n          height = minHeight;\n        } else {\n          const bottom = y + height;\n          y = bottom - minHeight;\n          height = minHeight;\n        }\n        changed = true;\n      }\n      if (!changed) return;\n      return { pose: { ...pose, x, y, width, height } };\n    },\n  };\n}\n"],"mappings":";AAMA,SAAgBA,EAAmC,GAGvB;CAC1B,IAAM,EAAE,aAAU,iBAAcC;CAChC,OAAO,EACL,OAAO,GAAM,EAAE,SAAM,aAAU;EAC7B,IAAI,EAAE,MAAG,MAAG,UAAO,cAAWC,GAC1BC,IAAU;EAwBd,IAvBIC,EAAO,MAAM,UAAUC,IAAQC,MAC7BF,EAAO,MAAM,UAOf,IADcG,IAAIF,IACNC,IALZ,IAAQA,GAQV,IAAU,KAERF,EAAO,MAAM,UAAUI,IAASC,MAC9BL,EAAO,MAAM,UAIf,IADeM,IAAIF,IACNC,IAHb,IAASA,GAMX,IAAU,KAEPN,GACL,OAAO,EAAE,MAAM;GAAE,GAAGD;GAAM;GAAG;GAAG;GAAO;EAAO,EAAE;CAClD,EACF;AACF"}

package/dist/interactions/actions/resize/behaviors/index.js

@@ -0,0 +1,8 @@
+import { clampMinSize as e } from "./clampMinSize.js";
+import { lockAspectWithModifier as t } from "./lockAspect.js";
+//#region src/interactions/actions/resize/behaviors/index.ts
+var n = Object.freeze([t()]);
+//#endregion
+export { n as DEFAULT_RESIZE_BEHAVIORS, e as clampMinSize, t as lockAspectWithModifier };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["DEFAULT_RESIZE_BEHAVIORS","lockAspectWithModifier","clampMinSize"],"sources":["../../../../../src/interactions/actions/resize/behaviors/index.ts"],"sourcesContent":["export { clampMinSize } from './clampMinSize';\nexport { lockAspectWithModifier } from './lockAspect';\n\nimport type { BoundsConstraint } from '../../../gestures/types';\nimport { lockAspectWithModifier } from './lockAspect';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** The kit's standard resize behaviors, applied when a consumer doesn't\n *  supply its own list: shift-drag locks the start pose's aspect ratio.\n *  Pass an explicit `behaviors: []` to opt out. Stateless, so one shared\n *  frozen instance is safe across every gesture. */\nexport const DEFAULT_RESIZE_BEHAVIORS: readonly BoundsConstraint<Bounds>[] =\n  Object.freeze([lockAspectWithModifier()]);\n"],"mappings":";;;AAWA,IAAaA,IACX,OAAO,OAAO,CAACC,EAAuB,CAAC,CAAC"}

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

@@ -0,0 +1,24 @@
+//#region src/interactions/actions/resize/behaviors/lockAspect.ts
+function e(e = {}) {
+	let { key: t = "shift" } = e;
+	return { onMove(e, { pose: n, anchor: r }) {
+		if (!e.modifiers[t]) return;
+		let i = e.origin.get(e.draggedIds[0]);
+		if (!i || i.width === 0 || i.height === 0) return;
+		let a = i.width / i.height, o = n.width - i.width, s = n.height - i.height, c, l;
+		if (r.x === "free" && r.y === "free") return;
+		r.x === "free" ? (l = n.height, c = l * a, c < 0 && (c = -c)) : r.y === "free" ? (c = n.width, l = c / a, l < 0 && (l = -l)) : Math.abs(o) >= Math.abs(s) ? (c = n.width, l = Math.abs(c) / a * Math.sign(n.height || 1)) : (l = n.height, c = Math.abs(l) * a * Math.sign(n.width || 1));
+		let u = n.x, d = n.y;
+		return u = r.x === "min" ? i.x : r.x === "max" ? i.x + i.width - c : i.x + i.width / 2 - c / 2, d = r.y === "min" ? i.y : r.y === "max" ? i.y + i.height - l : i.y + i.height / 2 - l / 2, { pose: {
+			...n,
+			x: u,
+			y: d,
+			width: c,
+			height: l
+		} };
+	} };
+}
+//#endregion
+export { e as lockAspectWithModifier };
+
+//# sourceMappingURL=lockAspect.js.map

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

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

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

@@ -0,0 +1,72 @@
+//#region src/interactions/actions/resize/cornerHandles.ts
+var e = [
+	{
+		xEdge: "min",
+		yEdge: "min",
+		anchor: {
+			x: "max",
+			y: "max"
+		},
+		kind: "handle:top-left",
+		tag: "min-min"
+	},
+	{
+		xEdge: "max",
+		yEdge: "min",
+		anchor: {
+			x: "min",
+			y: "max"
+		},
+		kind: "handle:top-right",
+		tag: "max-min"
+	},
+	{
+		xEdge: "min",
+		yEdge: "max",
+		anchor: {
+			x: "max",
+			y: "min"
+		},
+		kind: "handle:bottom-left",
+		tag: "min-max"
+	},
+	{
+		xEdge: "max",
+		yEdge: "max",
+		anchor: {
+			x: "min",
+			y: "min"
+		},
+		kind: "handle:bottom-right",
+		tag: "max-max"
+	}
+];
+function t(e, t) {
+	return {
+		x: t.xEdge === "max" ? e.x + e.width : e.x,
+		y: t.yEdge === "max" ? e.y + e.height : e.y
+	};
+}
+function n(n) {
+	return e.map((e) => {
+		let r = t(n, e);
+		return {
+			cx: r.x,
+			cy: r.y,
+			anchor: e.anchor
+		};
+	});
+}
+function r(e, t, n, r) {
+	return Math.abs(t - e.cx) <= r && Math.abs(n - e.cy) <= r;
+}
+function i(e, t) {
+	return {
+		x: t.x === "max" ? e.x + e.width : e.x,
+		y: t.y === "max" ? e.y + e.height : e.y
+	};
+}
+//#endregion
+export { e as CORNER_ANCHORS, t as cornerPoint, n as cornerResizeHandles, i as fixedCornerOf, r as hitCornerHandle };
+
+//# sourceMappingURL=cornerHandles.js.map

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

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

package/dist/interactions/actions/resolveOverlays.js

@@ -0,0 +1,60 @@
+import { insertPreviewExtent as e } from "../../canvas/insertPreviewExtent.js";
+//#region src/interactions/actions/resolveOverlays.ts
+function t(t) {
+	let n = [];
+	for (let r of t) switch (r.kind) {
+		case "marquee": {
+			let e = Math.min(r.start.x, r.current.x), t = Math.min(r.start.y, r.current.y), i = Math.abs(r.current.x - r.start.x), a = Math.abs(r.current.y - r.start.y);
+			if (i === 0 && a === 0) break;
+			n.push({
+				kind: "marquee",
+				visibilityId: "action.marquee",
+				bounds: {
+					x: e,
+					y: t,
+					width: i,
+					height: a
+				},
+				shiftHeld: r.shiftHeld
+			});
+			break;
+		}
+		case "lasso":
+			if (r.vertices.length < 2) break;
+			n.push({
+				kind: "lasso",
+				visibilityId: "action.lasso",
+				vertices: r.vertices,
+				current: r.current,
+				shiftHeld: r.shiftHeld
+			});
+			break;
+		case "insertPreview": {
+			let { bounds: t, geometry: i } = e(r);
+			if (t.width === 0 && t.height === 0 && r.shape !== "pencil" || i.kind === "pencil" && i.samples.length < 2) break;
+			n.push({
+				kind: "insertPreview",
+				visibilityId: "action.insert-preview",
+				shape: r.shape,
+				bounds: t,
+				geometry: i,
+				extras: r.extras,
+				...r.anchorPoint && r.shape !== "pencil" ? { anchorPoint: r.anchorPoint } : {}
+			});
+			break;
+		}
+		case "polyline":
+			if (r.points.length < 2) break;
+			n.push({
+				kind: "polyline",
+				visibilityId: "action.polyline",
+				points: r.points,
+				role: r.role ?? "chrome"
+			});
+	}
+	return n;
+}
+//#endregion
+export { t as resolveOverlays };
+
+//# sourceMappingURL=resolveOverlays.js.map

package/dist/interactions/actions/resolveOverlays.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveOverlays.js","names":["resolveOverlays","out","ov","overlays","x","y","width","height","insertPreviewExtent","bounds","geometry"],"sources":["../../../src/interactions/actions/resolveOverlays.ts"],"sourcesContent":["/**\n * What an in-flight gesture is proposing to paint *beside* the scene, resolved\n * to geometry.\n *\n * The sibling of `resolvePreviews`: that one answers for the ghosts of scene\n * nodes a gesture is displacing, this one for the chrome a gesture draws that\n * is no node at all — a marquee rect, a lasso trail, the outline of a shape\n * being dragged out. `<SceneCanvas>`'s `useDispatcherOverlayLayer` used to be\n * the only thing that knew how to read an `OngoingOverlay`, and it read one\n * straight into `DrawCommand`s, so a consumer with its own renderer got\n * nothing. None of the normalizing is about drawing.\n *\n * What stays out, as in `resolvePreviews`: no view, no screen projection, no\n * `DrawCommand`, no style, no React, no dispatcher. World coordinates only.\n */\n\nimport type { InsertPreviewGeometry } from '../../canvas/insertPreviewExtent';\nimport { insertPreviewExtent } from '../../canvas/insertPreviewExtent';\nimport type { Bounds } from '../../core/viewport/fitViewToBounds';\nimport type { KitInsertShape } from '../../core/shapeKinds';\nimport type { OngoingOverlay, OverlayRole } from '@weasel-js/routing';\n\ntype Point = { x: number; y: number };\n\n/**\n * The chrome-caps id a surface consults before painting each variant. The\n * gating itself is the painter's — two views of one surface may disagree about\n * whether to show an in-flight marquee — but the id is not something a caller\n * should have to guess.\n */\nexport type OverlayVisibilityId =\n  | 'action.marquee'\n  | 'action.lasso'\n  | 'action.insert-preview'\n  | 'action.polyline';\n\n/**\n * One in-flight overlay, in world coordinates.\n *\n * Every degenerate overlay is already gone: a marquee of zero size, a lasso\n * under two vertices, a zero-area insert of anything but a pencil, a pencil\n * under two samples, a run of fewer than two points. Whatever is in this list\n * is worth painting.\n */\nexport type ResolvedOverlay =\n  | {\n      kind: 'marquee';\n      visibilityId: 'action.marquee';\n      /** The drag normalized: `start`/`current` in either order, one AABB. */\n      bounds: Bounds;\n      /** Additive intent. Core's 2D layer paints the same rect either way. */\n      shiftHeld: boolean;\n    }\n  | {\n      kind: 'lasso';\n      visibilityId: 'action.lasso';\n      /** The trail so far, at least two long. The region it encloses is the\n       *  trail closed back to its first vertex. */\n      vertices: ReadonlyArray<Point>;\n      /** Live pointer position — the trail's last vertex until it advances. */\n      current: Point;\n      shiftHeld: boolean;\n    }\n  | {\n      kind: 'insertPreview';\n      visibilityId: 'action.insert-preview';\n      shape: KitInsertShape;\n      /** Extent of `geometry`, which for a radial or freehand shape is not the\n       *  drag rect. See `insertPreviewExtent`. */\n      bounds: Bounds;\n      geometry: InsertPreviewGeometry;\n      /** The drag's anchor — a growth axis to mark. Absent for a pencil, which\n       *  has none. */\n      anchorPoint?: Point;\n      /** The action's per-shape payload, verbatim. Carries what geometry\n       *  cannot: an image insert's `src`, say. */\n      extras: unknown;\n    }\n  | {\n      kind: 'polyline';\n      visibilityId: 'action.polyline';\n      /** The run, at least two long, open — the last point does not join the\n       *  first. A closed sweep is a `lasso`. */\n      points: ReadonlyArray<Point>;\n      /** What the run is, for a painter choosing a style. Never defaulted\n       *  away: `'chrome'` when the action named none. A role the painter has\n       *  no style for is drawn as plain chrome, not dropped. */\n      role: OverlayRole;\n    };\n\n/** The overlays worth painting, in the order the handles published them. */\nexport function resolveOverlays(overlays: Iterable<OngoingOverlay>): ResolvedOverlay[] {\n  const out: ResolvedOverlay[] = [];\n  for (const ov of overlays) {\n    switch (ov.kind) {\n      case 'marquee': {\n        const x = Math.min(ov.start.x, ov.current.x);\n        const y = Math.min(ov.start.y, ov.current.y);\n        const width = Math.abs(ov.current.x - ov.start.x);\n        const height = Math.abs(ov.current.y - ov.start.y);\n        if (width === 0 && height === 0) break;\n        out.push({\n          kind: 'marquee',\n          visibilityId: 'action.marquee',\n          bounds: { x, y, width, height },\n          shiftHeld: ov.shiftHeld,\n        });\n        break;\n      }\n      case 'lasso': {\n        if (ov.vertices.length < 2) break;\n        out.push({\n          kind: 'lasso',\n          visibilityId: 'action.lasso',\n          vertices: ov.vertices,\n          current: ov.current,\n          shiftHeld: ov.shiftHeld,\n        });\n        break;\n      }\n      case 'insertPreview': {\n        const { bounds, geometry } = insertPreviewExtent(ov);\n        // A pencil can be meaningful at zero AABB — a closed loop, a\n        // sub-threshold gesture — where every other shape cannot.\n        if (bounds.width === 0 && bounds.height === 0 && ov.shape !== 'pencil') break;\n        if (geometry.kind === 'pencil' && geometry.samples.length < 2) break;\n        out.push({\n          kind: 'insertPreview',\n          visibilityId: 'action.insert-preview',\n          // Routing types the insert shape as an open string: a\n          // consumer-defined kind is legal there and simply gets no live\n          // preview. This narrows to the kinds the kit's overlay draws —\n          // the `break` above has already rejected everything else.\n          shape: ov.shape as KitInsertShape,\n          bounds,\n          geometry,\n          extras: ov.extras,\n          ...(ov.anchorPoint && ov.shape !== 'pencil' ? { anchorPoint: ov.anchorPoint } : {}),\n        });\n        break;\n      }\n      case 'polyline': {\n        if (ov.points.length < 2) break;\n        out.push({\n          kind: 'polyline',\n          visibilityId: 'action.polyline',\n          points: ov.points,\n          role: ov.role ?? 'chrome',\n        });\n        break;\n      }\n    }\n  }\n  return out;\n}\n"],"mappings":";;AA2FA,SAAgBA,EAAgB,GAAuD;CACrF,IAAMC,IAAyB,CAAC;CAChC,KAAK,IAAMC,KAAMC,GACf,QAAQD,EAAG,MAAX;EACE,KAAK,WAAW;GACd,IAAME,IAAI,KAAK,IAAIF,EAAG,MAAM,GAAGA,EAAG,QAAQ,CAAC,GACrCG,IAAI,KAAK,IAAIH,EAAG,MAAM,GAAGA,EAAG,QAAQ,CAAC,GACrCI,IAAQ,KAAK,IAAIJ,EAAG,QAAQ,IAAIA,EAAG,MAAM,CAAC,GAC1CK,IAAS,KAAK,IAAIL,EAAG,QAAQ,IAAIA,EAAG,MAAM,CAAC;GACjD,IAAII,MAAU,KAAKC,MAAW,GAAG;GACjC,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,QAAQ;KAAE;KAAG;KAAG;KAAO;IAAO;IAC9B,WAAWL,EAAG;GAChB,CAAC;GACD;EACF;EACA,KAAK;GACH,IAAIA,EAAG,SAAS,SAAS,GAAG;GAC5B,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,UAAUA,EAAG;IACb,SAASA,EAAG;IACZ,WAAWA,EAAG;GAChB,CAAC;GACD;EAEF,KAAK,iBAAiB;GACpB,IAAM,EAAE,WAAQ,gBAAaM,EAAoBN,CAAE;GAInD,IADIO,EAAO,UAAU,KAAKA,EAAO,WAAW,KAAKP,EAAG,UAAU,YAC1DQ,EAAS,SAAS,YAAYA,EAAS,QAAQ,SAAS,GAAG;GAC/D,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IAKd,OAAOR,EAAG;IACV;IACA;IACA,QAAQA,EAAG;IACX,GAAIA,EAAG,eAAeA,EAAG,UAAU,WAAW,EAAE,aAAaA,EAAG,YAAY,IAAI,CAAC;GACnF,CAAC;GACD;EACF;EACA,KAAK;GACH,IAAIA,EAAG,OAAO,SAAS,GAAG;GAC1B,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,QAAQA,EAAG;IACX,MAAMA,EAAG,QAAQ;GACnB,CAAC;CAGL;CAEF,OAAOD;AACT"}

package/dist/interactions/actions/resolvePreviews.js

@@ -0,0 +1,61 @@
+import { asNodeId as e } from "../../core/scene/types.js";
+//#region src/interactions/actions/resolvePreviews.ts
+function t(e, t, n) {
+	for (let r of e) {
+		let e = n(r, t);
+		if (e != null) return e;
+	}
+	return null;
+}
+function n(n, r) {
+	let i = [...n], a = /* @__PURE__ */ new Set();
+	for (let e of i) {
+		let t = e.previewIds?.();
+		if (t) for (let e of t) a.add(e);
+	}
+	if (a.size === 0) return [];
+	let o = /* @__PURE__ */ new Set();
+	for (let e of i) {
+		let t = e.previewOpaqueIds?.();
+		if (t) for (let e of t) o.add(e);
+	}
+	let s = (n) => {
+		let c = r.get(e(n));
+		if (!c) return null;
+		let l = t(i, n, (e, t) => e.previewPose?.(t)), u = t(i, n, (e, t) => e.previewData?.(t));
+		if (l == null && u == null) return null;
+		let d = [];
+		for (let t of r.childrenOf(e(n))) {
+			if (!a.has(t)) continue;
+			let e = s(t);
+			e && d.push(e);
+		}
+		return {
+			id: e(n),
+			node: c,
+			pose: l ?? c.pose,
+			data: u ?? c.data,
+			opaque: o.has(n),
+			children: d
+		};
+	}, c = [];
+	for (let t of a) {
+		let n = r.get(e(t))?.parent;
+		if (n != null && a.has(n)) continue;
+		let i = s(t);
+		i && c.push(i);
+	}
+	return c;
+}
+function r(e) {
+	let t = [], n = (e) => {
+		t.push(e);
+		for (let t of e.children) n(t);
+	};
+	for (let t of e) n(t);
+	return t;
+}
+//#endregion
+export { r as flattenPreviews, n as resolvePreviews };
+
+//# sourceMappingURL=resolvePreviews.js.map

package/dist/interactions/actions/resolvePreviews.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePreviews.js","names":["firstNonNull","source","sources","value","read","id","resolvePreviews","list","ids","previewing","opaque","settled","build","node","scene","asNodeId","pose","s","i","data","children","childId","child","roots","parent","root","flattenPreviews","out","walk","entry"],"sources":["../../../src/interactions/actions/resolvePreviews.ts"],"sourcesContent":["/**\n * What an in-flight gesture is proposing, resolved against the committed scene.\n *\n * An ongoing action publishes interim poses on its handle rather than writing\n * them to the scene, and `<SceneCanvas>`'s ghost layer used to be the only\n * thing that knew how to read them: which ids are in flight, which of those are\n * roots, whose preview wins when two sources name the same id, and which are\n * merely displaced rather than dragged. None of that is about drawing, and a\n * consumer with its own renderer needs all of it.\n */\n\nimport type { GesturePreviewSource } from '../../canvas/gestureBounds';\nimport type { Node, NodeId, Scene } from '../../core/scene/types';\nimport { asNodeId } from '../../core/scene/types';\n\n/** One node an in-flight gesture is previewing, as {@link resolvePreviews} returns it. */\nexport interface PreviewNode<TData, TLayer extends string, TPose> {\n  id: NodeId;\n  /** The node as committed — the gesture has not touched the scene. */\n  node: Node<TData, TLayer, TPose>;\n  /** The interim pose, or the committed one when only data is in flight. */\n  pose: TPose;\n  /** The interim data, or the committed one when only the pose is in flight. */\n  data: TData;\n  /**\n   * The gesture is not carrying this one under the pointer — a layout sibling\n   * reflowing into its destination slot. It reads better painted settled.\n   */\n  opaque: boolean;\n  /** Previewed descendants, so a container's ghost brings its children. */\n  children: PreviewNode<TData, TLayer, TPose>[];\n}\n\n/** First non-null answer across sources: tool-side before dispatcher-side. */\nfunction firstNonNull<T>(\n  sources: readonly GesturePreviewSource[],\n  id: string,\n  read: (source: GesturePreviewSource, id: string) => unknown,\n): T | null {\n  for (const source of sources) {\n    const value = read(source, id);\n    if (value != null) return value as T;\n  }\n  return null;\n}\n\n/**\n * The previewing subtrees, as roots. A previewed node whose parent is also\n * previewing is a child of that parent's entry rather than a root of its own,\n * which is what lets a caller draw a container and its contents as one thing.\n *\n * An id with no node is skipped: an insert previews before the node it will\n * create exists. So is an id no source has a pose or data for.\n */\nexport function resolvePreviews<TData, TLayer extends string, TPose>(\n  sources: Iterable<GesturePreviewSource>,\n  scene: Scene<TData, TLayer, TPose>,\n): PreviewNode<TData, TLayer, TPose>[] {\n  const list = [...sources];\n  const ids = new Set<string>();\n  for (const source of list) {\n    const previewing = source.previewIds?.();\n    if (!previewing) continue;\n    for (const id of previewing) ids.add(id);\n  }\n  if (ids.size === 0) return [];\n\n  const opaque = new Set<string>();\n  for (const source of list) {\n    const settled = source.previewOpaqueIds?.();\n    if (!settled) continue;\n    for (const id of settled) opaque.add(id);\n  }\n\n  const build = (id: string): PreviewNode<TData, TLayer, TPose> | null => {\n    const node = scene.get(asNodeId(id));\n    if (!node) return null;\n    const pose = firstNonNull<TPose>(list, id, (s, i) => s.previewPose?.(i));\n    const data = firstNonNull<TData>(list, id, (s, i) => s.previewData?.(i));\n    if (pose == null && data == null) return null;\n\n    const children: PreviewNode<TData, TLayer, TPose>[] = [];\n    for (const childId of scene.childrenOf(asNodeId(id))) {\n      if (!ids.has(childId)) continue;\n      const child = build(childId);\n      if (child) children.push(child);\n    }\n\n    return {\n      id: asNodeId(id),\n      node,\n      pose: pose ?? node.pose,\n      data: data ?? node.data,\n      opaque: opaque.has(id),\n      children,\n    };\n  };\n\n  const roots: PreviewNode<TData, TLayer, TPose>[] = [];\n  for (const id of ids) {\n    const parent = scene.get(asNodeId(id))?.parent;\n    if (parent != null && ids.has(parent)) continue;\n    const root = build(id);\n    if (root) roots.push(root);\n  }\n  return roots;\n}\n\n/** Every entry in the forest, parents before their children. */\nexport function flattenPreviews<TData, TLayer extends string, TPose>(\n  roots: readonly PreviewNode<TData, TLayer, TPose>[],\n): PreviewNode<TData, TLayer, TPose>[] {\n  const out: PreviewNode<TData, TLayer, TPose>[] = [];\n  const walk = (entry: PreviewNode<TData, TLayer, TPose>) => {\n    out.push(entry);\n    for (const child of entry.children) walk(child);\n  };\n  for (const root of roots) walk(root);\n  return out;\n}\n"],"mappings":";;AAkCA,SAASA,EACP,GACA,GACA,GACU;CACV,KAAK,IAAMC,KAAUC,GAAS;EAC5B,IAAMC,IAAQC,EAAKH,GAAQI,CAAE;EAC7B,IAAIF,KAAS,MAAM,OAAOA;CAC5B;CACA,OAAO;AACT;AAUA,SAAgBG,EACd,GACA,GACqC;CACrC,IAAMC,IAAO,CAAC,GAAGL,CAAO,GAClBM,oBAAM,IAAI,IAAY;CAC5B,KAAK,IAAMP,KAAUM,GAAM;EACzB,IAAME,IAAaR,EAAO,aAAa;EACvC,IAAKQ,GACL,KAAK,IAAMJ,KAAMI,GAAY,EAAI,IAAIJ,CAAE;CACzC;CACA,IAAIG,EAAI,SAAS,GAAG,OAAO,CAAC;CAE5B,IAAME,oBAAS,IAAI,IAAY;CAC/B,KAAK,IAAMT,KAAUM,GAAM;EACzB,IAAMI,IAAUV,EAAO,mBAAmB;EAC1C,IAAKU,GACL,KAAK,IAAMN,KAAMM,GAAS,EAAO,IAAIN,CAAE;CACzC;CAEA,IAAMO,KAAS,MAAyD;EACtE,IAAMC,IAAOC,EAAM,IAAIC,EAASV,CAAE,CAAC;EACnC,IAAI,CAACQ,GAAM,OAAO;EAClB,IAAMG,IAAOhB,EAAoBO,GAAMF,IAAK,GAAG,MAAMY,EAAE,cAAcC,CAAC,CAAC,GACjEC,IAAOnB,EAAoBO,GAAMF,IAAK,GAAG,MAAMY,EAAE,cAAcC,CAAC,CAAC;EACvE,IAAIF,KAAQ,QAAQG,KAAQ,MAAM,OAAO;EAEzC,IAAMC,IAAgD,CAAC;EACvD,KAAK,IAAMC,KAAWP,EAAM,WAAWC,EAASV,CAAE,CAAC,GAAG;GACpD,IAAI,CAACG,EAAI,IAAIa,CAAO,GAAG;GACvB,IAAMC,IAAQV,EAAMS,CAAO;GAC3B,AAAIC,KAAOF,EAAS,KAAKE,CAAK;EAChC;EAEA,OAAO;GACL,IAAIP,EAASV,CAAE;GACf;GACA,MAAMW,KAAQH,EAAK;GACnB,MAAMM,KAAQN,EAAK;GACnB,QAAQH,EAAO,IAAIL,CAAE;GACrB;EACF;CACF,GAEMkB,IAA6C,CAAC;CACpD,KAAK,IAAMlB,KAAMG,GAAK;EACpB,IAAMgB,IAASV,EAAM,IAAIC,EAASV,CAAE,CAAC,CAAC,EAAE;EACxC,IAAImB,KAAU,QAAQhB,EAAI,IAAIgB,CAAM,GAAG;EACvC,IAAMC,IAAOb,EAAMP,CAAE;EACrB,AAAIoB,KAAMF,EAAM,KAAKE,CAAI;CAC3B;CACA,OAAOF;AACT;AAGA,SAAgBG,EACd,GACqC;CACrC,IAAMC,IAA2C,CAAC,GAC5CC,KAAQ,MAA6C;EACzD,EAAI,KAAKC,CAAK;EACd,KAAK,IAAMP,KAASO,EAAM,UAAU,EAAKP,CAAK;CAChD;CACA,KAAK,IAAMG,KAAQF,GAAO,EAAKE,CAAI;CACnC,OAAOE;AACT"}

package/dist/interactions/actions/rotate/geometry.js

@@ -0,0 +1,46 @@
+//#region src/interactions/actions/rotate/geometry.ts
+function e(e) {
+	return {
+		x: e.x + e.width / 2,
+		y: e.y + e.height / 2
+	};
+}
+function t(e, t, n, r, i) {
+	let a = Math.cos(i), o = Math.sin(i), s = e - n, c = t - r;
+	return {
+		x: n + s * a - c * o,
+		y: r + s * o + c * a
+	};
+}
+function n(e) {
+	return [
+		{
+			x: e.x,
+			y: e.y
+		},
+		{
+			x: e.x + e.width,
+			y: e.y
+		},
+		{
+			x: e.x + e.width,
+			y: e.y + e.height
+		},
+		{
+			x: e.x,
+			y: e.y + e.height
+		}
+	];
+}
+function r(r) {
+	let i = e(r);
+	return n(r).map((e) => t(e.x, e.y, i.x, i.y, r.rotation));
+}
+function i(n, r, i) {
+	let a = e(n), o = t(r, i, a.x, a.y, -n.rotation);
+	return o.x >= n.x && o.x <= n.x + n.width && o.y >= n.y && o.y <= n.y + n.height;
+}
+//#endregion
+export { e as aabbCenter, i as pointInRotatedRect, n as rectCorners, t as rotatePoint, r as rotatedRectCorners };
+
+//# sourceMappingURL=geometry.js.map

package/dist/interactions/actions/rotate/geometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.js","names":["aabbCenter","bounds","rotatePoint","c","angle","s","dx","px","cx","dy","py","cy","rectCorners","rotatedRectCorners","pose","p","pointInRotatedRect","local","worldX","worldY"],"sources":["../../../../src/interactions/actions/rotate/geometry.ts"],"sourcesContent":["import type { RotatedPose } from '../../gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** AABB center of an unrotated rect — the canonical rotation pivot. */\nexport function aabbCenter(bounds: Bounds): { x: number; y: number } {\n  return { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };\n}\n\n/** Rotate `(px, py)` by `angle` (radians) around `(cx, cy)`. */\nexport function rotatePoint(\n  px: number,\n  py: number,\n  cx: number,\n  cy: number,\n  angle: number,\n): { x: number; y: number } {\n  const c = Math.cos(angle);\n  const s = Math.sin(angle);\n  const dx = px - cx;\n  const dy = py - cy;\n  return { x: cx + dx * c - dy * s, y: cy + dx * s + dy * c };\n}\n\n/** Four corners of an unrotated rect, in TL/TR/BR/BL order. */\nexport function rectCorners(bounds: Bounds): { x: number; y: number }[] {\n  return [\n    { x: bounds.x, y: bounds.y },\n    { x: bounds.x + bounds.width, y: bounds.y },\n    { x: bounds.x + bounds.width, y: bounds.y + bounds.height },\n    { x: bounds.x, y: bounds.y + bounds.height },\n  ];\n}\n\n/** Four corners of a rotated rect (rotation around AABB center), in\n *  TL/TR/BR/BL order. Useful for selection-overlay rendering. */\nexport function rotatedRectCorners(pose: RotatedPose): { x: number; y: number }[] {\n  const c = aabbCenter(pose);\n  return rectCorners(pose).map((p) => rotatePoint(p.x, p.y, c.x, c.y, pose.rotation));\n}\n\n/** Hit-test a world point against a rotated rect (rotation around AABB\n *  center). Standard pattern: invert the rotation and AABB-test in the\n *  rect's local frame. */\nexport function pointInRotatedRect(\n  pose: RotatedPose,\n  worldX: number,\n  worldY: number,\n): boolean {\n  const c = aabbCenter(pose);\n  const local = rotatePoint(worldX, worldY, c.x, c.y, -pose.rotation);\n  return (\n    local.x >= pose.x &&\n    local.x <= pose.x + pose.width &&\n    local.y >= pose.y &&\n    local.y <= pose.y + pose.height\n  );\n}\n"],"mappings":";AAIA,SAAgBA,EAAW,GAA0C;CACnE,OAAO;EAAE,GAAGC,EAAO,IAAIA,EAAO,QAAQ;EAAG,GAAGA,EAAO,IAAIA,EAAO,SAAS;CAAE;AAC3E;AAGA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GAC0B;CAC1B,IAAMC,IAAI,KAAK,IAAIC,CAAK,GAClBC,IAAI,KAAK,IAAID,CAAK,GAClBE,IAAKC,IAAKC,GACVC,IAAKC,IAAKC;CAChB,OAAO;EAAE,GAAGH,IAAKF,IAAKH,IAAIM,IAAKJ;EAAG,GAAGM,IAAKL,IAAKD,IAAII,IAAKN;CAAE;AAC5D;AAGA,SAAgBS,EAAY,GAA4C;CACtE,OAAO;EACL;GAAE,GAAGX,EAAO;GAAG,GAAGA,EAAO;EAAE;EAC3B;GAAE,GAAGA,EAAO,IAAIA,EAAO;GAAO,GAAGA,EAAO;EAAE;EAC1C;GAAE,GAAGA,EAAO,IAAIA,EAAO;GAAO,GAAGA,EAAO,IAAIA,EAAO;EAAO;EAC1D;GAAE,GAAGA,EAAO;GAAG,GAAGA,EAAO,IAAIA,EAAO;EAAO;CAC7C;AACF;AAIA,SAAgBY,EAAmB,GAA+C;CAChF,IAAMV,IAAIH,EAAWc,CAAI;CACzB,OAAOF,EAAYE,CAAI,CAAC,CAAC,KAAK,MAAMZ,EAAYa,EAAE,GAAGA,EAAE,GAAGZ,EAAE,GAAGA,EAAE,GAAGW,EAAK,QAAQ,CAAC;AACpF;AAKA,SAAgBE,EACd,GACA,GACA,GACS;CACT,IAAMb,IAAIH,EAAWc,CAAI,GACnBG,IAAQf,EAAYgB,GAAQC,GAAQhB,EAAE,GAAGA,EAAE,GAAG,CAACW,EAAK,QAAQ;CAClE,OACEG,EAAM,KAAKH,EAAK,KAChBG,EAAM,KAAKH,EAAK,IAAIA,EAAK,SACzBG,EAAM,KAAKH,EAAK,KAChBG,EAAM,KAAKH,EAAK,IAAIA,EAAK;AAE7B"}

package/dist/interactions/actions/rotate/handle.js

@@ -0,0 +1,27 @@
+import { standoff as e } from "../../../core/viewport/pxExtent.js";
+import { ROTATION_HANDLE_BASE_PX as t } from "../../../core/device/targets.js";
+import { aabbCenter as n, rotatePoint as r } from "./geometry.js";
+//#region src/interactions/actions/rotate/handle.ts
+var i = t;
+function a(t, a = i, s = o) {
+	let c = t.rotation ?? 0, l = n(t), u = r(t.x + t.width / 2, t.y, l.x, l.y, c), d = e(u, {
+		x: Math.sin(c),
+		y: -Math.cos(c)
+	}, a, s);
+	return {
+		cx: d.x,
+		cy: d.y,
+		angle: Math.atan2(d.nx, -d.ny)
+	};
+}
+var o = {
+	x: 1,
+	y: 1
+};
+function s(e, t, n, r) {
+	return Math.abs(t - e.cx) <= r && Math.abs(n - e.cy) <= r;
+}
+//#endregion
+export { i as DEFAULT_ROTATION_HANDLE_DISTANCE, s as hitRotationHandle, a as rotationHandle };
+
+//# sourceMappingURL=handle.js.map

package/dist/interactions/actions/rotate/handle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle.js","names":["DEFAULT_ROTATION_HANDLE_DISTANCE","ROTATION_HANDLE_BASE_PX","rotationHandle","UNIT_SCALE","rotation","pose","c","aabbCenter","top","rotatePoint","p","standoff","distance","scale","hitRotationHandle","px","handle","radius","py"],"sources":["../../../../src/interactions/actions/rotate/handle.ts"],"sourcesContent":["import { aabbCenter, rotatePoint } from './geometry';\nimport { ROTATION_HANDLE_BASE_PX } from 'core/device/targets';\nimport { standoff, type Scale2 } from 'core/viewport/pxExtent';\n\n/** Default world-space distance from the rect's top edge to the rotation\n *  handle's center. Matches the demo's visual default; consumers can\n *  override per-call. Unscaled — kit-internal use sites multiply by\n *  `DeviceProfile.targetScale`. */\nexport const DEFAULT_ROTATION_HANDLE_DISTANCE = ROTATION_HANDLE_BASE_PX;\n\n/** Rotation handle position in world coords. */\nexport interface RotationHandle {\n  /** Handle center in world coords. */\n  cx: number;\n  cy: number;\n  /** How far the handle is turned on screen, radians: the angle from screen\n   *  up to the top edge's outward normal as it lands there. Equals the pose\n   *  rotation under uniform zoom. */\n  angle: number;\n}\n\n/** Rotation handle for a rotated rect: `distance` pixels off the top edge's\n *  midpoint, along that edge's outward normal as it lands on a screen whose\n *  per-axis zoom is `scale`. With no `scale`, a pixel is a world unit. When\n *  `pose.rotation` is missing it's treated as 0. */\nexport function rotationHandle(\n  pose: { x: number; y: number; width: number; height: number; rotation?: number },\n  distance: number = DEFAULT_ROTATION_HANDLE_DISTANCE,\n  scale: Scale2 = UNIT_SCALE,\n): RotationHandle {\n  const rotation = pose.rotation ?? 0;\n  const c = aabbCenter(pose);\n  const top = rotatePoint(pose.x + pose.width / 2, pose.y, c.x, c.y, rotation);\n  const p = standoff(top, { x: Math.sin(rotation), y: -Math.cos(rotation) }, distance, scale);\n  return { cx: p.x, cy: p.y, angle: Math.atan2(p.nx, -p.ny) };\n}\n\nconst UNIT_SCALE: Scale2 = { x: 1, y: 1 };\n\n/** Square hit-test: returns true if `(px, py)` is within `radius` of the\n *  handle's center on both axes. Mirrors `hitCornerHandle`. */\nexport function hitRotationHandle(\n  handle: Pick<RotationHandle, 'cx' | 'cy'>,\n  px: number,\n  py: number,\n  radius: number,\n): boolean {\n  return Math.abs(px - handle.cx) <= radius && Math.abs(py - handle.cy) <= radius;\n}\n"],"mappings":";;;;AAQA,IAAaA,IAAmCC;AAiBhD,SAAgBC,EACd,GACA,IAAmBF,GACnB,IAAgBG,GACA;CAChB,IAAMC,IAAWC,EAAK,YAAY,GAC5BC,IAAIC,EAAWF,CAAI,GACnBG,IAAMC,EAAYJ,EAAK,IAAIA,EAAK,QAAQ,GAAGA,EAAK,GAAGC,EAAE,GAAGA,EAAE,GAAGF,CAAQ,GACrEM,IAAIC,EAASH,GAAK;EAAE,GAAG,KAAK,IAAIJ,CAAQ;EAAG,GAAG,CAAC,KAAK,IAAIA,CAAQ;CAAE,GAAGQ,GAAUC,CAAK;CAC1F,OAAO;EAAE,IAAIH,EAAE;EAAG,IAAIA,EAAE;EAAG,OAAO,KAAK,MAAMA,EAAE,IAAI,CAACA,EAAE,EAAE;CAAE;AAC5D;AAEA,IAAMP,IAAqB;CAAE,GAAG;CAAG,GAAG;AAAE;AAIxC,SAAgBW,EACd,GACA,GACA,GACA,GACS;CACT,OAAO,KAAK,IAAIC,IAAKC,EAAO,EAAE,KAAKC,KAAU,KAAK,IAAIC,IAAKF,EAAO,EAAE,KAAKC;AAC3E"}

package/dist/interactions/actions/spatialReference.js

@@ -0,0 +1,42 @@
+import { visualBoundsViaDescriptor as e } from "../../core/geometry/poseDescriptor.js";
+//#region src/interactions/actions/spatialReference.ts
+function t(e, t) {
+	if (e === "pointer") {
+		let e = t.pointer();
+		return e ? {
+			x: e.x,
+			y: e.y,
+			width: 0,
+			height: 0
+		} : null;
+	}
+	if (typeof e != "object" || !e) return null;
+	if ("node" in e) return t.nodeBounds(e.node);
+	let n = e;
+	return typeof n.x != "number" || typeof n.y != "number" ? null : {
+		x: n.x,
+		y: n.y,
+		width: typeof n.width == "number" ? n.width : 0,
+		height: typeof n.height == "number" ? n.height : 0
+	};
+}
+function n(t, n, r, i, a) {
+	return {
+		pointer: () => {
+			if (typeof t?.worldX == "number" && typeof t.worldY == "number") return {
+				x: t.worldX,
+				y: t.worldY
+			};
+			let e = n?.get();
+			return e ? {
+				x: e.worldX,
+				y: e.worldY
+			} : null;
+		},
+		nodeBounds: (t) => r.get(t) === void 0 ? null : e(i.world(t), a)
+	};
+}
+//#endregion
+export { n as actionReferenceSources, t as resolveSpatialReference };
+
+//# sourceMappingURL=spatialReference.js.map

package/dist/interactions/actions/spatialReference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatialReference.js","names":["resolveSpatialReference","ref","p","src","r","actionReferenceSources","params","pointer","scene","id","visualBoundsViaDescriptor","frame","geom"],"sources":["../../../src/interactions/actions/spatialReference.ts"],"sourcesContent":["import type { NodeId, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { PointerContextValue } from 'features/pointer/PointerContext';\nimport type { PoseDescriptor } from './resize/geometry';\nimport { visualBoundsViaDescriptor } from './resize/geometry';\nimport type { PoseFrame } from './poseFrame';\n\n/**\n * @experimental\n * A world-space place a selection transform lines up against — what align\n * aligns to, what flip mirrors about — other than the selection itself:\n *\n * - `'pointer'` — where the pointer is: the click's world point when a click\n *   invoked the action, otherwise the latest position in the `pointer` dep.\n * - `{ x, y, width?, height? }` — a world point, or a world rect when it has\n *   extent.\n * - `{ node }` — that node's visual bounds (a key object; it does not move).\n */\nexport type SpatialReference =\n  | 'pointer'\n  | { x: number; y: number; width?: number; height?: number }\n  | { node: NodeId };\n\n/** @experimental Where `resolveSpatialReference` reads a reference's inputs. */\nexport interface SpatialReferenceSources {\n  /** The pointer's world position, or `null` when it is over no canvas. */\n  pointer(): { x: number; y: number } | null;\n  /** A node's world visual bounds, or `null` when it is not in the scene. */\n  nodeBounds(id: NodeId): Bounds | null;\n}\n\n/**\n * @experimental\n * The world bounds `ref` names — a point comes back as a zero-size rect — or\n * `null` when it names nothing right now (no pointer, a missing node, a\n * malformed value).\n */\nexport function resolveSpatialReference(\n  ref: SpatialReference | unknown,\n  src: SpatialReferenceSources,\n): Bounds | null {\n  if (ref === 'pointer') {\n    const p = src.pointer();\n    return p ? { x: p.x, y: p.y, width: 0, height: 0 } : null;\n  }\n  if (typeof ref !== 'object' || ref === null) return null;\n  if ('node' in ref) return src.nodeBounds((ref as { node: NodeId }).node);\n  const r = ref as { x?: unknown; y?: unknown; width?: unknown; height?: unknown };\n  if (typeof r.x !== 'number' || typeof r.y !== 'number') return null;\n  return {\n    x: r.x,\n    y: r.y,\n    width: typeof r.width === 'number' ? r.width : 0,\n    height: typeof r.height === 'number' ? r.height : 0,\n  };\n}\n\n/** The sources an immediate action resolves a reference from. A click's\n *  `worldX`/`worldY` params outrank the `pointer` dep. */\nexport function actionReferenceSources(\n  params: Record<string, unknown> | undefined,\n  pointer: PointerContextValue | undefined,\n  scene: Scene<unknown, string, unknown>,\n  frame: PoseFrame<unknown>,\n  geom: PoseDescriptor<unknown>,\n): SpatialReferenceSources {\n  return {\n    pointer: () => {\n      if (typeof params?.worldX === 'number' && typeof params.worldY === 'number') {\n        return { x: params.worldX, y: params.worldY };\n      }\n      const p = pointer?.get();\n      return p ? { x: p.worldX, y: p.worldY } : null;\n    },\n    nodeBounds: (id) => (scene.get(id) === undefined\n      ? null\n      : visualBoundsViaDescriptor(frame.world(id), geom)),\n  };\n}\n"],"mappings":";;AAqCA,SAAgBA,EACd,GACA,GACe;CACf,IAAIC,MAAQ,WAAW;EACrB,IAAMC,IAAIC,EAAI,QAAQ;EACtB,OAAOD,IAAI;GAAE,GAAGA,EAAE;GAAG,GAAGA,EAAE;GAAG,OAAO;GAAG,QAAQ;EAAE,IAAI;CACvD;CACA,IAAI,OAAOD,KAAQ,aAAYA,GAAc,OAAO;CACpD,IAAI,UAAUA,GAAK,OAAOE,EAAI,WAAYF,EAAyB,IAAI;CACvE,IAAMG,IAAIH;CAEV,OADI,OAAOG,EAAE,KAAM,YAAY,OAAOA,EAAE,KAAM,WAAiB,OACxD;EACL,GAAGA,EAAE;EACL,GAAGA,EAAE;EACL,OAAO,OAAOA,EAAE,SAAU,WAAWA,EAAE,QAAQ;EAC/C,QAAQ,OAAOA,EAAE,UAAW,WAAWA,EAAE,SAAS;CACpD;AACF;AAIA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GACyB;CACzB,OAAO;EACL,eAAe;GACb,IAAI,OAAOC,GAAQ,UAAW,YAAY,OAAOA,EAAO,UAAW,UACjE,OAAO;IAAE,GAAGA,EAAO;IAAQ,GAAGA,EAAO;GAAO;GAE9C,IAAMJ,IAAIK,GAAS,IAAI;GACvB,OAAOL,IAAI;IAAE,GAAGA,EAAE;IAAQ,GAAGA,EAAE;GAAO,IAAI;EAC5C;EACA,aAAa,MAAQM,EAAM,IAAIC,CAAE,MAAM,KAAA,IACnC,OACAC,EAA0BC,EAAM,MAAMF,CAAE,GAAGG,CAAI;CACrD;AACF"}

package/dist/interactions/actions/useStandardActions.js

@@ -0,0 +1,142 @@
+import { moveAction as e } from "./defaults/move.js";
+import { resizeAction as t } from "./defaults/resize.js";
+import { rotateAction as n } from "./defaults/rotate.js";
+import { areaSelectAction as r } from "./defaults/areaSelect.js";
+import { insertAction as i, insertRotateAction as a } from "./defaults/insert.js";
+import { clearSelectionAction as o } from "./defaults/clearSelection.js";
+import { cloneAction as ee } from "./defaults/clone.js";
+import { viewportDragPanAction as te } from "./defaults/viewportDragPan.js";
+import { editAnchorsAction as ne } from "./defaults/editAnchors.js";
+import { lassoSelectAction as re } from "./defaults/lassoSelect.js";
+import { pinchZoomAction as s } from "./defaults/pinchZoom.js";
+import { deleteAction as c } from "./defaults/delete.js";
+import { clipboardCopyAction as l, clipboardCutAction as u, clipboardPasteAction as d } from "./defaults/clipboard.js";
+import { enterTextEditAction as f } from "./defaults/enterTextEdit.js";
+import { escapeAction as p } from "./defaults/escape.js";
+import { cancelGestureAction as m } from "./defaults/cancelGesture.js";
+import { selectAllAction as h } from "./defaults/selectAll.js";
+import { duplicateAction as g } from "./defaults/duplicate.js";
+import { groupAction as _, ungroupAction as v } from "./defaults/group.js";
+import { redoAction as y, undoAction as b } from "./defaults/undoRedo.js";
+import { flipAction as x } from "./defaults/flip.js";
+import { nudgeDownAction as S, nudgeLeftAction as C, nudgeRightAction as w, nudgeUpAction as T } from "./defaults/nudge.js";
+import { reorderBackwardAction as E, reorderForwardAction as D } from "./defaults/reorder.js";
+import { alignBottomAction as O, alignCenterXAction as k, alignCenterYAction as A, alignLeftAction as j, alignRightAction as M, alignTopAction as N } from "./defaults/align.js";
+import { distributeHorizontalAction as P, distributeVerticalAction as ie } from "./defaults/distribute.js";
+import { pathfinderCropAction as F, pathfinderDivideAction as I, pathfinderExcludeAction as L, pathfinderIntersectAction as R, pathfinderSubtractAction as z, pathfinderUnionAction as B } from "./defaults/booleans.js";
+import { createOutlinesAction as V } from "./defaults/createOutlines.js";
+import { enterPathEditAction as H } from "./defaults/enterPathEdit.js";
+import { exitPathEditAction as U } from "./defaults/exitPathEdit.js";
+import { insertPathAnchorAction as W } from "./defaults/insertPathAnchor.js";
+import { cutPathAtAnchorAction as G, deleteAnchorsAction as K, marqueeAnchorsAction as q, nudgeAnchorsDownAction as J, nudgeAnchorsLeftAction as Y, nudgeAnchorsRightAction as ae, nudgeAnchorsUpAction as oe, selectAnchorAction as se } from "./defaults/anchorEditing.js";
+import { setFillAction as ce } from "./defaults/setFill.js";
+import { setStrokeAction as le } from "./defaults/setStroke.js";
+import { setFillOpacityAction as X } from "./defaults/setFillOpacity.js";
+import { setStrokeOpacityAction as ue } from "./defaults/setStrokeOpacity.js";
+import { ingestAction as de } from "./defaults/ingest.js";
+import { useEffect as Z } from "react";
+import { useLatest as Q } from "@weasel-js/react";
+import "@weasel-js/routing";
+import { useActionsRegistry as fe, useOptionalActiveToolContext as pe, useOptionalDepRegistry as me } from "@weasel-js/routing/react";
+//#region src/interactions/actions/useStandardActions.ts
+var $ = [
+	p,
+	m,
+	h,
+	g,
+	c,
+	_,
+	v,
+	b,
+	y,
+	x,
+	T,
+	S,
+	C,
+	w,
+	D,
+	E,
+	j,
+	k,
+	M,
+	N,
+	A,
+	O,
+	P,
+	ie,
+	B,
+	z,
+	R,
+	L,
+	I,
+	F,
+	V,
+	e,
+	t,
+	n,
+	r,
+	i,
+	a,
+	ee,
+	ne,
+	H,
+	U,
+	W,
+	oe,
+	J,
+	Y,
+	ae,
+	K,
+	G,
+	q,
+	se,
+	re,
+	s,
+	te,
+	o,
+	f,
+	ce,
+	le,
+	X,
+	ue,
+	de,
+	u,
+	l,
+	d
+], he = $.map((e) => e.id);
+function ge(e) {
+	let t = Q(e), n = pe(), r = Q(n), i = me();
+	Z(() => {
+		if (!i) return;
+		let e = [];
+		for (let n of [
+			"selection",
+			"view",
+			"scene",
+			"history"
+		]) e.push(i.register(n, () => t.current[n]));
+		return e.push(i.register("activeTool", () => t.current.activeTool ?? r.current)), () => {
+			for (let t of e) t();
+		};
+	}, [
+		i,
+		t,
+		r
+	]);
+	let a = fe(), o = e.exclude ? [...e.exclude].join("\0") : "";
+	Z(() => {
+		if (!a || !i) return;
+		let e = new Set(o ? o.split("\0") : []), t = $.filter((t) => !e.has(t.id)).map((e) => a.register(e));
+		return () => {
+			for (let e of t) e();
+		};
+	}, [
+		a,
+		i,
+		o
+	]);
+}
+//#endregion
+export { he as KIT_STANDARD_ACTION_IDS, ge as useStandardActions };
+
+//# sourceMappingURL=useStandardActions.js.map