@weasel-js/core 1.7.0 → 1.7.1

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

@@ -0,0 +1,27 @@
+//#region src/interactions/actions/defaults/selectAll.ts
+var e = {
+	id: "selectAll",
+	label: "Select All",
+	defaultBinding: {
+		kind: "key",
+		key: "a",
+		mods: { mod: !0 }
+	},
+	eligible: { capability: "creates-selection" },
+	requires: [
+		"scene",
+		"selection",
+		"view"
+	],
+	invoker: {
+		timing: "immediate",
+		run: (e) => {
+			let t = e.scene, n = e.view, r = new Set((t?.layers ?? []).filter((e) => !e.visible || e.locked === !0).map((e) => e.id)), i = !(r.size > 0 || n?.layerIsPainted !== void 0) || !t?.renderOrderNodes ? t?.renderOrder ? [...t.renderOrder()] : [] : t.renderOrderNodes().filter((e) => !r.has(e.layer) && n?.layerIsPainted?.(e.layer) !== !1 && t.isLocked?.(e.id) !== !0).map((e) => e.id);
+			i.length !== 0 && e.selection?.set(i);
+		}
+	}
+};
+//#endregion
+export { e as selectAllAction };
+
+//# sourceMappingURL=selectAll.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectAll.js","names":["selectAllAction","scene","deps","view","skipped","l","all","n"],"sources":["../../../../src/interactions/actions/defaults/selectAll.ts"],"sourcesContent":["import type { NodeId } from 'core/scene/types';\nimport type { Action } from '@weasel-js/routing';\n\n/** The slice of a scene this action reads. Structural, so a consumer store\n *  that answers these is a valid `scene` dep without being a `Scene`. */\ninterface SelectAllScene {\n  renderOrder?: () => Iterable<NodeId>;\n  renderOrderNodes?: () => readonly { id: NodeId; layer: string }[];\n  layers?: readonly { id: string; visible: boolean; locked?: boolean }[];\n  /** Consulted when present; a store without it is judged by layer alone. */\n  isLocked?: (id: NodeId) => boolean;\n}\n\n/**\n * @experimental\n * Static descriptor for the `selectAll` Action. Selects every scene node the\n * user can see and reach — nodes on a hidden or locked layer, or on a layer\n * the asking view does not paint, are left out, so Cmd+A then Delete cannot\n * take content that is off screen or locked.\n */\nexport const selectAllAction: Action & { requires: string[] } = {\n  id: 'selectAll',\n  label: 'Select All',\n  defaultBinding: { kind: 'key', key: 'a', mods: { mod: true } },\n  eligible: { capability: 'creates-selection' },\n  requires: ['scene', 'selection', 'view'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      const scene = deps.scene as SelectAllScene | undefined;\n      const view = deps.view as { layerIsPainted?(layerId: string): boolean } | undefined;\n      const skipped = new Set(\n        (scene?.layers ?? []).filter((l) => !l.visible || l.locked === true).map((l) => l.id),\n      );\n      // Scene exposes `renderOrder()` (bottom→top iterable of NodeIds), not\n      // the never-implemented `listAll()`. The node walk is the same sequence\n      // and carries the layer each id sits on, which the id walk cannot.\n      const filtered = skipped.size > 0 || view?.layerIsPainted !== undefined;\n      const all: NodeId[] = !filtered || !scene?.renderOrderNodes\n        ? (scene?.renderOrder ? [...scene.renderOrder()] : [])\n        : scene.renderOrderNodes()\n          .filter((n) => !skipped.has(n.layer)\n            && view?.layerIsPainted?.(n.layer) !== false\n            && scene.isLocked?.(n.id) !== true)\n          .map((n) => n.id);\n      if (all.length === 0) return;\n      (deps.selection as { set(ids: NodeId[]): void } | undefined)?.set(all);\n    },\n  },\n};\n"],"mappings":";AAoBA,IAAaA,IAAmD;CAC9D,IAAI;CACJ,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAO,KAAK;EAAK,MAAM,EAAE,KAAK,GAAK;CAAE;CAC7D,UAAU,EAAE,YAAY,oBAAoB;CAC5C,UAAU;EAAC;EAAS;EAAa;CAAM;CACvC,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,IAAMC,IAAQC,EAAK,OACbC,IAAOD,EAAK,MACZE,IAAU,IAAI,KACjBH,GAAO,UAAU,CAAC,EAAA,CAAG,QAAQ,MAAM,CAACI,EAAE,WAAWA,EAAE,WAAW,EAAI,CAAC,CAAC,KAAK,MAAMA,EAAE,EAAE,CACtF,GAKMC,IAAgB,EADLF,EAAQ,OAAO,KAAKD,GAAM,mBAAmB,KAAA,MAC3B,CAACF,GAAO,mBACtCA,GAAO,cAAc,CAAC,GAAGA,EAAM,YAAY,CAAC,IAAI,CAAC,IAClDA,EAAM,iBAAiB,CAAC,CACvB,QAAQ,MAAM,CAACG,EAAQ,IAAIG,EAAE,KAAK,KAC9BJ,GAAM,iBAAiBI,EAAE,KAAK,MAAM,MACpCN,EAAM,WAAWM,EAAE,EAAE,MAAM,EAAI,CAAC,CACpC,KAAK,MAAMA,EAAE,EAAE;GACpB,AAAID,EAAI,WAAW,KACnBJ,EAAM,WAAwD,IAAII,CAAG;EACvE;CACF;AACF"}

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

@@ -0,0 +1,27 @@
+import { createPaintAction as e } from "./createPaintAction.js";
+import { DEFAULT_FILL_COLOR as t, paintWithColor as n } from "../../../util/paint.js";
+//#region src/interactions/actions/defaults/setFill.ts
+var r = e({
+	id: "setFill",
+	label: "Set fill",
+	dataKey: "fill",
+	initialState: (e) => ({
+		color: e("color") ?? t,
+		paint: e("paint")
+	}),
+	readParams: (e, t) => {
+		let n = t?.color, r = t?.paint;
+		return n === void 0 && r === void 0 ? null : n === void 0 ? {
+			...e,
+			paint: r
+		} : {
+			color: n,
+			paint: r
+		};
+	},
+	merge: (e, t) => t.paint === void 0 ? n(e ?? void 0, t.color) : t.paint
+});
+//#endregion
+export { r as setFillAction };
+
+//# sourceMappingURL=setFill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setFill.js","names":["setFillAction","createPaintAction","pick","DEFAULT_FILL_COLOR","color","params","paint","prev","state","paintWithColor"],"sources":["../../../../src/interactions/actions/defaults/setFill.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { FillStyle } from '@weasel-js/paint';\nimport { createPaintAction } from './createPaintAction';\nimport { paintWithColor, DEFAULT_FILL_COLOR } from '../../../util/paint';\n\n/** `setFill`'s gesture state. A `paint` shadows the color until a later color\n *  supersedes it. */\ninterface SetFillState {\n  /** May be 6- or 8-char hex. Ignored while `paint` is set. */\n  color: string;\n  /** `null` is an explicit no-fill, distinct from `undefined`, which means\n   *  this gesture carries no paint and the color applies. */\n  paint?: FillStyle | null;\n}\n\n/**\n * Static descriptor for the `setFill` Action.\n *\n * Takes either `color` (a hex string) or `paint` (a whole `FillStyle`, for\n * gradients and patterns). `paint` wins when both are present.\n *\n * Alpha semantics: alpha lives on the paint's `opacity`. A 6-char (no-alpha)\n * color adopts the alpha of the node's existing paint; an 8-char color states\n * its own. A `paint` is written verbatim.\n */\nexport const setFillAction: Action & { requires: string[] } = createPaintAction<\n  SetFillState,\n  FillStyle,\n  'fill'\n>({\n  id: 'setFill',\n  label: 'Set fill',\n  dataKey: 'fill',\n  initialState: (pick) => ({\n    color: pick<string>('color') ?? DEFAULT_FILL_COLOR,\n    paint: pick<FillStyle | null>('paint'),\n  }),\n  readParams: (prev, params) => {\n    const color = params?.color as string | undefined;\n    const paint = params?.paint as FillStyle | null | undefined;\n    if (color === undefined && paint === undefined) return null;\n    if (color === undefined) return { ...prev, paint };\n    // An explicit color supersedes a paint from an earlier tick; otherwise a\n    // picker drag after a gradient would do nothing.\n    return { color, paint };\n  },\n  // `??` would read an explicit no-fill as \"no paint given\" and repaint the\n  // node with the state's color, so absence has to be tested for.\n  merge: (prev, state) => (state.paint !== undefined\n    ? state.paint\n    : paintWithColor(prev ?? undefined, state.color)),\n});\n"],"mappings":";;;AAyBA,IAAaA,IAAiDC,EAI5D;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,OAAU;EACvB,OAAOC,EAAa,OAAO,KAAKC;EAChC,OAAOD,EAAuB,OAAO;CACvC;CACA,aAAa,GAAM,MAAW;EAC5B,IAAME,IAAQC,GAAQ,OAChBC,IAAQD,GAAQ;EAKtB,OAJID,MAAU,KAAA,KAAaE,MAAU,KAAA,IAAkB,OACnDF,MAAU,KAAA,IAAkB;GAAE,GAAGG;GAAM;EAAM,IAG1C;GAAE;GAAO;EAAM;CACxB;CAGA,QAAQ,GAAM,MAAWC,EAAM,UAAU,KAAA,IAErCC,EAAeF,KAAQ,KAAA,GAAWC,EAAM,KAAK,IAD7CA,EAAM;AAEZ,CAAC"}

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

