@weasel-js/core 1.9.4 → 1.10.1

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/sliceOps.js

@@ -1,39 +1,38 @@
-import { pathToAnchors as e } from "../../../features/paths/anchors.js";
-import { createDeleteOp as t } from "../../../core/ops/delete.js";
-import { createInsertOp as n } from "../../../core/ops/create.js";
-import { boundsOfPath as r } from "@weasel-js/geom";
+import { createDeleteOp as e } from "../../../core/ops/delete.js";
+import { createInsertOp as t } from "../../../core/ops/create.js";
+import { boundsOfPath as n, hasOpenSubpath as r } from "@weasel-js/geom";
 import { snipPathByPolyline as i, splitPathByPolyline as a } from "@weasel-js/geom/booleans";
 //#region src/interactions/actions/defaults/sliceOps.ts
-function o(e) {
-	let { cut: o, nextId: l, selection: u } = e, d = e.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 = e.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: e } of g) {
-		let r = c(e.worldPath) ? i(e.worldPath, o) : a(e.worldPath, o);
-		if (!r) continue;
-		let s = e.node.id;
-		m.add(s), f.push(t({
-			node: e.node,
-			index: e.index,
+	for (let { leaf: n } of g) {
+		let o = r(n.worldPath) ? i(n.worldPath, c) : a(n.worldPath, c);
+		if (!o) continue;
+		let s = n.node.id;
+		m.add(s), f.push(e({
+			node: n.node,
+			index: n.index,
 			label: "Slice"
 		}));
-		for (let t of r) {
-			let r = d(e, t), i = {
-				...e.node,
+		for (let e of o) {
+			let r = d(n, e), i = {
+				...n.node,
 				id: l(),
 				pose: r.pose,
 				data: {
-					...e.node.data,
+					...n.node.data,
 					path: r.path
 				}
 			};
-			f.push(n({
+			f.push(t({
 				node: i,
-				index: e.index,
+				index: n.index,
 				label: "Slice"
 			})), p.has(s) && h.push(i.id);
 		}
@@ -53,7 +52,6 @@ function s(e, t) {
 		height: t.height
 	};
 }
-var c = (t) => t.kind === "polygon" && e(t).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

@@ -23,7 +23,7 @@ var i = {
 		start(i, a) {
 			let o = i.deps.view;
 			if (!o) return {};
-			let s = o.get(), c = t(a?.params) ?? {}, l = c.inertia === !1 ? void 0 : c.inertia, u = {
+			let s = o.get(), c = t(a?.params) ?? {}, l = c.inertia === !0 ? {} : c.inertia || void 0, u = {
 				startView: s,
 				base: s,
 				baseScreen: {

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

@@ -1 +1 @@
-{"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":["/**\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  /** 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. `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        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 —\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          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          // 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 - 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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"}
+{"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

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

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","zoomBindings","wheel","makeViewportZoomAction","clamp","opts","DEFAULT_MIN_ZOOM","DEFAULT_MAX_ZOOM","axis","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","axisZoomFactor","wheelZoomFactor","step","resetMs","viewportZoomAction"],"sources":["../../../../src/interactions/actions/defaults/viewportZoom.ts"],"sourcesContent":["import type { Action, BoundGesture } from '@weasel-js/routing';\nimport type { ViewApi } from '../depSchema';\nimport { axisZoomFactor, zoomAt, type ZoomAxis } 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  /** Hold wheel, trackpad-pinch, and key zoom to one axis; the other keeps its\n   *  scale and its translation. Default `'both'`. Cmd+0 still resets both. */\n  axis?: ZoomAxis;\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/** The gestures `viewport.zoom` answers: the configurable wheel trigger, then\n *  the fixed pinch and key bindings. */\nfunction zoomBindings(wheel: ViewportZoomOptions['wheel']): BoundGesture[] {\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    wheel === 'plain'\n      ? { kind: 'wheel' as const }\n      : { kind: 'wheel' as const, mods: { mod: true } };\n  return [\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}\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  const axis = opts.axis ?? 'both';\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: zoomBindings(opts.wheel),\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(), axisZoomFactor(factor, axis), 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 step = axisZoomFactor(kind === 'in' ? KEY_STEP : 1 / KEY_STEP, axis);\n            const target = zoomAt(from, keyAnchor(view), 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 }, axisZoomFactor(KEY_STEP, axis), 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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"}