@weasel-js/core 1.6.1 → 1.7.1

package/dist/interactions/actions/defaults/viewportZoom.js

@@ -0,0 +1,143 @@
+import { DEFAULT_MAX_ZOOM as e, DEFAULT_MIN_ZOOM as t } from "../../../core/viewport/zoomBounds.js";
+import { viewToTransform as n } from "../../../core/viewport/view.js";
+import { screenToWorld as r } from "../../../core/viewport/viewTransform.js";
+import { zoomAt as i } from "../../../core/viewport/zoomAt.js";
+import { wheelZoomFactor as a } from "../../../core/viewport/wheelHandler.js";
+//#region src/interactions/actions/defaults/viewportZoom.ts
+var o = 1.25;
+function s(e) {
+	let t = e.hostSize?.();
+	return t ? {
+		x: t.width / 2,
+		y: t.height / 2
+	} : {
+		x: 0,
+		y: 0
+	};
+}
+function c(c = {}) {
+	let l = {
+		min: c.min ?? t,
+		max: c.max ?? e
+	}, u = c.wheel === "plain" ? { kind: "wheel" } : {
+		kind: "wheel",
+		mods: { mod: !0 }
+	}, d = c.animate === !0 ? {} : c.animate || null, { resetMs: f, ...p } = d ?? {}, m = d ? p : null;
+	return {
+		id: "viewport.zoom",
+		label: "Zoom",
+		group: "viewport",
+		defaultBinding: [
+			{
+				spec: u,
+				opts: { params: { kind: "wheel" } }
+			},
+			{
+				spec: {
+					kind: "wheel",
+					mods: { ctrl: !0 }
+				},
+				opts: { params: { kind: "wheel" } }
+			},
+			{
+				spec: { kind: "pinch" },
+				opts: { params: { kind: "pinch" } }
+			},
+			{
+				spec: {
+					kind: "key",
+					key: "=",
+					mods: {
+						mod: !0,
+						shift: "optional"
+					}
+				},
+				opts: { params: { kind: "in" } }
+			},
+			{
+				spec: {
+					kind: "key",
+					key: "-",
+					mods: { mod: !0 }
+				},
+				opts: { params: { kind: "out" } }
+			},
+			{
+				spec: {
+					kind: "key",
+					key: "0",
+					mods: { mod: !0 }
+				},
+				opts: { params: { kind: "reset" } }
+			}
+		],
+		requires: ["view", "debug"],
+		invoker: {
+			timing: "immediate",
+			run(e, t) {
+				let c = e.view;
+				if (!c) return;
+				let u = e.debug, d = c.get(), p = (e, t, i) => {
+					if (!u) return;
+					let [a, o] = r(i.x, i.y, n(e));
+					u.recordViewport("zoom", e, t, {
+						x: a,
+						y: o
+					});
+				}, h = t?.kind, g = m !== null && typeof c.animate == "function", _ = (e, t) => {
+					if (!g) {
+						c.set(e);
+						return;
+					}
+					c.animate(e, {
+						...m,
+						ms: t ?? m.ms
+					});
+				}, v = () => g && c.animationTarget?.() || d, y = () => ({
+					x: t?.clientX ?? 0,
+					y: t?.clientY ?? 0
+				}), b = (e) => {
+					if (!(e > 0) || !Number.isFinite(e)) return;
+					let t = i(d, y(), e, l);
+					c.set(t), p(d, t, y());
+				};
+				switch (h) {
+					case "wheel":
+						b(a(t?.deltaY ?? 0));
+						break;
+					case "pinch":
+						b(t?.scale ?? NaN);
+						break;
+					case "in":
+					case "out": {
+						let e = v(), t = i(e, s(c), h === "in" ? o : 1 / o, l);
+						_(t), p(e, t, s(c));
+						break;
+					}
+					case "reset": {
+						let e = c.recenter ? c.recenter() : {
+							x: 0,
+							y: 0,
+							scale: {
+								x: 1,
+								y: 1
+							}
+						};
+						e && _(e, f);
+						break;
+					}
+					default: t === void 0 && c.set(i(d, {
+						x: 0,
+						y: 0
+					}, o, l));
+				}
+			}
+		},
+		enabled: () => !0
+	};
+}
+var l = c();
+//#endregion
+export { c as makeViewportZoomAction, l as viewportZoomAction };
+
+//# sourceMappingURL=viewportZoom.js.map