@@ -0,0 +1,15 @@
+import { createPaintAction as e } from "./createPaintAction.js";
+import { DEFAULT_FILL_COLOR as t, paintWithAlpha as n, solid as r } from "../../../util/paint.js";
+//#region src/interactions/actions/defaults/setFillOpacity.ts
+var i = e({
+	id: "setFillOpacity",
+	label: "Set fill opacity",
+	dataKey: "fill",
+	initialState: (e) => e("alpha01") ?? 1,
+	readParams: (e, t) => t?.alpha01 ?? null,
+	merge: (e, i) => n(e ?? r(t), i)
+});
+//#endregion
+export { i as setFillOpacityAction };
+
+//# sourceMappingURL=setFillOpacity.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setFillOpacity.js","names":["setFillOpacityAction","createPaintAction","pick","params","paintWithAlpha","prev","solid","DEFAULT_FILL_COLOR","alpha01"],"sources":["../../../../src/interactions/actions/defaults/setFillOpacity.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { FillStyle } from '@weasel-js/paint';\nimport { createPaintAction } from './createPaintAction';\nimport { paintWithAlpha, solid, DEFAULT_FILL_COLOR } from '../../../util/paint';\n\n/**\n * Static descriptor for the `setFillOpacity` Action.\n *\n * `params.alpha01` (0..1) becomes each node's fill paint `opacity`, leaving\n * the rest of the paint — color, gradient stops, pattern — alone. That is the\n * one alpha slot a gradient or a pattern has, so it is the slot all of them\n * use. A node with no fill yet takes the kit's default one.\n */\nexport const setFillOpacityAction: Action & { requires: string[] } = createPaintAction<\n  number,\n  FillStyle,\n  'fill'\n>({\n  id: 'setFillOpacity',\n  label: 'Set fill opacity',\n  dataKey: 'fill',\n  initialState: (pick) => pick<number>('alpha01') ?? 1,\n  readParams: (_prev, params) => (params?.alpha01 as number | undefined) ?? null,\n  merge: (prev, alpha01) => paintWithAlpha(prev ?? solid(DEFAULT_FILL_COLOR), alpha01),\n});\n"],"mappings":";;;AAaA,IAAaA,IAAwDC,EAInE;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,MAASC,EAAa,SAAS,KAAK;CACnD,aAAa,GAAO,MAAYC,GAAQ,WAAkC;CAC1E,QAAQ,GAAM,MAAYC,EAAeC,KAAQC,EAAMC,CAAkB,GAAGC,CAAO;AACrF,CAAC"}

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

@@ -0,0 +1,36 @@
+import { createPaintAction as e } from "./createPaintAction.js";
+import { DEFAULT_STROKE_COLOR as t, paintWithColor as n, strokeOf as r, strokeWith as i } from "../../../util/paint.js";
+//#region src/interactions/actions/defaults/setStroke.ts
+function a(e, t) {
+	return t.paint === null ? null : t.paint ? e ? {
+		...e,
+		paint: t.paint
+	} : i(t.paint) : e ? {
+		...e,
+		paint: n(e.paint, t.color)
+	} : r(t.color);
+}
+var o = e({
+	id: "setStroke",
+	label: "Set stroke",
+	dataKey: "stroke",
+	initialState: (e) => ({
+		color: e("color") ?? t,
+		paint: e("paint")
+	}),
+	readParams: (e, t) => {
+		let n = t?.color, r = t?.paint;
+		return n === void 0 && r === void 0 ? null : n === void 0 ? {
+			...e,
+			paint: r
+		} : {
+			color: n,
+			paint: r
+		};
+	},
+	merge: a
+});
+//#endregion
+export { o as setStrokeAction };
+
+//# sourceMappingURL=setStroke.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setStroke.js","names":["repaint","state","prev","strokeWith","paintWithColor","strokeOf","setStrokeAction","createPaintAction","pick","DEFAULT_STROKE_COLOR","color","params","paint"],"sources":["../../../../src/interactions/actions/defaults/setStroke.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\nimport { createPaintAction } from './createPaintAction';\nimport { paintWithColor, strokeOf, strokeWith, DEFAULT_STROKE_COLOR } from '../../../util/paint';\n\n/** `setStroke`'s gesture state — `setFill`'s, against a stroke. */\ninterface SetStrokeState {\n  /** May be 6- or 8-char hex. Ignored while `paint` is set. */\n  color: string;\n  /** `null` is an explicit no-stroke, distinct from `undefined`, which means\n   *  this gesture carries no paint and the color applies. */\n  paint?: FillStyle | null;\n}\n\n/** Repaint a node's stroke, keeping its width, cap, join, dash and align, so\n *  picking a paint does not discard the rest of the stroke. A node with no\n *  stroke yet gets a hairline one. */\nfunction repaint(prev: Stroke | null | undefined, state: SetStrokeState): Stroke | null {\n  // A stroke whose paint is none paints nothing, so the whole stroke goes\n  // rather than being kept as a widthful thing that draws no ink.\n  if (state.paint === null) return null;\n  if (state.paint) return prev ? { ...prev, paint: state.paint } : strokeWith(state.paint);\n  if (!prev) return strokeOf(state.color);\n  return { ...prev, paint: paintWithColor(prev.paint, state.color) };\n}\n\n/**\n * Static descriptor for the `setStroke` Action.\n *\n * Takes either `color` (a hex string) or `paint` (a whole `FillStyle`, for\n * gradients and patterns). `paint` wins when both are present. A stroke's\n * width, cap, join, dash and align survive either.\n *\n * Alpha semantics: alpha lives on the stroke paint's `opacity`. A 6-char\n * (no-alpha) color adopts the alpha of the node's existing stroke paint; an\n * 8-char color states its own. A `paint` is written verbatim.\n */\nexport const setStrokeAction: Action & { requires: string[] } = createPaintAction<\n  SetStrokeState,\n  Stroke,\n  'stroke'\n>({\n  id: 'setStroke',\n  label: 'Set stroke',\n  dataKey: 'stroke',\n  initialState: (pick) => ({\n    color: pick<string>('color') ?? DEFAULT_STROKE_COLOR,\n    paint: pick<FillStyle | null>('paint'),\n  }),\n  readParams: (prev, params) => {\n    const color = params?.color as string | undefined;\n    const paint = params?.paint as FillStyle | null | undefined;\n    if (color === undefined && paint === undefined) return null;\n    if (color === undefined) return { ...prev, paint };\n    // An explicit color supersedes a paint from an earlier tick; otherwise a\n    // picker drag after a gradient would do nothing.\n    return { color, paint };\n  },\n  merge: repaint,\n});\n"],"mappings":";;;AAiBA,SAASA,EAAQ,GAAiC,GAAsC;CAMtF,OAHIC,EAAM,UAAU,OAAa,OAC7BA,EAAM,QAAcC,IAAO;EAAE,GAAGA;EAAM,OAAOD,EAAM;CAAM,IAAIE,EAAWF,EAAM,KAAK,IAClFC,IACE;EAAE,GAAGA;EAAM,OAAOE,EAAeF,EAAK,OAAOD,EAAM,KAAK;CAAE,IAD/CI,EAASJ,EAAM,KAAK;AAExC;AAaA,IAAaK,IAAmDC,EAI9D;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,OAAU;EACvB,OAAOC,EAAa,OAAO,KAAKC;EAChC,OAAOD,EAAuB,OAAO;CACvC;CACA,aAAa,GAAM,MAAW;EAC5B,IAAME,IAAQC,GAAQ,OAChBC,IAAQD,GAAQ;EAKtB,OAJID,MAAU,KAAA,KAAaE,MAAU,KAAA,IAAkB,OACnDF,MAAU,KAAA,IAAkB;GAAE,GAAGR;GAAM;EAAM,IAG1C;GAAE;GAAO;EAAM;CACxB;CACA,OAAOF;AACT,CAAC"}

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

@@ -0,0 +1,21 @@
+import { createPaintAction as e } from "./createPaintAction.js";
+import { DEFAULT_STROKE_COLOR as t, paintWithAlpha as n, solid as r, strokeOf as i } from "../../../util/paint.js";
+//#region src/interactions/actions/defaults/setStrokeOpacity.ts
+var a = e({
+	id: "setStrokeOpacity",
+	label: "Set stroke opacity",
+	dataKey: "stroke",
+	initialState: (e) => e("alpha01") ?? 1,
+	readParams: (e, t) => t?.alpha01 ?? null,
+	merge: (e, a) => {
+		let o = e ?? i(t);
+		return {
+			...o,
+			paint: n(o.paint ?? r(t), a)
+		};
+	}
+});
+//#endregion
+export { a as setStrokeOpacityAction };
+
+//# sourceMappingURL=setStrokeOpacity.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setStrokeOpacity.js","names":["setStrokeOpacityAction","createPaintAction","pick","params","base","prev","strokeOf","DEFAULT_STROKE_COLOR","paintWithAlpha","solid","alpha01"],"sources":["../../../../src/interactions/actions/defaults/setStrokeOpacity.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { Stroke } from '@weasel-js/paint';\nimport { createPaintAction } from './createPaintAction';\nimport { paintWithAlpha, solid, strokeOf, DEFAULT_STROKE_COLOR } from '../../../util/paint';\n\n/**\n * Static descriptor for the `setStrokeOpacity` Action.\n *\n * `params.alpha01` (0..1) becomes each node's stroke paint `opacity`, leaving\n * the rest of the stroke — color, width, cap, join, dash — alone. A node with\n * no stroke yet gets a hairline one.\n */\nexport const setStrokeOpacityAction: Action & { requires: string[] } = createPaintAction<\n  number,\n  Stroke,\n  'stroke'\n>({\n  id: 'setStrokeOpacity',\n  label: 'Set stroke opacity',\n  dataKey: 'stroke',\n  initialState: (pick) => pick<number>('alpha01') ?? 1,\n  readParams: (_prev, params) => (params?.alpha01 as number | undefined) ?? null,\n  merge: (prev, alpha01) => {\n    const base = prev ?? strokeOf(DEFAULT_STROKE_COLOR);\n    // A stroke with no paint has no opacity to set; seed the same default\n    // colour a strokeless node gets, keeping the width and joins it has.\n    return { ...base, paint: paintWithAlpha(base.paint ?? solid(DEFAULT_STROKE_COLOR), alpha01) };\n  },\n});\n"],"mappings":";;;AAYA,IAAaA,IAA0DC,EAIrE;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,MAASC,EAAa,SAAS,KAAK;CACnD,aAAa,GAAO,MAAYC,GAAQ,WAAkC;CAC1E,QAAQ,GAAM,MAAY;EACxB,IAAMC,IAAOC,KAAQC,EAASC,CAAoB;EAGlD,OAAO;GAAE,GAAGH;GAAM,OAAOI,EAAeJ,EAAK,SAASK,EAAMF,CAAoB,GAAGG,CAAO;EAAE;CAC9F;AACF,CAAC"}

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

