@weasel-js/core 1.10.0 → 1.11.0

package/dist/canvas/copiesAbove.js

@@ -0,0 +1,37 @@
+import { multiply } from "@weasel-js/geom";
+
+//#region src/canvas/copiesAbove.ts
+/**
+* Every transform content placed in `container` is drawn under besides as
+* authored: the `copiesFromPose` of the container and of each container above
+* it, composed outermost first, the identity left out. Empty for the top of
+* the tree, or when nothing there draws copies. `poseOf` is the pose a
+* container is painted at, which is what its copies are computed from.
+*/
+function copiesWithin(scene, container, poseOf) {
+	if (container === null || scene.get(container) === void 0) return [];
+	let all = [[
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	]];
+	for (const aid of [container, ...scene.ancestorsOf(container)].reverse()) {
+		const a = scene.get(aid);
+		if (a?.kind !== "container" || !a.copiesFromPose) continue;
+		const copies = a.copiesFromPose(poseOf(a), a) ?? [];
+		if (copies.length === 0) continue;
+		all = all.flatMap((m) => [m, ...copies.map((c) => multiply(m, c))]);
+	}
+	return all.slice(1);
+}
+/** Every transform the ancestors of `id` draw it under; see {@link copiesWithin}. */
+function copiesAbove(scene, id, poseOf) {
+	return copiesWithin(scene, scene.get(id)?.parent ?? null, poseOf);
+}
+
+//#endregion
+export { copiesAbove, copiesWithin };
+//# sourceMappingURL=copiesAbove.js.map

package/dist/canvas/copiesAbove.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"copiesAbove.js","names":[],"sources":["../../src/canvas/copiesAbove.ts"],"sourcesContent":["import { multiply, type Affine } from '@weasel-js/geom';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\n\n/**\n * Every transform content placed in `container` is drawn under besides as\n * authored: the `copiesFromPose` of the container and of each container above\n * it, composed outermost first, the identity left out. Empty for the top of\n * the tree, or when nothing there draws copies. `poseOf` is the pose a\n * container is painted at, which is what its copies are computed from.\n */\nexport function copiesWithin<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  container: NodeId | null,\n  poseOf: (node: Node<TData, TLayer, TPose>) => TPose,\n): Affine[] {\n  if (container === null || scene.get(container) === undefined) return [];\n  let all: Affine[] = [[1, 0, 0, 1, 0, 0]];\n  for (const aid of [container, ...scene.ancestorsOf(container)].reverse()) {\n    const a = scene.get(aid);\n    if (a?.kind !== 'container' || !a.copiesFromPose) continue;\n    const copies = a.copiesFromPose(poseOf(a), a) ?? [];\n    if (copies.length === 0) continue;\n    // A copy at an outer level carries everything inside it, inner copies included.\n    all = all.flatMap((m) => [m, ...copies.map((c) => multiply(m, c))]);\n  }\n  return all.slice(1);\n}\n\n/** Every transform the ancestors of `id` draw it under; see {@link copiesWithin}. */\nexport function copiesAbove<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  id: NodeId,\n  poseOf: (node: Node<TData, TLayer, TPose>) => TPose,\n): Affine[] {\n  return copiesWithin(scene, scene.get(id)?.parent ?? null, poseOf);\n}\n"],"mappings":";;;;;;;;;;AAUA,SAAgB,aACd,OACA,WACA,QACU;CACV,IAAI,cAAc,QAAQ,MAAM,IAAI,SAAS,MAAM,QAAW,OAAO,CAAC;CACtE,IAAI,MAAgB,CAAC;EAAC;EAAG;EAAG;EAAG;EAAG;EAAG;CAAC,CAAC;CACvC,KAAK,MAAM,OAAO,CAAC,WAAW,GAAG,MAAM,YAAY,SAAS,CAAC,CAAC,CAAC,QAAQ,GAAG;EACxE,MAAM,IAAI,MAAM,IAAI,GAAG;EACvB,IAAI,GAAG,SAAS,eAAe,CAAC,EAAE,gBAAgB;EAClD,MAAM,SAAS,EAAE,eAAe,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC;EAClD,IAAI,OAAO,WAAW,GAAG;EAEzB,MAAM,IAAI,SAAS,MAAM,CAAC,GAAG,GAAG,OAAO,KAAK,MAAM,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC;CACpE;CACA,OAAO,IAAI,MAAM,CAAC;AACpB;;AAGA,SAAgB,YACd,OACA,IACA,QACU;CACV,OAAO,aAAa,OAAO,MAAM,IAAI,EAAE,CAAC,EAAE,UAAU,MAAM,MAAM;AAClE"}

package/dist/canvas/defaultDrawOne.js

@@ -1,24 +1,37 @@
-import { findNodeShape as e, findShapeBounds as t } from "./NodeShape.js";
-import { textCommandFromRuns as n } from "@weasel-js/renderer";
+import { findNodeShape, findShapeBounds } from "./NodeShape.js";
+import { overChildren } from "./overChildren.js";
+import { textCommandFromRuns } from "@weasel-js/renderer";
+
 //#region src/canvas/defaultDrawOne.ts
