@weasel-js/core 1.10.0 → 1.11.0

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

@@ -1 +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 { Paint, 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?: Paint | 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 `Paint`, 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<Paint | null>('paint'),\n  }),\n  readParams: (prev, params) => {\n    const color = params?.color as string | undefined;\n    const paint = params?.paint as Paint | 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,EAAmB,OAAO;CACnC;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"}
+{"version":3,"file":"setStroke.js","names":[],"sources":["../../../../src/interactions/actions/defaults/setStroke.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { Paint, 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?: Paint | 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 `Paint`, 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<Paint | null>('paint'),\n  }),\n  readParams: (prev, params) => {\n    const color = params?.color as string | undefined;\n    const paint = params?.paint as Paint | 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,SAAS,QAAQ,MAAiC,OAAsC;CAGtF,IAAI,MAAM,UAAU,MAAM,OAAO;CACjC,IAAI,MAAM,OAAO,OAAO,OAAO;EAAE,GAAG;EAAM,OAAO,MAAM;CAAM,IAAI,WAAW,MAAM,KAAK;CACvF,IAAI,CAAC,MAAM,OAAO,SAAS,MAAM,KAAK;CACtC,OAAO;EAAE,GAAG;EAAM,OAAO,eAAe,KAAK,OAAO,MAAM,KAAK;CAAE;AACnE;;;;;;;;;;;;AAaA,IAAa,kBAAmD,kBAI9D;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,UAAU;EACvB,OAAO,KAAa,OAAO,KAAK;EAChC,OAAO,KAAmB,OAAO;CACnC;CACA,aAAa,MAAM,WAAW;EAC5B,MAAM,QAAQ,QAAQ;EACtB,MAAM,QAAQ,QAAQ;EACtB,IAAI,UAAU,UAAa,UAAU,QAAW,OAAO;EACvD,IAAI,UAAU,QAAW,OAAO;GAAE,GAAG;GAAM;EAAM;EAGjD,OAAO;GAAE;GAAO;EAAM;CACxB;CACA,OAAO;AACT,CAAC"}

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

@@ -1,21 +1,29 @@
-import { DEFAULT_STROKE_COLOR as e, paintWithAlpha as t, solid as n, strokeOf as r } from "../../../util/paint.js";
-import { createPaintAction as i } from "./createPaintAction.js";
+import { DEFAULT_STROKE_COLOR, paintWithAlpha, solid, strokeOf } from "../../../util/paint.js";
+import { createPaintAction } from "./createPaintAction.js";
+
 //#region src/interactions/actions/defaults/setStrokeOpacity.ts
-var a = i({
+/**
+* Static descriptor for the `setStrokeOpacity` Action.
+*
+* `params.alpha01` (0..1) becomes each node's stroke paint `opacity`, leaving
+* the rest of the stroke — color, width, cap, join, dash — alone. A node with
+* no stroke yet gets a hairline one.
+*/
+var setStrokeOpacityAction = createPaintAction({
 	id: "setStrokeOpacity",
 	label: "Set stroke opacity",
 	dataKey: "stroke",
-	initialState: (e) => e("alpha01") ?? 1,
-	readParams: (e, t) => t?.alpha01 ?? null,
-	merge: (i, a) => {
-		let o = i ?? r(e);
+	initialState: (pick) => pick("alpha01") ?? 1,
+	readParams: (_prev, params) => params?.alpha01 ?? null,
+	merge: (prev, alpha01) => {
+		const base = prev ?? strokeOf(DEFAULT_STROKE_COLOR);
 		return {
-			...o,
-			paint: t(o.paint ?? n(e), a)
+			...base,
+			paint: paintWithAlpha(base.paint ?? solid(DEFAULT_STROKE_COLOR), alpha01)
 		};
 	}
 });
-//#endregion
-export { a as setStrokeOpacityAction };
 
+//#endregion
+export { setStrokeOpacityAction };
 //# sourceMappingURL=setStrokeOpacity.js.map

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

@@ -1 +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"}
+{"version":3,"file":"setStrokeOpacity.js","names":[],"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,IAAa,yBAA0D,kBAIrE;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,SAAS,KAAa,SAAS,KAAK;CACnD,aAAa,OAAO,WAAY,QAAQ,WAAkC;CAC1E,QAAQ,MAAM,YAAY;EACxB,MAAM,OAAO,QAAQ,SAAS,oBAAoB;EAGlD,OAAO;GAAE,GAAG;GAAM,OAAO,eAAe,KAAK,SAAS,MAAM,oBAAoB,GAAG,OAAO;EAAE;CAC9F;AACF,CAAC"}

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

@@ -1,39 +1,64 @@
-import { ActionDisabledReason as e, resolveParams as t } from "@weasel-js/routing";
+import { pathOperationTags } from "../pathGestureTags.js";
+import { ActionDisabledReason, resolveParams } from "@weasel-js/routing";
+
 //#region src/interactions/actions/defaults/slice.ts
-var n = {
+/**
+* Static descriptor for the `slice` Action.
+*
+* Ongoing drag invoker: tracks the cut while the gesture is in flight,
+* publishes it as a `'cut'` overlay, and on commit hands it to
+* `SliceDep.commit(cut)`. No-ops gracefully when the `slice` dep is absent.
+*
+* The cut is a straight line from drag start to the pointer by default. With
+* the binding param `cut: 'freehand'` it is the whole drag trail instead.
+*/
+var sliceAction = {
 	id: "slice",
 	label: "Slice",
+	tags: pathOperationTags("click"),
 	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];
+		start(ctx, opts) {
+			const dep = ctx.deps.slice;
+			const a = ctx.drag?.start ?? ctx.world;
+			let current = ctx.drag?.current ?? ctx.world;
+			let trail;
+			let open = true;
+			const freehand = () => resolveParams(opts?.params)?.["cut"] === "freehand";
+			const cut = () => freehand() && trail && trail.length >= 2 ? trail.map((p) => ({
+				x: p.x,
+				y: p.y
+			})) : [a, current];
 			return {
 				kind: "slice",
-				onMove(e) {
-					a = e.drag?.current ?? e.world, o = e.drag?.points;
+				onMove(moveCtx) {
+					current = moveCtx.drag?.current ?? moveCtx.world;
+					trail = moveCtx.drag?.points;
 				},
 				overlay() {
-					return s ? {
+					if (!open) return null;
+					return {
 						kind: "polyline",
-						points: l(),
+						points: cut(),
 						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()));
+				onEnd(endCtx, reason) {
+					open = false;
+					if (reason === "cancel" || !dep) return;
+					current = endCtx.drag?.current ?? endCtx.world;
+					trail = endCtx.drag?.points ?? trail;
+					dep.commit(cut());
 				}
 			};
 		}
 	},
-	enabled: (t) => t?.slice ? !0 : e.NotApplicable
+	enabled: (deps) => deps?.["slice"] ? true : ActionDisabledReason.NotApplicable
 };
-//#endregion
-export { n as sliceAction };
 
+//#endregion
+export { sliceAction };
 //# sourceMappingURL=slice.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"slice.js","names":["sliceAction","dep","ctx","a","current","trail","open","freehand","resolveParams","opts","\"cut\"","cut","p","moveCtx","reason","endCtx","deps","\"slice\"","ActionDisabledReason"],"sources":["../../../../src/interactions/actions/defaults/slice.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\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;\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":";;AAeA,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,KAAK,OACfC,IAAYD,EAAI,MAAM,SAASA,EAAI,OACrCE,IAAkBF,EAAI,MAAM,WAAWA,EAAI,OAC3CG,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,YAAab,MAC5B,IAAUc,EAAO,MAAM,WAAWA,EAAO,OACzC,IAAQA,EAAO,MAAM,UAAUV,GAC/BJ,EAAI,OAAOU,EAAI,CAAC;IAClB;GACF;EACF;CACF;CAIA,UAAU,MAAUK,GAAOC,QAAW,KAAOC,EAAqB;AACpE"}
+{"version":3,"file":"slice.js","names":[],"sources":["../../../../src/interactions/actions/defaults/slice.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport { ActionDisabledReason, resolveParams } from '@weasel-js/routing';\nimport type { BindingOpts, InvocationCtx, OngoingHandle, OngoingOverlay, Point2 } from '@weasel-js/routing';\nimport { pathOperationTags } from '../pathGestureTags';\n\n/**\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  tags: pathOperationTags('click'),\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;\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":";;;;;;;;;;;;;;AAeA,IAAa,cAA+C;CAC1D,IAAI;CACJ,OAAO;CACP,MAAM,kBAAkB,OAAO;CAC/B,OAAO;CACP,UAAU,EAAE,YAAY,aAAa;CACrC,UAAU,CAAC,OAAO;CAClB,SAAS;EACP,QAAQ;EACR,MAAM,KAAoB,MAAmC;GAC3D,MAAM,MAAM,IAAI,KAAK;GACrB,MAAM,IAAY,IAAI,MAAM,SAAS,IAAI;GACzC,IAAI,UAAkB,IAAI,MAAM,WAAW,IAAI;GAC/C,IAAI;GACJ,IAAI,OAAO;GAEX,MAAM,iBAAiB,cAAc,MAAM,MAAM,CAAC,GAAG,WAAW;GAChE,MAAM,YACJ,SAAS,KAAK,SAAS,MAAM,UAAU,IACnC,MAAM,KAAK,OAAO;IAAE,GAAG,EAAE;IAAG,GAAG,EAAE;GAAE,EAAE,IACrC,CAAC,GAAG,OAAO;GAEjB,OAAO;IACL,MAAM;IACN,OAAO,SAA8B;KACnC,UAAU,QAAQ,MAAM,WAAW,QAAQ;KAC3C,QAAQ,QAAQ,MAAM;IACxB;IACA,UAAiC;KAC/B,IAAI,CAAC,MAAM,OAAO;KAClB,OAAO;MAAE,MAAM;MAAY,QAAQ,IAAI;MAAG,MAAM;KAAM;IACxD;IACA,MAAM,QAAuB,QAAmC;KAC9D,OAAO;KACP,IAAI,WAAW,YAAY,CAAC,KAAK;KACjC,UAAU,OAAO,MAAM,WAAW,OAAO;KACzC,QAAQ,OAAO,MAAM,UAAU;KAC/B,IAAI,OAAO,IAAI,CAAC;IAClB;GACF;EACF;CACF;CAIA,UAAU,SAAU,OAAO,WAAW,OAAO,qBAAqB;AACpE"}

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

@@ -1,58 +1,79 @@
-import { createDeleteOp as e } from "../../../core/ops/delete.js";
-import { createInsertOp as t } from "../../../core/ops/create.js";
-import { boundsOfPath as n, hasOpenSubpath as r } from "@weasel-js/geom";
-import { snipPathByPolyline as i, splitPathByPolyline as a } from "@weasel-js/geom/booleans";
+import { createDeleteOp } from "../../../core/ops/delete.js";
+import { createInsertOp } from "../../../core/ops/create.js";
+import { boundsOfPath, hasOpenSubpath } from "@weasel-js/geom";
+import { snipPathByPolyline, splitPathByPolyline } from "@weasel-js/geom/booleans";
+
 //#region src/interactions/actions/defaults/sliceOps.ts
-function o(o) {
-	let { cut: c, nextId: l, selection: u } = o, d = o.placePiece ?? ((e, t) => ({
-		pose: s(e.node.pose, n(t)),
-		path: t
-	})), f = [], p = new Set(u ?? []), m = /* @__PURE__ */ new Set(), h = [], g = o.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 o = r(n.worldPath) ? i(n.worldPath, c) : a(n.worldPath, c);
-		if (!o) continue;
-		let s = n.node.id;
-		m.add(s), f.push(e({
-			node: n.node,
-			index: n.index,
+/**
+* Cut `leaves` along `cut` and return the ops that swap each crossed leaf for
+* its pieces.
+*
+* A path with an open subpath is snipped along its stroke
+* (`snipPathByPolyline`); a closed one is knifed into closed pieces
+* (`splitPathByPolyline`), which is also where a closed loop cuts out the
+* region it encloses. Each piece copies its source's node with the piece as
+* `data.path` and a fresh id. Leaves the cut misses produce nothing.
+*/
+function computeSliceOps(args) {
+	const { cut, nextId, selection } = args;
+	const placePiece = args.placePiece ?? ((leaf, piece) => ({
+		pose: piecePose(leaf.node.pose, boundsOfPath(piece)),
+		path: piece
+	}));
+	const ops = [];
+	const selected = new Set(selection ?? []);
+	const cutIds = /* @__PURE__ */ new Set();
+	const inherited = [];
+	const ordered = args.leaves.map((leaf, i) => ({
+		leaf,
+		i
+	})).sort((a, b) => b.leaf.index - a.leaf.index || a.i - b.i);
+	for (const { leaf } of ordered) {
+		const pieces = hasOpenSubpath(leaf.worldPath) ? snipPathByPolyline(leaf.worldPath, cut) : splitPathByPolyline(leaf.worldPath, cut);
+		if (!pieces) continue;
+		const sourceId = leaf.node.id;
+		cutIds.add(sourceId);
+		ops.push(createDeleteOp({
+			node: leaf.node,
+			index: leaf.index,
 			label: "Slice"
 		}));
-		for (let e of o) {
-			let r = d(n, e), i = {
-				...n.node,
-				id: l(),
-				pose: r.pose,
+		for (const piece of pieces) {
+			const stored = placePiece(leaf, piece);
+			const node = {
+				...leaf.node,
+				id: nextId(),
+				pose: stored.pose,
 				data: {
-					...n.node.data,
-					path: r.path
+					...leaf.node.data,
+					path: stored.path
 				}
 			};
-			f.push(t({
-				node: i,
-				index: n.index,
+			ops.push(createInsertOp({
+				node,
+				index: leaf.index,
 				label: "Slice"
-			})), p.has(s) && h.push(i.id);
+			}));
+			if (selected.has(sourceId)) inherited.push(node.id);
 		}
 	}
 	return {
-		ops: f,
-		nextSelection: u && m.size > 0 ? [...u.filter((e) => !m.has(e)), ...h] : null
+		ops,
+		nextSelection: selection && cutIds.size > 0 ? [...selection.filter((id) => !cutIds.has(id)), ...inherited] : 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
+function piecePose(source, b) {
+	const rest = source && typeof source === "object" ? { ...source } : {};
+	delete rest["rotation"];
+	return {
+		...rest,
+		x: b.x,
+		y: b.y,
+		width: b.width,
+		height: b.height
 	};
 }
-//#endregion
-export { o as computeSliceOps };
 
+//#endregion
+export { computeSliceOps };
 //# sourceMappingURL=sliceOps.js.map

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

@@ -1 +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\""],"sources":["../../../../src/interactions/actions/defaults/sliceOps.ts"],"sourcesContent":["import { boundsOfPath, hasOpenSubpath, type Path } from '@weasel-js/geom';\nimport { splitPathByPolyline, snipPathByPolyline } from '@weasel-js/geom/booleans';\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"],"mappings":";;;;;AA+EA,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"}
+{"version":3,"file":"sliceOps.js","names":[],"sources":["../../../../src/interactions/actions/defaults/sliceOps.ts"],"sourcesContent":["import { boundsOfPath, hasOpenSubpath, type Path } from '@weasel-js/geom';\nimport { splitPathByPolyline, snipPathByPolyline } from '@weasel-js/geom/booleans';\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"],"mappings":";;;;;;;;;;;;;;;;AA+EA,SAAgB,gBACd,MACoB;CACpB,MAAM,EAAE,KAAK,QAAQ,cAAc;CACnC,MAAM,aAAa,KAAK,gBACjB,MAAwB,WAA6B;EAAE,MAAM,UAAU,KAAK,KAAK,MAAM,aAAa,KAAK,CAAC;EAAG,MAAM;CAAM;CAChI,MAAM,MAAY,CAAC;CACnB,MAAM,WAAW,IAAI,IAAI,aAAa,CAAC,CAAC;CACxC,MAAM,yBAAS,IAAI,IAAY;CAC/B,MAAM,YAAsB,CAAC;CAI7B,MAAM,UAAU,KAAK,OAAO,KAAK,MAAM,OAAO;EAAE;EAAM;CAAE,EAAE,CAAC,CAAC,MAAM,GAAG,MAAM,EAAE,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,IAAI,EAAE,CAAC;CAEnH,KAAK,MAAM,EAAE,UAAU,SAAS;EAC9B,MAAM,SAAS,eAAe,KAAK,SAAS,IACxC,mBAAmB,KAAK,WAAW,GAAG,IACtC,oBAAoB,KAAK,WAAW,GAAG;EAC3C,IAAI,CAAC,QAAQ;EAEb,MAAM,WAAW,KAAK,KAAK;EAC3B,OAAO,IAAI,QAAQ;EACnB,IAAI,KAAK,eAAe;GAAE,MAAM,KAAK;GAAM,OAAO,KAAK;GAAO,OAAO;EAAQ,CAAC,CAAC;EAC/E,KAAK,MAAM,SAAS,QAAQ;GAC1B,MAAM,SAAS,WAAW,MAAM,KAAK;GACrC,MAAM,OAAO;IACX,GAAG,KAAK;IACR,IAAI,OAAO;IACX,MAAM,OAAO;IACb,MAAM;KAAE,GAAI,KAAK,KAAK;KAAiB,MAAM,OAAO;IAAK;GAC3D;GACA,IAAI,KAAK,eAAe;IAAE;IAAM,OAAO,KAAK;IAAO,OAAO;GAAQ,CAAC,CAAC;GACpE,IAAI,SAAS,IAAI,QAAQ,GAAG,UAAU,KAAK,KAAK,EAAE;EACpD;CACF;CAKA,OAAO;EAAE;EAAK,eAHQ,aAAa,OAAO,OAAO,IAC7C,CAAC,GAAG,UAAU,QAAQ,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC,GAAG,GAAG,SAAS,IAC3D;CACwB;AAC9B;AAEA,SAAS,UAAU,QAAiB,GAA6B;CAC/D,MAAM,OAAO,UAAU,OAAO,WAAW,WAAW,EAAE,GAAI,OAAmC,IAAI,CAAC;CAClG,OAAO,KAAK;CACZ,OAAO;EAAE,GAAG;EAAM,GAAG,EAAE;EAAG,GAAG,EAAE;EAAG,OAAO,EAAE;EAAO,QAAQ,EAAE;CAAO;AACrE"}

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

@@ -1,35 +1,53 @@
 //#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), {
+/** Canonical id of the consolidated tool-activation action. One descriptor
+*  serves every tool; the matched binding (or imperative caller) supplies
+*  `params.toolId` to select which tool to activate. */
+var TOOL_ACTIVATE_ID = "tool.activate";
+/** Build the per-tool `BoundGesture` list for the consolidated action's
+*  `defaultBinding`. Each entry carries `opts.params.toolId` so the
+*  invoker's `run` can pick out which tool to activate. */
+function buildToolActivateBindings(specs) {
+	return specs.map(({ toolId, keyOpts }) => {
+		const mods = {};
+		if (keyOpts.mod !== void 0) mods.mod = keyOpts.mod;
+		if (keyOpts.alt !== void 0) mods.alt = keyOpts.alt;
+		if (keyOpts.shift !== void 0) mods.shift = keyOpts.shift;
+		return {
 			spec: {
 				kind: "key",
-				key: t.key,
-				...Object.keys(n).length > 0 ? { mods: n } : {}
+				key: keyOpts.key,
+				...Object.keys(mods).length > 0 ? { mods } : {}
 			},
-			opts: { params: { toolId: e } }
+			opts: { params: { toolId } }
 		};
 	});
 }
-function n(t, n) {
+/** Build the consolidated `tool.activate` action. `bindings` enumerates one
+*  `{ spec, opts: { params: { toolId } } }` per tool. Imperative callers reach
+*  the same effect via `registry.trigger('tool.activate', { toolId })`.
+*
+*  `isEligible` gates activation per tool, which the static per-action
+*  `Action.eligible` cannot. Omit it for consumers with no mode registry. */
+function makeToolActivateAction(bindings, isEligible) {
 	return {
-		id: e,
+		id: TOOL_ACTIVATE_ID,
 		label: "Activate tool",
-		defaultBinding: t,
+		defaultBinding: bindings,
 		scope: "hotkey",
 		invoker: {
 			timing: "immediate",
-			run: (e, t) => {
-				let r = e.activeTool, i = t?.toolId;
-				r && i && (!n || n(i)) && r.setActive(i);
+			run: (deps, params) => {
+				const activeTool = deps.activeTool;
+				const toolId = params?.toolId;
+				if (!activeTool || !toolId) return;
+				if (isEligible && !isEligible(toolId)) return;
+				activeTool.setActive(toolId);
 			}
 		},
 		requires: ["activeTool"]
 	};
 }
-//#endregion
-export { e as TOOL_ACTIVATE_ID, t as buildToolActivateBindings, n as makeToolActivateAction };
 
+//#endregion
+export { TOOL_ACTIVATE_ID, buildToolActivateBindings, makeToolActivateAction };
 //# sourceMappingURL=toolActivate.js.map

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

@@ -1 +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';\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: the matcher treats an absent modifier as \"must NOT be held\".\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. Imperative callers reach\n *  the same effect via `registry.trigger('tool.activate', { toolId })`.\n *\n *  `isEligible` gates activation per tool, which the static per-action\n *  `Action.eligible` cannot. Omit it 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;\n      const toolId = params?.toolId as string | undefined;\n      if (!activeTool || !toolId) return;\n      // Grayed out in the palette ⇒ not reachable by shortcut either.\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":";AAOA,IAAaA,IAAmB;AAoBhC,SAAgBC,EACd,GACgB;CAChB,OAAOC,EAAM,KAAK,EAAE,WAAQ,iBAAc;EAGxC,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;AAQA,SAAgBE,EACd,GACA,GACQ;CAaR,OAAO;EACL,IAAIL;EACJ,OAAO;EACP,gBAAgBM;EAChB,OAAO;EACP,SAAA;GAhBA,QAAQ;GACR,MAAM,GAAM,MAAW;IACrB,IAAMC,IAAaC,EAAK,YAClBC,IAASC,GAAQ;IACvB,AAAKH,KAAeE,MAEhB,MAAeE,EAAWF,CAAM,MACpCF,EAAW,UAAUE,CAAM;GAC7B;EAQA;EACA,UAAU,CAAC,YAAY;CACzB;AACF"}
+{"version":3,"file":"toolActivate.js","names":[],"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';\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: the matcher treats an absent modifier as \"must NOT be held\".\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. Imperative callers reach\n *  the same effect via `registry.trigger('tool.activate', { toolId })`.\n *\n *  `isEligible` gates activation per tool, which the static per-action\n *  `Action.eligible` cannot. Omit it 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;\n      const toolId = params?.toolId as string | undefined;\n      if (!activeTool || !toolId) return;\n      // Grayed out in the palette ⇒ not reachable by shortcut either.\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":";;;;AAOA,IAAa,mBAAmB;;;;AAoBhC,SAAgB,0BACd,OACgB;CAChB,OAAO,MAAM,KAAK,EAAE,QAAQ,cAAc;EAGxC,MAAM,OAA6C,CAAC;EACpD,IAAI,QAAQ,QAAQ,QAAW,KAAK,MAAM,QAAQ;EAClD,IAAI,QAAQ,QAAQ,QAAW,KAAK,MAAM,QAAQ;EAClD,IAAI,QAAQ,UAAU,QAAW,KAAK,QAAQ,QAAQ;EACtD,OAAO;GACL,MAAM;IACJ,MAAM;IACN,KAAK,QAAQ;IACb,GAAI,OAAO,KAAK,IAAI,CAAC,CAAC,SAAS,IAAI,EAAE,KAAK,IAAI,CAAC;GACjD;GACA,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE;EAC7B;CACF,CAAC;AACH;;;;;;;AAQA,SAAgB,uBACd,UACA,YACQ;CAaR,OAAO;EACL,IAAI;EACJ,OAAO;EACP,gBAAgB;EAChB,OAAO;EACP;GAhBA,QAAQ;GACR,MAAM,MAAM,WAAW;IACrB,MAAM,aAAa,KAAK;IACxB,MAAM,SAAS,QAAQ;IACvB,IAAI,CAAC,cAAc,CAAC,QAAQ;IAE5B,IAAI,cAAc,CAAC,WAAW,MAAM,GAAG;IACvC,WAAW,UAAU,MAAM;GAC7B;EAQA;EACA,UAAU,CAAC,YAAY;CACzB;AACF"}

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

@@ -1,9 +1,26 @@
-import { ActionDisabledReason as e } from "@weasel-js/routing";
+import { ActionDisabledReason } from "@weasel-js/routing";
+
 //#region src/interactions/actions/defaults/toolResetToDefault.ts
-var t = "tool.resetToDefault";
-function n(n) {
+/** Canonical id of the "Escape returns to the default tool" action. */
+var TOOL_RESET_TO_DEFAULT_ID = "tool.resetToDefault";
+/**
+* Build the Escape-returns-to-default-tool action.
+*
+* It joins the dispatcher's Escape order, which is first-match-wins, at
+* ambient scope, the lowest priority, so one Escape press does exactly one
+* thing, in this order:
+*
+*   1. cancel an in-flight gesture
+*   2. exit path-anchor edit mode
+*   3. clear the selection
+*   4. return to the default tool   ← this action
+*
+* `getTarget` returns the tool id to return to, or `null` when the behavior
+* is disabled (consumer passed `defaultTool: null`) or already satisfied.
+*/
+function makeToolResetToDefaultAction(getTarget) {
 	return {
-		id: t,
+		id: TOOL_RESET_TO_DEFAULT_ID,
 		label: "Return to default tool",
 		defaultBinding: {
 			kind: "key",
@@ -11,16 +28,18 @@ function n(n) {
 		},
 		invoker: {
 			timing: "immediate",
-			run: (e) => {
-				let t = e.activeTool, r = n();
-				t && r && t.setActive(r);
+			run: (deps) => {
+				const activeTool = deps.activeTool;
+				const target = getTarget();
+				if (!activeTool || !target) return;
+				activeTool.setActive(target);
 			}
 		},
 		requires: ["activeTool"],
-		enabled: () => n() ? !0 : e.NotApplicable
+		enabled: () => getTarget() ? true : ActionDisabledReason.NotApplicable
 	};
 }
-//#endregion
-export { t as TOOL_RESET_TO_DEFAULT_ID, n as makeToolResetToDefaultAction };
 
+//#endregion
+export { TOOL_RESET_TO_DEFAULT_ID, makeToolResetToDefaultAction };
 //# sourceMappingURL=toolResetToDefault.js.map

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

@@ -1 +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';\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 * It joins the dispatcher's Escape order, which is first-match-wins, at\n * ambient scope, the lowest priority, so one Escape press does exactly one\n * 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 * `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;\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":";;AAKA,IAAaA,IAA2B;AAiBxC,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"}
+{"version":3,"file":"toolResetToDefault.js","names":[],"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';\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 * It joins the dispatcher's Escape order, which is first-match-wins, at\n * ambient scope, the lowest priority, so one Escape press does exactly one\n * 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 * `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;\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":";;;;AAKA,IAAa,2BAA2B;;;;;;;;;;;;;;;;AAiBxC,SAAgB,6BACd,WACQ;CAWR,OAAO;EACL,IAAI;EACJ,OAAO;EACP,gBAAgB;GAAE,MAAM;GAAO,KAAK;EAAS;EAC7C;GAbA,QAAQ;GACR,MAAM,SAAS;IACb,MAAM,aAAa,KAAK;IACxB,MAAM,SAAS,UAAU;IACzB,IAAI,CAAC,cAAc,CAAC,QAAQ;IAC5B,WAAW,UAAU,MAAM;GAC7B;EAOA;EACA,UAAU,CAAC,YAAY;EAIvB,eAAgB,UAAU,IAAI,OAAO,qBAAqB;CAC5D;AACF"}

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

@@ -1,51 +1,57 @@
-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";
+import { ActionDisabledReason } from "@weasel-js/routing";
+
 //#region src/interactions/actions/defaults/undoRedo.ts
-function i(e, t) {
-	return e?.history?.[t]?.() ? !0 : r.NotApplicable;
+function historyCan(deps, which) {
+	return deps?.history?.[which]?.() ? true : ActionDisabledReason.NotApplicable;
 }
-var a = {
+/**
+* Static descriptor for the `undo` Action.
+*/
+var undoAction = {
 	id: "undo",
 	label: "Undo",
-	icon: n(t),
+	icon: /* @icon */ "core:undo",
 	group: "history",
 	defaultBinding: {
 		kind: "key",
 		key: "z",
-		mods: { mod: !0 }
+		mods: { mod: true }
 	},
 	requires: ["history"],
 	invoker: {
 		timing: "immediate",
-		run: (e) => {
-			e.history?.undo?.();
+		run: (deps) => {
+			deps.history?.undo?.();
 		}
 	},
-	enabled: (e) => i(e, "canUndo")
-}, o = {
+	enabled: (deps) => historyCan(deps, "canUndo")
+};
+/**
+* Static descriptor for the `redo` Action.
+*/
+var redoAction = {
 	id: "redo",
 	label: "Redo",
-	icon: n(e),
+	icon: /* @icon */ "core:redo",
 	group: "history",
 	defaultBinding: {
 		kind: "key",
 		key: "z",
 		mods: {
-			mod: !0,
-			shift: !0
+			mod: true,
+			shift: true
 		}
 	},
 	requires: ["history"],
 	invoker: {
 		timing: "immediate",
-		run: (e) => {
-			e.history?.redo?.();
+		run: (deps) => {
+			deps.history?.redo?.();
 		}
 	},
-	enabled: (e) => i(e, "canRedo")
+	enabled: (deps) => historyCan(deps, "canRedo")
 };
-//#endregion
-export { o as redoAction, a as undoAction };
 
+//#endregion
+export { redoAction, undoAction };
 //# sourceMappingURL=undoRedo.js.map

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

@@ -1 +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\nfunction historyCan(deps: ActionDeps | undefined, which: 'canUndo' | 'canRedo'): true | ActionDisabledReason {\n  return deps?.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?.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?.redo?.();\n    },\n  },\n  enabled: (deps) => historyCan(deps, 'canRedo'),\n};\n"],"mappings":";;;;AAIA,SAASA,EAAW,GAA8B,GAA2D;CAC3G,OAAOC,GAAM,UAAUC,EAAM,GAAG,IAAI,KAAOC,EAAqB;AAClE;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,EAAK,SAAS,OAAO;EACvB;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,EAAK,SAAS,OAAO;EACvB;CACF;CACA,UAAU,MAASR,EAAWC,GAAM,SAAS;AAC/C"}
+{"version":3,"file":"undoRedo.js","names":[],"sources":["../../../../src/interactions/actions/defaults/undoRedo.ts"],"sourcesContent":["import { ActionDisabledReason, type Action, type ActionDeps } from '@weasel-js/routing';\nimport { icon } from '../../../icons.gen';\n\nfunction historyCan(deps: ActionDeps | undefined, which: 'canUndo' | 'canRedo'): true | ActionDisabledReason {\n  return deps?.history?.[which]?.() ? true : ActionDisabledReason.NotApplicable;\n}\n\n/**\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: icon('undo'),\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?.undo?.();\n    },\n  },\n  enabled: (deps) => historyCan(deps, 'canUndo'),\n};\n\n/**\n * Static descriptor for the `redo` Action.\n */\nexport const redoAction: Action & { requires: string[] } = {\n  id: 'redo',\n  label: 'Redo',\n  icon: icon('redo'),\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?.redo?.();\n    },\n  },\n  enabled: (deps) => historyCan(deps, 'canRedo'),\n};\n"],"mappings":"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"}