@@ -0,0 +1,39 @@
+import { ActionDisabledReason as e, resolveParams as t } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/slice.ts
+var n = {
+	id: "slice",
+	label: "Slice",
+	group: "edit",
+	eligible: { capability: "edits-page" },
+	requires: ["slice"],
+	invoker: {
+		timing: "ongoing",
+		start(e, n) {
+			let r = e.deps.slice, i = e.drag?.start ?? e.world, a = e.drag?.current ?? e.world, o, s = !0, c = () => t(n?.params)?.cut === "freehand", l = () => c() && o && o.length >= 2 ? o.map((e) => ({
+				x: e.x,
+				y: e.y
+			})) : [i, a];
+			return {
+				kind: "slice",
+				onMove(e) {
+					a = e.drag?.current ?? e.world, o = e.drag?.points;
+				},
+				overlay() {
+					return s ? {
+						kind: "polyline",
+						points: l(),
+						role: "cut"
+					} : null;
+				},
+				onEnd(e, t) {
+					s = !1, t !== "cancel" && r && (a = e.drag?.current ?? e.world, o = e.drag?.points ?? o, r.commit(l()));
+				}
+			};
+		}
+	},
+	enabled: (t) => t?.slice ? !0 : e.NotApplicable
+};
+//#endregion
+export { n as sliceAction };
+
+//# sourceMappingURL=slice.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slice.js","names":["sliceAction","dep","ctx","\"slice\"","a","current","trail","open","freehand","resolveParams","opts","\"cut\"","cut","p","moveCtx","reason","endCtx","deps","ActionDisabledReason"],"sources":["../../../../src/interactions/actions/defaults/slice.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { SliceDep } from '../depSchema';\nimport { ActionDisabledReason, resolveParams } from '@weasel-js/routing';\nimport type { BindingOpts, InvocationCtx, OngoingHandle, OngoingOverlay, Point2 } from '@weasel-js/routing';\n\n/**\n * @experimental\n * Static descriptor for the `slice` Action.\n *\n * Ongoing drag invoker: tracks the cut while the gesture is in flight,\n * publishes it as a `'cut'` overlay, and on commit hands it to\n * `SliceDep.commit(cut)`. No-ops gracefully when the `slice` dep is absent.\n *\n * The cut is a straight line from drag start to the pointer by default. With\n * the binding param `cut: 'freehand'` it is the whole drag trail instead.\n */\nexport const sliceAction: Action & { requires: string[] } = {\n  id: 'slice',\n  label: 'Slice',\n  group: 'edit',\n  eligible: { capability: 'edits-page' },\n  requires: ['slice'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const dep = ctx.deps['slice'] as SliceDep | undefined;\n      const a: Point2 = ctx.drag?.start ?? ctx.world;\n      let current: Point2 = ctx.drag?.current ?? ctx.world;\n      let trail: ReadonlyArray<Point2> | undefined;\n      let open = true;\n\n      const freehand = () => resolveParams(opts?.params)?.['cut'] === 'freehand';\n      const cut = (): Point2[] =>\n        freehand() && trail && trail.length >= 2\n          ? trail.map((p) => ({ x: p.x, y: p.y }))\n          : [a, current];\n\n      return {\n        kind: 'slice',\n        onMove(moveCtx: InvocationCtx): void {\n          current = moveCtx.drag?.current ?? moveCtx.world;\n          trail = moveCtx.drag?.points;\n        },\n        overlay(): OngoingOverlay | null {\n          if (!open) return null;\n          return { kind: 'polyline', points: cut(), role: 'cut' };\n        },\n        onEnd(endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          open = false;\n          if (reason === 'cancel' || !dep) return;\n          current = endCtx.drag?.current ?? endCtx.world;\n          trail = endCtx.drag?.points ?? trail;\n          dep.commit(cut());\n        },\n      };\n    },\n  },\n  // Slice can only act when a `slice` dep is wired (its `onEnd` no-ops\n  // otherwise), so reflect dep presence for any UI reading action-enabled\n  // state. The dispatcher still self-guards via the empty-handle path.\n  enabled: (deps) => (deps?.['slice'] ? true : ActionDisabledReason.NotApplicable),\n};\n"],"mappings":";;AAgBA,IAAaA,IAA+C;CAC1D,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,aAAa;CACrC,UAAU,CAAC,OAAO;CAClB,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAmC;GAC3D,IAAMC,IAAMC,EAAI,KAAKC,OACfC,IAAYF,EAAI,MAAM,SAASA,EAAI,OACrCG,IAAkBH,EAAI,MAAM,WAAWA,EAAI,OAC3CI,GACAC,IAAO,IAELC,UAAiBC,EAAcC,GAAM,MAAM,CAAC,EAAGC,QAAW,YAC1DC,UACJJ,EAAS,KAAKF,KAASA,EAAM,UAAU,IACnCA,EAAM,KAAK,OAAO;IAAE,GAAGO,EAAE;IAAG,GAAGA,EAAE;GAAE,EAAE,IACrC,CAACT,GAAGC,CAAO;GAEjB,OAAO;IACL,MAAM;IACN,OAAO,GAA8B;KAEnC,AADA,IAAUS,EAAQ,MAAM,WAAWA,EAAQ,OAC3C,IAAQA,EAAQ,MAAM;IACxB;IACA,UAAiC;KAE/B,OADKP,IACE;MAAE,MAAM;MAAY,QAAQK,EAAI;MAAG,MAAM;KAAM,IADpC;IAEpB;IACA,MAAM,GAAuB,GAAmC;KAE9D,AADA,IAAO,IACHG,MAAW,YAAad,MAC5B,IAAUe,EAAO,MAAM,WAAWA,EAAO,OACzC,IAAQA,EAAO,MAAM,UAAUV,GAC/BL,EAAI,OAAOW,EAAI,CAAC;IAClB;GACF;EACF;CACF;CAIA,UAAU,MAAUK,GAAOd,QAAW,KAAOe,EAAqB;AACpE"}

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