package/dist/interactions/actions/defaults/viewportZoom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewportZoom.js","names":["KEY_STEP","keyAnchor","size","view","makeViewportZoomAction","clamp","opts","DEFAULT_MIN_ZOOM","DEFAULT_MAX_ZOOM","wheelSpec","rawAnimate","animateRest","tweenOpts","deps","debug","current","record","wx","wy","screenToWorld","anchor","viewToTransform","from","to","kind","params","canAnimate","stepTo","target","ms","stepFrom","focal","scaleBy","factor","next","zoomAt","wheelZoomFactor","resetMs","viewportZoomAction"],"sources":["../../../../src/interactions/actions/defaults/viewportZoom.ts"],"sourcesContent":["/**\n * `viewportZoomAction` — immediate Action descriptor for viewport zoom.\n *\n * ## Bindings (parametric — each passes `params.kind`)\n * - `{ kind: 'wheel', mods: { mod: true } }` → Cmd+wheel, params: `{ kind: 'wheel' }`\n * - `{ kind: 'wheel', mods: { ctrl: true } }` → trackpad pinch, params: `{ kind: 'wheel' }`.\n *   Browsers synthesize a trackpad pinch as ctrl+wheel. On a Mac that is a\n *   *different* event from the `mod` binding above (`mod` is metaKey there), so\n *   pinch needs its own binding or nothing claims it and the page zooms instead.\n * - `{ kind: 'pinch' }` → Safari trackpad pinch (WebKit `gesturechange`),\n *   params: `{ kind: 'pinch' }`. Safari may send the same pinch as ctrl+wheel\n *   as well; the dispatcher swallows that copy while a claimed gesture is live,\n *   so only one of the two bindings fires per pinch.\n * - `{ kind: 'key', key: '=' }` → zoom in, params: `{ kind: 'in' }`\n * - `{ kind: 'key', key: '-' }` → zoom out, params: `{ kind: 'out' }`\n * - `{ kind: 'key', key: '0' }` → reset zoom, params: `{ kind: 'reset' }`\n *\n * ## Design notes\n * The invoker switches on `params.kind`:\n * - `'wheel'` and `'pinch'`: both reduce to a scale factor about a focal\n *   point and share one `zoomAt` call. A wheel sample's factor is\n *   `wheelZoomFactor(deltaY)`, the kit's one statement of the wheel\n *   convention; a pinch sample carries its factor as `scale`. The dispatcher\n *   merges event data into params and converts client coords to canvas-local\n *   (subtracting the canvas's bounding rect) before merging — `zoomAt`\n *   expects canvas-local.\n * - `'in'`/`'out'`: step zoom by ×1.25 / ×0.8, anchored at the host center\n *   when the `view` dep wires `hostSize()` (SceneCanvas does), falling back\n *   to the canvas top-left origin for consumers that don't.\n * - `'reset'`: resets scale to 1, translation to 0, or calls the `view` dep's\n *   `recenter()`.\n *\n * The three discrete branches glide instead of jumping when the `animate`\n * option is configured and the `view` dep implements `animate` — they hand the\n * action a target and nothing in between, which is the whole condition for\n * tweening. `'wheel'` and `'pinch'` always jump per sample.\n *\n * ## Key binding modifier notes\n * The key bindings (`=`, `-`, `0`) require `mod: true` (Cmd on Mac, Ctrl elsewhere).\n * This matches the behaviour of the dissolved `useKeyboardZoomTool`.\n */\n\nimport type { Action, DebugSink } from '@weasel-js/routing';\nimport type { ViewApi } from '../depSchema';\nimport { zoomAt } from 'core/viewport/zoomAt';\nimport { wheelZoomFactor } from 'core/viewport/wheelHandler';\nimport { DEFAULT_MIN_ZOOM, DEFAULT_MAX_ZOOM } from 'core/viewport/zoomBounds';\nimport { viewToTransform, type View } from 'core/viewport/view';\nimport { screenToWorld } from 'core/viewport/viewTransform';\nimport type { ViewAnimationOptions } from 'core/viewport/useViewAnimation';\n\n// Multiplicative step for keyboard zoom (matches useKeyboardZoomTool default).\nconst KEY_STEP = 1.25;\n\n/** Keyboard-zoom anchor: the host center when the view dep can measure it,\n *  else the canvas top-left origin (see design notes). */\nfunction keyAnchor(view: ViewApi): { x: number; y: number } {\n  const size = view.hostSize?.();\n  return size ? { x: size.width / 2, y: size.height / 2 } : { x: 0, y: 0 };\n}\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Tuning for the animated form of the discrete zoom steps.\n */\nexport interface ViewportZoomAnimateOptions extends ViewAnimationOptions {\n  /** Duration for the Cmd+0 reset branch. Defaults to `ms`. */\n  resetMs?: number;\n}\n\n/**\n * @experimental\n * Tuning for {@link makeViewportZoomAction}.\n */\nexport interface ViewportZoomOptions {\n  /**\n   * Which wheel gesture triggers zoom.\n   * - `'mod'` (default): Cmd/Ctrl+wheel — coexists with plain-wheel pan\n   *   (`viewport.wheelPan`). A Mac trackpad pinch arrives as ctrl+wheel, which\n   *   `mod: true` forbids on Mac; nothing here handles it.\n   * - `'plain'`: bare wheel, no modifier. Pair with `viewport.pan: false`,\n   *   since plain wheel otherwise drives pan and the two would compete.\n   */\n  wheel?: 'plain' | 'mod';\n  /** Lower clamp on the resulting view scale, forwarded to `zoomAt`. Default 0.1. */\n  min?: number;\n  /** Upper clamp on the resulting view scale, forwarded to `zoomAt`. Default 8. */\n  max?: number;\n  /**\n   * Glide the discrete steps (Cmd+=, Cmd+-, Cmd+0) instead of jumping.\n   * `true` uses the kit defaults; an object tunes them. Wheel and pinch never\n   * animate — their input already samples every frame. Requires a `view` dep\n   * that implements `animate`; without one this is ignored.\n   */\n  animate?: boolean | ViewportZoomAnimateOptions;\n}\n\n/**\n * @experimental\n * Build a `viewport.zoom` Action descriptor with a configurable wheel trigger\n * and scale clamp. The keyboard bindings (Cmd+=/-/0) are fixed; only the wheel\n * binding and the `zoomAt` clamp vary.\n *\n * Requires dep-schema entry: `view`.\n */\nexport function makeViewportZoomAction(\n  opts: ViewportZoomOptions = {},\n): Action & { requires: string[] } {\n  const clamp = { min: opts.min ?? DEFAULT_MIN_ZOOM, max: opts.max ?? DEFAULT_MAX_ZOOM };\n  // 'plain': bare wheel (omitting `mods` forbids any modifier — see the\n  // matcher's strict modifier check). 'mod': Cmd/Ctrl+wheel.\n  const wheelSpec =\n    opts.wheel === 'plain'\n      ? { kind: 'wheel' as const }\n      : { kind: 'wheel' as const, mods: { mod: true } };\n\n  const rawAnimate: ViewportZoomAnimateOptions | null =\n    opts.animate === true ? {} : (opts.animate || null);\n  const { resetMs, ...animateRest } = rawAnimate ?? {};\n  const tweenOpts: ViewAnimationOptions | null = rawAnimate ? animateRest : null;\n\n  return {\n    id: 'viewport.zoom',\n    label: 'Zoom',\n    group: 'viewport',\n    defaultBinding: [\n      // wheel → wheel zoom (mod-gated by default; plain when configured)\n      {\n        spec: wheelSpec,\n        opts: { params: { kind: 'wheel' } },\n      },\n      // Trackpad pinch, which the browser delivers as ctrl+wheel. Distinct from\n      // the `mod` binding on mac; a duplicate of it elsewhere, where `matchBest`\n      // picks a single winner. `viewport.wheelPan` forbids ctrl, so no contest.\n      {\n        spec: { kind: 'wheel' as const, mods: { ctrl: true } },\n        opts: { params: { kind: 'wheel' } },\n      },\n      // Safari's trackpad pinch, reported as a scale rather than a wheel.\n      {\n        spec: { kind: 'pinch' as const },\n        opts: { params: { kind: 'pinch' } },\n      },\n      // Cmd+= → zoom in (also accepts Cmd+Shift+= which is Cmd++ on many keyboards)\n      {\n        spec: { kind: 'key', key: '=', mods: { mod: true, shift: 'optional' } },\n        opts: { params: { kind: 'in' } },\n      },\n      // Cmd+- → zoom out\n      {\n        spec: { kind: 'key', key: '-', mods: { mod: true } },\n        opts: { params: { kind: 'out' } },\n      },\n      // Cmd+0 → reset zoom\n      {\n        spec: { kind: 'key', key: '0', mods: { mod: true } },\n        opts: { params: { kind: 'reset' } },\n      },\n    ],\n    requires: ['view', 'debug'],\n    invoker: {\n      timing: 'immediate',\n      run(deps, params) {\n        const view = deps.view as ViewApi | undefined;\n        if (!view) return;\n        const debug = deps.debug as DebugSink | undefined;\n        const current = view.get();\n        // Report a zoom about `anchor` (canvas-local px) from `from` to `to`.\n        const record = (from: View, to: View, anchor: { x: number; y: number }) => {\n          if (!debug) return;\n          const [wx, wy] = screenToWorld(anchor.x, anchor.y, viewToTransform(from));\n          debug.recordViewport('zoom', from, to, { x: wx, y: wy });\n        };\n        const kind = params?.kind as string | undefined;\n\n        const canAnimate = tweenOpts !== null && typeof view.animate === 'function';\n        const stepTo = (target: View, ms?: number) => {\n          if (!canAnimate) { view.set(target); return; }\n          view.animate!(target, { ...tweenOpts!, ms: ms ?? tweenOpts!.ms });\n        };\n        // Successive presses compound off where the camera is heading, not off\n        // whichever frame the tween happens to be on.\n        const stepFrom = (): View => (canAnimate && view.animationTarget?.()) || current;\n\n        const focal = () => ({\n          x: (params?.clientX as number | undefined) ?? 0,\n          y: (params?.clientY as number | undefined) ?? 0,\n        });\n        const scaleBy = (factor: number) => {\n          if (!(factor > 0) || !Number.isFinite(factor)) return;\n          const next = zoomAt(current, focal(), factor, clamp);\n          view.set(next);\n          record(current, next, focal());\n        };\n\n        switch (kind) {\n          case 'wheel':\n            scaleBy(wheelZoomFactor((params?.deltaY as number | undefined) ?? 0));\n            break;\n          case 'pinch':\n            scaleBy((params?.scale as number | undefined) ?? Number.NaN);\n            break;\n          case 'in':\n          case 'out': {\n            const from = stepFrom();\n            const target = zoomAt(from, keyAnchor(view), kind === 'in' ? KEY_STEP : 1 / KEY_STEP, clamp);\n            stepTo(target);\n            record(from, target, keyAnchor(view));\n            break;\n          }\n          case 'reset': {\n            // Prefer the consumer-supplied recenter when available — typically\n            // re-fits the document page into the workspace. A recenter that\n            // returns its target can be animated; one that returns nothing\n            // dispatched the view itself and is already done.\n            const target = view.recenter\n              ? view.recenter()\n              : { x: 0, y: 0, scale: { x: 1, y: 1 } };\n            if (target) stepTo(target, resetMs);\n            break;\n          }\n          default:\n            // Unknown kind — no-op. Legacy bridge calls with params=undefined;\n            // default to zoom-in as a sensible fallback.\n            if (params === undefined) {\n              view.set(zoomAt(current, { x: 0, y: 0 }, KEY_STEP, clamp));\n            }\n            break;\n        }\n      },\n    },\n    enabled: () => true,\n  };\n}\n\n/**\n * @experimental\n * Default `viewport.zoom` descriptor: Cmd/Ctrl+wheel zoom with the kit's\n * default 0.1–8 scale clamp. Equivalent to `makeViewportZoomAction()`.\n *\n * Requires dep-schema entry: `view`.\n */\nexport const viewportZoomAction: Action & { requires: string[] } = makeViewportZoomAction();\n"],"mappings":"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"}

package/dist/interactions/actions/distribute/distribute.js