-function r(e) {
-	let t = typeof window < "u" && window.devicePixelRatio || 1;
-	return Math.max(Math.abs(e.scale.x), Math.abs(e.scale.y)) * t;
+function pixelScaleOf(view) {
+	const dpr = typeof window !== "undefined" && window.devicePixelRatio || 1;
+	return Math.max(Math.abs(view.scale.x), Math.abs(view.scale.y)) * dpr;
 }
-var i, a = {};
-function o(e) {
-	let t = r(e);
-	return (e !== i || a.pixelScale !== t) && (i = e, a = { pixelScale: t }), a;
+var lastView;
+var lastViewCtx = {};
+function viewOnlyCtx(view) {
+	const pixelScale = pixelScaleOf(view);
+	if (view !== lastView || lastViewCtx.pixelScale !== pixelScale) {
+		lastView = view;
+		lastViewCtx = { pixelScale };
+	}
+	return lastViewCtx;
 }
-function s(t, i, a, s) {
-	let c = e(t), l = !a || s?.pixelScale !== void 0 ? s : s ? {
-		...s,
-		pixelScale: r(a)
-	} : o(a), u = c ? c.paint(t, i, l) : [], d = t.data;
-	if (d?.label && d.text == null) {
-		let e = i;
-		return [...u, n(e.x + 6, e.y + 14, [{
-			text: d.label,
+/** Paint one node the way the kit does by default: dispatch to the first
+*  registered node-shape painter that matches, then draw its `data.label` on
+*  top when it has one: on top of a container's children too. Consumers replace or wrap this via `drawOne`. */
+function defaultDrawOne(node, pose, view, ctx) {
+	const painter = findNodeShape(node);
+	const paintCtx = !view || ctx?.pixelScale !== void 0 ? ctx : ctx ? {
+		...ctx,
+		pixelScale: pixelScaleOf(view)
+	} : viewOnlyCtx(view);
+	const primary = painter ? painter.paint(node, pose, paintCtx) : [];
+	const data = node.data;
+	if (data?.label && data.text == null) {
+		const p = pose;
+		const label = textCommandFromRuns(p.x + 6, p.y + 14, [{
+			text: data.label,
 			fill: { paint: {
 				kind: "solid",
 				color: "rgba(0,0,0,0.7)"
@@ -26,23 +39,35 @@ function s(t, i, a, s) {
 		}], {
 			fontFamily: "sans-serif",
 			fontSize: 11
-		})];
+		});
+		return [...primary, node.kind === "container" ? overChildren([label]) : label];
 	}
-	return u;
+	return primary;
 }
-function c(e, n, r) {
-	let i = e.data;
-	if (i?.label && i.text == null) return null;
-	let a = Math.abs(r.scale.x), o = Math.abs(r.scale.y);
-	return t(e, n, {
-		scale: Math.sqrt(a * o),
-		leastScale: Math.min(a, o)
+/**
+* The box {@link defaultDrawOne}'s output for `node` fits in — the matched
+* painter's `bounds` — or `null` when it has none, or when a `data.label`
+* overlay adds text nothing bounds cheaply. The scene slot's `cull` reads it
+* to skip painting nodes the view cannot see.
+*/
+function defaultPaintBounds(node, pose, view) {
+	const data = node.data;
+	if (data?.label && data.text == null) return null;
+	const sx = Math.abs(view.scale.x), sy = Math.abs(view.scale.y);
+	return findShapeBounds(node, pose, {
+		scale: Math.sqrt(sx * sy),
+		leastScale: Math.min(sx, sy)
 	});
 }
-function l(e) {
-	return e === s ? c : void 0;
+/**
+* `defaultPaintBounds` when `drawOne` is `defaultDrawOne`, and nothing
+* otherwise: a painter's box says nothing about what a replacement
+* `drawOne` paints.
+*/
+function paintBoundsFor(drawOne) {
+	return drawOne === defaultDrawOne ? defaultPaintBounds : void 0;
 }
-//#endregion
-export { s as defaultDrawOne, c as defaultPaintBounds, l as paintBoundsFor };
 
+//#endregion
+export { defaultDrawOne, defaultPaintBounds, paintBoundsFor };
 //# sourceMappingURL=defaultDrawOne.js.map

package/dist/canvas/defaultDrawOne.js.map

@@ -1 +1 @@
-{"version":3,"file":"defaultDrawOne.js","names":["pixelScaleOf","dpr","view","lastView","lastViewCtx","viewOnlyCtx","pixelScale","defaultDrawOne","painter","findNodeShape","node","paintCtx","ctx","primary","pose","data","p","textCommandFromRuns","defaultPaintBounds","sx","sy","findShapeBounds","paintBoundsFor","drawOne"],"sources":["../../src/canvas/defaultDrawOne.ts"],"sourcesContent":["/**\n * The kit's default per-node draw function, kept apart from `SceneCanvas.tsx` so non-React\n * callers (headless rasterization via `renderSceneToPixels`) can use it without importing the\n * React component tree.\n *\n * To teach the kit about a new kind of shape, register a painter (`registerNodeShape`) — do not\n * override `drawOne`. Override `drawOne` only for cross-cutting decoration.\n */\nimport type { Node } from 'core/scene/types';\nimport type { View } from 'core/viewport/view';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { textCommandFromRuns } from '@weasel-js/renderer';\nimport { findNodeShape, findShapeBounds, type NodePaintCtx } from './NodeShape';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\nfunction pixelScaleOf(view: View): number {\n  const dpr = (typeof window !== 'undefined' && window.devicePixelRatio) || 1;\n  return Math.max(Math.abs(view.scale.x), Math.abs(view.scale.y)) * dpr;\n}\n\n// Shared across a frame's nodes, which all arrive with the same view.\nlet lastView: View | undefined;\nlet lastViewCtx: NodePaintCtx = {};\nfunction viewOnlyCtx(view: View): NodePaintCtx {\n  const pixelScale = pixelScaleOf(view);\n  if (view !== lastView || lastViewCtx.pixelScale !== pixelScale) {\n    lastView = view;\n    lastViewCtx = { pixelScale };\n  }\n  return lastViewCtx;\n}\n\n/** Paint one node the way the kit does by default: dispatch to the first\n *  registered node-shape painter that matches, then draw its `data.label` on\n *  top when it has one. Consumers replace or wrap this via `drawOne`. */\nexport function defaultDrawOne<TData, TLayer extends string, TPose>(\n  node: Node<TData, TLayer, TPose>,\n  pose: TPose,\n  view?: View,\n  ctx?: NodePaintCtx,\n): DrawCommand[] {\n  const painter = findNodeShape(node);\n  const paintCtx = !view || ctx?.pixelScale !== undefined\n    ? ctx\n    : ctx ? { ...ctx, pixelScale: pixelScaleOf(view) } : viewOnlyCtx(view);\n  const primary = painter ? painter.paint(node, pose, paintCtx) : [];\n\n  // Label overlay — skipped for text nodes (their content is the label).\n  const data = node.data as { label?: string; text?: string } | null;\n  if (data?.label && data.text == null) {\n    const p = pose as unknown as { x: number; y: number };\n    // Copy rather than `push`. A painter's return value is not ours to grow:\n    // one that memoizes its command list — which is the point of caching\n    // `paint` — would gain another label command on every frame, forever.\n    return [...primary, textCommandFromRuns(\n      p.x + 6,\n      p.y + 14,\n      [{ text: data.label, fill: { paint: { kind: 'solid', color: 'rgba(0,0,0,0.7)' } } }],\n      { fontFamily: 'sans-serif', fontSize: 11 },\n    )];\n  }\n\n  // Rotation and per-node alpha are applied OUTSIDE this function, by `wrapNodeOutput` in\n  // the scene walks and the preview-ghost layer, so that consumer-supplied painters get\n  // them too.\n  return primary;\n}\n\n/**\n * The box {@link defaultDrawOne}'s output for `node` fits in — the matched\n * painter's `bounds` — or `null` when it has none, or when a `data.label`\n * overlay adds text nothing bounds cheaply. The scene slot's `cull` reads it\n * to skip painting nodes the view cannot see.\n */\nexport function defaultPaintBounds<TData, TLayer extends string, TPose>(\n  node: Node<TData, TLayer, TPose>,\n  pose: TPose,\n  view: View,\n): Bounds | null {\n  const data = node.data as { label?: string; text?: string } | null;\n  if (data?.label && data.text == null) return null;\n  const sx = Math.abs(view.scale.x), sy = Math.abs(view.scale.y);\n  return findShapeBounds(node, pose, { scale: Math.sqrt(sx * sy), leastScale: Math.min(sx, sy) });\n}\n\n/**\n * `defaultPaintBounds` when `drawOne` is `defaultDrawOne`, and nothing\n * otherwise: a painter's box says nothing about what a replacement\n * `drawOne` paints.\n */\nexport function paintBoundsFor<TData, TLayer extends string, TPose>(\n  drawOne: unknown,\n): typeof defaultPaintBounds<TData, TLayer, TPose> | undefined {\n  return drawOne === defaultDrawOne ? defaultPaintBounds : undefined;\n}\n"],"mappings":";;;AAeA,SAASA,EAAa,GAAoB;CACxC,IAAMC,IAAO,OAAO,SAAW,OAAe,OAAO,oBAAqB;CAC1E,OAAO,KAAK,IAAI,KAAK,IAAIC,EAAK,MAAM,CAAC,GAAG,KAAK,IAAIA,EAAK,MAAM,CAAC,CAAC,IAAID;AACpE;AAGA,IAAIE,GACAC,IAA4B,CAAC;AACjC,SAASC,EAAY,GAA0B;CAC7C,IAAMC,IAAaN,EAAaE,CAAI;CAKpC,QAJIA,MAASC,KAAYC,EAAY,eAAeE,OAClD,IAAWJ,GACX,IAAc,EAAE,cAAW,IAEtBE;AACT;AAKA,SAAgBG,EACd,GACA,GACA,GACA,GACe;CACf,IAAMC,IAAUC,EAAcC,CAAI,GAC5BC,IAAW,CAACT,KAAQU,GAAK,eAAe,KAAA,IAC1CA,IACAA,IAAM;EAAE,GAAGA;EAAK,YAAYZ,EAAaE,CAAI;CAAE,IAAIG,EAAYH,CAAI,GACjEW,IAAUL,IAAUA,EAAQ,MAAME,GAAMI,GAAMH,CAAQ,IAAI,CAAC,GAG3DI,IAAOL,EAAK;CAClB,IAAIK,GAAM,SAASA,EAAK,QAAQ,MAAM;EACpC,IAAMC,IAAIF;EAIV,OAAO,CAAC,GAAGD,GAASI,EAClBD,EAAE,IAAI,GACNA,EAAE,IAAI,IACN,CAAC;GAAE,MAAMD,EAAK;GAAO,MAAM,EAAE,OAAO;IAAE,MAAM;IAAS,OAAO;GAAkB,EAAE;EAAE,CAAC,GACnF;GAAE,YAAY;GAAc,UAAU;EAAG,CAC3C,CAAC;CACH;CAKA,OAAOF;AACT;AAQA,SAAgBK,EACd,GACA,GACA,GACe;CACf,IAAMH,IAAOL,EAAK;CAClB,IAAIK,GAAM,SAASA,EAAK,QAAQ,MAAM,OAAO;CAC7C,IAAMI,IAAK,KAAK,IAAIjB,EAAK,MAAM,CAAC,GAAGkB,IAAK,KAAK,IAAIlB,EAAK,MAAM,CAAC;CAC7D,OAAOmB,EAAgBX,GAAMI,GAAM;EAAE,OAAO,KAAK,KAAKK,IAAKC,CAAE;EAAG,YAAY,KAAK,IAAID,GAAIC,CAAE;CAAE,CAAC;AAChG;AAOA,SAAgBE,EACd,GAC6D;CAC7D,OAAOC,MAAYhB,IAAiBW,IAAqB,KAAA;AAC3D"}
+{"version":3,"file":"defaultDrawOne.js","names":[],"sources":["../../src/canvas/defaultDrawOne.ts"],"sourcesContent":["/**\n * The kit's default per-node draw function, kept apart from `SceneCanvas.tsx` so non-React\n * callers (headless rasterization via `renderSceneToPixels`) can use it without importing the\n * React component tree.\n *\n * To teach the kit about a new kind of shape, register a painter (`registerNodeShape`) — do not\n * override `drawOne`. Override `drawOne` only for cross-cutting decoration.\n */\nimport type { Node } from 'core/scene/types';\nimport type { View } from 'core/viewport/view';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { textCommandFromRuns } from '@weasel-js/renderer';\nimport { findNodeShape, findShapeBounds, type NodePaintCtx } from './NodeShape';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { overChildren } from './overChildren';\n\nfunction pixelScaleOf(view: View): number {\n  const dpr = (typeof window !== 'undefined' && window.devicePixelRatio) || 1;\n  return Math.max(Math.abs(view.scale.x), Math.abs(view.scale.y)) * dpr;\n}\n\n// Shared across a frame's nodes, which all arrive with the same view.\nlet lastView: View | undefined;\nlet lastViewCtx: NodePaintCtx = {};\nfunction viewOnlyCtx(view: View): NodePaintCtx {\n  const pixelScale = pixelScaleOf(view);\n  if (view !== lastView || lastViewCtx.pixelScale !== pixelScale) {\n    lastView = view;\n    lastViewCtx = { pixelScale };\n  }\n  return lastViewCtx;\n}\n\n/** Paint one node the way the kit does by default: dispatch to the first\n *  registered node-shape painter that matches, then draw its `data.label` on\n *  top when it has one: on top of a container's children too. Consumers replace or wrap this via `drawOne`. */\nexport function defaultDrawOne<TData, TLayer extends string, TPose>(\n  node: Node<TData, TLayer, TPose>,\n  pose: TPose,\n  view?: View,\n  ctx?: NodePaintCtx,\n): DrawCommand[] {\n  const painter = findNodeShape(node);\n  const paintCtx = !view || ctx?.pixelScale !== undefined\n    ? ctx\n    : ctx ? { ...ctx, pixelScale: pixelScaleOf(view) } : viewOnlyCtx(view);\n  const primary = painter ? painter.paint(node, pose, paintCtx) : [];\n\n  // Label overlay — skipped for text nodes (their content is the label).\n  const data = node.data as { label?: string; text?: string } | null;\n  if (data?.label && data.text == null) {\n    const p = pose as unknown as { x: number; y: number };\n    // Copy rather than `push`. A painter's return value is not ours to grow:\n    // one that memoizes its command list — which is the point of caching\n    // `paint` — would gain another label command on every frame, forever.\n    const label = textCommandFromRuns(\n      p.x + 6,\n      p.y + 14,\n      [{ text: data.label, fill: { paint: { kind: 'solid', color: 'rgba(0,0,0,0.7)' } } }],\n      { fontFamily: 'sans-serif', fontSize: 11 },\n    );\n    // A container's children would cover a label drawn with the container.\n    return [...primary, node.kind === 'container' ? overChildren([label]) : label];\n  }\n\n  // Rotation and per-node alpha are applied OUTSIDE this function, by `wrapNodeOutput` in\n  // the scene walks and the preview-ghost layer, so that consumer-supplied painters get\n  // them too.\n  return primary;\n}\n\n/**\n * The box {@link defaultDrawOne}'s output for `node` fits in — the matched\n * painter's `bounds` — or `null` when it has none, or when a `data.label`\n * overlay adds text nothing bounds cheaply. The scene slot's `cull` reads it\n * to skip painting nodes the view cannot see.\n */\nexport function defaultPaintBounds<TData, TLayer extends string, TPose>(\n  node: Node<TData, TLayer, TPose>,\n  pose: TPose,\n  view: View,\n): Bounds | null {\n  const data = node.data as { label?: string; text?: string } | null;\n  if (data?.label && data.text == null) return null;\n  const sx = Math.abs(view.scale.x), sy = Math.abs(view.scale.y);\n  return findShapeBounds(node, pose, { scale: Math.sqrt(sx * sy), leastScale: Math.min(sx, sy) });\n}\n\n/**\n * `defaultPaintBounds` when `drawOne` is `defaultDrawOne`, and nothing\n * otherwise: a painter's box says nothing about what a replacement\n * `drawOne` paints.\n */\nexport function paintBoundsFor<TData, TLayer extends string, TPose>(\n  drawOne: unknown,\n): typeof defaultPaintBounds<TData, TLayer, TPose> | undefined {\n  return drawOne === defaultDrawOne ? defaultPaintBounds : undefined;\n}\n"],"mappings":";;;;;AAgBA,SAAS,aAAa,MAAoB;CACxC,MAAM,MAAO,OAAO,WAAW,eAAe,OAAO,oBAAqB;CAC1E,OAAO,KAAK,IAAI,KAAK,IAAI,KAAK,MAAM,CAAC,GAAG,KAAK,IAAI,KAAK,MAAM,CAAC,CAAC,IAAI;AACpE;AAGA,IAAI;AACJ,IAAI,cAA4B,CAAC;AACjC,SAAS,YAAY,MAA0B;CAC7C,MAAM,aAAa,aAAa,IAAI;CACpC,IAAI,SAAS,YAAY,YAAY,eAAe,YAAY;EAC9D,WAAW;EACX,cAAc,EAAE,WAAW;CAC7B;CACA,OAAO;AACT;;;;AAKA,SAAgB,eACd,MACA,MACA,MACA,KACe;CACf,MAAM,UAAU,cAAc,IAAI;CAClC,MAAM,WAAW,CAAC,QAAQ,KAAK,eAAe,SAC1C,MACA,MAAM;EAAE,GAAG;EAAK,YAAY,aAAa,IAAI;CAAE,IAAI,YAAY,IAAI;CACvE,MAAM,UAAU,UAAU,QAAQ,MAAM,MAAM,MAAM,QAAQ,IAAI,CAAC;CAGjE,MAAM,OAAO,KAAK;CAClB,IAAI,MAAM,SAAS,KAAK,QAAQ,MAAM;EACpC,MAAM,IAAI;EAIV,MAAM,QAAQ,oBACZ,EAAE,IAAI,GACN,EAAE,IAAI,IACN,CAAC;GAAE,MAAM,KAAK;GAAO,MAAM,EAAE,OAAO;IAAE,MAAM;IAAS,OAAO;GAAkB,EAAE;EAAE,CAAC,GACnF;GAAE,YAAY;GAAc,UAAU;EAAG,CAC3C;EAEA,OAAO,CAAC,GAAG,SAAS,KAAK,SAAS,cAAc,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK;CAC/E;CAKA,OAAO;AACT;;;;;;;AAQA,SAAgB,mBACd,MACA,MACA,MACe;CACf,MAAM,OAAO,KAAK;CAClB,IAAI,MAAM,SAAS,KAAK,QAAQ,MAAM,OAAO;CAC7C,MAAM,KAAK,KAAK,IAAI,KAAK,MAAM,CAAC,GAAG,KAAK,KAAK,IAAI,KAAK,MAAM,CAAC;CAC7D,OAAO,gBAAgB,MAAM,MAAM;EAAE,OAAO,KAAK,KAAK,KAAK,EAAE;EAAG,YAAY,KAAK,IAAI,IAAI,EAAE;CAAE,CAAC;AAChG;;;;;;AAOA,SAAgB,eACd,SAC6D;CAC7D,OAAO,YAAY,iBAAiB,qBAAqB;AAC3D"}

package/dist/canvas/deps/areaSelect.js

@@ -1,19 +1,37 @@
-import { hitTestArea as e, regionPickOptions as t } from "./hitTestArea.js";
-import { useLatest as n } from "@weasel-js/react";
-import { useDepSource as r } from "@weasel-js/routing/react";
+import { hitTestArea, regionPickOptions } from "./hitTestArea.js";
+import { useLatest } from "@weasel-js/react";
+import { useDepSource } from "@weasel-js/routing/react";
+
 //#region src/canvas/deps/areaSelect.ts
-function i(i, a, o, s) {
-	let c = n(i), l = n(a), u = n(o), d = n(s);
-	r("areaSelect", () => {
-		let n = c.current, r = l.current, i = u.current, a = d.current;
+/**
+* `useAreaSelectDepSource` — wires the `areaSelect` dep consumed by
+* `areaSelectAction`. The dep exposes:
+*   - `hitTestArea(bounds)` — silhouette-aware scan over `scene.renderOrderNodes()`
+*     (rect poses by AABB; polygon poses by the kernel polygon-overlap test).
+*   - `getSelection` / `setSelection` — passthrough to the kit selection api.
+*
+* Built once per render and stabilised by `useDepSource` (which reads via a
+* ref internally), so callers can pass fresh selection/scene refs without
+* triggering re-registration.
+*/
+function useAreaSelectDepSource(scene, selection, descriptor, alphaOf) {
+	const sceneRef = useLatest(scene);
+	const selectionRef = useLatest(selection);
+	const descriptorRef = useLatest(descriptor);
+	const alphaOfRef = useLatest(alphaOf);
+	useDepSource("areaSelect", () => {
+		const sc = sceneRef.current;
+		const s = selectionRef.current;
+		const d = descriptorRef.current;
+		const a = alphaOfRef.current;
 		return {
-			hitTestArea: (r, o) => e(n, r, t(o, a), i),
-			getSelection: () => r.current,
-			setSelection: (e) => r.set(e)
+			hitTestArea: (bounds, view) => hitTestArea(sc, bounds, regionPickOptions(view, a), d),
+			getSelection: () => s.current,
+			setSelection: (ids) => s.set(ids)
 		};
 	});
 }
-//#endregion
-export { i as useAreaSelectDepSource };
 
+//#endregion
+export { useAreaSelectDepSource };
 //# sourceMappingURL=areaSelect.js.map

package/dist/canvas/deps/areaSelect.js.map

@@ -1 +1 @@
-{"version":3,"file":"areaSelect.js","names":["hitTestAreaShared","useAreaSelectDepSource","sceneRef","useLatest","scene","selectionRef","selection","descriptorRef","descriptor","alphaOfRef","alphaOf","sc","s","d","hitTestArea","bounds","regionPickOptions","view","ids"],"sources":["../../../src/canvas/deps/areaSelect.ts"],"sourcesContent":["/**\n * `useAreaSelectDepSource` — wires the `areaSelect` dep consumed by\n * `areaSelectAction`. The dep exposes:\n *   - `hitTestArea(bounds)` — silhouette-aware scan over `scene.renderOrderNodes()`\n *     (rect poses by AABB; polygon poses by the kernel polygon-overlap test).\n *   - `getSelection` / `setSelection` — passthrough to the kit selection api.\n *\n * Built once per render and stabilised by `useDepSource` (which reads via a\n * ref internally), so callers can pass fresh selection/scene refs without\n * triggering re-registration.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { AreaSelectDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { hitTestArea as hitTestAreaShared, regionPickOptions } from './hitTestArea';\n\nexport function useAreaSelectDepSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  descriptor?: PoseDescriptor<unknown>,\n  /** The painted alpha the surface's layers apply, which every view shares. */\n  alphaOf?: (id: string) => number,\n): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const descriptorRef = useLatest(descriptor);\n  const alphaOfRef = useLatest(alphaOf);\n\n  useDepSource('areaSelect', (): AreaSelectDep => {\n    const sc = sceneRef.current;\n    const s = selectionRef.current;\n    const d = descriptorRef.current;\n    const a = alphaOfRef.current;\n    return {\n      hitTestArea: (bounds, view) =>\n        hitTestAreaShared(sc, bounds, regionPickOptions(view, a), d),\n      getSelection: () => s.current as NodeId[],\n      setSelection: (ids) => s.set(ids),\n    };\n  });\n}\n"],"mappings":";;;;AAmBA,SAAgBC,EACd,GACA,GACA,GAEA,GACM;CACN,IAAMC,IAAWC,EAAUC,CAAK,GAC1BC,IAAeF,EAAUG,CAAS,GAClCC,IAAgBJ,EAAUK,CAAU,GACpCC,IAAaN,EAAUO,CAAO;CAEpC,EAAa,oBAAmC;EAC9C,IAAMC,IAAKT,EAAS,SACdU,IAAIP,EAAa,SACjBQ,IAAIN,EAAc,SAClB,IAAIE,EAAW;EACrB,OAAO;GACL,cAAc,GAAQ,MACpBT,EAAkBW,GAAII,GAAQC,EAAkBC,GAAM,CAAC,GAAGJ,CAAC;GAC7D,oBAAoBD,EAAE;GACtB,eAAe,MAAQA,EAAE,IAAIM,CAAG;EAClC;CACF,CAAC;AACH"}
+{"version":3,"file":"areaSelect.js","names":["hitTestAreaShared"],"sources":["../../../src/canvas/deps/areaSelect.ts"],"sourcesContent":["/**\n * `useAreaSelectDepSource` — wires the `areaSelect` dep consumed by\n * `areaSelectAction`. The dep exposes:\n *   - `hitTestArea(bounds)` — silhouette-aware scan over `scene.renderOrderNodes()`\n *     (rect poses by AABB; polygon poses by the kernel polygon-overlap test).\n *   - `getSelection` / `setSelection` — passthrough to the kit selection api.\n *\n * Built once per render and stabilised by `useDepSource` (which reads via a\n * ref internally), so callers can pass fresh selection/scene refs without\n * triggering re-registration.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { AreaSelectDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { hitTestArea as hitTestAreaShared, regionPickOptions } from './hitTestArea';\n\nexport function useAreaSelectDepSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  descriptor?: PoseDescriptor<unknown>,\n  /** The painted alpha the surface's layers apply, which every view shares. */\n  alphaOf?: (id: string) => number,\n): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const descriptorRef = useLatest(descriptor);\n  const alphaOfRef = useLatest(alphaOf);\n\n  useDepSource('areaSelect', (): AreaSelectDep => {\n    const sc = sceneRef.current;\n    const s = selectionRef.current;\n    const d = descriptorRef.current;\n    const a = alphaOfRef.current;\n    return {\n      hitTestArea: (bounds, view) =>\n        hitTestAreaShared(sc, bounds, regionPickOptions(view, a), d),\n      getSelection: () => s.current as NodeId[],\n      setSelection: (ids) => s.set(ids),\n    };\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAmBA,SAAgB,uBACd,OACA,WACA,YAEA,SACM;CACN,MAAM,WAAW,UAAU,KAAK;CAChC,MAAM,eAAe,UAAU,SAAS;CACxC,MAAM,gBAAgB,UAAU,UAAU;CAC1C,MAAM,aAAa,UAAU,OAAO;CAEpC,aAAa,oBAAmC;EAC9C,MAAM,KAAK,SAAS;EACpB,MAAM,IAAI,aAAa;EACvB,MAAM,IAAI,cAAc;EACxB,MAAM,IAAI,WAAW;EACrB,OAAO;GACL,cAAc,QAAQ,SACpBA,YAAkB,IAAI,QAAQ,kBAAkB,MAAM,CAAC,GAAG,CAAC;GAC7D,oBAAoB,EAAE;GACtB,eAAe,QAAQ,EAAE,IAAI,GAAG;EAClC;CACF,CAAC;AACH"}

package/dist/canvas/deps/booleans.js

@@ -0,0 +1,104 @@
+import { poseDescriptorForNode } from "../../core/geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR } from "../../core/geometry/autoPoseDescriptor.js";
+import { pathPaintOf } from "../nodeShapes/nodePaint.js";
+import { asNodeId } from "../../core/scene/types.js";
+import { sceneMutators } from "../../core/scene/sceneMutators.js";
+import { scenePoseFrame } from "../../interactions/actions/poseFrame.js";
+import { drawnPose, leafPath, storePiece } from "./pathLeaf.js";
+import { pathInWorld } from "@weasel-js/geom";
+import { useMemo } from "react";
+import { useLatest } from "@weasel-js/react";
+import { useDepSource } from "@weasel-js/routing/react";
+
+//#region src/canvas/deps/booleans.ts
+/**
+* The kit `booleansAdapter` dep: what the Pathfinder actions, and any tool
+* reading the dep, work on over a canvas's own path leaves.
+*
+* `<SceneCanvas>` publishes it over its own scene. A consumer replaces it with
+* `useBooleansAdapter` from under the canvas — for text operands, say, which
+* this one does not read; the newest registration wins, and a canvas child
+* registers after the canvas's own.
+*/
+/**
+* Publish a `booleansAdapter` over `scene`'s path leaves (`data.path` drawn
+* through the pose's box). A result is minted from the source it stands in
+* for: its layer, parent, frame, and data, with the result's path, and the
+* result's paint in place of the source's when the operation gives one.
+*/
+function useBooleansAdapterSource(scene, selection, adapter, poseDescriptor) {
+	const sceneRef = useLatest(scene);
+	const selectionRef = useLatest(selection);
+	const adapterRef = useLatest(adapter);
+	const descriptorRef = useLatest(poseDescriptor);
+	const booleans = useMemo(() => {
+		const leafOf = (id) => {
+			const sc = sceneRef.current;
+			const node = sc.get(asNodeId(id));
+			const path = node ? leafPath(sc, node) : null;
+			if (!node || !path) return null;
+			const frame = scenePoseFrame(sc);
+			const g = poseDescriptorForNode(descriptorRef.current ?? AUTO_POSE_DESCRIPTOR, node);
+			const drawn = drawnPose(g, frame.world(node.id));
+			return drawn ? {
+				node,
+				path,
+				drawn,
+				frame
+			} : null;
+		};
+		const tree = () => sceneMutators(sceneRef.current);
+		return {
+			getNode: (id) => tree().getNode(id),
+			getParent: (id) => tree().getParent(id),
+			getChildren: (parentId) => tree().getChildren(parentId),
+			setChildOrder: (parentId, ids) => tree().setChildOrder(parentId, ids),
+			getSelection: () => selectionRef.current.get(),
+			getWorldPath: (id) => {
+				const leaf = leafOf(id);
+				return leaf ? pathInWorld(leaf.path, leaf.drawn.box) : void 0;
+			},
+			getPaint: (id) => {
+				const leaf = leafOf(id);
+				return leaf ? pathPaintOf(leaf.node.data) : void 0;
+			},
+			compareZ: (a, b) => {
+				const order = [...sceneRef.current.renderOrder()];
+				return order.indexOf(asNodeId(a)) - order.indexOf(asNodeId(b));
+			},
+			createPathNode: (path, _op, sourceId, paint) => {
+				const leaf = leafOf(sourceId);
+				if (!leaf) throw new Error(`[booleansAdapter] no path leaf behind source ${sourceId}`);
+				const stored = storePiece(leaf.drawn, path);
+				const { fill: _fill, stroke: _stroke, ...rest } = leaf.node.data ?? {};
+				const data = paint ? {
+					...rest,
+					...paint,
+					path: stored.path
+				} : {
+					...leaf.node.data,
+					path: stored.path
+				};
+				return {
+					id: sceneRef.current.mintId(),
+					kind: "leaf",
+					layer: leaf.node.layer,
+					parent: leaf.node.parent ?? null,
+					pose: leaf.frame.local(sourceId, stored.pose),
+					data
+				};
+			},
+			applyOps: (ops, label) => adapterRef.current.applyOps(ops, label)
+		};
+	}, [
+		sceneRef,
+		selectionRef,
+		adapterRef,
+		descriptorRef
+	]);
+	useDepSource("booleansAdapter", () => booleans);
+}
+
+//#endregion
+export { useBooleansAdapterSource };
+//# sourceMappingURL=booleans.js.map

package/dist/canvas/deps/booleans.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"booleans.js","names":[],"sources":["../../../src/canvas/deps/booleans.ts"],"sourcesContent":["/**\n * The kit `booleansAdapter` dep: what the Pathfinder actions, and any tool\n * reading the dep, work on over a canvas's own path leaves.\n *\n * `<SceneCanvas>` publishes it over its own scene. A consumer replaces it with\n * `useBooleansAdapter` from under the canvas — for text operands, say, which\n * this one does not read; the newest registration wins, and a canvas child\n * registers after the canvas's own.\n */\nimport { useMemo } from 'react';\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport { pathInWorld } from '@weasel-js/geom';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { sceneMutators } from 'core/scene/sceneMutators';\nimport { asNodeId, type Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { scenePoseFrame } from 'interactions/actions/poseFrame';\nimport type { BooleansAdapter } from 'interactions/actions/booleans/booleans';\nimport { pathPaintOf, type PathPaint } from '../nodeShapes/nodePaint';\nimport { drawnPose, leafPath, storePiece } from './pathLeaf';\nimport type { OpsApplier } from './slice';\n\n/**\n * Publish a `booleansAdapter` over `scene`'s path leaves (`data.path` drawn\n * through the pose's box). A result is minted from the source it stands in\n * for: its layer, parent, frame, and data, with the result's path, and the\n * result's paint in place of the source's when the operation gives one.\n */\nexport function useBooleansAdapterSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  adapter: OpsApplier,\n  poseDescriptor?: PoseDescriptor<unknown>,\n): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const adapterRef = useLatest(adapter);\n  const descriptorRef = useLatest(poseDescriptor);\n\n  const booleans = useMemo<BooleansAdapter>(() => {\n    const leafOf = (id: string) => {\n      const sc = sceneRef.current;\n      const node = sc.get(asNodeId(id));\n      const path = node ? leafPath(sc, node) : null;\n      if (!node || !path) return null;\n      const frame = scenePoseFrame(sc);\n      const g = poseDescriptorForNode(descriptorRef.current ?? AUTO_POSE_DESCRIPTOR, node);\n      const drawn = drawnPose(g, frame.world(node.id));\n      return drawn ? { node, path, drawn, frame } : null;\n    };\n    const tree = () => sceneMutators(sceneRef.current);\n    return {\n      getNode: (id) => tree().getNode(id),\n      getParent: (id) => tree().getParent(id),\n      getChildren: (parentId) => tree().getChildren(parentId),\n      setChildOrder: (parentId, ids) => tree().setChildOrder(parentId, ids),\n      getSelection: () => selectionRef.current.get(),\n      getWorldPath: (id) => {\n        const leaf = leafOf(id);\n        return leaf ? pathInWorld(leaf.path, leaf.drawn.box) : undefined;\n      },\n      getPaint: (id) => {\n        const leaf = leafOf(id);\n        return leaf ? pathPaintOf(leaf.node.data as Parameters<typeof pathPaintOf>[0]) : undefined;\n      },\n      compareZ: (a, b) => {\n        const order = [...sceneRef.current.renderOrder()];\n        return order.indexOf(asNodeId(a)) - order.indexOf(asNodeId(b));\n      },\n      createPathNode: (path, _op, sourceId, paint?: PathPaint) => {\n        const leaf = leafOf(sourceId);\n        if (!leaf) throw new Error(`[booleansAdapter] no path leaf behind source ${sourceId}`);\n        const stored = storePiece(leaf.drawn, path);\n        const { fill: _fill, stroke: _stroke, ...rest } = (leaf.node.data ?? {}) as Record<string, unknown>;\n        const data = paint ? { ...rest, ...paint, path: stored.path } : { ...(leaf.node.data as object), path: stored.path };\n        return {\n          id: sceneRef.current.mintId(),\n          kind: 'leaf',\n          layer: leaf.node.layer,\n          parent: leaf.node.parent ?? null,\n          pose: leaf.frame.local(sourceId, stored.pose),\n          data,\n        };\n      },\n      applyOps: (ops, label) => adapterRef.current.applyOps(ops, label),\n    };\n  }, [sceneRef, selectionRef, adapterRef, descriptorRef]);\n\n  useDepSource('booleansAdapter', () => booleans);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,yBACd,OACA,WACA,SACA,gBACM;CACN,MAAM,WAAW,UAAU,KAAK;CAChC,MAAM,eAAe,UAAU,SAAS;CACxC,MAAM,aAAa,UAAU,OAAO;CACpC,MAAM,gBAAgB,UAAU,cAAc;CAE9C,MAAM,WAAW,cAA+B;EAC9C,MAAM,UAAU,OAAe;GAC7B,MAAM,KAAK,SAAS;GACpB,MAAM,OAAO,GAAG,IAAI,SAAS,EAAE,CAAC;GAChC,MAAM,OAAO,OAAO,SAAS,IAAI,IAAI,IAAI;GACzC,IAAI,CAAC,QAAQ,CAAC,MAAM,OAAO;GAC3B,MAAM,QAAQ,eAAe,EAAE;GAC/B,MAAM,IAAI,sBAAsB,cAAc,WAAW,sBAAsB,IAAI;GACnF,MAAM,QAAQ,UAAU,GAAG,MAAM,MAAM,KAAK,EAAE,CAAC;GAC/C,OAAO,QAAQ;IAAE;IAAM;IAAM;IAAO;GAAM,IAAI;EAChD;EACA,MAAM,aAAa,cAAc,SAAS,OAAO;EACjD,OAAO;GACL,UAAU,OAAO,KAAK,CAAC,CAAC,QAAQ,EAAE;GAClC,YAAY,OAAO,KAAK,CAAC,CAAC,UAAU,EAAE;GACtC,cAAc,aAAa,KAAK,CAAC,CAAC,YAAY,QAAQ;GACtD,gBAAgB,UAAU,QAAQ,KAAK,CAAC,CAAC,cAAc,UAAU,GAAG;GACpE,oBAAoB,aAAa,QAAQ,IAAI;GAC7C,eAAe,OAAO;IACpB,MAAM,OAAO,OAAO,EAAE;IACtB,OAAO,OAAO,YAAY,KAAK,MAAM,KAAK,MAAM,GAAG,IAAI;GACzD;GACA,WAAW,OAAO;IAChB,MAAM,OAAO,OAAO,EAAE;IACtB,OAAO,OAAO,YAAY,KAAK,KAAK,IAAyC,IAAI;GACnF;GACA,WAAW,GAAG,MAAM;IAClB,MAAM,QAAQ,CAAC,GAAG,SAAS,QAAQ,YAAY,CAAC;IAChD,OAAO,MAAM,QAAQ,SAAS,CAAC,CAAC,IAAI,MAAM,QAAQ,SAAS,CAAC,CAAC;GAC/D;GACA,iBAAiB,MAAM,KAAK,UAAU,UAAsB;IAC1D,MAAM,OAAO,OAAO,QAAQ;IAC5B,IAAI,CAAC,MAAM,MAAM,IAAI,MAAM,gDAAgD,UAAU;IACrF,MAAM,SAAS,WAAW,KAAK,OAAO,IAAI;IAC1C,MAAM,EAAE,MAAM,OAAO,QAAQ,SAAS,GAAG,SAAU,KAAK,KAAK,QAAQ,CAAC;IACtE,MAAM,OAAO,QAAQ;KAAE,GAAG;KAAM,GAAG;KAAO,MAAM,OAAO;IAAK,IAAI;KAAE,GAAI,KAAK,KAAK;KAAiB,MAAM,OAAO;IAAK;IACnH,OAAO;KACL,IAAI,SAAS,QAAQ,OAAO;KAC5B,MAAM;KACN,OAAO,KAAK,KAAK;KACjB,QAAQ,KAAK,KAAK,UAAU;KAC5B,MAAM,KAAK,MAAM,MAAM,UAAU,OAAO,IAAI;KAC5C;IACF;GACF;GACA,WAAW,KAAK,UAAU,WAAW,QAAQ,SAAS,KAAK,KAAK;EAClE;CACF,GAAG;EAAC;EAAU;EAAc;EAAY;CAAa,CAAC;CAEtD,aAAa,yBAAyB,QAAQ;AAChD"}

package/dist/canvas/deps/changes.js

@@ -1,13 +1,21 @@
-import { useEffect as e } from "react";
-import { useDepRegistry as t } from "@weasel-js/routing/react";
+import { useEffect } from "react";
+import { useDepRegistry } from "@weasel-js/routing/react";
+
 //#region src/canvas/deps/changes.ts
-function n(n, r) {
-	let i = t();
-	e(() => n.subscribe(() => i.changed?.()), [n, i]), e(() => {
-		i.changed?.();
-	}, [i, r]);
+/**
+* `useDepChangeNotices` — tells the dep registry when the scene, the
+* selection, or the path-edit state changed. Sources are thunks, so nothing else lets chrome showing
+* an action's `enabled` or `active` state know to read them again.
+*/
+function useDepChangeNotices(scene, selected, pathEdit) {
+	const registry = useDepRegistry();
+	useEffect(() => scene.subscribe(() => registry.changed?.()), [scene, registry]);
+	useEffect(() => pathEdit?.subscribe?.(() => registry.changed?.()), [pathEdit, registry]);
+	useEffect(() => {
+		registry.changed?.();
+	}, [registry, selected]);
 }
-//#endregion
-export { n as useDepChangeNotices };
 
+//#endregion
+export { useDepChangeNotices };
 //# sourceMappingURL=changes.js.map

package/dist/canvas/deps/changes.js.map

@@ -1 +1 @@
-{"version":3,"file":"changes.js","names":["useDepChangeNotices","registry","useDepRegistry","useEffect","scene","selected"],"sources":["../../../src/canvas/deps/changes.ts"],"sourcesContent":["/**\n * `useDepChangeNotices` — tells the dep registry when the scene or the\n * selection changed. Sources are thunks, so nothing else lets chrome showing\n * an action's `enabled` or `active` state know to read them again.\n */\nimport { useEffect } from 'react';\nimport { useDepRegistry } from '@weasel-js/routing/react';\n\nexport function useDepChangeNotices(\n  scene: { subscribe(listener: () => void): () => void },\n  selected: readonly unknown[],\n): void {\n  const registry = useDepRegistry();\n  useEffect(() => scene.subscribe(() => registry.changed?.()), [scene, registry]);\n  useEffect(() => { registry.changed?.(); }, [registry, selected]);\n}\n"],"mappings":";;;AAQA,SAAgBA,EACd,GACA,GACM;CACN,IAAMC,IAAWC,EAAe;CAEhC,AADAC,QAAgBC,EAAM,gBAAgBH,EAAS,UAAU,CAAC,GAAG,CAACG,GAAOH,CAAQ,CAAC,GAC9EE,QAAgB;EAAE,EAAS,UAAU;CAAG,GAAG,CAACF,GAAUI,CAAQ,CAAC;AACjE"}
+{"version":3,"file":"changes.js","names":[],"sources":["../../../src/canvas/deps/changes.ts"],"sourcesContent":["/**\n * `useDepChangeNotices` — tells the dep registry when the scene, the\n * selection, or the path-edit state changed. Sources are thunks, so nothing else lets chrome showing\n * an action's `enabled` or `active` state know to read them again.\n */\nimport { useEffect } from 'react';\nimport { useDepRegistry } from '@weasel-js/routing/react';\n\nexport function useDepChangeNotices(\n  scene: { subscribe(listener: () => void): () => void },\n  selected: readonly unknown[],\n  pathEdit?: { subscribe?(listener: () => void): () => void },\n): void {\n  const registry = useDepRegistry();\n  useEffect(() => scene.subscribe(() => registry.changed?.()), [scene, registry]);\n  useEffect(() => pathEdit?.subscribe?.(() => registry.changed?.()), [pathEdit, registry]);\n  useEffect(() => { registry.changed?.(); }, [registry, selected]);\n}\n"],"mappings":";;;;;;;;;AAQA,SAAgB,oBACd,OACA,UACA,UACM;CACN,MAAM,WAAW,eAAe;CAChC,gBAAgB,MAAM,gBAAgB,SAAS,UAAU,CAAC,GAAG,CAAC,OAAO,QAAQ,CAAC;CAC9E,gBAAgB,UAAU,kBAAkB,SAAS,UAAU,CAAC,GAAG,CAAC,UAAU,QAAQ,CAAC;CACvF,gBAAgB;EAAE,SAAS,UAAU;CAAG,GAAG,CAAC,UAAU,QAAQ,CAAC;AACjE"}

package/dist/canvas/deps/debug.js

@@ -1,9 +1,16 @@
-import { useDepSource as e } from "@weasel-js/routing/react";
+import { useDepSource } from "@weasel-js/routing/react";
+
 //#region src/canvas/deps/debug.ts
-function t(t) {
-	e("debug", () => t.current?.getDebug() ?? void 0);
+/**
+* `useDebugDepSource` — wires the `debug` dep: the sink of the canvas this
+* registrar belongs to, so actions report to the debug overlay that canvas
+* draws. Resolved at invocation, because the canvas creates its sink after
+* this registers and swaps it whenever `debug` changes.
+*/
+function useDebugDepSource(canvasApiRef) {
+	useDepSource("debug", () => canvasApiRef.current?.getDebug() ?? void 0);
 }
-//#endregion
-export { t as useDebugDepSource };
 
+//#endregion
+export { useDebugDepSource };
 //# sourceMappingURL=debug.js.map

package/dist/canvas/deps/debug.js.map

@@ -1 +1 @@
-{"version":3,"file":"debug.js","names":["useDebugDepSource","canvasApiRef"],"sources":["../../../src/canvas/deps/debug.ts"],"sourcesContent":["/**\n * `useDebugDepSource` — wires the `debug` dep: the sink of the canvas this\n * registrar belongs to, so actions report to the debug overlay that canvas\n * draws. Resolved at invocation, because the canvas creates its sink after\n * this registers and swaps it whenever `debug` changes.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport type { CanvasExtensionApi } from '../canvasExtension';\n\nexport function useDebugDepSource(canvasApiRef: React.RefObject<CanvasExtensionApi | null>): void {\n  useDepSource('debug', () => canvasApiRef.current?.getDebug() ?? undefined);\n}\n"],"mappings":";;AASA,SAAgBA,EAAkB,GAAgE;CAChG,EAAa,eAAeC,EAAa,SAAS,SAAS,KAAK,KAAA,CAAS;AAC3E"}
+{"version":3,"file":"debug.js","names":[],"sources":["../../../src/canvas/deps/debug.ts"],"sourcesContent":["/**\n * `useDebugDepSource` — wires the `debug` dep: the sink of the canvas this\n * registrar belongs to, so actions report to the debug overlay that canvas\n * draws. Resolved at invocation, because the canvas creates its sink after\n * this registers and swaps it whenever `debug` changes.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport type { CanvasExtensionApi } from '../canvasExtension';\n\nexport function useDebugDepSource(canvasApiRef: React.RefObject<CanvasExtensionApi | null>): void {\n  useDepSource('debug', () => canvasApiRef.current?.getDebug() ?? undefined);\n}\n"],"mappings":";;;;;;;;;AASA,SAAgB,kBAAkB,cAAgE;CAChG,aAAa,eAAe,aAAa,SAAS,SAAS,KAAK,MAAS;AAC3E"}

package/dist/canvas/deps/dispatchSources.js

@@ -0,0 +1,27 @@
+import { useDepSource } from "@weasel-js/routing/react";
+
+//#region src/canvas/deps/dispatchSources.ts
+var hitOf = (c) => ({
+	bodyTarget: c.body,
+	bodyKind: c.kind,
+	...c.id !== void 0 ? { id: c.id } : {}
+});
+/** The `hitAt` answer for one view: its own classifier's verdict on a point. */
+function hitAtOf(classifyTarget) {
+	return (world) => {
+		const c = classifyTarget(world);
+		return {
+			...hitOf(c),
+			...c.doubleClick ? { doubleClick: hitOf(c.doubleClick) } : {}
+		};
+	};
+}
+function useDispatchDepSources(longPress, classifyTarget, kindOfNode) {
+	useDepSource("longPress", () => longPress);
+	useDepSource("hitAt", () => classifyTarget && hitAtOf(classifyTarget));
+	useDepSource("kindOfNode", () => (id) => kindOfNode.current?.(id));
+}
+
+//#endregion
+export { hitAtOf, useDispatchDepSources };
+//# sourceMappingURL=dispatchSources.js.map

package/dist/canvas/deps/dispatchSources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatchSources.js","names":[],"sources":["../../../src/canvas/deps/dispatchSources.ts"],"sourcesContent":["/**\n * `useDispatchDepSources` — the deps that carry what the gesture dispatcher\n * knows about a press: the pending `longPress`, `hitAt`, its classification of\n * a world point, and `kindOfNode`, the routing kind behind it. An action that\n * must agree with the dispatcher about what is under a point reads these, not\n * a picker of its own.\n */\nimport type { BodyClassification, BodyTarget } from '@weasel-js/gestures';\nimport type { DepSchema, LongPressState } from '@weasel-js/routing';\nimport { useDepSource } from '@weasel-js/routing/react';\n\ndeclare module '@weasel-js/routing' {\n  interface DepSchema {\n    /** What the dispatcher classifies a world point as: empty, or a body that\n     *  is or is not selected, with its routing kind and id, and `doubleClick`,\n     *  the same for the node a double-click there names where that is another\n     *  (a hit member's group). Sourced by `<SceneCanvas>`; absent when it has\n     *  no selection or picker to classify with. */\n    hitAt?: (world: { x: number; y: number }) => HitAt & { doubleClick?: HitAt };\n    /** A node's routing kind (`'rect'`, `'text'`), as `kind:` targets read it.\n     *  Sourced by `<SceneCanvas>`; absent under `routing={[]}`. */\n    kindOfNode?: (id: string) => string | undefined;\n  }\n}\n\n/** One classified body, as `hitAt` reports it. */\nexport interface HitAt { bodyTarget: BodyTarget; bodyKind?: string; id?: string }\n\ntype Classify = (world: { x: number; y: number }) => BodyClassification;\n\nconst hitOf = (c: { body: BodyTarget; kind?: string; id?: string }): HitAt =>\n  ({ bodyTarget: c.body, bodyKind: c.kind, ...(c.id !== undefined ? { id: c.id } : {}) });\n\n/** The `hitAt` answer for one view: its own classifier's verdict on a point. */\nexport function hitAtOf(classifyTarget: Classify): NonNullable<DepSchema['hitAt']> {\n  return (world) => {\n    const c = classifyTarget(world);\n    return { ...hitOf(c), ...(c.doubleClick ? { doubleClick: hitOf(c.doubleClick) } : {}) };\n  };\n}\n\nexport function useDispatchDepSources(\n  longPress: LongPressState,\n  classifyTarget: Classify | undefined,\n  kindOfNode: { readonly current: ((id: string) => string | undefined) | undefined },\n): void {\n  useDepSource('longPress', () => longPress);\n  useDepSource('hitAt', () => classifyTarget && hitAtOf(classifyTarget));\n  useDepSource('kindOfNode', () => (id) => kindOfNode.current?.(id));\n}\n"],"mappings":";;;AA8BA,IAAM,SAAS,OACZ;CAAE,YAAY,EAAE;CAAM,UAAU,EAAE;CAAM,GAAI,EAAE,OAAO,SAAY,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC;AAAG;;AAGvF,SAAgB,QAAQ,gBAA2D;CACjF,QAAQ,UAAU;EAChB,MAAM,IAAI,eAAe,KAAK;EAC9B,OAAO;GAAE,GAAG,MAAM,CAAC;GAAG,GAAI,EAAE,cAAc,EAAE,aAAa,MAAM,EAAE,WAAW,EAAE,IAAI,CAAC;EAAG;CACxF;AACF;AAEA,SAAgB,sBACd,WACA,gBACA,YACM;CACN,aAAa,mBAAmB,SAAS;CACzC,aAAa,eAAe,kBAAkB,QAAQ,cAAc,CAAC;CACrE,aAAa,qBAAqB,OAAO,WAAW,UAAU,EAAE,CAAC;AACnE"}

package/dist/canvas/deps/dispatcher.js

@@ -1,11 +1,22 @@
-import { useLatest as e } from "@weasel-js/react";
-import { useDepSource as t } from "@weasel-js/routing/react";
+import { useLatest } from "@weasel-js/react";
+import { useDepSource } from "@weasel-js/routing/react";
+
 //#region src/canvas/deps/dispatcher.ts
-function n(n) {
-	let r = e(n);
-	t("dispatcher", () => ({ cancelAll: (e) => r.current.cancelAll(e) }));
+/**
+* `useDispatcherDepSource` — wires the `dispatcher` dep so actions can
+* abort in-flight handles (`cancelGestureAction` is the kit's only
+* built-in consumer today; consumer-app actions wanting drag-cancel
+* semantics use the same surface).
+*
+* Exposes only the control methods actions might legitimately need —
+* `cancelAll(reason)` — not the full dispatcher API. Keeps the dep's
+* blast radius narrow.
+*/
+function useDispatcherDepSource(dispatcher) {
+	const ref = useLatest(dispatcher);
+	useDepSource("dispatcher", () => ({ cancelAll: (reason) => ref.current.cancelAll(reason) }));
 }
-//#endregion
-export { n as useDispatcherDepSource };
 
+//#endregion
+export { useDispatcherDepSource };
 //# sourceMappingURL=dispatcher.js.map

package/dist/canvas/deps/dispatcher.js.map

@@ -1 +1 @@
-{"version":3,"file":"dispatcher.js","names":["useDispatcherDepSource","ref","useLatest","dispatcher","reason"],"sources":["../../../src/canvas/deps/dispatcher.ts"],"sourcesContent":["/**\n * `useDispatcherDepSource` — wires the `dispatcher` dep so actions can\n * abort in-flight handles (`cancelGestureAction` is the kit's only\n * built-in consumer today; consumer-app actions wanting drag-cancel\n * semantics use the same surface).\n *\n * Exposes only the control methods actions might legitimately need —\n * `cancelAll(reason)` — not the full dispatcher API. Keeps the dep's\n * blast radius narrow.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Dispatcher } from '@weasel-js/routing';\n\nexport function useDispatcherDepSource(dispatcher: Dispatcher): void {\n  const ref = useLatest(dispatcher);\n\n  useDepSource('dispatcher', () => ({\n    cancelAll: (reason) => ref.current.cancelAll(reason),\n  }));\n}\n"],"mappings":";;;AAcA,SAAgBA,EAAuB,GAA8B;CACnE,IAAMC,IAAMC,EAAUC,CAAU;CAEhC,EAAa,qBAAqB,EAChC,YAAY,MAAWF,EAAI,QAAQ,UAAUG,CAAM,EACrD,EAAE;AACJ"}
+{"version":3,"file":"dispatcher.js","names":[],"sources":["../../../src/canvas/deps/dispatcher.ts"],"sourcesContent":["/**\n * `useDispatcherDepSource` — wires the `dispatcher` dep so actions can\n * abort in-flight handles (`cancelGestureAction` is the kit's only\n * built-in consumer today; consumer-app actions wanting drag-cancel\n * semantics use the same surface).\n *\n * Exposes only the control methods actions might legitimately need —\n * `cancelAll(reason)` — not the full dispatcher API. Keeps the dep's\n * blast radius narrow.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Dispatcher } from '@weasel-js/routing';\n\nexport function useDispatcherDepSource(dispatcher: Dispatcher): void {\n  const ref = useLatest(dispatcher);\n\n  useDepSource('dispatcher', () => ({\n    cancelAll: (reason) => ref.current.cancelAll(reason),\n  }));\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAgB,uBAAuB,YAA8B;CACnE,MAAM,MAAM,UAAU,UAAU;CAEhC,aAAa,qBAAqB,EAChC,YAAY,WAAW,IAAI,QAAQ,UAAU,MAAM,EACrD,EAAE;AACJ"}