@@ -0,0 +1,60 @@
+import { createDeleteOp as e } from "../../../core/ops/delete.js";
+import { createInsertOp as t } from "../../../core/ops/create.js";
+import { pathToAnchors as n } from "../../../features/paths/anchors.js";
+import { boundsOfPath as r } from "@weasel-js/geom";
+import { snipPathByPolyline as i, splitPathByPolyline as a } from "@weasel-js/geom/booleans";
+//#region src/interactions/actions/defaults/sliceOps.ts
+function o(n) {
+	let { cut: o, nextId: l, selection: u } = n, d = n.placePiece ?? ((e, t) => ({
+		pose: s(e.node.pose, r(t)),
+		path: t
+	})), f = [], p = new Set(u ?? []), m = /* @__PURE__ */ new Set(), h = [], g = n.leaves.map((e, t) => ({
+		leaf: e,
+		i: t
+	})).sort((e, t) => t.leaf.index - e.leaf.index || e.i - t.i);
+	for (let { leaf: n } of g) {
+		let r = c(n.worldPath) ? i(n.worldPath, o) : a(n.worldPath, o);
+		if (!r) continue;
+		let s = n.node.id;
+		m.add(s), f.push(e({
+			node: n.node,
+			index: n.index,
+			label: "Slice"
+		}));
+		for (let e of r) {
+			let r = d(n, e), i = {
+				...n.node,
+				id: l(),
+				pose: r.pose,
+				data: {
+					...n.node.data,
+					path: r.path
+				}
+			};
+			f.push(t({
+				node: i,
+				index: n.index,
+				label: "Slice"
+			})), p.has(s) && h.push(i.id);
+		}
+	}
+	return {
+		ops: f,
+		nextSelection: u && m.size > 0 ? [...u.filter((e) => !m.has(e)), ...h] : null
+	};
+}
+function s(e, t) {
+	let n = e && typeof e == "object" ? { ...e } : {};
+	return delete n.rotation, {
+		...n,
+		x: t.x,
+		y: t.y,
+		width: t.width,
+		height: t.height
+	};
+}
+var c = (e) => e.kind === "polygon" && n(e).closed.some((e) => !e);
+//#endregion
+export { o as computeSliceOps };
+
+//# sourceMappingURL=sliceOps.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sliceOps.js","names":["computeSliceOps","args","placePiece","piecePose","leaf","boundsOfPath","piece","ops","selected","selection","cutIds","inherited","ordered","b","a","pieces","hasOpenSubpath","snipPathByPolyline","cut","splitPathByPolyline","sourceId","createDeleteOp","stored","node","nextId","createInsertOp","id","rest","source","\"rotation\"","path","pathToAnchors","closed"],"sources":["../../../../src/interactions/actions/defaults/sliceOps.ts"],"sourcesContent":["import { boundsOfPath, type Path } from '@weasel-js/geom';\nimport { splitPathByPolyline, snipPathByPolyline } from '@weasel-js/geom/booleans';\nimport { pathToAnchors } from 'features/paths/anchors';\nimport type { Op } from 'core/ops/types';\nimport { createDeleteOp } from 'core/ops/delete';\nimport { createInsertOp } from 'core/ops/create';\n\n/** The fields a slice reads from and writes to a node. */\nexport interface SliceableNode {\n  id: string;\n  pose: unknown;\n  data: unknown;\n}\n\n/** One scene leaf a cut is tested against. */\nexport interface SliceLeaf<TNode extends SliceableNode = SliceableNode> {\n  /** The whole node, which the delete op carries so undo restores it intact. */\n  node: TNode;\n  /** Its ordinal among its siblings: where the delete's undo puts it back,\n   *  and where its pieces go in. */\n  index: number;\n  /** Its path with every pose above it baked in: the space the cut is in. */\n  worldPath: Path;\n}\n\ninterface SliceBounds {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Arguments to {@link computeSliceOps}. */\nexport interface ComputeSliceOpsArgs<TNode extends SliceableNode = SliceableNode> {\n  leaves: readonly SliceLeaf<TNode>[];\n  /** The cut, a polyline in world space. A last point equal to the first\n   *  closes it into a loop. */\n  cut: ReadonlyArray<{ x: number; y: number }>;\n  /** Mints the id of each piece. */\n  nextId: () => string;\n  /** The selection before the cut. Given, the result carries the selection\n   *  after it; omitted, `nextSelection` is `null`. */\n  selection?: readonly string[];\n  /** How a piece, cut in world space, is stored on its node. By default the\n   *  pose is the source's with the piece's bounds and no rotation, and the\n   *  path is the world piece itself, so any rotation is baked into it. A\n   *  scene with rotated poses or parent frames maps the piece back into the\n   *  node's own frame here. */\n  placePiece?: (leaf: SliceLeaf<TNode>, piece: Path) => SlicePiece;\n}\n\n/** One piece as it is stored: the node's pose and its `data.path`. */\nexport interface SlicePiece {\n  pose: unknown;\n  path: Path;\n}\n\n/** Result of {@link computeSliceOps}. */\nexport interface ComputeSliceResult {\n  /** A delete per cut leaf followed by an insert per piece, as one batch. */\n  ops: Op[];\n  /**\n   * The selection after the cut: the cut sources dropped, the pieces of each\n   * selected one added, everything else kept. `null` when no selection was\n   * given or nothing was cut. It is not an op, so the caller sets it after\n   * the batch commits; undo restores the one before either way.\n   */\n  nextSelection: string[] | null;\n}\n\n/**\n * Cut `leaves` along `cut` and return the ops that swap each crossed leaf for\n * its pieces.\n *\n * A path with an open subpath is snipped along its stroke\n * (`snipPathByPolyline`); a closed one is knifed into closed pieces\n * (`splitPathByPolyline`), which is also where a closed loop cuts out the\n * region it encloses. Each piece copies its source's node with the piece as\n * `data.path` and a fresh id. Leaves the cut misses produce nothing.\n */\nexport function computeSliceOps<TNode extends SliceableNode>(\n  args: ComputeSliceOpsArgs<TNode>,\n): ComputeSliceResult {\n  const { cut, nextId, selection } = args;\n  const placePiece = args.placePiece\n    ?? ((leaf: SliceLeaf<TNode>, piece: Path): SlicePiece => ({ pose: piecePose(leaf.node.pose, boundsOfPath(piece)), path: piece }));\n  const ops: Op[] = [];\n  const selected = new Set(selection ?? []);\n  const cutIds = new Set<string>();\n  const inherited: string[] = [];\n\n  // Highest slot first: swapping a leaf changes how many siblings sit below\n  // the next one only when the next one is above it.\n  const ordered = args.leaves.map((leaf, i) => ({ leaf, i })).sort((a, b) => b.leaf.index - a.leaf.index || a.i - b.i);\n\n  for (const { leaf } of ordered) {\n    const pieces = hasOpenSubpath(leaf.worldPath)\n      ? snipPathByPolyline(leaf.worldPath, cut)\n      : splitPathByPolyline(leaf.worldPath, cut);\n    if (!pieces) continue;\n\n    const sourceId = leaf.node.id;\n    cutIds.add(sourceId);\n    ops.push(createDeleteOp({ node: leaf.node, index: leaf.index, label: 'Slice' }));\n    for (const piece of pieces) {\n      const stored = placePiece(leaf, piece);\n      const node = {\n        ...leaf.node,\n        id: nextId(),\n        pose: stored.pose,\n        data: { ...(leaf.node.data as object), path: stored.path },\n      };\n      ops.push(createInsertOp({ node, index: leaf.index, label: 'Slice' }));\n      if (selected.has(sourceId)) inherited.push(node.id);\n    }\n  }\n\n  const nextSelection = selection && cutIds.size > 0\n    ? [...selection.filter((id) => !cutIds.has(id)), ...inherited]\n    : null;\n  return { ops, nextSelection };\n}\n\nfunction piecePose(source: unknown, b: SliceBounds): SliceBounds {\n  const rest = source && typeof source === 'object' ? { ...(source as Record<string, unknown>) } : {};\n  delete rest['rotation'];\n  return { ...rest, x: b.x, y: b.y, width: b.width, height: b.height };\n}\n\nconst hasOpenSubpath = (path: Path): boolean =>\n  path.kind === 'polygon' && pathToAnchors(path).closed.some((closed) => !closed);\n"],"mappings":";;;;;;AAgFA,SAAgBA,EACd,GACoB;CACpB,IAAM,EAAE,QAAK,WAAQ,iBAAcC,GAC7BC,IAAaD,EAAK,gBACjB,GAAwB,OAA6B;EAAE,MAAME,EAAUC,EAAK,KAAK,MAAMC,EAAaC,CAAK,CAAC;EAAG,MAAMA;CAAM,KAC1HC,IAAY,CAAC,GACbC,IAAW,IAAI,IAAIC,KAAa,CAAC,CAAC,GAClCC,oBAAS,IAAI,IAAY,GACzBC,IAAsB,CAAC,GAIvBC,IAAUX,EAAK,OAAO,KAAK,GAAM,OAAO;EAAE;EAAM;CAAE,EAAE,CAAC,CAAC,MAAM,GAAG,MAAMY,EAAE,KAAK,QAAQC,EAAE,KAAK,SAASA,EAAE,IAAID,EAAE,CAAC;CAEnH,KAAK,IAAM,EAAE,aAAUD,GAAS;EAC9B,IAAMG,IAASC,EAAeZ,EAAK,SAAS,IACxCa,EAAmBb,EAAK,WAAWc,CAAG,IACtCC,EAAoBf,EAAK,WAAWc,CAAG;EAC3C,IAAI,CAACH,GAAQ;EAEb,IAAMK,IAAWhB,EAAK,KAAK;EAE3B,AADAM,EAAO,IAAIU,CAAQ,GACnBb,EAAI,KAAKc,EAAe;GAAE,MAAMjB,EAAK;GAAM,OAAOA,EAAK;GAAO,OAAO;EAAQ,CAAC,CAAC;EAC/E,KAAK,IAAME,KAASS,GAAQ;GAC1B,IAAMO,IAASpB,EAAWE,GAAME,CAAK,GAC/BiB,IAAO;IACX,GAAGnB,EAAK;IACR,IAAIoB,EAAO;IACX,MAAMF,EAAO;IACb,MAAM;KAAE,GAAIlB,EAAK,KAAK;KAAiB,MAAMkB,EAAO;IAAK;GAC3D;GAEA,AADAf,EAAI,KAAKkB,EAAe;IAAE;IAAM,OAAOrB,EAAK;IAAO,OAAO;GAAQ,CAAC,CAAC,GAChEI,EAAS,IAAIY,CAAQ,KAAGT,EAAU,KAAKY,EAAK,EAAE;EACpD;CACF;CAKA,OAAO;EAAE;EAAK,eAHQd,KAAaC,EAAO,OAAO,IAC7C,CAAC,GAAGD,EAAU,QAAQ,MAAO,CAACC,EAAO,IAAIgB,CAAE,CAAC,GAAG,GAAGf,CAAS,IAC3D;CACwB;AAC9B;AAEA,SAASR,EAAU,GAAiB,GAA6B;CAC/D,IAAMwB,IAAOC,KAAU,OAAOA,KAAW,WAAW,EAAE,GAAIA,EAAmC,IAAI,CAAC;CAElG,OADA,OAAOD,EAAKE,UACL;EAAE,GAAGF;EAAM,GAAGd,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;AACrE;AAEA,IAAMG,KAAkB,MACtBc,EAAK,SAAS,aAAaC,EAAcD,CAAI,CAAC,CAAC,OAAO,MAAM,MAAW,CAACE,CAAM"}

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