@@ -0,0 +1,42 @@
+import { IDENTITY_POSE_COMPOSITION as e } from "../../../core/scene/composeFrame.js";
+import { createTransformOp as t } from "../../../core/ops/transform.js";
+import { RECT_POSE_DESCRIPTOR as n, translatePoseViaDescriptor as r, visualBoundsViaDescriptor as i } from "../../../core/geometry/poseDescriptor.js";
+import { poseFrame as a } from "../poseFrame.js";
+import { dispatchApplyBatch as o } from "../../../core/applyOps.js";
+import { planDistribute as s } from "./plan.js";
+import { useCallback as c } from "react";
+import { useLatest as l } from "@weasel-js/react";
+//#region src/interactions/actions/distribute/distribute.ts
+function u(u, d = {}) {
+	let f = l(u), p = l(d);
+	return { distribute: c((c, l) => {
+		let u = f.current, d = p.current, m = u.getSelection();
+		if (m.length < 3) return;
+		let h = d.geometry ?? n, g = l ?? d.defaultMode ?? "centers", _ = a({
+			getPose: (e) => u.getPose(e),
+			getParent: (e) => u.getParent?.(e) ?? null
+		}, d.composition ?? e), v = m.map((e) => {
+			let t = _.world(e);
+			return {
+				id: e,
+				pose: t,
+				b: i(t, h)
+			};
+		}), y = s(v.map((e) => e.b), c, g), b = [];
+		for (let e = 0; e < v.length; e++) {
+			let n = v[e], i = y[e] - (c === "x" ? n.b.x : n.b.y);
+			if (i === 0) continue;
+			let a = c === "x" ? i : 0, o = c === "y" ? i : 0, s = r(n.pose, a, o, h);
+			b.push(t({
+				id: n.id,
+				from: u.getPose(n.id),
+				to: _.local(n.id, s)
+			}));
+		}
+		b.length !== 0 && o(u, b, d.label ?? "Distribute");
+	}, [f, p]) };
+}
+//#endregion
+export { u as useDistribute };
+
+//# sourceMappingURL=distribute.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"distribute.js","names":["useDistribute","adapterRef","useLatest","adapter","optsRef","options","useCallback","a","o","sel","geom","RECT_POSE_DESCRIPTOR","m","mode","frame","poseFrame","id","IDENTITY_POSE_COMPOSITION","items","pose","visualBoundsViaDescriptor","targets","planDistribute","it","axis","ops","i","delta","dx","dy","to","translatePoseViaDescriptor","createTransformOp","dispatchApplyBatch"],"sources":["../../../../src/interactions/actions/distribute/distribute.ts"],"sourcesContent":["import { useCallback } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport type { NodeId } from 'core/scene/types';\nimport { RECT_POSE_DESCRIPTOR, type PoseDescriptor } from '../resize/geometry';\nimport { translatePoseViaDescriptor, visualBoundsViaDescriptor } from '../align/align';\nimport { planDistribute } from './plan';\nimport { poseFrame } from '../poseFrame';\nimport { IDENTITY_POSE_COMPOSITION, type PoseComposition } from 'features/groups/composePose';\n\n/** Axis along which selection is distributed. `'x'` spreads horizontally. */\nexport type DistributeAxis = 'x' | 'y';\n\n/** `'centers'` spaces centers equally; `'gaps'` makes the gap between\n *  consecutive items equal. Both measure a rotated item by its ink extent.\n *  Endpoints stay put in both modes. */\nexport type DistributeMode = 'centers' | 'gaps';\n\n/** Adapter for `useDistribute`. */\nexport interface DistributeAdapter<TPose> {\n  getSelection(): NodeId[];\n  /** The pose as stored — local to the node's parent. */\n  getPose(id: NodeId): TPose;\n  /** The parent chain, for a scene whose container poses define a frame.\n   *  Omit it (or leave `composition` unset) for an absolute-pose scene. */\n  getParent?(id: NodeId): NodeId | null;\n  applyOps?(ops: Op[], label?: string): void;\n}\n\n/** Options for `useDistribute`. */\nexport interface UseDistributeOptions<TPose> {\n  /** Projection between `TPose` and bounds. Defaults to `RECT_POSE_DESCRIPTOR`\n   *  for `{x,y,width,height}` poses. */\n  geometry?: PoseDescriptor<TPose>;\n  /** Default mode when `distribute(axis)` is called without one. Default 'centers'. */\n  defaultMode?: DistributeMode;\n  /** Label passed to applyOps. Default 'Distribute'. */\n  label?: string;\n  /** How local poses fold up to world. Default IDENTITY, where the two are\n   *  the same value and the spread runs entirely in stored coordinates. */\n  composition?: PoseComposition<TPose>;\n}\n\n/** Return shape of `useDistribute`. */\nexport interface UseDistributeReturn {\n  /** Imperative trigger. No-op when fewer than 3 items selected. */\n  distribute(axis: DistributeAxis, mode?: DistributeMode): void;\n}\n\n/** Distribute the current multi-selection along `axis`. Requires ≥3 items;\n *  no-op otherwise. Endpoints (min and max along the axis) stay put; the\n *  remaining items are repositioned. Single batch — one undo step.\n *\n *  The span being divided is a world span: bounds are measured and translated\n *  in world, and each result is stored back in its own parent's frame. */\nexport function useDistribute<TPose>(\n  adapter: DistributeAdapter<TPose>,\n  options: UseDistributeOptions<TPose> = {},\n): UseDistributeReturn {\n  const adapterRef = useLatest(adapter);\n  const optsRef = useLatest(options);\n\n  const distribute = useCallback((axis: DistributeAxis, mode?: DistributeMode): void => {\n    const a = adapterRef.current;\n    const o = optsRef.current;\n    const sel = a.getSelection();\n    if (sel.length < 3) return;\n    const geom =\n      o.geometry ??\n      (RECT_POSE_DESCRIPTOR as unknown as PoseDescriptor<TPose>);\n    const m = mode ?? o.defaultMode ?? 'centers';\n\n    const frame = poseFrame<TPose>(\n      {\n        getPose: (id) => a.getPose(id as NodeId),\n        getParent: (id) => (a.getParent?.(id as NodeId) ?? null) as string | null,\n      },\n      o.composition ?? (IDENTITY_POSE_COMPOSITION as PoseComposition<TPose>),\n    );\n    const items = sel.map((id) => {\n      const pose = frame.world(id);\n      return { id, pose, b: visualBoundsViaDescriptor(pose, geom) };\n    });\n    const targets = planDistribute(items.map((it) => it.b), axis, m);\n\n    const ops: Op[] = [];\n    for (let i = 0; i < items.length; i++) {\n      const it = items[i];\n      const delta = targets[i] - (axis === 'x' ? it.b.x : it.b.y);\n      if (delta === 0) continue;\n      const dx = axis === 'x' ? delta : 0;\n      const dy = axis === 'y' ? delta : 0;\n      const to = translatePoseViaDescriptor(it.pose, dx, dy, geom);\n      ops.push(createTransformOp<TPose>({\n        id: it.id,\n        from: a.getPose(it.id),\n        to: frame.local(it.id, to),\n      }));\n    }\n    if (ops.length === 0) return;\n    dispatchApplyBatch(a, ops, o.label ?? 'Distribute');\n  }, [adapterRef, optsRef]);\n\n  return { distribute };\n}\n"],"mappings":";;;;;;;;;AAyDA,SAAgBA,EACd,GACA,IAAuC,CAAC,GACnB;CACrB,IAAMC,IAAaC,EAAUC,CAAO,GAC9BC,IAAUF,EAAUG,CAAO;CA2CjC,OAAO,EAAE,YAzCUC,GAAa,GAAsB,MAAgC;EACpF,IAAMC,IAAIN,EAAW,SACfO,IAAIJ,EAAQ,SACZK,IAAMF,EAAE,aAAa;EAC3B,IAAIE,EAAI,SAAS,GAAG;EACpB,IAAMC,IACJF,EAAE,YACDG,GACGC,IAAIC,KAAQL,EAAE,eAAe,WAE7BM,IAAQC,EACZ;GACE,UAAU,MAAOR,EAAE,QAAQS,CAAY;GACvC,YAAY,MAAQT,EAAE,YAAYS,CAAY,KAAK;EACrD,GACAR,EAAE,eAAgBS,CACpB,GACMC,IAAQT,EAAI,KAAK,MAAO;GAC5B,IAAMU,IAAOL,EAAM,MAAME,CAAE;GAC3B,OAAO;IAAE;IAAI;IAAM,GAAGI,EAA0BD,GAAMT,CAAI;GAAE;EAC9D,CAAC,GACKW,IAAUC,EAAeJ,EAAM,KAAK,MAAOK,EAAG,CAAC,GAAGC,GAAMZ,CAAC,GAEzDa,IAAY,CAAC;EACnB,KAAK,IAAIC,IAAI,GAAGA,IAAIR,EAAM,QAAQ,KAAK;GACrC,IAAMK,IAAKL,EAAMQ,IACXC,IAAQN,EAAQK,MAAMF,MAAS,MAAMD,EAAG,EAAE,IAAIA,EAAG,EAAE;GACzD,IAAII,MAAU,GAAG;GACjB,IAAMC,IAAKJ,MAAS,MAAMG,IAAQ,GAC5BE,IAAKL,MAAS,MAAMG,IAAQ,GAC5BG,IAAKC,EAA2BR,EAAG,MAAMK,GAAIC,GAAInB,CAAI;GAC3D,EAAI,KAAKsB,EAAyB;IAChC,IAAIT,EAAG;IACP,MAAMhB,EAAE,QAAQgB,EAAG,EAAE;IACrB,IAAIT,EAAM,MAAMS,EAAG,IAAIO,CAAE;GAC3B,CAAC,CAAC;EACJ;EACA,AAAIL,EAAI,WAAW,KACnBQ,EAAmB1B,GAAGkB,GAAKjB,EAAE,SAAS,YAAY;CACpD,GAAG,CAACP,GAAYG,CAAO,CAEd,EAAW;AACtB"}

package/dist/interactions/actions/distribute/plan.js

@@ -0,0 +1,29 @@
+//#region src/interactions/actions/distribute/plan.ts
+function e(e, t, n) {
+	let r = (e) => t === "x" ? e.x : e.y, i = (e) => t === "x" ? e.width : e.height, a = (e) => r(e) + i(e) / 2, o = e.map((e, t) => ({
+		b: e,
+		i: t
+	})).sort((e, t) => r(e.b) - r(t.b)), s = o.length, c = Array(s);
+	if (s === 0) return c;
+	let l = o[0].b, u = o[s - 1].b;
+	if (n === "centers") {
+		let e = a(l), t = (a(u) - e) / (s - 1);
+		for (let n = 0; n < s; n++) {
+			let { b: r, i: a } = o[n];
+			c[a] = e + t * n - i(r) / 2;
+		}
+		return c;
+	}
+	let d = r(u) + i(u) - r(l), f = 0;
+	for (let { b: e } of o) f += i(e);
+	let p = (d - f) / (s - 1), m = r(l);
+	for (let e = 0; e < s; e++) {
+		let { b: t, i: n } = o[e];
+		c[n] = m, m += i(t) + p;
+	}
+	return c;
+}
+//#endregion
+export { e as planDistribute };
+
+//# sourceMappingURL=plan.js.map

