@weasel-js/core 1.10.1 → 1.11.0

package/dist/canvas/SceneCanvas/useDepartureGhostLayer.js

@@ -0,0 +1,64 @@
+import { deriveParallaxView } from "../../core/viewport/parallax.js";
+import { composeWorldPose, composesFrames } from "../../core/scene/composeFrame.js";
+import { definesFrame, effectivePose } from "../../core/scene/effectivePose.js";
+import { wrapWithPoseRotation } from "../poseRotation.js";
+import { isCustomEntry } from "../layerSlots.js";
+import { useMemo } from "react";
+import { useLatest } from "@weasel-js/react";
+
+//#region src/canvas/SceneCanvas/useDepartureGhostLayer.ts
+/**
+* The layer `<SceneCanvas poseTransition exit>` draws removed nodes leaving
+* on: each ghost through the scene slot's `drawOne`, at the pose and opacity
+* its glide shows, inside the frame of a parent still in the scene.
+*/
+function useDepartureGhostLayer(args) {
+	const sceneRef = useLatest(args.scene);
+	const slotRef = useLatest(args.sceneSlot);
+	const { departures } = args;
+	return useMemo(() => ({
+		id: "departure-ghost",
+		label: "Departing nodes",
+		draw: (_data, view) => {
+			const slot = slotRef.current;
+			const leaving = departures.shown();
+			if (leaving.length === 0 || !slot || isCustomEntry(slot) || !slot.drawOne) return [];
+			const drawOne = slot.drawOne;
+			const sc = sceneRef.current;
+			const { compose } = sc.composition;
+			const composes = composesFrames(sc.composition);
+			const frames = {
+				getParent: (id) => sc.get(id)?.parent ?? null,
+				getPose: (id) => effectivePose(sc, sc.get(id)),
+				definesFrame: (id) => definesFrame(sc.get(id))
+			};
+			const viewOf = (layer) => {
+				const parallax = sc.layers.find((l) => l.id === layer)?.parallax;
+				return parallax ? deriveParallaxView(view, parallax) : view;
+			};
+			const draw = (r, pose, out) => {
+				out.push(...wrapWithPoseRotation(drawOne(r.node, pose, viewOf(r.node.layer)), pose));
+				for (const c of r.children) draw(c, composes ? compose(pose, c.pose) : c.pose, out);
+			};
+			return leaving.map(({ removal, pose, alpha }) => {
+				const parent = removal.parent !== null && sc.get(removal.parent) ? removal.parent : null;
+				const world = composes && parent !== null ? compose(composeWorldPose(frames, parent, compose), pose) : pose;
+				const children = [];
+				draw(removal, world, children);
+				return {
+					kind: "group",
+					alpha: Math.max(0, Math.min(1, alpha)),
+					children
+				};
+			});
+		}
+	}), [
+		departures,
+		sceneRef,
+		slotRef
+	]);
+}
+
+//#endregion
+export { useDepartureGhostLayer };
+//# sourceMappingURL=useDepartureGhostLayer.js.map