@@ -0,0 +1,35 @@
+//#region src/interactions/actions/defaults/toolActivate.ts
+var e = "tool.activate";
+function t(e) {
+	return e.map(({ toolId: e, keyOpts: t }) => {
+		let n = {};
+		return t.mod !== void 0 && (n.mod = t.mod), t.alt !== void 0 && (n.alt = t.alt), t.shift !== void 0 && (n.shift = t.shift), {
+			spec: {
+				kind: "key",
+				key: t.key,
+				...Object.keys(n).length > 0 ? { mods: n } : {}
+			},
+			opts: { params: { toolId: e } }
+		};
+	});
+}
+function n(t, n) {
+	return {
+		id: e,
+		label: "Activate tool",
+		defaultBinding: t,
+		scope: "hotkey",
+		invoker: {
+			timing: "immediate",
+			run: (e, t) => {
+				let r = e.activeTool, i = t?.toolId;
+				r && i && (!n || n(i)) && r.setActive(i);
+			}
+		},
+		requires: ["activeTool"]
+	};
+}
+//#endregion
+export { e as TOOL_ACTIVATE_ID, t as buildToolActivateBindings, n as makeToolActivateAction };
+
+//# sourceMappingURL=toolActivate.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolActivate.js","names":["TOOL_ACTIVATE_ID","buildToolActivateBindings","specs","mods","keyOpts","makeToolActivateAction","bindings","activeTool","deps","toolId","params","isEligible"],"sources":["../../../../src/interactions/actions/defaults/toolActivate.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { BoundGesture } from '@weasel-js/routing';\nimport type { ImmediateInvoker } from '@weasel-js/routing';\nimport type { ActiveToolContextValue } from '@weasel-js/routing/react';\n\n/** Canonical id of the consolidated tool-activation action. One descriptor\n *  serves every tool; the matched binding (or imperative caller) supplies\n *  `params.toolId` to select which tool to activate. */\nexport const TOOL_ACTIVATE_ID = 'tool.activate';\n\n/** Per-tool key spec consumed by `makeToolActivateAction`. `mod/alt/shift`\n *  sit at the top level, mirroring the `KeyBinding` shape tools declare. */\nexport interface ToolActivateKeyOpts {\n  key: string;\n  mod?: boolean;\n  alt?: boolean;\n  shift?: boolean | 'optional';\n}\n\n/** Single entry pairing a tool id with the key spec that activates it. */\nexport interface ToolActivateBindingSpec {\n  toolId: string;\n  keyOpts: ToolActivateKeyOpts;\n}\n\n/** Build the per-tool `BoundGesture` list for the consolidated action's\n *  `defaultBinding`. Each entry carries `opts.params.toolId` so the\n *  invoker's `run` can pick out which tool to activate. */\nexport function buildToolActivateBindings(\n  specs: readonly ToolActivateBindingSpec[],\n): BoundGesture[] {\n  return specs.map(({ toolId, keyOpts }) => {\n    // Modifiers belong under `mods` (a `ModSpec`), not at the top level of\n    // the spec. They used to be spread flat and the mismatch was hidden by an\n    // `as never` cast, so the matcher — which treats an absent modifier as\n    // \"must NOT be held\" — could never match a modifier-qualified shortcut\n    // like Cmd+D. Nobody noticed while `useKeybindings`'s own document\n    // listener was doing the real matching.\n    const mods: Record<string, boolean | 'optional'> = {};\n    if (keyOpts.mod !== undefined) mods.mod = keyOpts.mod;\n    if (keyOpts.alt !== undefined) mods.alt = keyOpts.alt;\n    if (keyOpts.shift !== undefined) mods.shift = keyOpts.shift;\n    return {\n      spec: {\n        kind: 'key',\n        key: keyOpts.key,\n        ...(Object.keys(mods).length > 0 ? { mods } : {}),\n      },\n      opts: { params: { toolId } },\n    } as BoundGesture;\n  });\n}\n\n/** Build the consolidated `tool.activate` action. `bindings` enumerates one\n *  `{ spec, opts: { params: { toolId } } }` per tool; the invoker reads\n *  `params.toolId` and calls `activeTool.setActive(toolId)`. Imperative\n *  callers (palette, toolbar) reach the same effect via\n *  `registry.trigger('tool.activate', { toolId })`.\n *\n *  `isEligible` gates activation on the tool's `eligibility.capabilities` vs the active\n *  mode — the same predicate `ToolPalette` uses to grey a button out. It has\n *  to live in the invoker rather than in `Action.eligible` because eligibility\n *  here is per-TOOL (read off `params.toolId`), while `Action.eligible` is a\n *  static per-action descriptor. Omit it (or pass one that always returns\n *  true) for consumers with no mode registry. */\nexport function makeToolActivateAction(\n  bindings: BoundGesture[],\n  isEligible?: (toolId: string) => boolean,\n): Action {\n  const invoker: ImmediateInvoker = {\n    timing: 'immediate',\n    run: (deps, params) => {\n      const activeTool = deps.activeTool as ActiveToolContextValue | undefined;\n      const toolId = params?.toolId as string | undefined;\n      if (!activeTool || !toolId) return;\n      // Greyed out in the palette ⇒ not reachable by shortcut either. Before\n      // this, `ToolDef.capabilities` described an intent the runtime never\n      // enforced: in text-edit mode the palette greyed the pen button while\n      // `P` still activated pen.\n      if (isEligible && !isEligible(toolId)) return;\n      activeTool.setActive(toolId);\n    },\n  };\n\n  return {\n    id: TOOL_ACTIVATE_ID,\n    label: 'Activate tool',\n    defaultBinding: bindings,\n    scope: 'hotkey',\n    invoker,\n    requires: ['activeTool'],\n  } as Action & { requires: string[] };\n}\n"],"mappings":";AAQA,IAAaA,IAAmB;AAoBhC,SAAgBC,EACd,GACgB;CAChB,OAAOC,EAAM,KAAK,EAAE,WAAQ,iBAAc;EAOxC,IAAMC,IAA6C,CAAC;EAIpD,OAHIC,EAAQ,QAAQ,KAAA,MAAW,EAAK,MAAMA,EAAQ,MAC9CA,EAAQ,QAAQ,KAAA,MAAW,EAAK,MAAMA,EAAQ,MAC9CA,EAAQ,UAAU,KAAA,MAAW,EAAK,QAAQA,EAAQ,QAC/C;GACL,MAAM;IACJ,MAAM;IACN,KAAKA,EAAQ;IACb,GAAI,OAAO,KAAKD,CAAI,CAAC,CAAC,SAAS,IAAI,EAAE,QAAK,IAAI,CAAC;GACjD;GACA,MAAM,EAAE,QAAQ,EAAE,UAAO,EAAE;EAC7B;CACF,CAAC;AACH;AAcA,SAAgBE,EACd,GACA,GACQ;CAgBR,OAAO;EACL,IAAIL;EACJ,OAAO;EACP,gBAAgBM;EAChB,OAAO;EACP,SAAA;GAnBA,QAAQ;GACR,MAAM,GAAM,MAAW;IACrB,IAAMC,IAAaC,EAAK,YAClBC,IAASC,GAAQ;IACvB,AAAKH,KAAeE,MAKhB,MAAeE,EAAWF,CAAM,MACpCF,EAAW,UAAUE,CAAM;GAC7B;EAQA;EACA,UAAU,CAAC,YAAY;CACzB;AACF"}

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

@@ -0,0 +1,26 @@
+import { ActionDisabledReason as e } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/toolResetToDefault.ts
+var t = "tool.resetToDefault";
+function n(n) {
+	return {
+		id: t,
+		label: "Return to default tool",
+		defaultBinding: {
+			kind: "key",
+			key: "Escape"
+		},
+		invoker: {
+			timing: "immediate",
+			run: (e) => {
+				let t = e.activeTool, r = n();
+				t && r && t.setActive(r);
+			}
+		},
+		requires: ["activeTool"],
+		enabled: () => n() ? !0 : e.NotApplicable
+	};
+}
+//#endregion
+export { t as TOOL_RESET_TO_DEFAULT_ID, n as makeToolResetToDefaultAction };
+
+//# sourceMappingURL=toolResetToDefault.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolResetToDefault.js","names":["TOOL_RESET_TO_DEFAULT_ID","makeToolResetToDefaultAction","activeTool","deps","target","getTarget","ActionDisabledReason"],"sources":["../../../../src/interactions/actions/defaults/toolResetToDefault.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\nimport type { ImmediateInvoker } from '@weasel-js/routing';\nimport type { ActiveToolContextValue } from '@weasel-js/routing/react';\n\n/** Canonical id of the \"Escape returns to the default tool\" action. */\nexport const TOOL_RESET_TO_DEFAULT_ID = 'tool.resetToDefault';\n\n/**\n * Build the Escape-returns-to-default-tool action.\n *\n * This used to live in a raw document `keydown` listener inside\n * `useKeybindings`, running alongside — and unaware of — the dispatcher's own\n * Escape bindings (`cancelGesture`, `exitPathEdit`, `escape`). Both fired on\n * the same keypress because they were separate listeners.\n *\n * As an Action it joins the dispatcher's Escape order, which is\n * first-match-wins. It registers at ambient scope, the lowest priority, so\n * one Escape press does exactly one thing, in this order:\n *\n *   1. cancel an in-flight gesture\n *   2. exit path-anchor edit mode\n *   3. clear the selection\n *   4. return to the default tool   ← this action\n *\n * That IS a behavior change from \"reset the tool *and* clear the selection on\n * the same press.\" That order is the coherent reading of Escape, and the old\n * pairing was an artifact of two uncoordinated listeners rather than a design.\n *\n * `getTarget` returns the tool id to return to, or `null` when the behavior\n * is disabled (consumer passed `defaultTool: null`) or already satisfied.\n */\nexport function makeToolResetToDefaultAction(\n  getTarget: () => string | null,\n): Action {\n  const invoker: ImmediateInvoker = {\n    timing: 'immediate',\n    run: (deps) => {\n      const activeTool = deps.activeTool as ActiveToolContextValue | undefined;\n      const target = getTarget();\n      if (!activeTool || !target) return;\n      activeTool.setActive(target);\n    },\n  };\n\n  return {\n    id: TOOL_RESET_TO_DEFAULT_ID,\n    label: 'Return to default tool',\n    defaultBinding: { kind: 'key', key: 'Escape' },\n    invoker,\n    requires: ['activeTool'],\n    // Report disabled (rather than silently no-op'ing) when there's nothing\n    // to return to, so the dispatcher falls through and the keypress isn't\n    // swallowed.\n    enabled: () => (getTarget() ? true : ActionDisabledReason.NotApplicable),\n  } as Action & { requires: string[] };\n}\n"],"mappings":";;AAMA,IAAaA,IAA2B;AA0BxC,SAAgBC,EACd,GACQ;CAWR,OAAO;EACL,IAAID;EACJ,OAAO;EACP,gBAAgB;GAAE,MAAM;GAAO,KAAK;EAAS;EAC7C,SAAA;GAbA,QAAQ;GACR,MAAM,MAAS;IACb,IAAME,IAAaC,EAAK,YAClBC,IAASC,EAAU;IACzB,AAAKH,KAAeE,KACpBF,EAAW,UAAUE,CAAM;GAC7B;EAOA;EACA,UAAU,CAAC,YAAY;EAIvB,eAAgBC,EAAU,IAAI,KAAOC,EAAqB;CAC5D;AACF"}

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