package/dist/interactions/actions/distribute/plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.js","names":["planDistribute","min","axis","b","size","center","order","bounds","p","q","n","targets","first","last","mode","c0","stride","i","orig","span","sumSizes","gap","cursor"],"sources":["../../../../src/interactions/actions/distribute/plan.ts"],"sourcesContent":["import type { DistributeAxis, DistributeMode } from './distribute';\n\n/** Axis-aligned box a distribute plan is computed from. Pass the *visual*\n *  bounds (`visualBoundsViaDescriptor`) — a rotated shape's ink is wider than\n *  the box it was posed in, and both the stride and the gap divide by size. */\nexport interface DistributeBounds {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/**\n * Where each box's min edge along `axis` should land. Result is parallel to\n * `bounds`. The two extreme boxes stay put in both modes; `'centers'` spaces\n * centers evenly between them, `'gaps'` spaces the empty runs evenly.\n *\n * Callers translate by `target - currentMin`, so the plan is expressed in the\n * same frame as the bounds it was given.\n */\nexport function planDistribute(\n  bounds: readonly DistributeBounds[],\n  axis: DistributeAxis,\n  mode: DistributeMode,\n): number[] {\n  const min = (b: DistributeBounds): number => (axis === 'x' ? b.x : b.y);\n  const size = (b: DistributeBounds): number => (axis === 'x' ? b.width : b.height);\n  const center = (b: DistributeBounds): number => min(b) + size(b) / 2;\n\n  const order = bounds.map((b, i) => ({ b, i })).sort((p, q) => min(p.b) - min(q.b));\n  const n = order.length;\n  const targets = new Array<number>(n);\n  if (n === 0) return targets;\n  const first = order[0].b;\n  const last = order[n - 1].b;\n\n  if (mode === 'centers') {\n    const c0 = center(first);\n    const stride = (center(last) - c0) / (n - 1);\n    for (let i = 0; i < n; i++) {\n      const { b, i: orig } = order[i];\n      targets[orig] = c0 + stride * i - size(b) / 2;\n    }\n    return targets;\n  }\n\n  const span = (min(last) + size(last)) - min(first);\n  let sumSizes = 0;\n  for (const { b } of order) sumSizes += size(b);\n  const gap = (span - sumSizes) / (n - 1);\n  let cursor = min(first);\n  for (let i = 0; i < n; i++) {\n    const { b, i: orig } = order[i];\n    targets[orig] = cursor;\n    cursor += size(b) + gap;\n  }\n  return targets;\n}\n"],"mappings":";AAoBA,SAAgBA,EACd,GACA,GACA,GACU;CACV,IAAMC,KAAO,MAAiCC,MAAS,MAAMC,EAAE,IAAIA,EAAE,GAC/DC,KAAQ,MAAiCF,MAAS,MAAMC,EAAE,QAAQA,EAAE,QACpEE,KAAU,MAAgCJ,EAAIE,CAAC,IAAIC,EAAKD,CAAC,IAAI,GAE7DG,IAAQC,EAAO,KAAK,GAAG,OAAO;EAAE;EAAG;CAAE,EAAE,CAAC,CAAC,MAAM,GAAG,MAAMN,EAAIO,EAAE,CAAC,IAAIP,EAAIQ,EAAE,CAAC,CAAC,GAC3EC,IAAIJ,EAAM,QACVK,IAAc,MAAcD,CAAC;CACnC,IAAIA,MAAM,GAAG,OAAOC;CACpB,IAAMC,IAAQN,EAAM,EAAE,CAAC,GACjBO,IAAOP,EAAMI,IAAI,EAAE,CAAC;CAE1B,IAAII,MAAS,WAAW;EACtB,IAAMC,IAAKV,EAAOO,CAAK,GACjBI,KAAUX,EAAOQ,CAAI,IAAIE,MAAOL,IAAI;EAC1C,KAAK,IAAIO,IAAI,GAAGA,IAAIP,GAAG,KAAK;GAC1B,IAAM,EAAE,MAAG,GAAGQ,MAASZ,EAAMW;GAC7B,EAAQC,KAAQH,IAAKC,IAASC,IAAIb,EAAKD,CAAC,IAAI;EAC9C;EACA,OAAOQ;CACT;CAEA,IAAMQ,IAAQlB,EAAIY,CAAI,IAAIT,EAAKS,CAAI,IAAKZ,EAAIW,CAAK,GAC7CQ,IAAW;CACf,KAAK,IAAM,EAAE,UAAOd,GAAO,KAAYF,EAAKD,CAAC;CAC7C,IAAMkB,KAAOF,IAAOC,MAAaV,IAAI,IACjCY,IAASrB,EAAIW,CAAK;CACtB,KAAK,IAAIK,IAAI,GAAGA,IAAIP,GAAG,KAAK;EAC1B,IAAM,EAAE,MAAG,GAAGQ,MAASZ,EAAMW;EAE7B,AADA,EAAQC,KAAQI,GAChB,KAAUlB,EAAKD,CAAC,IAAIkB;CACtB;CACA,OAAOV;AACT"}

package/dist/interactions/actions/edit-anchors/geometry.js

@@ -0,0 +1,61 @@
+import { PATH_C as e, PATH_L as t, PATH_M as n, PATH_Q as r, PATH_Z as i, forEachSegment as a } from "@weasel-js/geom";
+//#region src/interactions/actions/edit-anchors/geometry.ts
+function o(o) {
+	let { commands: s, coords: c } = o, l = [], u = null, d = (e, t) => {
+		let n = {
+			anchorIndex: l.length,
+			x: c[e],
+			y: c[e + 1],
+			coordIndex: e,
+			...t ? { controlIn: t } : {}
+		};
+		l.push(n), u = n;
+	};
+	return a(s, c, (a, o) => {
+		switch (a) {
+			case n:
+			case t:
+				d(o);
+				break;
+			case e:
+				u && (u.controlOut = {
+					x: c[o],
+					y: c[o + 1],
+					coordIndex: o
+				}), d(o + 4, {
+					x: c[o + 2],
+					y: c[o + 3],
+					coordIndex: o + 2
+				});
+				break;
+			case r:
+				u && (u.controlOut = {
+					x: c[o],
+					y: c[o + 1],
+					coordIndex: o
+				}), d(o + 2, {
+					x: c[o],
+					y: c[o + 1],
+					coordIndex: o
+				});
+				break;
+			case i:
+				u = null;
+				break;
+			default: throw Error(`enumerateAnchors: unknown command ${a}`);
+		}
+	}), l;
+}
+function s(e, t, n, r) {
+	let i = new Float32Array(e.coords);
+	return i[t] = n, i[t + 1] = r, {
+		kind: "polygon",
+		commands: e.commands,
+		coords: i,
+		fillRule: e.fillRule
+	};
+}
+//#endregion
+export { o as enumerateAnchors, s as withCoord };
+
+//# sourceMappingURL=geometry.js.map

package/dist/interactions/actions/edit-anchors/geometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.js","names":["enumerateAnchors","path","anchors","lastAnchor","push","a","coords","coordIndex","controlIn","forEachSegment","commands","cmd","PATH_M","PATH_L","ci","PATH_C","PATH_Q","PATH_Z","withCoord","next","x","y"],"sources":["../../../../src/interactions/actions/edit-anchors/geometry.ts"],"sourcesContent":["import { forEachSegment, PATH_C, PATH_L, PATH_M, PATH_Q, PATH_Z, type PolygonPath } from '@weasel-js/geom';\n\n/** A single anchor on a `PolygonPath`, with its incoming/outgoing bezier\n *  control points (when present). `coordIndex` points at the anchor's own\n *  on-curve x in the `coords` array. `inCoordIndex` / `outCoordIndex` point\n *  at the corresponding control x. */\nexport interface PathAnchor {\n  /** Sequential anchor index in walk order (0-based). */\n  anchorIndex: number;\n  /** On-curve point. */\n  x: number;\n  y: number;\n  /** Incoming control (from the previous segment, when it was C/Q). */\n  controlIn?: { x: number; y: number; coordIndex: number };\n  /** Outgoing control (from the next segment, when it is C/Q). */\n  controlOut?: { x: number; y: number; coordIndex: number };\n  /** Index of the anchor's on-curve x in `coords`. */\n  coordIndex: number;\n}\n\n/** Walk a PolygonPath's command stream and yield one `PathAnchor` per\n *  on-curve point. Adjacent C/Q control points are attached as\n *  `controlIn`/`controlOut`. Subpath boundaries (M after a previous M or Z)\n *  start fresh — the new M's anchor has no `controlIn` from a Z. */\nexport function enumerateAnchors(path: PolygonPath): PathAnchor[] {\n  const { commands, coords } = path;\n  const anchors: PathAnchor[] = [];\n  let lastAnchor: PathAnchor | null = null;\n\n  const push = (coordIndex: number, controlIn?: PathAnchor['controlIn']): void => {\n    const a: PathAnchor = {\n      anchorIndex: anchors.length,\n      x: coords[coordIndex],\n      y: coords[coordIndex + 1],\n      coordIndex,\n      ...(controlIn ? { controlIn } : {}),\n    };\n    anchors.push(a);\n    lastAnchor = a;\n  };\n\n  forEachSegment(commands, coords, (cmd, ci) => {\n    switch (cmd) {\n      case PATH_M:\n      case PATH_L:\n        push(ci);\n        break;\n      case PATH_C:\n        if (lastAnchor) {\n          lastAnchor.controlOut = { x: coords[ci], y: coords[ci + 1], coordIndex: ci };\n        }\n        push(ci + 4, { x: coords[ci + 2], y: coords[ci + 3], coordIndex: ci + 2 });\n        break;\n      case PATH_Q:\n        if (lastAnchor) {\n          lastAnchor.controlOut = { x: coords[ci], y: coords[ci + 1], coordIndex: ci };\n        }\n        push(ci + 2, { x: coords[ci], y: coords[ci + 1], coordIndex: ci });\n        break;\n      case PATH_Z:\n        lastAnchor = null;\n        break;\n      default:\n        throw new Error(`enumerateAnchors: unknown command ${cmd}`);\n    }\n  });\n  return anchors;\n}\n\n/** Mutate `coords` in-place: write `(x, y)` at `coordIndex`, return a new\n *  PolygonPath sharing the same commands but with a fresh coords buffer. */\nexport function withCoord(path: PolygonPath, coordIndex: number, x: number, y: number): PolygonPath {\n  const next = new Float32Array(path.coords);\n  next[coordIndex] = x;\n  next[coordIndex + 1] = y;\n  return { kind: 'polygon', commands: path.commands, coords: next, fillRule: path.fillRule };\n}\n\n/** Translate anchor `anchorIndex` AND its attached control handles\n *  (`controlIn` / `controlOut`) by `(dx, dy)`. Used by `editAnchorsAction`\n *  when the dragged affordance is the anchor itself — moving the anchor\n *  without its handles would shear the surrounding bezier segments. */\nexport function translateAnchor(\n  path: PolygonPath,\n  anchorIndex: number,\n  dx: number,\n  dy: number,\n): PolygonPath {\n  const anchors = enumerateAnchors(path);\n  const a = anchors[anchorIndex];\n  if (!a) return path;\n  const next = new Float32Array(path.coords);\n  // Anchor itself.\n  next[a.coordIndex] += dx;\n  next[a.coordIndex + 1] += dy;\n  // In-handle of THIS anchor — the trailing pair of the incoming C/Q.\n  if (a.controlIn) {\n    next[a.controlIn.coordIndex] += dx;\n    next[a.controlIn.coordIndex + 1] += dy;\n  }\n  // Out-handle: the leading pair of the OUTGOING C/Q. Owned by this\n  // anchor's segment.\n  if (a.controlOut) {\n    next[a.controlOut.coordIndex] += dx;\n    next[a.controlOut.coordIndex + 1] += dy;\n  }\n  return { kind: 'polygon', commands: path.commands, coords: next, fillRule: path.fillRule };\n}\n"],"mappings":";;AAwBA,SAAgBA,EAAiB,GAAiC;CAChE,IAAM,EAAE,aAAU,cAAWC,GACvBC,IAAwB,CAAC,GAC3BC,IAAgC,MAE9BC,KAAQ,GAAoB,MAA8C;EAC9E,IAAMC,IAAgB;GACpB,aAAaH,EAAQ;GACrB,GAAGI,EAAOC;GACV,GAAGD,EAAOC,IAAa;GACvB;GACA,GAAIC,IAAY,EAAE,aAAU,IAAI,CAAC;EACnC;EAEA,AADAN,EAAQ,KAAKG,CAAC,GACd,IAAaA;CACf;CA2BA,OAzBAI,EAAeC,GAAUJ,IAAS,GAAK,MAAO;EAC5C,QAAQK,GAAR;GACE,KAAKC;GACL,KAAKC;IACH,EAAKC,CAAE;IACP;GACF,KAAKC;IAIH,AAHIZ,MACF,EAAW,aAAa;KAAE,GAAGG,EAAOQ;KAAK,GAAGR,EAAOQ,IAAK;KAAI,YAAYA;IAAG,IAE7EV,EAAKU,IAAK,GAAG;KAAE,GAAGR,EAAOQ,IAAK;KAAI,GAAGR,EAAOQ,IAAK;KAAI,YAAYA,IAAK;IAAE,CAAC;IACzE;GACF,KAAKE;IAIH,AAHIb,MACF,EAAW,aAAa;KAAE,GAAGG,EAAOQ;KAAK,GAAGR,EAAOQ,IAAK;KAAI,YAAYA;IAAG,IAE7EV,EAAKU,IAAK,GAAG;KAAE,GAAGR,EAAOQ;KAAK,GAAGR,EAAOQ,IAAK;KAAI,YAAYA;IAAG,CAAC;IACjE;GACF,KAAKG;IACH,IAAa;IACb;GACF,SACE,MAAU,MAAM,qCAAqCN,GAAK;EAC9D;CACF,CAAC,GACMT;AACT;AAIA,SAAgBgB,EAAU,GAAmB,GAAoB,GAAW,GAAwB;CAClG,IAAMC,IAAO,IAAI,aAAalB,EAAK,MAAM;CAGzC,OAFA,EAAKM,KAAca,GACnB,EAAKb,IAAa,KAAKc,GAChB;EAAE,MAAM;EAAW,UAAUpB,EAAK;EAAU,QAAQkB;EAAM,UAAUlB,EAAK;CAAS;AAC3F"}

package/dist/interactions/actions/edit-anchors/handles.js

@@ -0,0 +1,43 @@
+import { enumerateAnchors as e } from "./geometry.js";
+//#region src/interactions/actions/edit-anchors/handles.ts
+function t(t, n, r, i) {
+	let a = e(t), o = null, s = null, c = i * i;
+	for (let e of a) {
+		if (e.controlIn) {
+			let t = e.controlIn.x - n, i = e.controlIn.y - r, a = t * t + i * i;
+			a <= c && (!o || a < o.d2) && (o = {
+				d2: a,
+				hit: {
+					anchorIndex: e.anchorIndex,
+					kind: "controlIn",
+					coordIndex: e.controlIn.coordIndex
+				}
+			});
+		}
+		if (e.controlOut) {
+			let t = e.controlOut.x - n, i = e.controlOut.y - r, a = t * t + i * i;
+			a <= c && (!o || a < o.d2) && (o = {
+				d2: a,
+				hit: {
+					anchorIndex: e.anchorIndex,
+					kind: "controlOut",
+					coordIndex: e.controlOut.coordIndex
+				}
+			});
+		}
+		let t = e.x - n, i = e.y - r, a = t * t + i * i;
+		a <= c && (!s || a < s.d2) && (s = {
+			d2: a,
+			hit: {
+				anchorIndex: e.anchorIndex,
+				kind: "anchor",
+				coordIndex: e.coordIndex
+			}
+		});
+	}
+	return o ? o.hit : s ? s.hit : null;
+}
+//#endregion
+export { t as hitAnchor };
+
+//# sourceMappingURL=handles.js.map

package/dist/interactions/actions/edit-anchors/handles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handles.js","names":["hitAnchor","anchors","enumerateAnchors","path","bestControl","bestAnchor","t2","threshold","a","dx","worldX","dy","worldY","d2"],"sources":["../../../../src/interactions/actions/edit-anchors/handles.ts"],"sourcesContent":["import type { PolygonPath } from '@weasel-js/geom';\nimport { enumerateAnchors, type PathAnchor } from './geometry';\n\n/** Result of a hit-test against a path's anchors / control handles. */\nexport interface AnchorHit {\n  anchorIndex: number;\n  kind: 'anchor' | 'controlIn' | 'controlOut';\n  /** Index in `coords` of the hit point's x. */\n  coordIndex: number;\n}\n\n/** Hit-test anchors and control handles. Controls win over anchors when both\n *  are within `threshold` (controls are smaller and rendered on top). */\nexport function hitAnchor(\n  path: PolygonPath,\n  worldX: number,\n  worldY: number,\n  threshold: number,\n): AnchorHit | null {\n  const anchors = enumerateAnchors(path);\n  let bestControl: { d2: number; hit: AnchorHit } | null = null;\n  let bestAnchor: { d2: number; hit: AnchorHit } | null = null;\n  const t2 = threshold * threshold;\n\n  for (const a of anchors) {\n    if (a.controlIn) {\n      const dx = a.controlIn.x - worldX;\n      const dy = a.controlIn.y - worldY;\n      const d2 = dx * dx + dy * dy;\n      if (d2 <= t2 && (!bestControl || d2 < bestControl.d2)) {\n        bestControl = {\n          d2,\n          hit: { anchorIndex: a.anchorIndex, kind: 'controlIn', coordIndex: a.controlIn.coordIndex },\n        };\n      }\n    }\n    if (a.controlOut) {\n      const dx = a.controlOut.x - worldX;\n      const dy = a.controlOut.y - worldY;\n      const d2 = dx * dx + dy * dy;\n      if (d2 <= t2 && (!bestControl || d2 < bestControl.d2)) {\n        bestControl = {\n          d2,\n          hit: { anchorIndex: a.anchorIndex, kind: 'controlOut', coordIndex: a.controlOut.coordIndex },\n        };\n      }\n    }\n    const dx = a.x - worldX;\n    const dy = a.y - worldY;\n    const d2 = dx * dx + dy * dy;\n    if (d2 <= t2 && (!bestAnchor || d2 < bestAnchor.d2)) {\n      bestAnchor = {\n        d2,\n        hit: { anchorIndex: a.anchorIndex, kind: 'anchor', coordIndex: a.coordIndex },\n      };\n    }\n  }\n  if (bestControl) return bestControl.hit;\n  if (bestAnchor) return bestAnchor.hit;\n  return null;\n}\n\nexport type { PathAnchor };\n"],"mappings":";;AAaA,SAAgBA,EACd,GACA,GACA,GACA,GACkB;CAClB,IAAMC,IAAUC,EAAiBC,CAAI,GACjCC,IAAqD,MACrDC,IAAoD,MAClDC,IAAKC,IAAYA;CAEvB,KAAK,IAAMC,KAAKP,GAAS;EACvB,IAAIO,EAAE,WAAW;GACf,IAAMC,IAAKD,EAAE,UAAU,IAAIE,GACrBC,IAAKH,EAAE,UAAU,IAAII,GACrBC,IAAKJ,IAAKA,IAAKE,IAAKA;GAC1B,AAAIE,KAAMP,MAAO,CAACF,KAAeS,IAAKT,EAAY,QAChD,IAAc;IACZ;IACA,KAAK;KAAE,aAAaI,EAAE;KAAa,MAAM;KAAa,YAAYA,EAAE,UAAU;IAAW;GAC3F;EAEJ;EACA,IAAIA,EAAE,YAAY;GAChB,IAAMC,IAAKD,EAAE,WAAW,IAAIE,GACtBC,IAAKH,EAAE,WAAW,IAAII,GACtBC,IAAKJ,IAAKA,IAAKE,IAAKA;GAC1B,AAAIE,KAAMP,MAAO,CAACF,KAAeS,IAAKT,EAAY,QAChD,IAAc;IACZ;IACA,KAAK;KAAE,aAAaI,EAAE;KAAa,MAAM;KAAc,YAAYA,EAAE,WAAW;IAAW;GAC7F;EAEJ;EACA,IAAMC,IAAKD,EAAE,IAAIE,GACXC,IAAKH,EAAE,IAAII,GACXC,IAAKJ,IAAKA,IAAKE,IAAKA;EAC1B,AAAIE,KAAMP,MAAO,CAACD,KAAcQ,IAAKR,EAAW,QAC9C,IAAa;GACX;GACA,KAAK;IAAE,aAAaG,EAAE;IAAa,MAAM;IAAU,YAAYA,EAAE;GAAW;EAC9E;CAEJ;CAGA,OAFIJ,IAAoBA,EAAY,MAChCC,IAAmBA,EAAW,MAC3B;AACT"}

package/dist/interactions/actions/flip/helpers.js

@@ -0,0 +1,35 @@
+//#region src/interactions/actions/flip/helpers.ts
+function e(e, t, i, a) {
+	let o = i.getBounds(e), s = a.x + a.width / 2, c = a.y + a.height / 2, l = t === "x" ? {
+		x: 2 * s - o.x,
+		y: o.y,
+		width: -o.width,
+		height: o.height
+	} : {
+		x: o.x,
+		y: 2 * c - o.y,
+		width: o.width,
+		height: -o.height
+	}, u = i.remapBounds(e, o, l), d = i.getRotation?.(e) ?? o.rotation ?? 0;
+	return n(r(u), d, i);
+}
+function t(t, n, r) {
+	return e(t, n, r, r.getBounds(t));
+}
+function n(e, t, n) {
+	return t === 0 ? e : n.withRotation ? n.withRotation(e, -t) : e;
+}
+function r(e) {
+	let t = e, n = !1, r = t.x, i = t.y, a = t.width, o = t.height;
+	return typeof a == "number" && a < 0 && typeof r == "number" && (r += a, a = -a, n = !0), typeof o == "number" && o < 0 && typeof i == "number" && (i += o, o = -o, n = !0), n ? {
+		...e,
+		x: r,
+		y: i,
+		width: a,
+		height: o
+	} : e;
+}
+//#endregion
+export { e as flipPoseAboutBounds, t as flipPoseViaDescriptor };
+
+//# sourceMappingURL=helpers.js.map

package/dist/interactions/actions/flip/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","names":["flipPoseAboutBounds","src","geometry","pose","cxPivot","pivotBounds","cyPivot","dst","axis","next","rotation","negateRotation","normalizeNegativeExtent","flipPoseViaDescriptor","p","mutated","nx","ny","nw","nh"],"sources":["../../../../src/interactions/actions/flip/helpers.ts"],"sourcesContent":["/**\n * Pose-flip helpers used by `flipAction` (via `defaults/flip.ts`).\n *\n * These were extracted from the legacy `useFlip` hook when it was removed —\n * they remain because the descriptor-style `flipAction` still needs to reflect\n * arbitrary `TPose` values through a `PoseDescriptor`.\n */\nimport type { PoseDescriptor } from '../resize/geometry';\nimport type { SpatialReference } from '../spatialReference';\n\n/** Axis for flip. `'x'` mirrors horizontally (left↔right); `'y'` mirrors vertically (top↔bottom). */\nexport type FlipAxis = 'x' | 'y';\n\n/** How a multi-selection flip chooses its pivot.\n *\n *  - `'each'` — every pose mirrors about its own AABB; spatial layout of the\n *    selection is unchanged, individual items are reflected in place.\n *  - `'union'` — every pose mirrors about the selection's union AABB; items\n *    swap sides as well as reflect, matching Illustrator/Figma defaults.\n *  - a {@link SpatialReference} — every pose mirrors about the center of the\n *    bounds it names: the pointer, a world point or rect, or a key node. */\nexport type FlipPivot = 'each' | 'union' | SpatialReference;\n\n/** Reflect `pose` across the centerline of `pivotBounds` along `axis`, using\n *  `geometry` to read bounds and remap. The pose's own AABB is read once to\n *  compute the reflected destination rect; coords inside the pose are then\n *  remapped through the affine that takes its own bounds → reflected dst.\n *  A rotation the pose carries is negated: a mirror reverses the sense of the\n *  turn, and `remapBounds` carries the original angle through untouched. */\nexport function flipPoseAboutBounds<TPose>(\n  pose: TPose,\n  axis: FlipAxis,\n  geometry: PoseDescriptor<TPose>,\n  pivotBounds: { x: number; y: number; width: number; height: number },\n): TPose {\n  const src = geometry.getBounds(pose);\n  const cxPivot = pivotBounds.x + pivotBounds.width / 2;\n  const cyPivot = pivotBounds.y + pivotBounds.height / 2;\n  const dst = axis === 'x'\n    ? { x: 2 * cxPivot - src.x, y: src.y, width: -src.width, height: src.height }\n    : { x: src.x, y: 2 * cyPivot - src.y, width: src.width, height: -src.height };\n  const next = geometry.remapBounds(pose, src, dst);\n  const rotation = geometry.getRotation?.(pose) ?? (src as { rotation?: number }).rotation ?? 0;\n  return negateRotation(normalizeNegativeExtent(next), rotation, geometry);\n}\n\n/** Reflect `pose` across the centerline of its own AABB along `axis`. */\nexport function flipPoseViaDescriptor<TPose>(\n  pose: TPose,\n  axis: FlipAxis,\n  geometry: PoseDescriptor<TPose>,\n): TPose {\n  return flipPoseAboutBounds(pose, axis, geometry, geometry.getBounds(pose));\n}\n\nfunction negateRotation<TPose>(pose: TPose, rotation: number, geometry: PoseDescriptor<TPose>): TPose {\n  if (rotation === 0) return pose;\n  return geometry.withRotation ? geometry.withRotation(pose, -rotation) : pose;\n}\n\nfunction normalizeNegativeExtent<TPose>(pose: TPose): TPose {\n  const p = pose as unknown as { x?: number; y?: number; width?: number; height?: number };\n  let mutated = false;\n  let nx = p.x;\n  let ny = p.y;\n  let nw = p.width;\n  let nh = p.height;\n  if (typeof nw === 'number' && nw < 0 && typeof nx === 'number') {\n    nx = nx + nw;\n    nw = -nw;\n    mutated = true;\n  }\n  if (typeof nh === 'number' && nh < 0 && typeof ny === 'number') {\n    ny = ny + nh;\n    nh = -nh;\n    mutated = true;\n  }\n  if (!mutated) return pose;\n  return { ...(pose as object), x: nx, y: ny, width: nw, height: nh } as TPose;\n}\n"],"mappings":";AA6BA,SAAgBA,EACd,GACA,GACA,GACA,GACO;CACP,IAAMC,IAAMC,EAAS,UAAUC,CAAI,GAC7BC,IAAUC,EAAY,IAAIA,EAAY,QAAQ,GAC9CC,IAAUD,EAAY,IAAIA,EAAY,SAAS,GAC/CE,IAAMC,MAAS,MACjB;EAAE,GAAG,IAAIJ,IAAUH,EAAI;EAAG,GAAGA,EAAI;EAAG,OAAO,CAACA,EAAI;EAAO,QAAQA,EAAI;CAAO,IAC1E;EAAE,GAAGA,EAAI;EAAG,GAAG,IAAIK,IAAUL,EAAI;EAAG,OAAOA,EAAI;EAAO,QAAQ,CAACA,EAAI;CAAO,GACxEQ,IAAOP,EAAS,YAAYC,GAAMF,GAAKM,CAAG,GAC1CG,IAAWR,EAAS,cAAcC,CAAI,KAAMF,EAA8B,YAAY;CAC5F,OAAOU,EAAeC,EAAwBH,CAAI,GAAGC,GAAUR,CAAQ;AACzE;AAGA,SAAgBW,EACd,GACA,GACA,GACO;CACP,OAAOb,EAAoBG,GAAMK,GAAMN,GAAUA,EAAS,UAAUC,CAAI,CAAC;AAC3E;AAEA,SAASQ,EAAsB,GAAa,GAAkB,GAAwC;CAEpG,OADID,MAAa,IAAUP,IACpBD,EAAS,eAAeA,EAAS,aAAaC,GAAM,CAACO,CAAQ,IAAIP;AAC1E;AAEA,SAASS,EAA+B,GAAoB;CAC1D,IAAME,IAAIX,GACNY,IAAU,IACVC,IAAKF,EAAE,GACPG,IAAKH,EAAE,GACPI,IAAKJ,EAAE,OACPK,IAAKL,EAAE;CAYX,OAXI,OAAOI,KAAO,YAAYA,IAAK,KAAK,OAAOF,KAAO,aACpD,KAAUE,GACV,IAAK,CAACA,GACN,IAAU,KAER,OAAOC,KAAO,YAAYA,IAAK,KAAK,OAAOF,KAAO,aACpD,KAAUE,GACV,IAAK,CAACA,GACN,IAAU,KAEPJ,IACE;EAAE,GAAIZ;EAAiB,GAAGa;EAAI,GAAGC;EAAI,OAAOC;EAAI,QAAQC;CAAG,IAD7ChB;AAEvB"}

package/dist/interactions/actions/geometryProjection.js

@@ -0,0 +1,18 @@
+import { createSetDataOp as e } from "../../core/ops/setData.js";
+import "@weasel-js/geom";
+//#region src/interactions/actions/geometryProjection.ts
+function t(t, n, r, i) {
+	if (!t || !n) return;
+	let a = t.transform(n, r);
+	if (a != null) return e({
+		id: n.id,
+		from: n.data,
+		to: a,
+		label: i,
+		coalesceKey: `setData:${n.id}`
+	});
+}
+//#endregion
+export { t as geometryDataOp };
+
+//# sourceMappingURL=geometryProjection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometryProjection.js","names":["geometryDataOp","projection","node","next","m","createSetDataOp"],"sources":["../../../src/interactions/actions/geometryProjection.ts"],"sourcesContent":["import { type Mat3 } from '@weasel-js/geom';\nimport { createSetDataOp } from 'core/ops/setData';\nimport type { Op } from 'core/ops/types';\n\n/** Optional consumer seam: given a node and the affine `m` that a pose-transform\n *  action applied to the node's POSE, return updated `data` with the node's\n *  data-held geometry transformed by `m`, or `null` if this node has no\n *  data-held geometry (the kit leaves `data` alone). */\nexport interface GeometryProjection {\n  transform(node: { id?: string; data: unknown; pose: unknown }, m: Mat3): unknown | null;\n}\n\n/** Build the `setData` op for a node when a geometryProjection is wired and\n *  returns non-null. Returns `undefined` (no op) otherwise — keeping the data\n *  op strictly opt-in so adapters without `setData` are never invoked. */\nexport function geometryDataOp(\n  projection: GeometryProjection | undefined,\n  node: { id: string; data: unknown; pose: unknown } | undefined,\n  m: Mat3,\n  label: string,\n): Op | undefined {\n  if (!projection || !node) return undefined;\n  const next = projection.transform(node, m);\n  if (next == null) return undefined;\n  return createSetDataOp({ id: node.id, from: node.data, to: next, label, coalesceKey: `setData:${node.id}` });\n}\n"],"mappings":";;;AAeA,SAAgBA,EACd,GACA,GACA,GACA,GACgB;CAChB,IAAI,CAACC,KAAc,CAACC,GAAM;CAC1B,IAAMC,IAAOF,EAAW,UAAUC,GAAME,CAAC;CACzC,IAAID,KAAQ,MACZ,OAAOE,EAAgB;EAAE,IAAIH,EAAK;EAAI,MAAMA,EAAK;EAAM,IAAIC;EAAM;EAAO,aAAa,WAAWD,EAAK;CAAK,CAAC;AAC7G"}

package/dist/interactions/actions/gestureLifecycle.js

@@ -0,0 +1,44 @@
+//#region src/interactions/actions/gestureLifecycle.ts
+function e(e) {
+	let t = {};
+	return e.label !== void 0 && (t.label = e.label), e.transient !== void 0 && (t.transient = e.transient), e.onGestureStart && (t.onGestureStart = e.onGestureStart), e.onGestureEnd && (t.onGestureEnd = e.onGestureEnd), t;
+}
+function t(e, t, n = []) {
+	let r = e ?? {}, i = !1, a = !1;
+	return {
+		label: r.label ?? t,
+		labelFor: (e) => r.label ?? e[0]?.label ?? t,
+		transient: r.transient ?? n.some((e) => e.defaultTransient === !0),
+		start(e) {
+			i || (i = !0, r.onGestureStart?.([...e]));
+		},
+		end(e) {
+			i && !a && (a = !0, r.onGestureEnd?.(e));
+		}
+	};
+}
+function n(e, t, n) {
+	if (t.transient) {
+		e.scene.untracked(() => {
+			for (let t of n) t.apply(e.adapter);
+		});
+		return;
+	}
+	let r = t.labelFor(n);
+	e.applyOps ? e.applyOps(n, r) : e.scene.applyBatch(n, r, e.adapter);
+}
+function r(e, t) {
+	let n;
+	for (let r of e) {
+		let e = r.onEnd?.(t, { answered: n !== void 0 });
+		n === void 0 && e !== void 0 && (n = e);
+	}
+	return n;
+}
+function i(e, t) {
+	for (let n of e) n.onCancel?.(t);
+}
+//#endregion
+export { n as commitGestureOps, e as gestureLifecycleParams, t as readGestureLifecycle, r as reduceBehaviorEnd, i as runBehaviorCancel };
+
+//# sourceMappingURL=gestureLifecycle.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gestureLifecycle.js","names":["gestureLifecycleParams","out","o","readGestureLifecycle","source","started","ended","defaultLabel","ops","behaviors","b","ids","committed","commitGestureOps","lifecycle","op","target","label","reduceBehaviorEnd","answer","r","ctx","runBehaviorCancel"],"sources":["../../../src/interactions/actions/gestureLifecycle.ts"],"sourcesContent":["/**\n * The lifecycle the ongoing transform actions (`move`, `resize`, `rotate`)\n * share: what their committed batch is called in history, whether it is\n * recorded at all, and the callbacks fired as the gesture opens and closes.\n *\n * Move and rotate read it from their binding's params; resize reads it from\n * the `resizePolicy` dep, where the rest of its options already live.\n */\nimport type { Op } from 'core/ops/types';\nimport type { Scene } from 'core/scene/types';\nimport type { BehaviorEnd } from 'interactions/gestures/types';\n\n/** The lifecycle options, as a binding's params or the resize policy carry\n *  them. */\nexport interface GestureLifecycleOptions {\n  /** History label for the committed batch. Unset, the batch takes its first\n   *  op's label (a layout drop or a behavior names its own), else the\n   *  action's. */\n  label?: string;\n  /** Commit through `scene.untracked`: the edit lands, but no undo entry\n   *  records it and the consumer `applyOps` hook is bypassed. Unset, any\n   *  behavior's `defaultTransient: true` turns it on. */\n  transient?: boolean;\n  /** Fired once the gesture starts changing poses, with the ids it moves. */\n  onGestureStart?(ids: string[]): void;\n  /** Fired once per `onGestureStart`: `true` when the gesture wrote to the\n   *  document, `false` on cancel, abort, or a release with nothing to write. */\n  onGestureEnd?(committed: boolean): void;\n}\n\n/** The params entries for {@link GestureLifecycleOptions}, with the unset\n *  keys left out. */\nexport function gestureLifecycleParams(o: GestureLifecycleOptions): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  if (o.label !== undefined) out.label = o.label;\n  if (o.transient !== undefined) out.transient = o.transient;\n  if (o.onGestureStart) out.onGestureStart = o.onGestureStart;\n  if (o.onGestureEnd) out.onGestureEnd = o.onGestureEnd;\n  return out;\n}\n\n/** A gesture's resolved lifecycle. `start` and `end` fire their callbacks at\n *  most once each, and `end` only after `start`. */\nexport interface GestureLifecycle {\n  /** The label ops built by the action itself carry. */\n  readonly label: string;\n  /** The history label for committing `ops`. */\n  labelFor(ops: readonly Op[]): string;\n  readonly transient: boolean;\n  start(ids: readonly string[]): void;\n  end(committed: boolean): void;\n}\n\nexport function readGestureLifecycle(\n  source: GestureLifecycleOptions | Record<string, unknown> | undefined,\n  defaultLabel: string,\n  behaviors: readonly { defaultTransient?: boolean }[] = [],\n): GestureLifecycle {\n  const o = (source ?? {}) as GestureLifecycleOptions;\n  let started = false;\n  let ended = false;\n  return {\n    label: o.label ?? defaultLabel,\n    labelFor: (ops) => o.label ?? ops[0]?.label ?? defaultLabel,\n    transient: o.transient ?? behaviors.some((b) => b.defaultTransient === true),\n    start(ids) {\n      if (started) return;\n      started = true;\n      o.onGestureStart?.([...ids]);\n    },\n    end(committed) {\n      if (!started || ended) return;\n      ended = true;\n      o.onGestureEnd?.(committed);\n    },\n  };\n}\n\n/** Commit a gesture's ops: untracked when transient, else through the\n *  consumer `applyOps` hook when one is wired, else into the scene's history. */\nexport function commitGestureOps(\n  target: {\n    scene: Scene<unknown, string, unknown>;\n    applyOps?: (ops: Op[], label: string) => void;\n    adapter: unknown;\n  },\n  lifecycle: GestureLifecycle,\n  ops: Op[],\n): void {\n  if (lifecycle.transient) {\n    target.scene.untracked(() => {\n      for (const op of ops) op.apply(target.adapter);\n    });\n    return;\n  }\n  const label = lifecycle.labelFor(ops);\n  if (target.applyOps) target.applyOps(ops, label);\n  else target.scene.applyBatch(ops, label, target.adapter);\n}\n\n/** Runs every behavior's `onEnd` in order; the first that answers decides the\n *  commit and later answers are ignored. `null` aborts, `Op[]` claims it (an\n *  empty array included), and `undefined` means every behavior deferred to the\n *  action's own commit. */\nexport function reduceBehaviorEnd<TCtx>(\n  behaviors: readonly { onEnd?(ctx: TCtx, end: BehaviorEnd): Op[] | null | void }[],\n  ctx: TCtx,\n): Op[] | null | undefined {\n  let answer: Op[] | null | undefined;\n  for (const b of behaviors) {\n    const r = b.onEnd?.(ctx, { answered: answer !== undefined });\n    if (answer === undefined && r !== undefined) answer = r;\n  }\n  return answer;\n}\n\n/** Runs every behavior's `onCancel`, for a gesture closing without a commit. */\nexport function runBehaviorCancel<TCtx>(\n  behaviors: readonly { onCancel?(ctx: TCtx): void }[],\n  ctx: TCtx,\n): void {\n  for (const b of behaviors) b.onCancel?.(ctx);\n}\n"],"mappings":";AAgCA,SAAgBA,EAAuB,GAAqD;CAC1F,IAAMC,IAA+B,CAAC;CAKtC,OAJIC,EAAE,UAAU,KAAA,MAAW,EAAI,QAAQA,EAAE,QACrCA,EAAE,cAAc,KAAA,MAAW,EAAI,YAAYA,EAAE,YAC7CA,EAAE,mBAAgB,EAAI,iBAAiBA,EAAE,iBACzCA,EAAE,iBAAc,EAAI,eAAeA,EAAE,eAClCD;AACT;AAcA,SAAgBE,EACd,GACA,GACA,IAAuD,CAAC,GACtC;CAClB,IAAMD,IAAKE,KAAU,CAAC,GAClBC,IAAU,IACVC,IAAQ;CACZ,OAAO;EACL,OAAOJ,EAAE,SAASK;EAClB,WAAW,MAAQL,EAAE,SAASM,EAAI,EAAE,EAAE,SAASD;EAC/C,WAAWL,EAAE,aAAaO,EAAU,MAAM,MAAMC,EAAE,qBAAqB,EAAI;EAC3E,MAAM,GAAK;GACT,AAAIL,MACJ,IAAU,IACVH,EAAE,iBAAiB,CAAC,GAAGS,CAAG,CAAC;EAC7B;EACA,IAAI,GAAW;GACb,AAAKN,KAAW,OAChB,IAAQ,IACRH,EAAE,eAAeU,CAAS;EAC5B;CACF;AACF;AAIA,SAAgBC,EACd,GAKA,GACA,GACM;CACN,IAAIC,EAAU,WAAW;EACvB,EAAO,MAAM,gBAAgB;GAC3B,KAAK,IAAMC,KAAMP,GAAK,EAAG,MAAMQ,EAAO,OAAO;EAC/C,CAAC;EACD;CACF;CACA,IAAMC,IAAQH,EAAU,SAASN,CAAG;CACpC,AAAIQ,EAAO,WAAUA,EAAO,SAASR,GAAKS,CAAK,IAC1CD,EAAO,MAAM,WAAWR,GAAKS,GAAOD,EAAO,OAAO;AACzD;AAMA,SAAgBE,EACd,GACA,GACyB;CACzB,IAAIC;CACJ,KAAK,IAAMT,KAAKD,GAAW;EACzB,IAAMW,IAAIV,EAAE,QAAQW,GAAK,EAAE,UAAUF,MAAW,KAAA,EAAU,CAAC;EAC3D,AAAIA,MAAW,KAAA,KAAaC,MAAM,KAAA,MAAW,IAASA;CACxD;CACA,OAAOD;AACT;AAGA,SAAgBG,EACd,GACA,GACM;CACN,KAAK,IAAMZ,KAAKD,GAAW,EAAE,WAAWY,CAAG;AAC7C"}

package/dist/interactions/actions/lasso-select/behaviors/selectFromLasso.js

@@ -0,0 +1,39 @@
+import { createSetSelectionOp as e } from "../../../../core/ops/select.js";
+import { getScratch as t, scratchKey as n } from "@weasel-js/routing";
+//#region src/interactions/actions/lasso-select/behaviors/selectFromLasso.ts
+var r = n("lassoSelect.vertices"), i = 4;
+function a(n) {
+	let a = n?.mode ?? "intersect";
+	return {
+		defaultTransient: !0,
+		onEnd(n) {
+			let c = n.adapter;
+			if (!c.getSelection || !c.hitTestLasso) return null;
+			let l = t(n.scratch, r) ?? [], u = n.origin.get("gesture"), d = u ? u.shiftHeld === !0 : !1, f = c.getSelection();
+			if (l.length < 3 || o(l) < i) return [e({
+				from: f,
+				to: d ? f : []
+			})];
+			let p = c.hitTestLasso(l, a), m = d ? s(f, p) : p;
+			return [e({
+				from: f,
+				to: m
+			})];
+		}
+	};
+}
+function o(e) {
+	if (e.length === 0) return 0;
+	let t = Infinity, n = Infinity, r = -Infinity, i = -Infinity;
+	for (let a of e) a.x < t && (t = a.x), a.y < n && (n = a.y), a.x > r && (r = a.x), a.y > i && (i = a.y);
+	return (r - t) * (i - n);
+}
+function s(e, t) {
+	let n = [...e];
+	for (let e of t) n.includes(e) || n.push(e);
+	return n;
+}
+//#endregion
+export { r as LASSO_VERTICES, a as selectFromLasso };
+
+//# sourceMappingURL=selectFromLasso.js.map

package/dist/interactions/actions/lasso-select/behaviors/selectFromLasso.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectFromLasso.js","names":["LASSO_VERTICES","scratchKey","MIN_AREA","selectFromLasso","mode","opts","adapter","ctx","vertices","getScratch","startPose","shiftHeld","from","polygonAabbArea","createSetSelectionOp","hits","to","mergeUnique","minX","minY","maxX","maxY","v","out","a","id","b"],"sources":["../../../../../src/interactions/actions/lasso-select/behaviors/selectFromLasso.ts"],"sourcesContent":["import { createSetSelectionOp } from 'core/ops/select';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport type {\n  LassoHitMode,\n  LassoSelectAdapter,\n} from 'core/adapters/types';\nimport type { LassoSelectBehavior } from '../../../gestures/types';\nimport { scratchKey, getScratch } from '@weasel-js/routing';\n\n/** Typed scratch slot the lasso tool's gesture writes into for this behavior\n *  to consume. Shared identity: tools producing the polygon for a lasso\n *  selection write under this same key. */\nexport const LASSO_VERTICES = scratchKey<ReadonlyArray<{ x: number; y: number }>>('lassoSelect.vertices');\n\nconst MIN_AREA = 4;\n\n/** Options for `selectFromLasso`. */\nexport interface SelectFromLassoOptions {\n  /** Hit mode for `hitTestLasso`. Default 'intersect'. */\n  mode?: LassoHitMode;\n}\n\n/** A lasso behavior (`useLassoTool({ behaviors })`): replace selection with\n *  polygon hits in its own `mode`, or extend the existing selection when shift\n *  is held at gesture start. Tiny / degenerate lassos behave like a click —\n *  clear (or preserve, with shift). Hits come from the gesture adapter's\n *  `hitTestLasso`, which under `lassoSelectAction` is the `lassoSelect` dep. */\nexport function selectFromLasso(opts?: SelectFromLassoOptions): LassoSelectBehavior {\n  const mode: LassoHitMode = opts?.mode ?? 'intersect';\n  return {\n    defaultTransient: true,\n    onEnd(ctx) {\n      const adapter = ctx.adapter as unknown as LassoSelectAdapter;\n      if (!adapter.getSelection || !adapter.hitTestLasso) return null;\n\n      const vertices = getScratch(ctx.scratch, LASSO_VERTICES) ?? [];\n      const startPose = ctx.origin.get('gesture');\n      const shiftHeld = startPose ? (startPose as { shiftHeld?: boolean }).shiftHeld === true : false;\n      const from = adapter.getSelection();\n\n      // Tiny / degenerate lassos behave like a click: clear (or preserve on shift).\n      const tiny = vertices.length < 3 || polygonAabbArea(vertices) < MIN_AREA;\n      if (tiny) {\n        const to = shiftHeld ? from : [];\n        const op: Op = createSetSelectionOp({ from: from as NodeId[], to: to as NodeId[] });\n        return [op];\n      }\n\n      const hits = adapter.hitTestLasso(vertices, mode);\n      const to = shiftHeld\n        ? mergeUnique(from, hits)\n        : hits;\n      const op: Op = createSetSelectionOp({ from: from as NodeId[], to: to as NodeId[] });\n      return [op];\n    },\n  };\n}\n\nfunction polygonAabbArea(vertices: ReadonlyArray<{ x: number; y: number }>): number {\n  if (vertices.length === 0) return 0;\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (const v of vertices) {\n    if (v.x < minX) minX = v.x;\n    if (v.y < minY) minY = v.y;\n    if (v.x > maxX) maxX = v.x;\n    if (v.y > maxY) maxY = v.y;\n  }\n  return (maxX - minX) * (maxY - minY);\n}\n\nfunction mergeUnique(a: ReadonlyArray<string>, b: ReadonlyArray<string>): string[] {\n  const out = [...a];\n  for (const id of b) if (!out.includes(id)) out.push(id);\n  return out;\n}\n"],"mappings":";;;AAaA,IAAaA,IAAiBC,EAAoD,sBAAsB,GAElGC,IAAW;AAajB,SAAgBC,EAAgB,GAAoD;CAClF,IAAMC,IAAqBC,GAAM,QAAQ;CACzC,OAAO;EACL,kBAAkB;EAClB,MAAM,GAAK;GACT,IAAMC,IAAUC,EAAI;GACpB,IAAI,CAACD,EAAQ,gBAAgB,CAACA,EAAQ,cAAc,OAAO;GAE3D,IAAME,IAAWC,EAAWF,EAAI,SAASP,CAAc,KAAK,CAAC,GACvDU,IAAYH,EAAI,OAAO,IAAI,SAAS,GACpCI,IAAYD,IAAaA,EAAsC,cAAc,KAAO,IACpFE,IAAON,EAAQ,aAAa;GAIlC,IADaE,EAAS,SAAS,KAAKK,EAAgBL,CAAQ,IAAIN,GAI9D,OAAO,CADQY,EAAqB;IAAQ;IAAsB,IADvDH,IAAYC,IAAO,CAAC;GACkD,CACzE,CAAE;GAGZ,IAAMG,IAAOT,EAAQ,aAAaE,GAAUJ,CAAI,GAC1CY,IAAKL,IACPM,EAAYL,GAAMG,CAAI,IACtBA;GAEJ,OAAO,CADQD,EAAqB;IAAQ;IAAsB;GAAe,CACzE,CAAE;EACZ;CACF;AACF;AAEA,SAASD,EAAgB,GAA2D;CAClF,IAAIL,EAAS,WAAW,GAAG,OAAO;CAClC,IAAIU,IAAO,UAAUC,IAAO,UAAUC,IAAO,WAAWC,IAAO;CAC/D,KAAK,IAAMC,KAAKd,GAId,AAHIc,EAAE,IAAIJ,MAAM,IAAOI,EAAE,IACrBA,EAAE,IAAIH,MAAM,IAAOG,EAAE,IACrBA,EAAE,IAAIF,MAAM,IAAOE,EAAE,IACrBA,EAAE,IAAID,MAAM,IAAOC,EAAE;CAE3B,QAAQF,IAAOF,MAASG,IAAOF;AACjC;AAEA,SAASF,EAAY,GAA0B,GAAoC;CACjF,IAAMM,IAAM,CAAC,GAAGC,CAAC;CACjB,KAAK,IAAMC,KAAMC,GAAG,AAAKH,EAAI,SAASE,CAAE,KAAGF,EAAI,KAAKE,CAAE;CACtD,OAAOF;AACT"}

package/dist/interactions/actions/move/behaviors/snapBackOrDelete.js

@@ -0,0 +1,36 @@
+import { createDeleteOp as e } from "../../../../core/ops/delete.js";
+import { AUTO_ORIGIN_PROJECTION as t } from "../../../gestures/shared/originProjection.js";
+import { getScratch as n, scratchKey as r, setScratch as i } from "@weasel-js/routing";
+//#region src/interactions/actions/move/behaviors/snapBackOrDelete.ts
+var a = r("snapBackOrDelete.snapshots"), o = r("snapBackOrDelete.indexes");
+function s(r) {
+	let { radius: s, onFreeRelease: c, deleteLabel: l = "Delete" } = r, u = r.origin ?? t, d = s * s;
+	return {
+		onStart(e) {
+			let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = e.adapter.getNodes();
+			for (let i of e.draggedIds) {
+				let a = e.adapter.getNode(i) ?? { id: i };
+				t.set(i, a), n.set(i, r.findIndex((e) => e.id === i));
+			}
+			i(e.scratch, a, t), i(e.scratch, o, n);
+		},
+		onEnd(t) {
+			if (t.snap) return;
+			let r = t.draggedIds[0], i = u.getOrigin(t.origin.get(r)), s = u.getOrigin(t.current.get(r)), f = s.x - i.x, p = s.y - i.y;
+			if (f * f + p * p <= d) return null;
+			if (c === "delete") {
+				let i = n(t.scratch, a), s = n(t.scratch, o), c = i?.get(r) ?? { id: r }, u = s?.get(r) ?? -1;
+				return [e({
+					node: c,
+					label: l,
+					index: u
+				})];
+			}
+			return null;
+		}
+	};
+}
+//#endregion
+export { s as snapBackOrDelete };
+
+//# sourceMappingURL=snapBackOrDelete.js.map