@weasel-js/core 1.9.3 → 1.10.0

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

@@ -1,13 +1,16 @@
-import { createPaintAction as e } from "./createPaintAction.js";
-import { DEFAULT_FILL_COLOR as t, paintWithAlpha as n, solid as r } from "../../../util/paint.js";
+import { DEFAULT_FILL_COLOR as e, paintWithAlpha as t, solid as n } from "../../../util/paint.js";
+import { createPaintAction as r } from "./createPaintAction.js";
 //#region src/interactions/actions/defaults/setFillOpacity.ts
-var i = e({
+var i = r({
 	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)
+	merge: (r, i) => ({
+		...r,
+		paint: t(r?.paint ?? n(e), i)
+	})
 });
 //#endregion
 export { i as setFillOpacityAction };

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

@@ -1 +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"}
+{"version":3,"file":"setFillOpacity.js","names":["setFillOpacityAction","createPaintAction","pick","params","prev","paintWithAlpha","solid","DEFAULT_FILL_COLOR","alpha01"],"sources":["../../../../src/interactions/actions/defaults/setFillOpacity.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { Fill } 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  Fill,\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) => ({ ...prev, paint: paintWithAlpha(prev?.paint ?? 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,OAAa;EAAE,GAAGC;EAAM,OAAOC,EAAeD,GAAM,SAASE,EAAMC,CAAkB,GAAGC,CAAO;CAAE;AACjH,CAAC"}

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

@@ -1,22 +1,22 @@
-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";
+import { DEFAULT_STROKE_COLOR as e, paintWithColor as t, strokeOf as n, strokeWith as r } from "../../../util/paint.js";
+import { createPaintAction as i } from "./createPaintAction.js";
 //#region src/interactions/actions/defaults/setStroke.ts
-function a(e, t) {
-	return t.paint === null ? null : t.paint ? e ? {
+function a(e, i) {
+	return i.paint === null ? null : i.paint ? e ? {
 		...e,
-		paint: t.paint
-	} : i(t.paint) : e ? {
+		paint: i.paint
+	} : r(i.paint) : e ? {
 		...e,
-		paint: n(e.paint, t.color)
-	} : r(t.color);
+		paint: t(e.paint, i.color)
+	} : n(i.color);
 }
-var o = e({
+var o = i({
 	id: "setStroke",
 	label: "Set stroke",
 	dataKey: "stroke",
-	initialState: (e) => ({
-		color: e("color") ?? t,
-		paint: e("paint")
+	initialState: (t) => ({
+		color: t("color") ?? e,
+		paint: t("paint")
 	}),
 	readParams: (e, t) => {
 		let n = t?.color, r = t?.paint;

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 { 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"}
+{"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"}

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

@@ -1,17 +1,17 @@
-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";
+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";
 //#region src/interactions/actions/defaults/setStrokeOpacity.ts
-var a = e({
+var a = i({
 	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);
+	merge: (i, a) => {
+		let o = i ?? r(e);
 		return {
 			...o,
-			paint: n(o.paint ?? r(t), a)
+			paint: t(o.paint ?? n(e), a)
 		};
 	}
 });

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

@@ -1,27 +1,26 @@
 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 { boundsOfPath as n, hasOpenSubpath 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)),
+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 = n.leaves.map((e, 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 r = c(n.worldPath) ? i(n.worldPath, o) : a(n.worldPath, o);
-		if (!r) continue;
+		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,
 			label: "Slice"
 		}));
-		for (let e of r) {
+		for (let e of o) {
 			let r = d(n, e), i = {
 				...n.node,
 				id: l(),
@@ -53,7 +52,6 @@ function s(e, t) {
 		height: t.height
 	};
 }
-var c = (e) => e.kind === "polygon" && n(e).closed.some((e) => !e);
 //#endregion
 export { o as computeSliceOps };
 

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\"","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"}
+{"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"}

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. 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;\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":";AAOA,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"}
+{"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"}

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 * 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;\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;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"}
+{"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"}

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

@@ -8,7 +8,10 @@ function n(e, t) {
 		y: (e.current.y - r.y - (e.start.y - n.y)) * n.scale.y
 	};
 }
-var r = {
+function r(e, t) {
+	return e === t || e.x === t.x && e.y === t.y && e.scale.x === t.scale.x && e.scale.y === t.scale.y;
+}
+var i = {
 	id: "viewport.dragPan",
 	label: "Drag to pan viewport",
 	group: "viewport",
@@ -17,43 +20,51 @@ var r = {
 	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,
+		start(i, a) {
+			let o = i.deps.view;
+			if (!o) return {};
+			let s = o.get(), c = t(a?.params) ?? {}, l = c.inertia === !0 ? {} : c.inertia || void 0, u = {
+				startView: s,
+				base: s,
+				baseScreen: {
+					x: 0,
+					y: 0
+				},
+				seen: s,
+				view: o,
+				axis: c.axis ?? "both",
+				inertia: l,
+				tracker: l && o.decay ? e() : void 0,
 				lastScreen: {
 					x: 0,
 					y: 0
 				}
-			}, u = r.deps.debug, d = r.drag?.start;
+			}, d = i.deps.debug, f = i.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
+					let t = e.drag.screenDelta ?? n(e.drag, u), i = u.axis === "y" ? 0 : t.x, a = u.axis === "x" ? 0 : t.y;
+					u.tracker?.record(i - u.lastScreen.x, a - u.lastScreen.y, performance.now());
+					let o = u.view.get();
+					r(o, u.seen) || (u.base = o, u.baseScreen = u.lastScreen), u.lastScreen = {
+						x: i,
+						y: a
+					};
+					let s = u.base, c = {
+						...s,
+						x: s.x - (i - u.baseScreen.x) / s.scale.x,
+						y: s.y - (a - u.baseScreen.y) / s.scale.y
 					};
-					l.view.set(o), u?.recordViewport("pan", a, o, d && {
-						x: d.x,
-						y: d.y
+					u.view.set(c), u.seen = u.view.get(), d?.recordViewport("pan", s, c, f && {
+						x: f.x,
+						y: f.y
 					});
 				},
 				onEnd(e, t) {
-					let { tracker: n, inertia: r, view: i } = l;
+					let { tracker: n, inertia: r, view: i } = u;
 					if (t === "cancel" || !n || !r || !i.decay) return;
-					let { vx: a, vy: o } = n.getVelocity(), s = l.startView.scale;
+					let { vx: a, vy: o } = n.getVelocity(), s = u.base.scale;
 					i.decay({
 						velocity: {
 							vx: -a / s.x,
@@ -83,6 +94,6 @@ var r = {
 	enabled: () => !0
 };
 //#endregion
-export { r as viewportDragPanAction };
+export { i as viewportDragPanAction };
 
 //# sourceMappingURL=viewportDragPan.js.map

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

@@ -1 +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 } 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;\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;\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"}
+{"version":3,"file":"viewportDragPan.js","names":["screenDeltaFromWorld","v0","scratch","now","drag","sameCamera","a","b","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":["import type { Action } 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\ninterface DragPanScratch {\n  startView: View;\n  /** The view the pan is measured from, and the cumulative screen delta it\n   *  was taken at. The press, until something else moves the camera. */\n  base: View;\n  baseScreen: { x: number; y: number };\n  /** The view as this pan last left it. */\n  seen: 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\nfunction sameCamera(a: View, b: View): boolean {\n  return a === b\n    || (a.x === b.x && a.y === b.y && a.scale.x === b.scale.x && a.scale.y === b.scale.y);\n}\n\n/** Binding params `viewport.dragPan` understands, read at `start`. A bare\n *  binding pans both axes with no coasting. `inertia` coasts the view after\n *  release through the optional `view.decay` dep; with none wired the pan\n *  simply lands. `true` coasts with the kit defaults. */\nexport interface DragPanParams {\n  axis?: 'both' | 'x' | 'y';\n  inertia?: boolean | InertiaConfig;\n}\n\n/**\n * @experimental\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 * It has no binding of its own: the hand tool binds a drag to it, and a canvas\n * that pans on any unclaimed drag adds `dragPanContribution`.\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  cursor: 'grab',\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;\n      if (!view) return {};\n\n      const startView = view.get();\n      // The dispatcher hands the binding's unresolved `opts` here and nowhere\n      // else, and pumps `onMove` / `onEnd` with an empty deps bag. Everything\n      // the gesture needs has to be captured now.\n      const params = (resolveParams(opts?.params) ?? {}) as DragPanParams;\n      const inertia = params.inertia === true ? {} : params.inertia || undefined;\n      const scratch: DragPanScratch = {\n        startView,\n        base: startView,\n        baseScreen: { x: 0, y: 0 },\n        seen: 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;\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 and\n          // halve the apparent movement on every pointermove after the first.\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          scratch.tracker?.record(\n            screenDx - scratch.lastScreen.x,\n            screenDy - scratch.lastScreen.y,\n            performance.now(),\n          );\n          // A zoom or pan from elsewhere while the drag is held (a wheel, a\n          // key) is kept: the pan carries on from where it left the camera.\n          const now = scratch.view.get();\n          if (!sameCamera(now, scratch.seen)) {\n            scratch.base = now;\n            scratch.baseScreen = scratch.lastScreen;\n          }\n          scratch.lastScreen = { x: screenDx, y: screenDy };\n          const sv = scratch.base;\n          const next = {\n            ...sv,\n            x: sv.x - (screenDx - scratch.baseScreen.x) / sv.scale.x,\n            y: sv.y - (screenDy - scratch.baseScreen.y) / sv.scale.y,\n          };\n          scratch.view.set(next);\n          scratch.seen = scratch.view.get();\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.base.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":"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"}

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

@@ -1 +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 } from '@weasel-js/routing';\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;\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?.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":";;AAwCA,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,EAAK,OAAO,eAAe,OAAOK,GAAMC,CAAI;EAC9C;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"}
+{"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":["import type { Action } from '@weasel-js/routing';\nimport { wheelPan } from 'core/viewport/wheelHandler';\n\n/**\n * @experimental\n * Wheel and trackpad pan. Shift+wheel pans horizontally, by routing deltaY\n * into the x axis (`params.swapAxis`). `params.axis` locks the pan to one\n * axis, and outranks `swapAxis`: a shift-wheel routed into a barred axis\n * moves nothing.\n */\nexport const viewportWheelPanAction: Action & { requires: string[] } = {\n  id: 'viewport.wheelPan',\n  label: 'Pan (wheel)',\n  group: 'viewport',\n  /**\n   * The matcher's strict modifier check keeps the bindings exclusive, and\n   * leaves Cmd+wheel to `viewportZoomAction`: omitting `mods` forbids any\n   * 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;\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?.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'`. */\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":";;AAUA,IAAaA,IAA0D;CACrE,IAAI;CACJ,OAAO;CACP,OAAO;CAMP,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,EAAK,OAAO,eAAe,OAAOK,GAAMC,CAAI;EAC9C;CACF;CACA,eAAe;AACjB;AAUA,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"}

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

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

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

@@ -0,0 +1,66 @@
+import { visualBoundsViaDescriptor as e } from "../../../core/geometry/poseDescriptor.js";
+import { poseDescriptorOf as t } from "../poseDescriptorDep.js";
+import { translateEach as n } from "../selectionSubtree.js";
+import { scenePoseFrame as r } from "../poseFrame.js";
+import { planDistribute as i } from "./plan.js";
+import { DistributeHorizontalIcon as a, DistributeVerticalIcon as o } from "../defaults/icons/distributeIcons.js";
+import { ActionDisabledReason as s } from "@weasel-js/routing";
+import { jsx as c } from "react/jsx-runtime";
+//#region src/interactions/actions/distribute/action.tsx
+var l = {
+	x: "distribute.horizontal",
+	y: "distribute.vertical"
+}, u = {
+	x: "Distribute Horizontally",
+	y: "Distribute Vertically"
+}, d = {
+	x: /* @__PURE__ */ c(a, {}),
+	y: /* @__PURE__ */ c(o, {})
+};
+function f(t, a, o, s, c) {
+	let l = t.get();
+	if (l.length < 3) return;
+	let u = r(a), d = l.map((t) => {
+		let n = u.world(t);
+		return {
+			id: t,
+			pose: n,
+			b: e(n, c)
+		};
+	}), f = i(d.map((e) => e.b), o, s), p = d.map((e, t) => {
+		let n = f[t] - (o === "x" ? e.b.x : e.b.y);
+		return {
+			id: e.id,
+			dx: o === "x" ? n : 0,
+			dy: o === "y" ? n : 0
+		};
+	});
+	a.batch("Distribute", () => n(a, u, c, p));
+}
+function p(e) {
+	return {
+		id: l[e],
+		label: u[e],
+		icon: d[e],
+		group: "distribute",
+		eligible: { capability: "transforms-selection" },
+		requires: [
+			"selection",
+			"scene",
+			"poseDescriptor"
+		],
+		invoker: {
+			timing: "immediate",
+			run: (n, r) => {
+				let i = n.selection, a = n.scene;
+				i && a && f(i, a, e, r?.mode ?? "centers", t(n.poseDescriptor));
+			}
+		},
+		enabled: (e) => ((e?.selection)?.get().length ?? 0) >= 3 || s.SelectionRequired
+	};
+}
+var m = p("x"), h = p("y");
+//#endregion
+export { m as distributeHorizontalAction, h as distributeVerticalAction };
+
+//# sourceMappingURL=action.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","names":["ID_FOR","LABEL_FOR","ICON_FOR","DistributeHorizontalIcon","DistributeVerticalIcon","distributeSelection","ids","selection","frame","scenePoseFrame","scene","items","pose","id","visualBoundsViaDescriptor","geom","targets","planDistribute","it","axis","mode","moves","delta","i","translateEach","makeDistributeAction","deps","params","poseDescriptorOf","ActionDisabledReason","distributeHorizontalAction","distributeVerticalAction"],"sources":["../../../../src/interactions/actions/distribute/action.tsx"],"sourcesContent":["import type { ReactNode } from 'react';\nimport type { Scene } from 'core/scene/types';\nimport type { PoseDescriptor } from '../resize/geometry';\nimport { poseDescriptorOf } from '../poseDescriptorDep';\nimport { visualBoundsViaDescriptor } from '../align/align';\nimport type { DistributeAxis, DistributeMode } from './distribute';\nimport { planDistribute } from './plan';\nimport { scenePoseFrame } from '../poseFrame';\nimport { translateEach } from '../selectionSubtree';\nimport type { Action } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { ImmediateInvoker } from '@weasel-js/routing';\nimport { DistributeHorizontalIcon, DistributeVerticalIcon } from '../defaults/icons/distributeIcons';\n\nconst ID_FOR: Record<DistributeAxis, string> = { x: 'distribute.horizontal', y: 'distribute.vertical' };\nconst LABEL_FOR: Record<DistributeAxis, string> = { x: 'Distribute Horizontally', y: 'Distribute Vertically' };\nconst ICON_FOR: Record<DistributeAxis, ReactNode> = {\n  x: <DistributeHorizontalIcon />,\n  y: <DistributeVerticalIcon />,\n};\n\n// ---------------------------------------------------------------------------\n// Shared helper for descriptor invokers\n// ---------------------------------------------------------------------------\n\n/**\n * Apply a distribute operation to the current selection via the Scene API.\n * Reads poses through the `poseDescriptor` dep; `mode` comes from the\n * binding's `params.mode`.\n *\n * The span being divided is a world span, so the bounds are read and\n * translated in world and each result is stored back in its own parent's\n * frame.\n */\nfunction distributeSelection(\n  selection: SelectionApi,\n  scene: Scene<unknown, string, unknown>,\n  axis: DistributeAxis,\n  mode: DistributeMode,\n  geom: PoseDescriptor<unknown>,\n): void {\n  const ids = selection.get();\n  if (ids.length < 3) return;\n  const frame = scenePoseFrame(scene);\n\n  const items = ids.map((id) => {\n    const pose = frame.world(id);\n    return { id, pose, b: visualBoundsViaDescriptor(pose, geom) };\n  });\n  const targets = planDistribute(items.map((it) => it.b), axis, mode);\n\n  const moves = items.map((it, i) => {\n    const delta = targets[i] - (axis === 'x' ? it.b.x : it.b.y);\n    return { id: it.id, dx: axis === 'x' ? delta : 0, dy: axis === 'y' ? delta : 0 };\n  });\n  scene.batch('Distribute', () => translateEach(scene, frame, geom, moves));\n}\n\n// ---------------------------------------------------------------------------\n// Static descriptors\n// ---------------------------------------------------------------------------\n\nfunction makeDistributeAction(axis: DistributeAxis): Action {\n  return {\n    id: ID_FOR[axis],\n    label: LABEL_FOR[axis],\n    icon: ICON_FOR[axis],\n    group: 'distribute',\n    eligible: { capability: 'transforms-selection' },\n    requires: ['selection', 'scene', 'poseDescriptor'],\n    // No default keybindings. Wire bindings explicitly via the actions registry.\n    invoker: {\n      timing: 'immediate',\n      run: (deps, params) => {\n        const selection = deps.selection;\n        const scene = deps.scene;\n        if (!selection || !scene) return;\n        const mode = (params?.mode as DistributeMode | undefined) ?? 'centers';\n        distributeSelection(selection, scene, axis, mode, poseDescriptorOf(deps.poseDescriptor));\n      },\n    } satisfies ImmediateInvoker,\n    // Deps-aware, matching `distributeSelection`'s own `ids.length < 3` guard:\n    // a constant disabled reason greys the entry out forever (see\n    // `requiresSelection`).\n    enabled: (deps) => {\n      const selection = deps?.selection;\n      const count = selection?.get().length ?? 0;\n      return count >= 3 ? true : ActionDisabledReason.SelectionRequired;\n    },\n  };\n}\n\n/** @experimental Static descriptor for distribute-horizontal. */\nexport const distributeHorizontalAction = makeDistributeAction('x');\n/** @experimental Static descriptor for distribute-vertical. */\nexport const distributeVerticalAction   = makeDistributeAction('y');\n\n"],"mappings":";;;;;;;;;AAeA,IAAMA,IAAyC;CAAE,GAAG;CAAyB,GAAG;AAAsB,GAChGC,IAA4C;CAAE,GAAG;CAA2B,GAAG;AAAwB,GACvGC,IAA8C;CAClD,GAAG,kBAACC,GAAD,CAA2B,CAAA;CAC9B,GAAG,kBAACC,GAAD,CAAyB,CAAA;AAC9B;AAeA,SAASC,EACP,GACA,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAMC,EAAU,IAAI;CAC1B,IAAID,EAAI,SAAS,GAAG;CACpB,IAAME,IAAQC,EAAeC,CAAK,GAE5BC,IAAQL,EAAI,KAAK,MAAO;EAC5B,IAAMM,IAAOJ,EAAM,MAAMK,CAAE;EAC3B,OAAO;GAAE;GAAI;GAAM,GAAGC,EAA0BF,GAAMG,CAAI;EAAE;CAC9D,CAAC,GACKC,IAAUC,EAAeN,EAAM,KAAK,MAAOO,EAAG,CAAC,GAAGC,GAAMC,CAAI,GAE5DC,IAAQV,EAAM,KAAK,GAAI,MAAM;EACjC,IAAMW,IAAQN,EAAQO,MAAMJ,MAAS,MAAMD,EAAG,EAAE,IAAIA,EAAG,EAAE;EACzD,OAAO;GAAE,IAAIA,EAAG;GAAI,IAAIC,MAAS,MAAMG,IAAQ;GAAG,IAAIH,MAAS,MAAMG,IAAQ;EAAE;CACjF,CAAC;CACD,EAAM,MAAM,oBAAoBE,EAAcd,GAAOF,GAAOO,GAAMM,CAAK,CAAC;AAC1E;AAMA,SAASI,EAAqB,GAA8B;CAC1D,OAAO;EACL,IAAIzB,EAAOmB;EACX,OAAOlB,EAAUkB;EACjB,MAAMjB,EAASiB;EACf,OAAO;EACP,UAAU,EAAE,YAAY,uBAAuB;EAC/C,UAAU;GAAC;GAAa;GAAS;EAAgB;EAEjD,SAAS;GACP,QAAQ;GACR,MAAM,GAAM,MAAW;IACrB,IAAMZ,IAAYmB,EAAK,WACjBhB,IAAQgB,EAAK;IACnB,AAAKnB,KAAcG,KAEnBL,EAAoBE,GAAWG,GAAOS,GADxBQ,GAAQ,QAAuC,WACXC,EAAiBF,EAAK,cAAc,CAAC;GACzF;EACF;EAIA,UAAU,QACUA,GAAM,UAAA,EACC,IAAI,CAAC,CAAC,UAAU,MACzB,KAAWG,EAAqB;CAEpD;AACF;AAGA,IAAaC,IAA6BL,EAAqB,GAAG,GAErDM,IAA6BN,EAAqB,GAAG"}