@@ -0,0 +1,51 @@
+import { RedoIcon as e, UndoIcon as t } from "./icons/actionGlyphIcons.js";
+import { createElement as n } from "react";
+import { ActionDisabledReason as r } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/undoRedo.ts
+function i(e, t) {
+	return (e?.history)?.[t]?.() ? !0 : r.NotApplicable;
+}
+var a = {
+	id: "undo",
+	label: "Undo",
+	icon: n(t),
+	group: "history",
+	defaultBinding: {
+		kind: "key",
+		key: "z",
+		mods: { mod: !0 }
+	},
+	requires: ["history"],
+	invoker: {
+		timing: "immediate",
+		run: (e) => {
+			e.history?.undo?.();
+		}
+	},
+	enabled: (e) => i(e, "canUndo")
+}, o = {
+	id: "redo",
+	label: "Redo",
+	icon: n(e),
+	group: "history",
+	defaultBinding: {
+		kind: "key",
+		key: "z",
+		mods: {
+			mod: !0,
+			shift: !0
+		}
+	},
+	requires: ["history"],
+	invoker: {
+		timing: "immediate",
+		run: (e) => {
+			e.history?.redo?.();
+		}
+	},
+	enabled: (e) => i(e, "canRedo")
+};
+//#endregion
+export { o as redoAction, a as undoAction };
+
+//# sourceMappingURL=undoRedo.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"undoRedo.js","names":["historyCan","deps","which","ActionDisabledReason","undoAction","createElement","UndoIcon","redoAction","RedoIcon"],"sources":["../../../../src/interactions/actions/defaults/undoRedo.ts"],"sourcesContent":["import { createElement } from 'react';\nimport { RedoIcon, UndoIcon } from './icons/actionGlyphIcons';\nimport { ActionDisabledReason, type Action, type ActionDeps } from '@weasel-js/routing';\n\ntype HistoryReads = { canUndo?: () => boolean; canRedo?: () => boolean };\n\nfunction historyCan(deps: ActionDeps | undefined, which: 'canUndo' | 'canRedo'): true | ActionDisabledReason {\n  const history = deps?.history as HistoryReads | undefined;\n  return history?.[which]?.() ? true : ActionDisabledReason.NotApplicable;\n}\n\n/**\n * @experimental\n * Static descriptor for the `undo` Action.\n */\n// No `eligible` field → undo/redo are always eligible across all modes.\nexport const undoAction: Action & { requires: string[] } = {\n  id: 'undo',\n  label: 'Undo',\n  icon: createElement(UndoIcon),\n  group: 'history',\n  defaultBinding: { kind: 'key', key: 'z', mods: { mod: true } },\n  requires: ['history'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      (deps.history as { undo?: () => boolean } | undefined)?.undo?.();\n    },\n  },\n  enabled: (deps) => historyCan(deps, 'canUndo'),\n};\n\n/**\n * @experimental\n * Static descriptor for the `redo` Action.\n */\nexport const redoAction: Action & { requires: string[] } = {\n  id: 'redo',\n  label: 'Redo',\n  icon: createElement(RedoIcon),\n  group: 'history',\n  defaultBinding: { kind: 'key', key: 'z', mods: { mod: true, shift: true } },\n  requires: ['history'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      (deps.history as { redo?: () => boolean } | undefined)?.redo?.();\n    },\n  },\n  enabled: (deps) => historyCan(deps, 'canRedo'),\n};\n"],"mappings":";;;;AAMA,SAASA,EAAW,GAA8B,GAA2D;CAE3G,QADgBC,GAAM,QAAA,GACLC,EAAM,GAAG,IAAI,KAAOC,EAAqB;AAC5D;AAOA,IAAaC,IAA8C;CACzD,IAAI;CACJ,OAAO;CACP,MAAMC,EAAcC,CAAQ;CAC5B,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAO,KAAK;EAAK,MAAM,EAAE,KAAK,GAAK;CAAE;CAC7D,UAAU,CAAC,SAAS;CACpB,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,EAAM,SAAkD,OAAO;EACjE;CACF;CACA,UAAU,MAASN,EAAWC,GAAM,SAAS;AAC/C,GAMaM,IAA8C;CACzD,IAAI;CACJ,OAAO;CACP,MAAMF,EAAcG,CAAQ;CAC5B,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAO,KAAK;EAAK,MAAM;GAAE,KAAK;GAAM,OAAO;EAAK;CAAE;CAC1E,UAAU,CAAC,SAAS;CACpB,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,EAAM,SAAkD,OAAO;EACjE;CACF;CACA,UAAU,MAASR,EAAWC,GAAM,SAAS;AAC/C"}

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