package/dist/canvas/SceneCanvas/useDepartureGhostLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDepartureGhostLayer.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useDepartureGhostLayer.ts"],"sourcesContent":["/**\n * The layer `<SceneCanvas poseTransition exit>` draws removed nodes leaving\n * on: each ghost through the scene slot's `drawOne`, at the pose and opacity\n * its glide shows, inside the frame of a parent still in the scene.\n */\nimport { useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { composesFrames, composeWorldPose } from 'core/scene/composePose';\nimport { definesFrame, effectivePose } from 'core/scene/effectivePose';\nimport type { RemovedNode } from 'core/scene/poseWrites';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { deriveParallaxView } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport type { Departures } from '../../animation/departures';\nimport { isCustomEntry, type LayersMap } from '../layerSlots';\nimport { wrapWithPoseRotation } from '../poseRotation';\n\nexport function useDepartureGhostLayer<TData, TLayer extends string, TPose>(args: {\n  scene: Scene<TData, TLayer, TPose>;\n  sceneSlot: LayersMap<Node<TData, TLayer, TPose>, TPose>['scene'];\n  departures: Departures<TPose, Node<TData, TLayer, TPose>>;\n}): RenderLayer<unknown> {\n  const sceneRef = useLatest(args.scene);\n  const slotRef = useLatest(args.sceneSlot);\n  const { departures } = args;\n\n  return useMemo<RenderLayer<unknown>>(() => ({\n    id: 'departure-ghost',\n    label: 'Departing nodes',\n    draw: (_data, view) => {\n      const slot = slotRef.current;\n      const leaving = departures.shown();\n      if (leaving.length === 0 || !slot || isCustomEntry(slot) || !slot.drawOne) return [];\n      const drawOne = slot.drawOne;\n      const sc = sceneRef.current;\n      const { compose } = sc.composition;\n      const composes = composesFrames(sc.composition);\n      const frames = {\n        getParent: (id: string) => sc.get(id as NodeId)?.parent ?? null,\n        getPose: (id: string) => effectivePose(sc, sc.get(id as NodeId)!),\n        definesFrame: (id: string) => definesFrame(sc.get(id as NodeId)!),\n      };\n      const viewOf = (layer: string): View => {\n        const parallax = sc.layers.find((l) => l.id === layer)?.parallax;\n        return parallax ? deriveParallaxView(view, parallax) : view;\n      };\n      const draw = (r: RemovedNode<TPose, Node<TData, TLayer, TPose>>, pose: TPose, out: DrawCommand[]): void => {\n        out.push(...wrapWithPoseRotation(drawOne(r.node, pose, viewOf(r.node.layer)), pose));\n        for (const c of r.children) draw(c, composes ? compose(pose, c.pose) : c.pose, out);\n      };\n      return leaving.map(({ removal, pose, alpha }): DrawCommand => {\n        const parent = removal.parent !== null && sc.get(removal.parent) ? removal.parent : null;\n        const world = composes && parent !== null ? compose(composeWorldPose(frames, parent, compose), pose) : pose;\n        const children: DrawCommand[] = [];\n        draw(removal, world, children);\n        return { kind: 'group', alpha: Math.max(0, Math.min(1, alpha)), children };\n      });\n    },\n  }), [departures, sceneRef, slotRef]);\n}\n"],"mappings":";;;;;;;;;;;;;;AAmBA,SAAgB,uBAA4D,MAInD;CACvB,MAAM,WAAW,UAAU,KAAK,KAAK;CACrC,MAAM,UAAU,UAAU,KAAK,SAAS;CACxC,MAAM,EAAE,eAAe;CAEvB,OAAO,eAAqC;EAC1C,IAAI;EACJ,OAAO;EACP,OAAO,OAAO,SAAS;GACrB,MAAM,OAAO,QAAQ;GACrB,MAAM,UAAU,WAAW,MAAM;GACjC,IAAI,QAAQ,WAAW,KAAK,CAAC,QAAQ,cAAc,IAAI,KAAK,CAAC,KAAK,SAAS,OAAO,CAAC;GACnF,MAAM,UAAU,KAAK;GACrB,MAAM,KAAK,SAAS;GACpB,MAAM,EAAE,YAAY,GAAG;GACvB,MAAM,WAAW,eAAe,GAAG,WAAW;GAC9C,MAAM,SAAS;IACb,YAAY,OAAe,GAAG,IAAI,EAAY,CAAC,EAAE,UAAU;IAC3D,UAAU,OAAe,cAAc,IAAI,GAAG,IAAI,EAAY,CAAE;IAChE,eAAe,OAAe,aAAa,GAAG,IAAI,EAAY,CAAE;GAClE;GACA,MAAM,UAAU,UAAwB;IACtC,MAAM,WAAW,GAAG,OAAO,MAAM,MAAM,EAAE,OAAO,KAAK,CAAC,EAAE;IACxD,OAAO,WAAW,mBAAmB,MAAM,QAAQ,IAAI;GACzD;GACA,MAAM,QAAQ,GAAmD,MAAa,QAA6B;IACzG,IAAI,KAAK,GAAG,qBAAqB,QAAQ,EAAE,MAAM,MAAM,OAAO,EAAE,KAAK,KAAK,CAAC,GAAG,IAAI,CAAC;IACnF,KAAK,MAAM,KAAK,EAAE,UAAU,KAAK,GAAG,WAAW,QAAQ,MAAM,EAAE,IAAI,IAAI,EAAE,MAAM,GAAG;GACpF;GACA,OAAO,QAAQ,KAAK,EAAE,SAAS,MAAM,YAAyB;IAC5D,MAAM,SAAS,QAAQ,WAAW,QAAQ,GAAG,IAAI,QAAQ,MAAM,IAAI,QAAQ,SAAS;IACpF,MAAM,QAAQ,YAAY,WAAW,OAAO,QAAQ,iBAAiB,QAAQ,QAAQ,OAAO,GAAG,IAAI,IAAI;IACvG,MAAM,WAA0B,CAAC;IACjC,KAAK,SAAS,OAAO,QAAQ;IAC7B,OAAO;KAAE,MAAM;KAAS,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,KAAK,CAAC;KAAG;IAAS;GAC3E,CAAC;EACH;CACF,IAAI;EAAC;EAAY;EAAU;CAAO,CAAC;AACrC"}

package/dist/canvas/SceneCanvas/useDispatcherOverlayLayer.js

@@ -1,108 +1,141 @@
-import { viewToTransform as e } from "../../core/viewport/view.js";
-import { worldToScreen as t } from "../../core/viewport/viewTransform.js";
-import { OVERLAY_ROLE_STROKES as n } from "../overlayRoleStrokes.js";
-import { gestureOverlaysFrom as r, isVisibleFrom as i } from "../drawEnvelope.js";
-import { resolveOverlays as a } from "../../interactions/actions/resolveOverlays.js";
-import { insertPreviewCommands as o } from "./insertPreviewCommands.js";
-import { polygonFromPoints as s, polylineFromPoints as c } from "@weasel-js/geom";
-import { useEffect as l, useMemo as u, useReducer as d } from "react";
-import { useLatest as f } from "@weasel-js/react";
+import { viewToTransform } from "../../core/viewport/view.js";
+import { worldToScreen } from "../../core/viewport/viewTransform.js";
+import { OVERLAY_ROLE_STROKES } from "../overlayRoleStrokes.js";
+import { gestureOverlaysFrom, isVisibleFrom } from "../drawEnvelope.js";
+import { resolveOverlays } from "../../interactions/actions/resolveOverlays.js";
+import { insertPreviewCommands } from "./insertPreviewCommands.js";
+import { brushOverlayCommands } from "./brushOverlay.js";
+import { polygonFromPoints, polylineFromPoints } from "@weasel-js/geom";
+import { useEffect, useMemo, useReducer } from "react";
+import { useLatest } from "@weasel-js/react";
+
 //#region src/canvas/SceneCanvas/useDispatcherOverlayLayer.ts
-var p = {
+/**
+* Dispatcher overlay render layer for `<SceneCanvas>`.
+*
+* Paints the overlay shapes the drawing view's in-flight handles publish,
+* taken off the draw envelope so a panel shows its own gesture rather than
+* the surface's. `resolveOverlays` does the reading; everything here is
+* painting.
+*
+* Distinct from `usePreviewGhostLayer`, which paints displaced scene-node
+* silhouettes. This layer is for gestures whose visual feedback isn't a moved
+* scene node — a marquee rect, a lasso polyline, an insert preview, a brush.
+*/
+var DEFAULT_STYLE = {
 	fill: "rgba(164, 139, 212, 0.18)",
 	stroke: "#a48bd4",
 	dash: [3, 3],
 	lineWidth: 1
 };
-function m(m) {
-	let { dispatcher: h, style: g } = m, _ = f(g), [, v] = d((e) => e + 1, 0);
-	return l(() => {
-		if (h) return h.subscribe(v);
-	}, [h]), u(() => ({
+function onScreen(points, t) {
+	return points.map((p) => {
+		const [sx, sy] = worldToScreen(p.x, p.y, t);
+		return {
+			x: sx,
+			y: sy
+		};
+	});
+}
+function useDispatcherOverlayLayer(args) {
+	const { dispatcher, style } = args;
+	const styleRef = useLatest(style);
+	const [, forceRerender] = useReducer((n) => n + 1, 0);
+	useEffect(() => {
+		if (!dispatcher) return;
+		return dispatcher.subscribe(forceRerender);
+	}, [dispatcher]);
+	return useMemo(() => ({
 		id: "dispatcher-overlay",
 		label: "Dispatcher overlay",
 		space: "screen",
-		draw: (l, u) => {
-			let d = {
-				...p,
-				..._.current ?? {}
-			}, f = {
-				...n,
-				..._.current?.roles ?? {}
-			}, m = e(u), h = [], g = i(l), v = (e) => !g || g(e);
-			for (let e of a(r(l))) if (v(e.visibilityId)) {
-				if (e.kind === "marquee") {
-					let n = e.bounds, [r, i] = t(n.x, n.y, m), a = {
+		draw: (data, view) => {
+			const cfg = {
+				...DEFAULT_STYLE,
+				...styleRef.current ?? {}
+			};
+			const roles = {
+				...OVERLAY_ROLE_STROKES,
+				...styleRef.current?.roles ?? {}
+			};
+			const t = viewToTransform(view);
+			const out = [];
+			const isVisible = isVisibleFrom(data);
+			const passes = (id) => isVisible ? isVisible(id) : true;
+			for (const ov of resolveOverlays(gestureOverlaysFrom(data))) {
+				if (!passes(ov.visibilityId)) continue;
+				if (ov.kind === "marquee") {
+					const b = ov.bounds;
+					const [sx, sy] = worldToScreen(b.x, b.y, t);
+					const cmd = {
 						kind: "path",
 						path: {
 							kind: "rect",
-							x: r,
-							y: i,
-							width: n.width * u.scale.x,
-							height: n.height * u.scale.y
+							x: sx,
+							y: sy,
+							width: b.width * view.scale.x,
+							height: b.height * view.scale.y
 						},
-						fill: { paint: { color: d.fill } },
+						fill: { paint: { color: cfg.fill } },
 						stroke: {
-							paint: { color: d.stroke },
-							width: d.lineWidth,
-							dash: d.dash
+							paint: { color: cfg.stroke },
+							width: cfg.lineWidth,
+							dash: cfg.dash
 						}
 					};
-					h.push(a);
+					out.push(cmd);
 					continue;
 				}
-				if (e.kind === "insertPreview") {
-					for (let t of o(e, u, d)) h.push(t);
+				if (ov.kind === "insertPreview") {
+					for (const cmd of insertPreviewCommands(ov, view, cfg)) out.push(cmd);
 					continue;
 				}
-				if (e.kind === "lasso") {
-					let n = [];
-					for (let r of e.vertices) {
-						let [e, i] = t(r.x, r.y, m);
-						n.push({
-							x: e,
-							y: i
+				if (ov.kind === "lasso") {
+					const screenPts = [];
+					for (const v of ov.vertices) {
+						const [sx, sy] = worldToScreen(v.x, v.y, t);
+						screenPts.push({
+							x: sx,
+							y: sy
 						});
 					}
-					let r = {
+					const cmd = {
 						kind: "path",
-						path: s(n),
-						fill: { paint: { color: d.fill } },
+						path: polygonFromPoints(screenPts),
+						fill: { paint: { color: cfg.fill } },
 						stroke: {
-							paint: { color: d.stroke },
-							width: d.lineWidth,
-							dash: d.dash
+							paint: { color: cfg.stroke },
+							width: cfg.lineWidth,
+							dash: cfg.dash
 						}
 					};
-					h.push(r);
+					out.push(cmd);
 					continue;
 				}
-				if (e.kind === "polyline") {
-					let n = f[e.role] ?? {
-						paint: { color: d.stroke },
-						width: d.lineWidth,
-						dash: d.dash
-					}, r = [];
-					for (let n of e.points) {
-						let [e, i] = t(n.x, n.y, m);
-						r.push({
-							x: e,
-							y: i
-						});
-					}
-					h.push({
+				if (ov.kind === "polyline") {
+					const stroke = roles[ov.role] ?? {
+						paint: { color: cfg.stroke },
+						width: cfg.lineWidth,
+						dash: cfg.dash
+					};
+					out.push({
 						kind: "path",
-						path: c(r),
-						stroke: n
+						path: polylineFromPoints(onScreen(ov.points, t)),
+						stroke
 					});
 					continue;
 				}
+				if (ov.kind === "brush") {
+					out.push(...brushOverlayCommands(onScreen(ov.points, t), ov.radiusPx, cfg));
+					continue;
+				}
 			}
-			return h.length === 0 ? [] : h;
+			if (out.length === 0) return [];
+			return out;
 		}
-	}), [_]);
+	}), [styleRef]);
 }
-//#endregion
-export { m as useDispatcherOverlayLayer };
 
+//#endregion
+export { useDispatcherOverlayLayer };
 //# sourceMappingURL=useDispatcherOverlayLayer.js.map

package/dist/canvas/SceneCanvas/useDispatcherOverlayLayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"useDispatcherOverlayLayer.js","names":["DEFAULT_STYLE","useDispatcherOverlayLayer","args","styleRef","useLatest","style","forceRerender","useReducer","n","useEffect","dispatcher","useMemo","cfg","roles","OVERLAY_ROLE_STROKES","t","viewToTransform","view","out","isVisible","isVisibleFrom","data","passes","id","ov","resolveOverlays","gestureOverlaysFrom","b","sx","sy","worldToScreen","cmd","insertPreviewCommands","screenPts","v","polygonFromPoints","stroke","pt","polylineFromPoints"],"sources":["../../../src/canvas/SceneCanvas/useDispatcherOverlayLayer.ts"],"sourcesContent":["/**\n * Dispatcher overlay render layer for `<SceneCanvas>`.\n *\n * Paints the overlay shapes the drawing view's in-flight handles publish,\n * taken off the draw envelope so a panel shows its own gesture rather than\n * the surface's. `resolveOverlays` does the reading; everything here is\n * painting.\n *\n * Distinct from `usePreviewGhostLayer`, which paints displaced scene-node\n * silhouettes. This layer is for gestures whose visual feedback isn't a moved\n * scene node — a marquee rect, a lasso polyline, an insert preview.\n */\nimport { useEffect, useMemo, useReducer } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { DrawCommand, PathDrawCommand } from '@weasel-js/renderer';\nimport type { CommandStroke } from '@weasel-js/paint';\nimport type { RenderLayer } from 'core/layers/render';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport { polygonFromPoints, polylineFromPoints } from '@weasel-js/geom';\nimport { resolveOverlays } from 'interactions/actions/resolveOverlays';\nimport { gestureOverlaysFrom, isVisibleFrom } from '../drawEnvelope';\nimport { insertPreviewCommands } from './insertPreviewCommands';\nimport { OVERLAY_ROLE_STROKES } from '../overlayRoleStrokes';\n\n/** Style knobs for the dispatcher-overlay layer's marquee + lasso paints. */\nexport interface DispatcherOverlayStyle {\n  fill?: string;\n  stroke?: string;\n  dash?: number[];\n  lineWidth?: number;\n  /** Stroke per `polyline` overlay role, merged over the kit's. A role with\n   *  no entry here and none of the kit's paints as plain chrome — the\n   *  `stroke` / `lineWidth` / `dash` above. */\n  roles?: Readonly<Record<string, CommandStroke>>;\n}\n\nconst DEFAULT_STYLE: Required<Omit<DispatcherOverlayStyle, 'roles'>> = {\n  fill: 'rgba(164, 139, 212, 0.18)',\n  stroke: '#a48bd4',\n  dash: [3, 3],\n  lineWidth: 1,\n};\n\n\n\nexport function useDispatcherOverlayLayer(args: {\n  /** The surface's dispatcher, subscribed to only so a pump repaints. What\n   *  gets painted is the drawing view's own `getGestureOverlays()`. */\n  dispatcher: Dispatcher | null | undefined;\n  style?: DispatcherOverlayStyle;\n}): RenderLayer<unknown> {\n  const { dispatcher, style } = args;\n\n  const styleRef = useLatest(style);\n\n  // Re-render on every dispatcher pump so live overlay (marquee, lasso\n  // polyline) tracks pointermove instead of freezing on the first frame.\n  const [, forceRerender] = useReducer((n: number) => n + 1, 0);\n  useEffect(() => {\n    if (!dispatcher) return;\n    return dispatcher.subscribe(forceRerender);\n  }, [dispatcher]);\n\n  return useMemo<RenderLayer<unknown>>(\n    () => ({\n      id: 'dispatcher-overlay',\n      label: 'Dispatcher overlay',\n      space: 'screen',\n      draw: (data, view) => {\n        const cfg = { ...DEFAULT_STYLE, ...(styleRef.current ?? {}) };\n        // Merged rather than replaced: naming one role must not delete the\n        // kit's others.\n        const roles = { ...OVERLAY_ROLE_STROKES, ...(styleRef.current?.roles ?? {}) };\n        const t = viewToTransform(view);\n        const out: DrawCommand[] = [];\n\n        // Chrome-caps gate. Absent envelope → every overlay paints. This stays\n        // on the painting side: the predicate is a property of the view's\n        // envelope, and two views of one surface may answer differently for\n        // the same in-flight gesture.\n        const isVisible = isVisibleFrom(data);\n        const passes = (id: string) => (isVisible ? isVisible(id) : true);\n\n        for (const ov of resolveOverlays(gestureOverlaysFrom(data))) {\n          if (!passes(ov.visibilityId)) continue;\n\n          if (ov.kind === 'marquee') {\n            const b = ov.bounds;\n            const [sx, sy] = worldToScreen(b.x, b.y, t);\n            const sw = b.width * view.scale.x;\n            const sh = b.height * view.scale.y;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: { kind: 'rect', x: sx, y: sy, width: sw, height: sh },\n              fill: { paint: { color: cfg.fill } },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'insertPreview') {\n            for (const cmd of insertPreviewCommands(ov, view, cfg)) out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'lasso') {\n            // `polygonFromPoints` closes the path, which draws the dashed\n            // close-line back to the first vertex.\n            const screenPts: { x: number; y: number }[] = [];\n            for (const v of ov.vertices) {\n              const [sx, sy] = worldToScreen(v.x, v.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: polygonFromPoints(screenPts),\n              fill: { paint: { color: cfg.fill } },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'polyline') {\n            const stroke =\n              roles[ov.role] ??\n              { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash };\n            const screenPts: { x: number; y: number }[] = [];\n            for (const pt of ov.points) {\n              const [sx, sy] = worldToScreen(pt.x, pt.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            out.push({\n              kind: 'path',\n              path: polylineFromPoints(screenPts),\n              stroke,\n            } satisfies PathDrawCommand);\n            continue;\n          }\n        }\n\n        if (out.length === 0) return [];\n        return out;\n      },\n    }),\n    [styleRef],\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"useDispatcherOverlayLayer.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useDispatcherOverlayLayer.ts"],"sourcesContent":["/**\n * Dispatcher overlay render layer for `<SceneCanvas>`.\n *\n * Paints the overlay shapes the drawing view's in-flight handles publish,\n * taken off the draw envelope so a panel shows its own gesture rather than\n * the surface's. `resolveOverlays` does the reading; everything here is\n * painting.\n *\n * Distinct from `usePreviewGhostLayer`, which paints displaced scene-node\n * silhouettes. This layer is for gestures whose visual feedback isn't a moved\n * scene node — a marquee rect, a lasso polyline, an insert preview, a brush.\n */\nimport { useEffect, useMemo, useReducer } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { DrawCommand, PathDrawCommand } from '@weasel-js/renderer';\nimport type { CommandStroke } from '@weasel-js/paint';\nimport type { RenderLayer } from 'core/layers/render';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport { polygonFromPoints, polylineFromPoints } from '@weasel-js/geom';\nimport { resolveOverlays } from 'interactions/actions/resolveOverlays';\nimport { gestureOverlaysFrom, isVisibleFrom } from '../drawEnvelope';\nimport { insertPreviewCommands } from './insertPreviewCommands';\nimport { OVERLAY_ROLE_STROKES } from '../overlayRoleStrokes';\nimport { brushOverlayCommands } from './brushOverlay';\n\n/** Style knobs for the dispatcher-overlay layer's marquee + lasso paints. */\nexport interface DispatcherOverlayStyle {\n  fill?: string;\n  stroke?: string;\n  dash?: number[];\n  lineWidth?: number;\n  /** Stroke per `polyline` overlay role, merged over the kit's. A role with\n   *  no entry here and none of the kit's paints as plain chrome — the\n   *  `stroke` / `lineWidth` / `dash` above. */\n  roles?: Readonly<Record<string, CommandStroke>>;\n}\n\nconst DEFAULT_STYLE: Required<Omit<DispatcherOverlayStyle, 'roles'>> = {\n  fill: 'rgba(164, 139, 212, 0.18)',\n  stroke: '#a48bd4',\n  dash: [3, 3],\n  lineWidth: 1,\n};\n\n\n\nfunction onScreen(\n  points: ReadonlyArray<{ x: number; y: number }>,\n  t: ReturnType<typeof viewToTransform>,\n): { x: number; y: number }[] {\n  return points.map((p) => {\n    const [sx, sy] = worldToScreen(p.x, p.y, t);\n    return { x: sx, y: sy };\n  });\n}\n\nexport function useDispatcherOverlayLayer(args: {\n  /** The surface's dispatcher, subscribed to only so a pump repaints. What\n   *  gets painted is the drawing view's own `getGestureOverlays()`. */\n  dispatcher: Dispatcher | null | undefined;\n  style?: DispatcherOverlayStyle;\n}): RenderLayer<unknown> {\n  const { dispatcher, style } = args;\n\n  const styleRef = useLatest(style);\n\n  // Re-render on every dispatcher pump so live overlay (marquee, lasso\n  // polyline) tracks pointermove instead of freezing on the first frame.\n  const [, forceRerender] = useReducer((n: number) => n + 1, 0);\n  useEffect(() => {\n    if (!dispatcher) return;\n    return dispatcher.subscribe(forceRerender);\n  }, [dispatcher]);\n\n  return useMemo<RenderLayer<unknown>>(\n    () => ({\n      id: 'dispatcher-overlay',\n      label: 'Dispatcher overlay',\n      space: 'screen',\n      draw: (data, view) => {\n        const cfg = { ...DEFAULT_STYLE, ...(styleRef.current ?? {}) };\n        // Merged rather than replaced: naming one role must not delete the\n        // kit's others.\n        const roles = { ...OVERLAY_ROLE_STROKES, ...(styleRef.current?.roles ?? {}) };\n        const t = viewToTransform(view);\n        const out: DrawCommand[] = [];\n\n        // Chrome-caps gate. Absent envelope → every overlay paints. This stays\n        // on the painting side: the predicate is a property of the view's\n        // envelope, and two views of one surface may answer differently for\n        // the same in-flight gesture.\n        const isVisible = isVisibleFrom(data);\n        const passes = (id: string) => (isVisible ? isVisible(id) : true);\n\n        for (const ov of resolveOverlays(gestureOverlaysFrom(data))) {\n          if (!passes(ov.visibilityId)) continue;\n\n          if (ov.kind === 'marquee') {\n            const b = ov.bounds;\n            const [sx, sy] = worldToScreen(b.x, b.y, t);\n            const sw = b.width * view.scale.x;\n            const sh = b.height * view.scale.y;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: { kind: 'rect', x: sx, y: sy, width: sw, height: sh },\n              fill: { paint: { color: cfg.fill } },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'insertPreview') {\n            for (const cmd of insertPreviewCommands(ov, view, cfg)) out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'lasso') {\n            // `polygonFromPoints` closes the path, which draws the dashed\n            // close-line back to the first vertex.\n            const screenPts: { x: number; y: number }[] = [];\n            for (const v of ov.vertices) {\n              const [sx, sy] = worldToScreen(v.x, v.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: polygonFromPoints(screenPts),\n              fill: { paint: { color: cfg.fill } },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'polyline') {\n            const stroke =\n              roles[ov.role] ??\n              { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash };\n            out.push({ kind: 'path', path: polylineFromPoints(onScreen(ov.points, t)), stroke });\n            continue;\n          }\n\n          if (ov.kind === 'brush') {\n            out.push(...brushOverlayCommands(onScreen(ov.points, t), ov.radiusPx, cfg));\n            continue;\n          }\n        }\n\n        if (out.length === 0) return [];\n        return out;\n      },\n    }),\n    [styleRef],\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuCA,IAAM,gBAAiE;CACrE,MAAM;CACN,QAAQ;CACR,MAAM,CAAC,GAAG,CAAC;CACX,WAAW;AACb;AAIA,SAAS,SACP,QACA,GAC4B;CAC5B,OAAO,OAAO,KAAK,MAAM;EACvB,MAAM,CAAC,IAAI,MAAM,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC;EAC1C,OAAO;GAAE,GAAG;GAAI,GAAG;EAAG;CACxB,CAAC;AACH;AAEA,SAAgB,0BAA0B,MAKjB;CACvB,MAAM,EAAE,YAAY,UAAU;CAE9B,MAAM,WAAW,UAAU,KAAK;CAIhC,MAAM,GAAG,iBAAiB,YAAY,MAAc,IAAI,GAAG,CAAC;CAC5D,gBAAgB;EACd,IAAI,CAAC,YAAY;EACjB,OAAO,WAAW,UAAU,aAAa;CAC3C,GAAG,CAAC,UAAU,CAAC;CAEf,OAAO,eACE;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,OAAO,MAAM,SAAS;GACpB,MAAM,MAAM;IAAE,GAAG;IAAe,GAAI,SAAS,WAAW,CAAC;GAAG;GAG5D,MAAM,QAAQ;IAAE,GAAG;IAAsB,GAAI,SAAS,SAAS,SAAS,CAAC;GAAG;GAC5E,MAAM,IAAI,gBAAgB,IAAI;GAC9B,MAAM,MAAqB,CAAC;GAM5B,MAAM,YAAY,cAAc,IAAI;GACpC,MAAM,UAAU,OAAgB,YAAY,UAAU,EAAE,IAAI;GAE5D,KAAK,MAAM,MAAM,gBAAgB,oBAAoB,IAAI,CAAC,GAAG;IAC3D,IAAI,CAAC,OAAO,GAAG,YAAY,GAAG;IAE9B,IAAI,GAAG,SAAS,WAAW;KACzB,MAAM,IAAI,GAAG;KACb,MAAM,CAAC,IAAI,MAAM,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC;KAG1C,MAAM,MAAuB;MAC3B,MAAM;MACN,MAAM;OAAE,MAAM;OAAQ,GAAG;OAAI,GAAG;OAAI,OAJ3B,EAAE,QAAQ,KAAK,MAAM;OAIiB,QAHtC,EAAE,SAAS,KAAK,MAAM;MAG2B;MAC1D,MAAM,EAAE,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE;MACnC,QAAQ;OAAE,OAAO,EAAE,OAAO,IAAI,OAAO;OAAG,OAAO,IAAI;OAAW,MAAM,IAAI;MAAK;KAC/E;KACA,IAAI,KAAK,GAAG;KACZ;IACF;IAEA,IAAI,GAAG,SAAS,iBAAiB;KAC/B,KAAK,MAAM,OAAO,sBAAsB,IAAI,MAAM,GAAG,GAAG,IAAI,KAAK,GAAG;KACpE;IACF;IAEA,IAAI,GAAG,SAAS,SAAS;KAGvB,MAAM,YAAwC,CAAC;KAC/C,KAAK,MAAM,KAAK,GAAG,UAAU;MAC3B,MAAM,CAAC,IAAI,MAAM,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC;MAC1C,UAAU,KAAK;OAAE,GAAG;OAAI,GAAG;MAAG,CAAC;KACjC;KACA,MAAM,MAAuB;MAC3B,MAAM;MACN,MAAM,kBAAkB,SAAS;MACjC,MAAM,EAAE,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE;MACnC,QAAQ;OAAE,OAAO,EAAE,OAAO,IAAI,OAAO;OAAG,OAAO,IAAI;OAAW,MAAM,IAAI;MAAK;KAC/E;KACA,IAAI,KAAK,GAAG;KACZ;IACF;IAEA,IAAI,GAAG,SAAS,YAAY;KAC1B,MAAM,SACJ,MAAM,GAAG,SACT;MAAE,OAAO,EAAE,OAAO,IAAI,OAAO;MAAG,OAAO,IAAI;MAAW,MAAM,IAAI;KAAK;KACvE,IAAI,KAAK;MAAE,MAAM;MAAQ,MAAM,mBAAmB,SAAS,GAAG,QAAQ,CAAC,CAAC;MAAG;KAAO,CAAC;KACnF;IACF;IAEA,IAAI,GAAG,SAAS,SAAS;KACvB,IAAI,KAAK,GAAG,qBAAqB,SAAS,GAAG,QAAQ,CAAC,GAAG,GAAG,UAAU,GAAG,CAAC;KAC1E;IACF;GACF;GAEA,IAAI,IAAI,WAAW,GAAG,OAAO,CAAC;GAC9B,OAAO;EACT;CACF,IACA,CAAC,QAAQ,CACX;AACF"}

package/dist/canvas/SceneCanvas/useHeldModifiers.js

@@ -1,20 +1,27 @@
-import { useKeyState as e } from "../../input/useKeyState.js";
-import { useMemo as t } from "react";
+import { useKeyState } from "../../input/useKeyState.js";
+import { useMemo } from "react";
+
 //#region src/canvas/SceneCanvas/useHeldModifiers.ts
-function n() {
-	let n = e({ skipInEditable: !1 });
-	return t(() => ({
-		get: n.modifiers,
-		subscribe(e) {
-			let t = n.modifiers();
-			return n.subscribe(() => {
-				let r = n.modifiers();
-				r !== t && (t = r, e());
+/** The modifier keys held, for a surface's rule context. */
+/** The modifiers held anywhere in the window, a text field included: a rule
+*  is asked about the keyboard, not about where focus is. `subscribe` reports
+*  a modifier going down or up and no other key. */
+function useHeldModifiers() {
+	const keys = useKeyState({ skipInEditable: false });
+	return useMemo(() => ({
+		get: keys.modifiers,
+		subscribe(listener) {
+			let held = keys.modifiers();
+			return keys.subscribe(() => {
+				const now = keys.modifiers();
+				if (now === held) return;
+				held = now;
+				listener();
 			});
 		}
-	}), [n]);
+	}), [keys]);
 }
-//#endregion
-export { n as useHeldModifiers };
 
+//#endregion
+export { useHeldModifiers };
 //# sourceMappingURL=useHeldModifiers.js.map

package/dist/canvas/SceneCanvas/useHeldModifiers.js.map

@@ -1 +1 @@
-{"version":3,"file":"useHeldModifiers.js","names":["useHeldModifiers","keys","useKeyState","useMemo","held","now","listener"],"sources":["../../../src/canvas/SceneCanvas/useHeldModifiers.ts"],"sourcesContent":["/** The modifier keys held, for a surface's rule context. */\nimport { useMemo } from 'react';\nimport type { ModifierState } from '../../core/modifierState';\nimport type { RedrawSource } from '../../core/layers/render';\nimport { useKeyState } from '../../input/useKeyState';\n\nexport interface HeldModifiers extends RedrawSource {\n  /** Read when a rule is evaluated. The same object until a modifier changes. */\n  get(): ModifierState;\n}\n\n/** The modifiers held anywhere in the window, a text field included: a rule\n *  is asked about the keyboard, not about where focus is. `subscribe` reports\n *  a modifier going down or up and no other key. */\nexport function useHeldModifiers(): HeldModifiers {\n  const keys = useKeyState({ skipInEditable: false });\n  return useMemo(() => ({\n    get: keys.modifiers,\n    subscribe(listener) {\n      let held = keys.modifiers();\n      return keys.subscribe(() => {\n        const now = keys.modifiers();\n        if (now === held) return;\n        held = now;\n        listener();\n      });\n    },\n  }), [keys]);\n}\n"],"mappings":";;;AAcA,SAAgBA,IAAkC;CAChD,IAAMC,IAAOC,EAAY,EAAE,gBAAgB,GAAM,CAAC;CAClD,OAAOC,SAAe;EACpB,KAAKF,EAAK;EACV,UAAU,GAAU;GAClB,IAAIG,IAAOH,EAAK,UAAU;GAC1B,OAAOA,EAAK,gBAAgB;IAC1B,IAAMI,IAAMJ,EAAK,UAAU;IAC3B,AAAII,MAAQD,MACZ,IAAOC,GACPC,EAAS;GACX,CAAC;EACH;CACF,IAAI,CAACL,CAAI,CAAC;AACZ"}
+{"version":3,"file":"useHeldModifiers.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useHeldModifiers.ts"],"sourcesContent":["/** The modifier keys held, for a surface's rule context. */\nimport { useMemo } from 'react';\nimport type { ModifierState } from '../../core/modifierState';\nimport type { RedrawSource } from '../../core/layers/render';\nimport { useKeyState } from '../../input/useKeyState';\n\nexport interface HeldModifiers extends RedrawSource {\n  /** Read when a rule is evaluated. The same object until a modifier changes. */\n  get(): ModifierState;\n}\n\n/** The modifiers held anywhere in the window, a text field included: a rule\n *  is asked about the keyboard, not about where focus is. `subscribe` reports\n *  a modifier going down or up and no other key. */\nexport function useHeldModifiers(): HeldModifiers {\n  const keys = useKeyState({ skipInEditable: false });\n  return useMemo(() => ({\n    get: keys.modifiers,\n    subscribe(listener) {\n      let held = keys.modifiers();\n      return keys.subscribe(() => {\n        const now = keys.modifiers();\n        if (now === held) return;\n        held = now;\n        listener();\n      });\n    },\n  }), [keys]);\n}\n"],"mappings":";;;;;;;;AAcA,SAAgB,mBAAkC;CAChD,MAAM,OAAO,YAAY,EAAE,gBAAgB,MAAM,CAAC;CAClD,OAAO,eAAe;EACpB,KAAK,KAAK;EACV,UAAU,UAAU;GAClB,IAAI,OAAO,KAAK,UAAU;GAC1B,OAAO,KAAK,gBAAgB;IAC1B,MAAM,MAAM,KAAK,UAAU;IAC3B,IAAI,QAAQ,MAAM;IAClB,OAAO;IACP,SAAS;GACX,CAAC;EACH;CACF,IAAI,CAAC,IAAI,CAAC;AACZ"}

package/dist/canvas/SceneCanvas/useNodeAtPoint.js

@@ -1,26 +1,28 @@
-import { makeGetNodeAtPoint as e } from "../getNodeAtPoint.js";
-import { useMemo as t } from "react";
+import { makeGetNodeAtPoint } from "../getNodeAtPoint.js";
+import { useMemo } from "react";
+
 //#region src/canvas/SceneCanvas/useNodeAtPoint.ts
-function n(n) {
-	let { pickBest: r, nodes: i, kindOfData: a, isPointerInteractive: o } = n;
-	return t(() => {
-		if (!r) return;
-		let t = e(r, (e) => {
-			let t = i.getNode(e);
-			return t ? { kind: a ? a(t.data) : "unknown" } : null;
+/**
+* The node under a world point with its routing kind, resolved through the
+* select tool's own single-hit picker, so `onClick`, `onDoubleClick`, hover,
+* and tool routing all name the node a click selects.
+*/
+function useNodeAtPoint(args) {
+	const { pickBest, nodes, kindOf } = args;
+	return useMemo(() => {
+		if (!pickBest) return void 0;
+		return makeGetNodeAtPoint(pickBest, (id) => {
+			const node = nodes.getNode(id);
+			if (!node) return null;
+			return { kind: kindOf ? kindOf(node) : "unknown" };
 		});
-		return o ? (e, n, r) => {
-			let i = t(e, n, r);
-			return i == null || o(i.id) === !1 ? null : i;
-		} : t;
 	}, [
-		i,
-		r,
-		o,
-		a
+		nodes,
+		pickBest,
+		kindOf
 	]);
 }
-//#endregion
-export { n as useNodeAtPoint };
 
+//#endregion
+export { useNodeAtPoint };
 //# sourceMappingURL=useNodeAtPoint.js.map

package/dist/canvas/SceneCanvas/useNodeAtPoint.js.map

@@ -1 +1 @@
-{"version":3,"file":"useNodeAtPoint.js","names":["useNodeAtPoint","args","useMemo","pickBest","base","makeGetNodeAtPoint","node","nodes","id","kindOfData","isPointerInteractive","hit","wx","wy","view"],"sources":["../../../src/canvas/SceneCanvas/useNodeAtPoint.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { makeGetNodeAtPoint, type NodeAtPointHit } from '../getNodeAtPoint';\nimport type { PickView } from './useSceneSelectTool';\n\nexport type NodeAtPoint = (wx: number, wy: number, view?: PickView | null) => NodeAtPointHit | null;\n\n/**\n * The node under a world point with its routing kind, resolved through the\n * select tool's own single-hit picker, so `onClick`, `onDoubleClick`, hover,\n * and tool routing all name the node a click selects. A hit whose id\n * `isPointerInteractive` rejects comes back null.\n */\nexport function useNodeAtPoint<TData>(args: {\n  pickBest: ((wx: number, wy: number, view?: PickView | null) => string | null) | undefined;\n  /** A caller's `geometry.pickEvery` can answer an id the scene does not hold. */\n  nodes: { getNode(id: string): { data: TData } | null | undefined };\n  kindOfData: ((data: TData) => string) | undefined;\n  isPointerInteractive: ((id: string) => boolean) | undefined;\n}): NodeAtPoint | undefined {\n  const { pickBest, nodes, kindOfData, isPointerInteractive } = args;\n  return useMemo(() => {\n    if (!pickBest) return undefined;\n    const base = makeGetNodeAtPoint(pickBest, (id) => {\n      const node = nodes.getNode(id);\n      if (!node) return null;\n      return { kind: kindOfData ? kindOfData(node.data) : 'unknown' };\n    });\n    if (!isPointerInteractive) return base;\n    return (wx, wy, view) => {\n      const hit = base(wx, wy, view);\n      if (hit == null) return null;\n      if (isPointerInteractive(hit.id) === false) return null;\n      return hit;\n    };\n  }, [nodes, pickBest, isPointerInteractive, kindOfData]);\n}\n"],"mappings":";;;AAYA,SAAgBA,EAAsB,GAMV;CAC1B,IAAM,EAAE,aAAU,UAAO,eAAY,4BAAyBC;CAC9D,OAAOC,QAAc;EACnB,IAAI,CAACC,GAAU;EACf,IAAMC,IAAOC,EAAmBF,IAAW,MAAO;GAChD,IAAMG,IAAOC,EAAM,QAAQC,CAAE;GAE7B,OADKF,IACE,EAAE,MAAMG,IAAaA,EAAWH,EAAK,IAAI,IAAI,UAAU,IAD5C;EAEpB,CAAC;EAED,OADKI,KACG,GAAI,GAAI,MAAS;GACvB,IAAMC,IAAMP,EAAKQ,GAAIC,GAAIC,CAAI;GAG7B,OAFIH,KAAO,QACPD,EAAqBC,EAAI,EAAE,MAAM,KAAc,OAC5CA;EACT,IANkCP;CAOpC,GAAG;EAACG;EAAOJ;EAAUO;EAAsBD;CAAU,CAAC;AACxD"}
+{"version":3,"file":"useNodeAtPoint.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useNodeAtPoint.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { makeGetNodeAtPoint, type NodeAtPointHit } from '../getNodeAtPoint';\nimport type { PickView } from './useSceneSelectTool';\n\nexport type NodeAtPoint = (wx: number, wy: number, view?: PickView | null) => NodeAtPointHit | null;\n\n/**\n * The node under a world point with its routing kind, resolved through the\n * select tool's own single-hit picker, so `onClick`, `onDoubleClick`, hover,\n * and tool routing all name the node a click selects.\n */\nexport function useNodeAtPoint<TData>(args: {\n  pickBest: ((wx: number, wy: number, view?: PickView | null) => string | null) | undefined;\n  /** A caller's `geometry.pickEvery` can answer an id the scene does not hold. */\n  nodes: { getNode(id: string): { kind: string; data: TData } | null | undefined };\n  kindOf: ((node: { kind: string; data: TData }) => string) | undefined;\n}): NodeAtPoint | undefined {\n  const { pickBest, nodes, kindOf } = args;\n  return useMemo(() => {\n    if (!pickBest) return undefined;\n    return makeGetNodeAtPoint(pickBest, (id) => {\n      const node = nodes.getNode(id);\n      if (!node) return null;\n      return { kind: kindOf ? kindOf(node) : 'unknown' };\n    });\n  }, [nodes, pickBest, kindOf]);\n}\n"],"mappings":";;;;;;;;;AAWA,SAAgB,eAAsB,MAKV;CAC1B,MAAM,EAAE,UAAU,OAAO,WAAW;CACpC,OAAO,cAAc;EACnB,IAAI,CAAC,UAAU,OAAO;EACtB,OAAO,mBAAmB,WAAW,OAAO;GAC1C,MAAM,OAAO,MAAM,QAAQ,EAAE;GAC7B,IAAI,CAAC,MAAM,OAAO;GAClB,OAAO,EAAE,MAAM,SAAS,OAAO,IAAI,IAAI,UAAU;EACnD,CAAC;CACH,GAAG;EAAC;EAAO;EAAU;CAAM,CAAC;AAC9B"}

package/dist/canvas/SceneCanvas/useNodeKinds.js

@@ -1,26 +1,35 @@
-import { createNodeRouting as e } from "../../core/scene/NodeRouting.js";
-import { inferredNodeRouting as t } from "./defaultNodeRouting.js";
-import { useMemo as n } from "react";
+import { createNodeRouting } from "../../core/scene/NodeRouting.js";
+import { inferredNodeRouting } from "./defaultNodeRouting.js";
+import { useMemo } from "react";
+
 //#region src/canvas/SceneCanvas/useNodeKinds.ts
-function r(r, i) {
-	let a = n(() => {
-		let n = i === void 0 ? t : i;
-		if (n.length === 0) return;
-		let r = e();
-		for (let e of n) r.register(e);
-		return (e) => r.classify(e);
-	}, [i]);
+/**
+* The canvas's routing-trait classifier, by node data and by node id, so
+* `target: 'kind:text'` on a binding speaks the vocabulary of `Hit.kind`.
+* Unset `routing` falls back to `inferredNodeRouting`. An explicit empty list
+* opts out: both are undefined, every hit is `kind: 'unknown'`, and no
+* `kind:` target form can match.
+*/
+function useNodeKinds(scene, routing) {
+	const kindOf = useMemo(() => {
+		const effective = routing === void 0 ? inferredNodeRouting : routing;
+		if (effective.length === 0) return void 0;
+		const registry = createNodeRouting();
+		for (const k of effective) registry.register(k);
+		return (node) => registry.classify(node.data, node);
+	}, [routing]);
 	return {
-		kindOfData: a,
-		kindOfNode: n(() => {
-			if (a) return (e) => {
-				let t = r.get(e);
-				return t ? a(t.data) : void 0;
+		kindOf,
+		kindOfNode: useMemo(() => {
+			if (!kindOf) return void 0;
+			return (id) => {
+				const node = scene.get(id);
+				return node ? kindOf(node) : void 0;
 			};
-		}, [a, r])
+		}, [kindOf, scene])
 	};
 }
-//#endregion
-export { r as useNodeKinds };
 
+//#endregion
+export { useNodeKinds };
 //# sourceMappingURL=useNodeKinds.js.map

package/dist/canvas/SceneCanvas/useNodeKinds.js.map

@@ -1 +1 @@
-{"version":3,"file":"useNodeKinds.js","names":["useNodeKinds","kindOfData","useMemo","effective","routing","inferredNodeRouting","registry","createNodeRouting","k","data","node","scene","id"],"sources":["../../../src/canvas/SceneCanvas/useNodeKinds.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { createNodeRouting, type NodeRoutingEntry } from 'core/scene/NodeRouting';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { inferredNodeRouting } from './defaultNodeRouting';\n\n/**\n * The canvas's routing-trait classifier, by node data and by node id, so\n * `target: 'kind:text'` on a binding speaks the vocabulary of `Hit.kind`.\n * Unset `routing` falls back to `inferredNodeRouting`. An explicit empty list\n * opts out: both are undefined, every hit is `kind: 'unknown'`, and no\n * `kind:` target form can match.\n */\nexport function useNodeKinds<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  routing: readonly NodeRoutingEntry[] | undefined,\n): {\n  kindOfData: ((data: TData) => string) | undefined;\n  kindOfNode: ((id: string) => string | undefined) | undefined;\n} {\n  const kindOfData = useMemo(() => {\n    const effective = routing === undefined ? inferredNodeRouting : routing;\n    if (effective.length === 0) return undefined;\n    const registry = createNodeRouting();\n    for (const k of effective) registry.register(k);\n    return (data: TData) => registry.classify(data);\n  }, [routing]);\n\n  const kindOfNode = useMemo(() => {\n    if (!kindOfData) return undefined;\n    return (id: string): string | undefined => {\n      const node = scene.get(id as NodeId);\n      return node ? kindOfData(node.data) : undefined;\n    };\n  }, [kindOfData, scene]);\n\n  return { kindOfData, kindOfNode };\n}\n"],"mappings":";;;;AAYA,SAAgBA,EACd,GACA,GAIA;CACA,IAAMC,IAAaC,QAAc;EAC/B,IAAMC,IAAYC,MAAY,KAAA,IAAYC,IAAsBD;EAChE,IAAID,EAAU,WAAW,GAAG;EAC5B,IAAMG,IAAWC,EAAkB;EACnC,KAAK,IAAMC,KAAKL,GAAW,EAAS,SAASK,CAAC;EAC9C,QAAQ,MAAgBF,EAAS,SAASG,CAAI;CAChD,GAAG,CAACL,CAAO,CAAC;CAUZ,OAAO;EAAE;EAAY,YARFF,QAAc;GAC/B,IAAKD,GACL,QAAQ,MAAmC;IACzC,IAAMS,IAAOC,EAAM,IAAIC,CAAY;IACnC,OAAOF,IAAOT,EAAWS,EAAK,IAAI,IAAI,KAAA;GACxC;EACF,GAAG,CAACT,GAAYU,CAAK,CAEA;CAAW;AAClC"}
+{"version":3,"file":"useNodeKinds.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useNodeKinds.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { createNodeRouting, type NodeRoutingEntry } from 'core/scene/NodeRouting';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { inferredNodeRouting } from './defaultNodeRouting';\n\n/**\n * The canvas's routing-trait classifier, by node data and by node id, so\n * `target: 'kind:text'` on a binding speaks the vocabulary of `Hit.kind`.\n * Unset `routing` falls back to `inferredNodeRouting`. An explicit empty list\n * opts out: both are undefined, every hit is `kind: 'unknown'`, and no\n * `kind:` target form can match.\n */\nexport function useNodeKinds<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  routing: readonly NodeRoutingEntry[] | undefined,\n): {\n  kindOf: ((node: { kind: string; data: TData }) => string) | undefined;\n  kindOfNode: ((id: string) => string | undefined) | undefined;\n} {\n  const kindOf = useMemo(() => {\n    const effective = routing === undefined ? inferredNodeRouting : routing;\n    if (effective.length === 0) return undefined;\n    const registry = createNodeRouting();\n    for (const k of effective) registry.register(k);\n    return (node: { kind: string; data: TData }) => registry.classify(node.data, node);\n  }, [routing]);\n\n  const kindOfNode = useMemo(() => {\n    if (!kindOf) return undefined;\n    return (id: string): string | undefined => {\n      const node = scene.get(id as NodeId);\n      return node ? kindOf(node) : undefined;\n    };\n  }, [kindOf, scene]);\n\n  return { kindOf, kindOfNode };\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgB,aACd,OACA,SAIA;CACA,MAAM,SAAS,cAAc;EAC3B,MAAM,YAAY,YAAY,SAAY,sBAAsB;EAChE,IAAI,UAAU,WAAW,GAAG,OAAO;EACnC,MAAM,WAAW,kBAAkB;EACnC,KAAK,MAAM,KAAK,WAAW,SAAS,SAAS,CAAC;EAC9C,QAAQ,SAAwC,SAAS,SAAS,KAAK,MAAM,IAAI;CACnF,GAAG,CAAC,OAAO,CAAC;CAUZ,OAAO;EAAE;EAAQ,YARE,cAAc;GAC/B,IAAI,CAAC,QAAQ,OAAO;GACpB,QAAQ,OAAmC;IACzC,MAAM,OAAO,MAAM,IAAI,EAAY;IACnC,OAAO,OAAO,OAAO,IAAI,IAAI;GAC/B;EACF,GAAG,CAAC,QAAQ,KAAK,CAEA;CAAW;AAC9B"}