@@ -0,0 +1,88 @@
+import { createVelocityTracker as e } from "../../../core/viewport/createVelocityTracker.js";
+import { resolveParams as t } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/viewportDragPan.ts
+function n(e, t) {
+	let n = t.startView, r = t.view.get();
+	return {
+		x: (e.current.x - r.x - (e.start.x - n.x)) * n.scale.x,
+		y: (e.current.y - r.y - (e.start.y - n.y)) * n.scale.y
+	};
+}
+var r = {
+	id: "viewport.dragPan",
+	label: "Drag to pan viewport",
+	group: "viewport",
+	cursor: "grab",
+	activeCursor: "grabbing",
+	requires: ["view", "debug"],
+	invoker: {
+		timing: "ongoing",
+		start(r, i) {
+			let a = r.deps.view;
+			if (!a) return {};
+			let o = a.get(), s = t(i?.params) ?? {}, c = s.inertia === !1 ? void 0 : s.inertia, l = {
+				startView: o,
+				view: a,
+				axis: s.axis ?? "both",
+				inertia: c,
+				tracker: c && a.decay ? e() : void 0,
+				lastScreen: {
+					x: 0,
+					y: 0
+				}
+			}, u = r.deps.debug, d = r.drag?.start;
+			return {
+				kind: "pan",
+				onMove(e) {
+					if (!e.drag) return;
+					let t = e.drag.screenDelta ?? n(e.drag, l), r = l.axis === "y" ? 0 : t.x, i = l.axis === "x" ? 0 : t.y;
+					l.tracker && (l.tracker.record(r - l.lastScreen.x, i - l.lastScreen.y, performance.now()), l.lastScreen = {
+						x: r,
+						y: i
+					});
+					let a = l.startView, o = {
+						...a,
+						x: a.x - r / a.scale.x,
+						y: a.y - i / a.scale.y
+					};
+					l.view.set(o), u?.recordViewport("pan", a, o, d && {
+						x: d.x,
+						y: d.y
+					});
+				},
+				onEnd(e, t) {
+					let { tracker: n, inertia: r, view: i } = l;
+					if (t === "cancel" || !n || !r || !i.decay) return;
+					let { vx: a, vy: o } = n.getVelocity(), s = l.startView.scale;
+					i.decay({
+						velocity: {
+							vx: -a / s.x,
+							vy: -o / s.y
+						},
+						friction: r.friction,
+						minSpeed: r.minSpeed,
+						boundary: r.boundary,
+						viewBounds: r.bounds,
+						initialPosition: {
+							x: i.get().x,
+							y: i.get().y
+						},
+						onTick: (e, t) => {
+							let n = i.get();
+							i.set({
+								...n,
+								x: n.x + e,
+								y: n.y + t
+							});
+						}
+					});
+				}
+			};
+		}
+	},
+	enabled: () => !0
+};
+//#endregion
+export { r as viewportDragPanAction };
+
+//# sourceMappingURL=viewportDragPan.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"viewportDragPan.js","names":["screenDeltaFromWorld","v0","scratch","now","drag","viewportDragPanAction","view","ctx","startView","params","resolveParams","opts","inertia","createVelocityTracker","debug","grab","moveCtx","screen","screenDx","screenDy","sv","next","v","reason","tracker","scale","vx","vy","cur","dx","dy"],"sources":["../../../../src/interactions/actions/defaults/viewportDragPan.ts"],"sourcesContent":["/**\n * `viewportDragPanAction` — ongoing Action descriptor for drag-to-pan the viewport.\n *\n * ## Bindings\n * None of its own. The hand tool binds a drag to it, and a canvas that pans on\n * any unclaimed drag adds `dragPanContribution`.\n *\n * ## Design notes\n * The drag delta from the dispatcher is in screen space (pixels). The pan\n * formula converts screen pixels to world units by dividing by zoom:\n *\n *   newView.x = startView.x - screenDx / startView.scale.x\n *   newView.y = startView.y - screenDy / startView.scale.y\n *\n * where `screenDx` / `screenDy` are the screen-space pixel deltas from the\n * drag origin. This ensures that at any zoom level, the drag behavior is\n * consistent: 1 screen pixel always pans the same amount relative to the\n * viewport's zoom (e.g., at 1x zoom: 100px → 100 world units; at 2x zoom:\n * 100px → 50 world units). The camera moves opposite to the drag direction\n * so that the scene content appears to follow the pointer.\n *\n * The descriptor captures `startView` in its own scratch at `start` time,\n * parallel to `useHandTool`'s `startView` capture in its scratch object.\n *\n * ## Axis locking and inertia\n * Both are read from the binding's `params` at `start`, so any consumer\n * binding this action gets them — not just `useHandTool`. `axis` drops one\n * component of every pan delta. `inertia` coasts the view after release,\n * through the optional `view.decay` dep; with no such dep wired the pan\n * simply lands, which is what an unconfigured consumer already expects.\n *\n * @see useHandTool — the React hook this descriptor parallels.\n */\n\nimport type { Action, DebugSink } from '@weasel-js/routing';\nimport { resolveParams, type InvocationCtx, type OngoingHandle, type BindingOpts } from '@weasel-js/routing';\nimport type { View } from 'core/viewport/view';\nimport type { ViewApi } from '../depSchema';\nimport type { InertiaConfig } from 'core/viewport/useDecayLoop';\nimport { createVelocityTracker, type VelocityTracker } from 'core/viewport/createVelocityTracker';\n\n// ---------------------------------------------------------------------------\n// Internal scratch\n// ---------------------------------------------------------------------------\n\ninterface DragPanScratch {\n  startView: View;\n  view: ViewApi;\n  axis: 'both' | 'x' | 'y';\n  inertia: InertiaConfig | undefined;\n  tracker: VelocityTracker | undefined;\n  lastScreen: { x: number; y: number };\n}\n\n/**\n * Rebuild the client-pixel drag delta from the world one, for an event source\n * that supplied no `clientX`/`clientY`.\n *\n * A world delta is self-referential mid-pan — its two ends were measured under\n * different views — so it cannot simply be scaled. Undoing each end against the\n * view that produced it recovers the client delta exactly, since\n * `world = (client - origin) / scale + view` and neither the canvas origin nor\n * the scale moves during a pan.\n */\nfunction screenDeltaFromWorld(\n  drag: NonNullable<InvocationCtx['drag']>,\n  scratch: DragPanScratch,\n): { x: number; y: number } {\n  const v0 = scratch.startView;\n  const now = scratch.view.get();\n  return {\n    x: (drag.current.x - now.x - (drag.start.x - v0.x)) * v0.scale.x,\n    y: (drag.current.y - now.y - (drag.start.y - v0.y)) * v0.scale.y,\n  };\n}\n\n/** Binding params `viewport.dragPan` understands. `useHandTool` supplies both;\n *  a bare binding supplies neither and pans both axes with no coasting. */\nexport interface DragPanParams {\n  axis?: 'both' | 'x' | 'y';\n  inertia?: false | InertiaConfig;\n}\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Static descriptor for the `viewport.dragPan` Action.\n *\n * Requires dep-schema entry: `view`.\n *\n * Translates the viewport by the screen-space drag delta so the canvas content\n * follows the pointer. Produces no scene ops — view changes are not undoable.\n */\n// No `eligible` field → viewport pan is always eligible across all modes.\nexport const viewportDragPanAction: Action & { requires: string[] } = {\n  id: 'viewport.dragPan',\n  label: 'Drag to pan viewport',\n  group: 'viewport',\n  // Hover hint: when this action would win the drag at the hovered point\n  // (e.g. empty canvas with no marquee-capable tool ahead of it), the\n  // hover-cursor pump shows the open hand.\n  cursor: 'grab',\n  // ...and the closed hand once the pan is actually running. This was\n  // `useHandTool`'s `engaged: { cursor: 'grabbing' }` — a phase-table entry\n  // on a tool, which meant a consumer who bound `viewport.dragPan` without\n  // the hand tool got no state cursor at all.\n  activeCursor: 'grabbing',\n  requires: ['view', 'debug'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const view = ctx.deps.view as ViewApi | undefined;\n      if (!view) return {};\n\n      const startView = view.get();\n      // Gesture-driven ongoing actions never see `ctx.params` — the dispatcher\n      // hands the binding's unresolved `opts` here and nowhere else, and pumps\n      // `onMove` / `onEnd` with an empty deps bag. Everything the gesture needs\n      // has to be captured now.\n      const params = (resolveParams(opts?.params) ?? {}) as DragPanParams;\n      const inertia = params.inertia === false ? undefined : params.inertia;\n      const scratch: DragPanScratch = {\n        startView,\n        view,\n        axis: params.axis ?? 'both',\n        inertia,\n        // Only track when a coast could actually happen, so the common\n        // no-inertia drag does no per-move work.\n        tracker: inertia && view.decay ? createVelocityTracker() : undefined,\n        lastScreen: { x: 0, y: 0 },\n      };\n      const debug = ctx.deps.debug as DebugSink | undefined;\n      const grab = ctx.drag?.start;\n\n      return {\n        kind: 'pan',\n        onMove(moveCtx: InvocationCtx): void {\n          if (!moveCtx.drag) return;\n          // Use `screenDelta` (client/CSS pixels), NOT `delta` (world). Pan\n          // mutates the view itself, so world deltas are self-referential —\n          // after the first commit, `toWorld(currentClient)` returns a\n          // position offset by the just-applied pan, halving the apparent\n          // movement on every subsequent pointermove. Screen coords come\n          // straight from the DOM event and don't drift.\n          const screen = moveCtx.drag.screenDelta ?? screenDeltaFromWorld(moveCtx.drag, scratch);\n          // An axis lock drops the other component of the *cumulative* delta,\n          // so the locked axis never moves however the pointer wanders.\n          const screenDx = scratch.axis === 'y' ? 0 : screen.x;\n          const screenDy = scratch.axis === 'x' ? 0 : screen.y;\n          if (scratch.tracker) {\n            scratch.tracker.record(\n              screenDx - scratch.lastScreen.x,\n              screenDy - scratch.lastScreen.y,\n              performance.now(),\n            );\n            scratch.lastScreen = { x: screenDx, y: screenDy };\n          }\n          const sv = scratch.startView;\n          // 1 screen px maps to 1/scale world units (at 2x zoom, 100 px →\n          // 50 world units of pan).\n          const next = {\n            ...sv,\n            x: sv.x - screenDx / sv.scale.x,\n            y: sv.y - screenDy / sv.scale.y,\n          };\n          scratch.view.set(next);\n          debug?.recordViewport('pan', sv, next, grab && { x: grab.x, y: grab.y });\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          // No scene ops to commit; the pan itself is already live. What is\n          // left is the coast, and only for a drag that actually ended.\n          const { tracker, inertia, view: v } = scratch;\n          if (reason === 'cancel' || !tracker || !inertia || !v.decay) return;\n          const { vx, vy } = tracker.getVelocity();\n          const scale = scratch.startView.scale;\n          v.decay({\n            // Screen px/ms → world units/ms, matching the onMove conversion.\n            velocity: { vx: -vx / scale.x, vy: -vy / scale.y },\n            friction: inertia.friction,\n            minSpeed: inertia.minSpeed,\n            boundary: inertia.boundary,\n            viewBounds: inertia.bounds,\n            initialPosition: { x: v.get().x, y: v.get().y },\n            onTick: (dx, dy) => {\n              const cur = v.get();\n              v.set({ ...cur, x: cur.x + dx, y: cur.y + dy });\n            },\n          });\n        },\n      };\n    },\n  },\n  enabled: () => true,\n};\n"],"mappings":";;;AAgEA,SAASA,EACP,GACA,GAC0B;CAC1B,IAAMC,IAAKC,EAAQ,WACbC,IAAMD,EAAQ,KAAK,IAAI;CAC7B,OAAO;EACL,IAAIE,EAAK,QAAQ,IAAID,EAAI,KAAKC,EAAK,MAAM,IAAIH,EAAG,MAAMA,EAAG,MAAM;EAC/D,IAAIG,EAAK,QAAQ,IAAID,EAAI,KAAKC,EAAK,MAAM,IAAIH,EAAG,MAAMA,EAAG,MAAM;CACjE;AACF;AAuBA,IAAaI,IAAyD;CACpE,IAAI;CACJ,OAAO;CACP,OAAO;CAIP,QAAQ;CAKR,cAAc;CACd,UAAU,CAAC,QAAQ,OAAO;CAC1B,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAmC;GAC3D,IAAMC,IAAOC,EAAI,KAAK;GACtB,IAAI,CAACD,GAAM,OAAO,CAAC;GAEnB,IAAME,IAAYF,EAAK,IAAI,GAKrBG,IAAUC,EAAcC,GAAM,MAAM,KAAK,CAAC,GAC1CC,IAAUH,EAAO,YAAY,KAAQ,KAAA,IAAYA,EAAO,SACxDP,IAA0B;IAC9B;IACA;IACA,MAAMO,EAAO,QAAQ;IACrB;IAGA,SAASG,KAAWN,EAAK,QAAQO,EAAsB,IAAI,KAAA;IAC3D,YAAY;KAAE,GAAG;KAAG,GAAG;IAAE;GAC3B,GACMC,IAAQP,EAAI,KAAK,OACjBQ,IAAOR,EAAI,MAAM;GAEvB,OAAO;IACL,MAAM;IACN,OAAO,GAA8B;KACnC,IAAI,CAACS,EAAQ,MAAM;KAOnB,IAAMC,IAASD,EAAQ,KAAK,eAAehB,EAAqBgB,EAAQ,MAAMd,CAAO,GAG/EgB,IAAWhB,EAAQ,SAAS,MAAM,IAAIe,EAAO,GAC7CE,IAAWjB,EAAQ,SAAS,MAAM,IAAIe,EAAO;KACnD,AAAIf,EAAQ,YACVA,EAAQ,QAAQ,OACdgB,IAAWhB,EAAQ,WAAW,GAC9BiB,IAAWjB,EAAQ,WAAW,GAC9B,YAAY,IAAI,CAClB,GACA,EAAQ,aAAa;MAAE,GAAGgB;MAAU,GAAGC;KAAS;KAElD,IAAMC,IAAKlB,EAAQ,WAGbmB,IAAO;MACX,GAAGD;MACH,GAAGA,EAAG,IAAIF,IAAWE,EAAG,MAAM;MAC9B,GAAGA,EAAG,IAAID,IAAWC,EAAG,MAAM;KAChC;KAEA,AADAlB,EAAQ,KAAK,IAAImB,CAAI,GACrBP,GAAO,eAAe,OAAOM,GAAIC,GAAMN,KAAQ;MAAE,GAAGA,EAAK;MAAG,GAAGA,EAAK;KAAE,CAAC;IACzE;IACA,MAAM,GAAwB,GAAmC;KAG/D,IAAM,EAAE,YAAS,YAAS,MAAMO,MAAMpB;KACtC,IAAIqB,MAAW,YAAY,CAACC,KAAW,CAACZ,KAAW,CAACU,EAAE,OAAO;KAC7D,IAAM,EAAE,OAAI,UAAOE,EAAQ,YAAY,GACjCC,IAAQvB,EAAQ,UAAU;KAChC,EAAE,MAAM;MAEN,UAAU;OAAE,IAAI,CAACwB,IAAKD,EAAM;OAAG,IAAI,CAACE,IAAKF,EAAM;MAAE;MACjD,UAAUb,EAAQ;MAClB,UAAUA,EAAQ;MAClB,UAAUA,EAAQ;MAClB,YAAYA,EAAQ;MACpB,iBAAiB;OAAE,GAAGU,EAAE,IAAI,CAAC,CAAC;OAAG,GAAGA,EAAE,IAAI,CAAC,CAAC;MAAE;MAC9C,SAAS,GAAI,MAAO;OAClB,IAAMM,IAAMN,EAAE,IAAI;OAClB,EAAE,IAAI;QAAE,GAAGM;QAAK,GAAGA,EAAI,IAAIC;QAAI,GAAGD,EAAI,IAAIE;OAAG,CAAC;MAChD;KACF,CAAC;IACH;GACF;EACF;CACF;CACA,eAAe;AACjB"}

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

@@ -0,0 +1,57 @@
+import { wheelPan as e } from "../../../core/viewport/wheelHandler.js";
+//#region src/interactions/actions/defaults/viewportWheelPan.ts
+var t = {
+	id: "viewport.wheelPan",
+	label: "Pan (wheel)",
+	group: "viewport",
+	defaultBinding: [{
+		spec: { kind: "wheel" },
+		opts: {}
+	}, {
+		spec: {
+			kind: "wheel",
+			mods: { shift: !0 }
+		},
+		opts: { params: { swapAxis: !0 } }
+	}],
+	requires: ["view", "debug"],
+	invoker: {
+		timing: "immediate",
+		run(t, n) {
+			let r = t.view;
+			if (!r) return;
+			let i = n?.axis ?? "both", a = n?.deltaX ?? 0, o = n?.deltaY ?? 0, s = r.get(), c = e(s, {
+				deltaX: a,
+				deltaY: o
+			}, {
+				axis: i,
+				swapAxis: n?.swapAxis === !0
+			});
+			r.set(c), t.debug?.recordViewport("pan", s, c);
+		}
+	},
+	enabled: () => !0
+};
+function n(e = {}) {
+	let n = e.axis ?? "both";
+	return {
+		...t,
+		defaultBinding: [{
+			spec: { kind: "wheel" },
+			opts: { params: { axis: n } }
+		}, {
+			spec: {
+				kind: "wheel",
+				mods: { shift: !0 }
+			},
+			opts: { params: {
+				swapAxis: !0,
+				axis: n
+			} }
+		}]
+	};
+}
+//#endregion
+export { n as makeViewportWheelPanAction, t as viewportWheelPanAction };
+
+//# sourceMappingURL=viewportWheelPan.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"viewportWheelPan.js","names":["viewportWheelPanAction","view","deps","axis","params","deltaX","deltaY","from","next","wheelPan","makeViewportWheelPanAction","opts"],"sources":["../../../../src/interactions/actions/defaults/viewportWheelPan.ts"],"sourcesContent":["/**\n * `viewportWheelPanAction` — immediate Action descriptor for wheel-based viewport pan.\n *\n * ## Bindings\n * - Plain wheel (no mod) → pan by deltaX/deltaY\n * - Shift+wheel → horizontal pan (mouse-wheel users get a horizontal axis\n *   without a horizontal scroll device). Implemented by routing deltaY into\n *   the x axis when the spec carries `params.swapAxis: true`.\n *\n * ## Design notes\n * The dispatcher merges wheel event data (deltaX, deltaY, clientX, clientY)\n * into params at dispatch time. The invoker reads them from the params bag\n * and defers to `wheelPan` (`core/viewport/wheelHandler`), the kit's one\n * statement of the wheel convention — which divides the delta by `view.scale`\n * so one screen-pixel scroll is one screen-pixel pan at any zoom.\n *\n * `axis` locks the pan to one axis, matching `viewport.dragPan`'s param of\n * the same name, so a consumer that wants a single-axis viewport can say so\n * once per action instead of clamping every committed view. An axis lock\n * outranks `swapAxis`: a shift-wheel routed into a barred axis moves nothing.\n */\n\nimport type { Action, DebugSink } from '@weasel-js/routing';\nimport type { ViewApi } from '../depSchema';\nimport { wheelPan } from 'core/viewport/wheelHandler';\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Static descriptor for the `viewport.wheelPan` Action.\n *\n * Companion to `viewport.dragPan` (drag-to-pan via the hand tool /\n * space-held). This one is the wheel/trackpad path; both share the\n * same `view` dep but fire on different gesture kinds, so they\n * coexist without competing.\n *\n * Requires dep-schema entry: `view`.\n */\nexport const viewportWheelPanAction: Action & { requires: string[] } = {\n  id: 'viewport.wheelPan',\n  label: 'Pan (wheel)',\n  group: 'viewport',\n  /**\n   * Plain wheel → pan; Shift+wheel → horizontal pan (axis swap).\n   * Cmd+wheel is claimed by `viewportZoomAction`. The matcher's strict\n   * modifier check keeps the bindings exclusive: omitting `mods` forbids\n   * any modifier, and `mods: { shift: true }` forbids the others.\n   */\n  defaultBinding: [\n    { spec: { kind: 'wheel' }, opts: {} },\n    { spec: { kind: 'wheel', mods: { shift: true } }, opts: { params: { swapAxis: true } } },\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 axis = (params?.axis as 'both' | 'x' | 'y' | undefined) ?? 'both';\n      const deltaX = (params?.deltaX as number | undefined) ?? 0;\n      const deltaY = (params?.deltaY as number | undefined) ?? 0;\n      const from = view.get();\n      const next = wheelPan(from, { deltaX, deltaY }, { axis, swapAxis: params?.swapAxis === true });\n      view.set(next);\n      (deps.debug as DebugSink | undefined)?.recordViewport('pan', from, next);\n    },\n  },\n  enabled: () => true,\n};\n\n/** Tuning for {@link makeViewportWheelPanAction}. */\nexport interface WheelPanOptions {\n  /** Lock the pan to one axis. Default `'both'`. Mirrors `viewport.dragPan`'s\n   *  `axis` param, so a single-axis viewport is declared once per action\n   *  rather than clamped on every committed view. */\n  axis?: 'both' | 'x' | 'y';\n}\n\n/** Builds a `viewport.wheelPan` descriptor with `opts` baked into both of its\n *  default bindings. `viewportWheelPanAction` is the unconfigured one. */\nexport function makeViewportWheelPanAction(\n  opts: WheelPanOptions = {},\n): Action & { requires: string[] } {\n  const axis = opts.axis ?? 'both';\n  return {\n    ...viewportWheelPanAction,\n    defaultBinding: [\n      { spec: { kind: 'wheel' }, opts: { params: { axis } } },\n      { spec: { kind: 'wheel', mods: { shift: true } }, opts: { params: { swapAxis: true, axis } } },\n    ],\n  };\n}\n"],"mappings":";;AAyCA,IAAaA,IAA0D;CACrE,IAAI;CACJ,OAAO;CACP,OAAO;CAOP,gBAAgB,CACd;EAAE,MAAM,EAAE,MAAM,QAAQ;EAAG,MAAM,CAAC;CAAE,GACpC;EAAE,MAAM;GAAE,MAAM;GAAS,MAAM,EAAE,OAAO,GAAK;EAAE;EAAG,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAK,EAAE;CAAE,CACzF;CACA,UAAU,CAAC,QAAQ,OAAO;CAC1B,SAAS;EACP,QAAQ;EACR,IAAI,GAAM,GAAQ;GAChB,IAAMC,IAAOC,EAAK;GAClB,IAAI,CAACD,GAAM;GACX,IAAME,IAAQC,GAAQ,QAA2C,QAC3DC,IAAUD,GAAQ,UAAiC,GACnDE,IAAUF,GAAQ,UAAiC,GACnDG,IAAON,EAAK,IAAI,GAChBO,IAAOC,EAASF,GAAM;IAAE;IAAQ;GAAO,GAAG;IAAE;IAAM,UAAUH,GAAQ,aAAa;GAAK,CAAC;GAE7F,AADAH,EAAK,IAAIO,CAAI,GACbN,EAAM,OAAiC,eAAe,OAAOK,GAAMC,CAAI;EACzE;CACF;CACA,eAAe;AACjB;AAYA,SAAgBE,EACd,IAAwB,CAAC,GACQ;CACjC,IAAMP,IAAOQ,EAAK,QAAQ;CAC1B,OAAO;EACL,GAAGX;EACH,gBAAgB,CACd;GAAE,MAAM,EAAE,MAAM,QAAQ;GAAG,MAAM,EAAE,QAAQ,EAAE,QAAK,EAAE;EAAE,GACtD;GAAE,MAAM;IAAE,MAAM;IAAS,MAAM,EAAE,OAAO,GAAK;GAAE;GAAG,MAAM,EAAE,QAAQ;IAAE,UAAU;IAAM;GAAK,EAAE;EAAE,CAC/F;CACF;AACF"}