@weasel-js/core 1.7.0 → 1.7.2

package/dist/canvas/SceneCanvas/useDispatcherOverlayLayer.js

@@ -0,0 +1,172 @@
+import { viewToTransform as e } from "../../core/viewport/view.js";
+import { worldToScreen as t } from "../../core/viewport/viewTransform.js";
+import { getImageBitmap as n } from "../../features/images/imageCache.js";
+import { OVERLAY_ROLE_STROKES as r } from "../overlayRoleStrokes.js";
+import { gestureOverlaysFrom as i, isVisibleFrom as a } from "../drawEnvelope.js";
+import { resolveOverlays as o } from "../../interactions/actions/resolveOverlays.js";
+import { ellipsePath as s, linePath as c, polygonFromPoints as l, polylineFromPoints as u, rectPath as d, regularPolygonPath as f, starPath as p } from "@weasel-js/geom";
+import { useEffect as m, useMemo as h, useReducer as g } from "react";
+import { useLatest as _ } from "@weasel-js/react";
+//#region src/canvas/SceneCanvas/useDispatcherOverlayLayer.ts
+var v = {
+	fill: "rgba(164, 139, 212, 0.18)",
+	stroke: "#a48bd4",
+	dash: [3, 3],
+	lineWidth: 1
+}, y = .85;
+function b(b) {
+	let { dispatcher: x, style: S } = b, C = _(S), [, w] = g((e) => e + 1, 0);
+	return m(() => {
+		if (x) return x.subscribe(w);
+	}, [x]), h(() => ({
+		id: "dispatcher-overlay",
+		label: "Dispatcher overlay",
+		space: "screen",
+		draw: (m, h) => {
+			let g = {
+				...v,
+				...C.current ?? {}
+			}, _ = {
+				...r,
+				...C.current?.roles ?? {}
+			}, b = e(h), x = [], S = a(m), w = (e) => !S || S(e);
+			for (let e of o(i(m))) if (w(e.visibilityId)) {
+				if (e.kind === "marquee") {
+					let n = e.bounds, [r, i] = t(n.x, n.y, b), a = {
+						kind: "path",
+						path: {
+							kind: "rect",
+							x: r,
+							y: i,
+							width: n.width * h.scale.x,
+							height: n.height * h.scale.y
+						},
+						fill: { color: g.fill },
+						stroke: {
+							paint: { color: g.stroke },
+							width: g.lineWidth,
+							dash: g.dash
+						}
+					};
+					x.push(a);
+					continue;
+				}
+				if (e.kind === "insertPreview") {
+					let r = e.bounds, i = (e, n) => {
+						let [r, i] = t(e, n, b);
+						return {
+							x: r,
+							y: i
+						};
+					}, a = (e) => e.map((e) => i(e.x, e.y)), o = (h.scale.x + h.scale.y) / 2, l = null, m = e.geometry;
+					switch (m.kind) {
+						case "box": {
+							let [i, a] = t(r.x, r.y, b), o = r.width * h.scale.x, c = r.height * h.scale.y;
+							if (e.shape === "image") {
+								let t = e.extras, r = t.preview === "outline" || !t.src ? void 0 : n(t.src);
+								r && x.push({
+									kind: "image",
+									image: r,
+									x: i,
+									y: a,
+									w: o,
+									h: c,
+									opacity: y
+								});
+							}
+							l = e.shape === "ellipse" ? s({
+								x: i,
+								y: a,
+								width: o,
+								height: c
+							}) : d(i, a, o, c);
+							break;
+						}
+						case "line":
+							l = c(i(m.a.x, m.a.y), i(m.b.x, m.b.y));
+							break;
+						case "polygon":
+							l = f(i(m.center.x, m.center.y), m.radius * o, m.sides, m.rotation);
+							break;
+						case "star":
+							l = p(i(m.center.x, m.center.y), m.outerRadius * o, m.points, m.innerRadius * o, m.rotation);
+							break;
+						case "pencil": l = u(a(m.samples));
+					}
+					if (!l) continue;
+					let _ = {
+						kind: "path",
+						path: l,
+						fill: e.shape === "line" || e.shape === "pencil" || e.shape === "image" ? void 0 : { color: g.fill },
+						stroke: {
+							paint: { color: g.stroke },
+							width: g.lineWidth,
+							dash: g.dash
+						}
+					};
+					if (x.push(_), e.anchorPoint) {
+						let t = i(e.anchorPoint.x, e.anchorPoint.y);
+						x.push({
+							kind: "path",
+							path: s({
+								x: t.x - 4,
+								y: t.y - 4,
+								width: 8,
+								height: 8
+							}),
+							fill: { color: g.stroke }
+						});
+					}
+					continue;
+				}
+				if (e.kind === "lasso") {
+					let n = [];
+					for (let r of e.vertices) {
+						let [e, i] = t(r.x, r.y, b);
+						n.push({
+							x: e,
+							y: i
+						});
+					}
+					let r = {
+						kind: "path",
+						path: l(n),
+						fill: { color: g.fill },
+						stroke: {
+							paint: { color: g.stroke },
+							width: g.lineWidth,
+							dash: g.dash
+						}
+					};
+					x.push(r);
+					continue;
+				}
+				if (e.kind === "polyline") {
+					let n = _[e.role] ?? {
+						paint: { color: g.stroke },
+						width: g.lineWidth,
+						dash: g.dash
+					}, r = [];
+					for (let n of e.points) {
+						let [e, i] = t(n.x, n.y, b);
+						r.push({
+							x: e,
+							y: i
+						});
+					}
+					x.push({
+						kind: "path",
+						path: u(r),
+						stroke: n
+					});
+					continue;
+				}
+			}
+			return x.length === 0 ? [] : x;
+		}
+	}), [C]);
+}
+//#endregion
+export { b as useDispatcherOverlayLayer };
+
+//# sourceMappingURL=useDispatcherOverlayLayer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDispatcherOverlayLayer.js","names":["DEFAULT_STYLE","PREVIEW_CONTENT_OPACITY","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","projectPoint","wx","wy","projectPoints","pts","p","radialScale","pathCmd","geom","sw","sh","e","bmp","getImageBitmap","ellipsePath","rectPath","linePath","regularPolygonPath","starPath","polylineFromPoints","anchorScreen","screenPts","v","polygonFromPoints","stroke","pt"],"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 — normalizing the drag,\n * sizing the nascent shape, dropping what is degenerate — and everything left\n * here is painting: projection into screen coordinates, the chrome-caps gate,\n * fill/stroke policy, the stroke each overlay role reads as, the anchor dot's\n * size, and the image bitmap.\n *\n * Distinct from `usePreviewGhostLayer`, which paints displaced scene-node\n * silhouettes via `previewIds()` / `previewPose(id)`. The dispatcher\n * overlay layer is for gestures whose visual feedback isn't a moved scene\n * node — marquee rect (area-select), polyline + dashed close-line (lasso),\n * and any future overlay-only chrome an action wants to render.\n *\n * Replaces the per-tool `select-overlay` rendering for the same gestures\n * once the dispatcher path is the sole driver. Until\n * then both run side-by-side; the visuals overlap exactly so the\n * user-visible result is identical.\n */\nimport { useEffect, useMemo, useReducer } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { DrawCommand, PathDrawCommand } from '../../renderer';\nimport type { Stroke } 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 {\n  polygonFromPoints,\n  polylineFromPoints,\n  rectPath,\n  ellipsePath,\n  linePath,\n  regularPolygonPath,\n  starPath,\n} from '@weasel-js/geom';\nimport { getImageBitmap } from 'features/images/imageCache';\nimport { resolveOverlays } from 'interactions/actions/resolveOverlays';\nimport { gestureOverlaysFrom, isVisibleFrom } from '../drawEnvelope';\nimport { OVERLAY_ROLE_STROKES } from '../overlayRoleStrokes';\n\n/** Style knobs for the dispatcher-overlay layer's marquee + lasso paints.\n *  Defaults match the legacy `useSelectTool` `areaSelectOverlayStyle`\n *  defaults so the visual swap is invisible to users. */\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, Stroke>>;\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/** Alpha for content previewed inside an in-flight gesture. Matches the\n *  preview-ghost layer, so a dragged node and an uncommitted insert read as\n *  equally provisional. */\nconst PREVIEW_CONTENT_OPACITY = 0.85;\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. Mirrors `composeAffordanceLayer` /\n        // `createSelectionOverlayLayer`: pull a visibility predicate off\n        // the data envelope and consult it per overlay before pushing draw\n        // commands. Absent envelope → every overlay paints. This stays on the\n        // painting side: the predicate is a property of the view's envelope,\n        // and two views of one surface may answer differently for the same\n        // 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: { 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            const b = ov.bounds;\n            const projectPoint = (wx: number, wy: number): { x: number; y: number } => {\n              const [sx, sy] = worldToScreen(wx, wy, t);\n              return { x: sx, y: sy };\n            };\n            const projectPoints = (\n              pts: ReadonlyArray<{ x: number; y: number }>,\n            ): { x: number; y: number }[] => pts.map((p) => projectPoint(p.x, p.y));\n            // Radial shapes inscribe in a square, so a single screen-space\n            // radius needs one scale factor; average the axes.\n            const radialScale = (view.scale.x + view.scale.y) / 2;\n\n            let pathCmd: PathDrawCommand['path'] | null = null;\n            const geom = ov.geometry;\n            switch (geom.kind) {\n              case 'box': {\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                if (ov.shape === 'image') {\n                  const e = ov.extras as Partial<{ src: string; preview: string }>;\n                  // The bitmap when it has decoded, the bare outline until then\n                  // (or when the tool opted out) — the outline is drawn either\n                  // way, so the drag always has an edge to read.\n                  const bmp = e.preview === 'outline' || !e.src\n                    ? undefined\n                    : getImageBitmap(e.src);\n                  if (bmp) {\n                    out.push({\n                      kind: 'image',\n                      image: bmp,\n                      x: sx, y: sy, w: sw, h: sh,\n                      opacity: PREVIEW_CONTENT_OPACITY,\n                    });\n                  }\n                }\n                pathCmd = ov.shape === 'ellipse'\n                  ? ellipsePath({ x: sx, y: sy, width: sw, height: sh })\n                  : rectPath(sx, sy, sw, sh);\n                break;\n              }\n              case 'line':\n                pathCmd = linePath(projectPoint(geom.a.x, geom.a.y), projectPoint(geom.b.x, geom.b.y));\n                break;\n              case 'polygon':\n                pathCmd = regularPolygonPath(\n                  projectPoint(geom.center.x, geom.center.y),\n                  geom.radius * radialScale,\n                  geom.sides,\n                  geom.rotation,\n                );\n                break;\n              case 'star':\n                pathCmd = starPath(\n                  projectPoint(geom.center.x, geom.center.y),\n                  geom.outerRadius * radialScale,\n                  geom.points,\n                  geom.innerRadius * radialScale,\n                  geom.rotation,\n                );\n                break;\n              case 'pencil':\n                // Genuinely open: `polygonFromPoints` closes the path, and the\n                // closing edge from the last sample back to the first reads as\n                // a marquee rather than as the stroke being drawn.\n                pathCmd = polylineFromPoints(projectPoints(geom.samples));\n                break;\n            }\n\n            if (!pathCmd) continue;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: pathCmd,\n              fill: ov.shape === 'line' || ov.shape === 'pencil' || ov.shape === 'image'\n                ? undefined\n                : { color: cfg.fill },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            // Anchor dot at the drag's click point. Sells the anchoring\n            // visually for radial shapes (polygon/star — no vertex sits\n            // at the AABB corner) and for center mode (dot marks the\n            // growth axis). 4 CSS-px radius, same stroke color as the\n            // ghost so it reads as part of the chrome.\n            if (ov.anchorPoint) {\n              const anchorScreen = projectPoint(ov.anchorPoint.x, ov.anchorPoint.y);\n              out.push({\n                kind: 'path',\n                path: ellipsePath({\n                  x: anchorScreen.x - 4,\n                  y: anchorScreen.y - 4,\n                  width: 8,\n                  height: 8,\n                }),\n                fill: { color: cfg.stroke },\n              });\n            }\n            continue;\n          }\n\n          if (ov.kind === 'lasso') {\n            // Project every vertex to screen coords; build a single polygon\n            // path. The polygon already closes (polygonFromPoints adds Z),\n            // which renders as the dashed \"close-line\" implicit in the\n            // legacy hook's visual. Fill paints the would-be selection\n            // region; stroke paints the polyline + close-line.\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: { 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        // Screen-space layer: emit commands directly. The worldToScreen\n        // projection above has already mapped every coord into CSS pixels.\n        return out;\n      },\n    }),\n    [styleRef],\n  );\n}\n"],"mappings":"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"}

package/dist/canvas/SceneCanvas/usePreviewGhostLayer.js

@@ -0,0 +1,69 @@
+import { deriveParallaxView as e } from "../../core/viewport/parallax.js";
+import { resolveDerivedPath as t } from "../../core/scene/derivedPath.js";
+import { findShapeSilhouette as n } from "../NodeShape.js";
+import { sceneDepLookup as r } from "../derivedPath.js";
+import { planeTransform as i } from "../planeClips.js";
+import { scenePlaneOf as a } from "../pickWalk.js";
+import { wrapWithPoseRotation as o } from "../poseRotation.js";
+import { previewSourcesFrom as s } from "../drawEnvelope.js";
+import { resolvePreviews as c } from "../../interactions/actions/resolvePreviews.js";
+import { useEffect as l, useMemo as u, useReducer as d } from "react";
+import { useLatest as f } from "@weasel-js/react";
+//#region src/canvas/SceneCanvas/usePreviewGhostLayer.ts
+var p = .85;
+function m(m) {
+	let { scene: h, sceneSlot: g, dispatcher: _ } = m, v = f(h), y = f(g), [, b] = d((e) => e + 1, 0);
+	return l(() => {
+		if (_) return _.subscribe(b);
+	}, [_]), u(() => ({
+		id: "preview-ghost",
+		label: "Preview ghost",
+		draw: (l, u) => {
+			let d = y.current, f = d?.drawOne;
+			if (!d || !f) return [];
+			let m = s(l), h = v.current, g = c(m, h);
+			if (g.length === 0) return [];
+			let _ = r(h), b = a(h.layers, u), x = (e) => b?.(e) ?? null, S = (t) => {
+				let n = b ? h.layers.find((e) => e.id === t)?.parallax : void 0;
+				return n ? e(u, n) : u;
+			}, C = (e, r) => {
+				let a = e.data === e.node.data ? e.node : {
+					...e.node,
+					data: e.data
+				}, s = x(e.node.layer), c = f(a, e.pose, S(e.node.layer)), l = [...o(c, e.pose)];
+				for (let t of e.children) for (let e of C(t, s)) l.push(e);
+				let u = i(s, r), d = u ? {
+					kind: "group",
+					transform: u,
+					children: l
+				} : {
+					kind: "group",
+					children: l
+				};
+				if (a.kind === "container") {
+					let r = n(a, e.pose, { derivedPath: t(a, _, (e) => h.childrenOf(e)) });
+					r && (d.clip = r);
+				}
+				return [d];
+			}, w = [], T = [];
+			for (let e of g) {
+				let t = e.opaque ? T : w;
+				for (let n of C(e, null)) t.push(n);
+			}
+			if (w.length === 0 && T.length === 0) return [];
+			let E = [];
+			return T.length > 0 && E.push({
+				kind: "group",
+				children: T
+			}), w.length > 0 && E.push({
+				kind: "group",
+				alpha: p,
+				children: w
+			}), E;
+		}
+	}), [v, y]);
+}
+//#endregion
+export { m as usePreviewGhostLayer };
+
+//# sourceMappingURL=usePreviewGhostLayer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"usePreviewGhostLayer.js","names":["GHOST_ALPHA","usePreviewGhostLayer","args","sceneRef","useLatest","scene","sceneSlotRef","sceneSlot","forceRerender","useReducer","n","useEffect","dispatcher","useMemo","slot","drawOne","sources","previewSourcesFrom","data","sc","roots","resolvePreviews","depOf","sceneDepLookup","planeOf","scenePlaneOf","view","mapOf","layer","viewOf","parallax","l","deriveParallaxView","drawEntry","effNode","entry","plane","self","children","wrapWithPoseRotation","child","cmd","transform","planeTransform","parentPlane","group","clip","findShapeSilhouette","resolveDerivedPath","nid","ghosted","settled","root","sink","out"],"sources":["../../../src/canvas/SceneCanvas/usePreviewGhostLayer.ts"],"sourcesContent":["/**\n * Preview-ghost render layer for `<SceneCanvas>`. Renders in-flight gesture\n * poses on top of the committed scene by reusing the scene slot's `drawOne`.\n * Which ids are displaced (`previewIds`) and where (`previewPose`) comes from\n * the drawing view's preview sources on the draw envelope — tools first, then\n * that view's in-flight handles.\n *\n * This replaces the per-tool `drawGhost` fold-in — a single SceneCanvas\n * concern instead of every consumer wiring it.\n */\nimport { useEffect, useMemo, useReducer } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { type DrawCommand, type GroupDrawCommand } from '../../renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { LayersMap } from '../Canvas';\nimport type { Node, Scene } from 'core/scene/types';\nimport { findShapeSilhouette } from '../NodeShape';\nimport { wrapWithPoseRotation } from '../poseRotation';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport { previewSourcesFrom } from '../drawEnvelope';\nimport { resolvePreviews, type PreviewNode } from 'interactions/actions/resolvePreviews';\nimport { resolveDerivedPath, sceneDepLookup } from '../derivedPath';\nimport { scenePlaneOf } from '../pickWalk';\nimport { planeTransform } from '../planeClips';\nimport { deriveParallaxView } from 'core/viewport/parallax';\nimport type { PlaneMap } from 'core/viewport/parallax';\n\nconst GHOST_ALPHA = 0.85;\n\nexport function usePreviewGhostLayer<TData, TLayer extends string, TPose>(args: {\n  scene: Scene<TData, TLayer, TPose>;\n  sceneSlot: LayersMap<Node<TData, TLayer, TPose>, TPose>['scene'];\n  /**\n   * The surface's dispatcher, subscribed to only so a pump repaints — preview\n   * poses mutate silently inside handles otherwise. What gets *painted* is the\n   * drawing view's own `getPreviewSources()`, off the draw envelope.\n   */\n  dispatcher?: Dispatcher | null;\n}): RenderLayer<unknown> {\n  const { scene, sceneSlot, dispatcher } = args;\n\n  // Refs let the layer body read the last committed scene/slot without\n  // re-creating the layer on every host render.\n  const sceneRef = useLatest(scene);\n  const sceneSlotRef = useLatest(sceneSlot);\n\n  // Subscribe to dispatcher state changes so the canvas re-renders on every\n  // ongoing-action pump (preview poses mutate silently inside handles\n  // otherwise — single-frame ghost stuck on the start pose).\n  const [, forceRerender] = useReducer((n: number) => n + 1, 0);\n  useEffect(() => {\n    if (!dispatcher) return;\n    const unsub = dispatcher.subscribe(forceRerender);\n    return unsub;\n  }, [dispatcher]);\n\n  return useMemo<RenderLayer<unknown>>(() => ({\n    id: 'preview-ghost',\n    label: 'Preview ghost',\n    draw: (data, view) => {\n      const slot = sceneSlotRef.current;\n      const drawOne = slot?.drawOne;\n      if (!slot || !drawOne) return [];\n      // Whose gesture this frame is showing belongs to the view being drawn,\n      // not to the surface that built the layer.\n      const sources = previewSourcesFrom(data);\n      const sc = sceneRef.current;\n      const roots = resolvePreviews(sources, sc);\n      if (roots.length === 0) return [];\n\n      // Reads the same overrides an in-flight gesture publishes, so a derived\n      // container ghosts with the clip it will actually impose.\n      const depOf = sceneDepLookup(sc);\n\n      // A node on a parallax layer ghosts where its plane draws it: through\n      // the plane's view, inside a group carrying it into its parent's world.\n      const planeOf = scenePlaneOf(sc.layers, view);\n      const mapOf = (layer: string): PlaneMap | null => planeOf?.(layer) ?? null;\n      const viewOf = (layer: string) => {\n        const parallax = planeOf ? sc.layers.find((l) => l.id === layer)?.parallax : undefined;\n        return parallax ? deriveParallaxView(view, parallax) : view;\n      };\n\n      // Mirrors buildSceneTree's structure — a container group carries a clip\n      // from its painter's silhouette — but drawn from the previewed pose and\n      // data, so children are clipped to the shape the container is taking.\n      const drawEntry = (\n        entry: PreviewNode<TData, TLayer, TPose>,\n        parentPlane: PlaneMap | null,\n      ): DrawCommand[] => {\n        const effNode = entry.data === entry.node.data\n          ? entry.node\n          : ({ ...entry.node, data: entry.data } as typeof entry.node);\n        const plane = mapOf(entry.node.layer);\n        const self = drawOne(effNode, entry.pose, viewOf(entry.node.layer));\n        const children: DrawCommand[] = [...wrapWithPoseRotation(self, entry.pose as unknown)];\n        for (const child of entry.children) {\n          for (const cmd of drawEntry(child, plane)) children.push(cmd);\n        }\n        const transform = planeTransform(plane, parentPlane);\n        const group: GroupDrawCommand = transform ? { kind: 'group', transform, children } : { kind: 'group', children };\n        if (effNode.kind === 'container') {\n          const clip = findShapeSilhouette(\n            effNode as unknown as Node<unknown, string, TPose>,\n            entry.pose,\n            { derivedPath: resolveDerivedPath(effNode, depOf, (nid) => sc.childrenOf(nid)) },\n          );\n          if (clip) group.clip = clip;\n        }\n        return [group];\n      };\n\n      // Opaque is honored at subtree-root granularity, as it always was: a\n      // sibling reflowing into place brings its own contents with it.\n      const ghosted: DrawCommand[] = [];\n      const settled: DrawCommand[] = [];\n      for (const root of roots) {\n        const sink = root.opaque ? settled : ghosted;\n        for (const cmd of drawEntry(root, null)) sink.push(cmd);\n      }\n      if (ghosted.length === 0 && settled.length === 0) return [];\n      // World-space commands; drawLayers wraps in viewToMat3 automatically.\n      const out: DrawCommand[] = [];\n      if (settled.length > 0) out.push({ kind: 'group', children: settled });\n      if (ghosted.length > 0) out.push({ kind: 'group', alpha: GHOST_ALPHA, children: ghosted });\n      return out;\n    },\n  }), [sceneRef, sceneSlotRef]);\n}\n"],"mappings":";;;;;;;;;;;;AA2BA,IAAMA,IAAc;AAEpB,SAAgBC,EAA0D,GASjD;CACvB,IAAM,EAAE,UAAO,cAAW,kBAAeC,GAInCC,IAAWC,EAAUC,CAAK,GAC1BC,IAAeF,EAAUG,CAAS,GAKlC,GAAGC,KAAiBC,GAAY,MAAcC,IAAI,GAAG,CAAC;CAO5D,OANAC,QAAgB;EACd,IAAKC,GAEL,OADcA,EAAW,UAAUJ,CAC5B;CACT,GAAG,CAACI,CAAU,CAAC,GAERC,SAAqC;EAC1C,IAAI;EACJ,OAAO;EACP,OAAO,GAAM,MAAS;GACpB,IAAMC,IAAOR,EAAa,SACpBS,IAAUD,GAAM;GACtB,IAAI,CAACA,KAAQ,CAACC,GAAS,OAAO,CAAC;GAG/B,IAAMC,IAAUC,EAAmBC,CAAI,GACjCC,IAAKhB,EAAS,SACdiB,IAAQC,EAAgBL,GAASG,CAAE;GACzC,IAAIC,EAAM,WAAW,GAAG,OAAO,CAAC;GAIhC,IAAME,IAAQC,EAAeJ,CAAE,GAIzBK,IAAUC,EAAaN,EAAG,QAAQO,CAAI,GACtCC,KAAS,MAAmCH,IAAUI,CAAK,KAAK,MAChEC,KAAU,MAAkB;IAChC,IAAMC,IAAWN,IAAUL,EAAG,OAAO,MAAM,MAAMY,EAAE,OAAOH,CAAK,CAAC,EAAE,WAAW,KAAA;IAC7E,OAAOE,IAAWE,EAAmBN,GAAMI,CAAQ,IAAIJ;GACzD,GAKMO,KACJ,GACA,MACkB;IAClB,IAAMC,IAAUC,EAAM,SAASA,EAAM,KAAK,OACtCA,EAAM,OACL;KAAE,GAAGA,EAAM;KAAM,MAAMA,EAAM;IAAK,GACjCC,IAAQT,EAAMQ,EAAM,KAAK,KAAK,GAC9BE,IAAOtB,EAAQmB,GAASC,EAAM,MAAMN,EAAOM,EAAM,KAAK,KAAK,CAAC,GAC5DG,IAA0B,CAAC,GAAGC,EAAqBF,GAAMF,EAAM,IAAe,CAAC;IACrF,KAAK,IAAMK,KAASL,EAAM,UACxB,KAAK,IAAMM,KAAOR,EAAUO,GAAOJ,CAAK,GAAG,EAAS,KAAKK,CAAG;IAE9D,IAAMC,IAAYC,EAAeP,GAAOQ,CAAW,GAC7CC,IAA0BH,IAAY;KAAE,MAAM;KAAS;KAAW;IAAS,IAAI;KAAE,MAAM;KAAS;IAAS;IAC/G,IAAIR,EAAQ,SAAS,aAAa;KAChC,IAAMY,IAAOC,EACXb,GACAC,EAAM,MACN,EAAE,aAAaa,EAAmBd,GAASZ,IAAQ,MAAQH,EAAG,WAAW8B,CAAG,CAAC,EAAE,CACjF;KACA,AAAIH,MAAM,EAAM,OAAOA;IACzB;IACA,OAAO,CAACD,CAAK;GACf,GAIMK,IAAyB,CAAC,GAC1BC,IAAyB,CAAC;GAChC,KAAK,IAAMC,KAAQhC,GAAO;IACxB,IAAMiC,IAAOD,EAAK,SAASD,IAAUD;IACrC,KAAK,IAAMT,KAAOR,EAAUmB,GAAM,IAAI,GAAG,EAAK,KAAKX,CAAG;GACxD;GACA,IAAIS,EAAQ,WAAW,KAAKC,EAAQ,WAAW,GAAG,OAAO,CAAC;GAE1D,IAAMG,IAAqB,CAAC;GAG5B,OAFIH,EAAQ,SAAS,KAAGG,EAAI,KAAK;IAAE,MAAM;IAAS,UAAUH;GAAQ,CAAC,GACjED,EAAQ,SAAS,KAAGI,EAAI,KAAK;IAAE,MAAM;IAAS,OAAOtD;IAAa,UAAUkD;GAAQ,CAAC,GAClFI;EACT;CACF,IAAI,CAACnD,GAAUG,CAAY,CAAC;AAC9B"}

package/dist/canvas/SceneCanvas/useSceneSelectTool.js

@@ -0,0 +1,127 @@
+import { rectFromPlane as e, toPlane as t } from "../../core/viewport/parallax.js";
+import { meanScale as n } from "../../core/viewport/meanScale.js";
+import { asNodeId as r } from "../../core/scene/types.js";
+import { poseDescriptorForNode as i } from "../../core/geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as a } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { findShapeInk as o, shapeCoversPoint as s } from "../NodeShape.js";
+import { pickWalk as c, scenePickSource as l, scenePlaneOf as u } from "../pickWalk.js";
+import { pickTopMostHit as d } from "../../tools/builtin/pickTopMostHit.js";
+import { useSelectTool as f } from "../../tools/builtin/select/useSelectTool.js";
+import { snap as p } from "../../interactions/gestures/shared/snap.js";
+import { poseContains as m, poseContainsRotated as h } from "./poseGeometry.js";
+import { pathContainsPoint as g } from "@weasel-js/geom";
+import { useMemo as _ } from "react";
+import { useLatest as v } from "@weasel-js/react";
+//#region src/canvas/SceneCanvas/useSceneSelectTool.ts
+var y = 4;
+function b(e) {
+	return e && typeof e.x == "number" && typeof e.y == "number" ? {
+		x: e.x,
+		y: e.y,
+		scale: e.scale
+	} : null;
+}
+function x(x) {
+	let { scene: S, adapter: C, geometry: w, selectTool: T, getView: E, alphaOf: D, layerIsPainted: O } = x, k = x.poseDescriptor ?? a, A = w?.pickEvery, j = w?.boundsOf, M = (w?.picking ?? "shape") === "shape", N = w?.pickTolerancePx ?? y, P = T?.move, F = T?.snap, I = _(() => {
+		let e = { ...P ?? {} };
+		if (F) {
+			let t = e.behaviors ?? [];
+			e.behaviors = [p(F), ...t];
+		}
+		return e;
+	}, [P, F]), L = _(() => (e, r, i) => {
+		if (A) {
+			let t = A(e, r);
+			return t == null ? [] : Array.isArray(t) ? t : [t];
+		}
+		let a = i ?? E?.() ?? null, u = i?.alphaOf ?? D, d = i?.layerIsPainted ?? O, f = b(a), p = l(S, {
+			getPose: (e) => C.getWorldPose(e),
+			...u ? { alphaOf: u } : {},
+			...d ? { layerIsPainted: d } : {},
+			...f ? { camera: f } : {}
+		}), _ = (e, r, i) => {
+			let a = n(i), c = {
+				px: N,
+				scale: i
+			};
+			return {
+				hits: (t, n, i) => {
+					let l = M ? o(t, n, { scale: a })?.outset ?? 0 : 0, u = {
+						...c,
+						reach: l
+					};
+					return (i ? m(i, e, r, u, k) : h(n, e, r, u, k)) ? !M || s(t, n, e, r, {
+						tolerance: c,
+						scale: a,
+						derivedPath: i
+					}) : !1;
+				},
+				clipAdmits: (t) => g(t, e, r),
+				inPlane: (n) => {
+					let a = t(n, {
+						x: e,
+						y: r
+					});
+					return _(a.x, a.y, {
+						x: i.x / n.scale.x,
+						y: i.y / n.scale.y
+					});
+				}
+			};
+		};
+		return c(p, _(e, r, a?.scale ?? {
+			x: 1,
+			y: 1
+		}));
+	}, [
+		S,
+		C,
+		A,
+		M,
+		N,
+		E,
+		D,
+		O,
+		k
+	]), R = v(E), z = _(() => (e, t) => {
+		let n = S.get(r(e)), i = b(t ?? R.current?.() ?? null);
+		return !n || !i ? null : u(S.layers, i)?.(n.layer) ?? null;
+	}, [S, R]), B = _(() => (t, n, a) => {
+		let o = S.get(r(t));
+		if (!o) return null;
+		let s = i(k, o), c = s.getBounds(n), l = s.getRotation?.(n) ?? c.rotation ?? 0, u = l ? {
+			...c,
+			rotation: l
+		} : c, d = z(t, a);
+		return d ? e(d, u) : u;
+	}, [
+		S,
+		k,
+		z
+	]), V = _(() => (e, t) => j ? j(e) : S.get(r(e)) ? B(e, C.getWorldPose(e), t) : null, [
+		S,
+		C,
+		j,
+		B
+	]);
+	return {
+		selectTool: f(C, {
+			pickEvery: L,
+			...T?.pickBest ? { pickBest: T.pickBest } : {},
+			...T?.extendClickLocked ? { extendClickLocked: T.extendClickLocked } : {}
+		}),
+		pickEvery: L,
+		pickBest: _(() => (e, t, n) => {
+			let r = L(e, t, n);
+			return d(r, C);
+		}, [L, C]),
+		boundsOf: V,
+		boundsOfPose: B,
+		planeOfNode: z,
+		moveOptions: I
+	};
+}
+//#endregion
+export { y as DEFAULT_PICK_TOLERANCE_PX, x as useSceneSelectTool };
+
+//# sourceMappingURL=useSceneSelectTool.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSceneSelectTool.js","names":["snap","snapBehavior","DEFAULT_PICK_TOLERANCE_PX","cameraOf","v","useSceneSelectTool","opts","args","d","AUTO_POSE_DESCRIPTOR","pickEveryProp","geometry","boundsOfProp","shapePicking","pickTolerancePx","moveOptions","snap$1","wiredMoveOptions","useMemo","merged","existing","snap","wiredHitBody","r","wx","wy","asked","view","getView","viewAlpha","alphaOf","viewLayers","layerIsPainted","camera","src","scenePickSource","scene","adapter","id","pointQuery","scale","meanScale","s","tolerance","outset","findShapeInk","n","pose","slop","derived","poseContains","px","py","poseContainsRotated","shapeCoversPoint","pathContainsPoint","clip","p","toPlane","m","pickWalk","getViewRef","useLatest","wiredPlaneOfNode","asNodeId","scenePlaneOf","wiredBoundsOfPose","g","poseDescriptorForNode","b","rot","own","plane","rectFromPlane","wiredBoundsOf","useSelectTool","ids","pickTopMostHit"],"sources":["../../../src/canvas/SceneCanvas/useSceneSelectTool.ts"],"sourcesContent":["/**\n * Scene-aware select-tool synthesis for `<SceneCanvas>`: a `useSelectTool`\n * over the caller's scene adapter, configured with kit-default pickEvery /\n * boundsOf derived from pose shape. Caller-supplied `pickEvery` / `boundsOf`\n * overrides via the `geometry` arg take precedence.\n */\nimport { useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { SceneCanvasAdapter } from '../sceneAdapter';\nimport { pickWalk, scenePickSource, scenePlaneOf, type PickQuery, type ViewPickGates } from 'canvas/pickWalk';\nimport { rectFromPlane, toPlane, type PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport { pathContainsPoint } from '@weasel-js/geom';\nimport { useSelectTool, type Bounds } from 'tools/builtin/select';\nimport { pickTopMostHit, type PickTopMostHitAdapter } from 'tools/builtin/pickTopMostHit';\nimport type { Node, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { UseMoveOptions } from 'interactions/actions/move/options';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport type { SnapStrategy } from 'interactions/gestures/types';\nimport { snap as snapBehavior } from 'interactions/gestures/shared/snap';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport { poseContains, poseContainsRotated } from './poseGeometry';\nimport { shapeCoversPoint, findShapeInk } from 'canvas/NodeShape';\nimport { meanScale } from 'core/viewport/meanScale';\n\n/**\n * Default grab slop around a shape's outline, in screen pixels.\n *\n * Four is the same number the path-pose stroke test has always used, and it's\n * the difference between a hairline being clickable and not: a 1px stroke is\n * half a world unit of reach at scale 1, which no pointing device can hit\n * reliably. It also lets a filled shape be grabbed a few pixels outside its\n * edge, which is what makes edge-adjacent dragging feel possible.\n */\nexport const DEFAULT_PICK_TOLERANCE_PX = 4;\n\n/** The view a pick is asked for. A world point carries neither the scale it\n *  was produced under nor what that view paints, so a caller picking for a\n *  view other than the surface's says both. A gate left out is the one this\n *  hook was built with. */\nexport interface PickView extends ViewPickGates {\n  scale: { x: number; y: number };\n  /** The rest of the asking camera. Supplied, it lets a parallax layer be\n   *  picked through its plane; left out, every layer is taken to move with\n   *  the camera. */\n  x?: number;\n  y?: number;\n}\n\n/** A pick view that names a whole camera, or null. */\nfunction cameraOf(v: Pick<PickView, 'scale' | 'x' | 'y'> | null): View | null {\n  return v && typeof v.x === 'number' && typeof v.y === 'number'\n    ? { x: v.x, y: v.y, scale: v.scale }\n    : null;\n}\n\nexport interface UseSceneSelectToolArgs<TData, TLayer extends string, TPose> {\n  scene: Scene<TData, TLayer, TPose>;\n  /** The adapter the select tool drives, built over `scene` with the same\n   *  `poseDescriptor`. Its world poses are what picking and bounds read. */\n  adapter: SceneCanvasAdapter<TData, TLayer, TPose>;\n  /** How to read and rewrite this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  geometry?: {\n    pickEvery?: (worldX: number, worldY: number) => string | string[] | null;\n    boundsOf?: (id: string) => Bounds | null;\n    /** How the default body-pick decides a node covers the pointer. Defaults\n     *  to `'shape'`; `'pose'` opts back down to the bare pose rect. See\n     *  `SceneCanvasProps.geometry.picking`. Ignored when `pickEvery` is\n     *  supplied — that override owns the whole test. */\n    picking?: 'pose' | 'shape';\n    /** Grab slop around a shape's outline, in screen pixels. See\n     *  `SceneCanvasProps.geometry.pickTolerancePx`. */\n    pickTolerancePx?: number;\n  };\n  /** The surface's camera, for converting the screen-pixel pick tolerance into\n   *  world units. A caller picking for another view passes that view's camera\n   *  to `pickEvery` / `pickBest` instead. Omitted in tests and non-viewport\n   *  hosts, where scale is 1. */\n  getView?: () => Pick<PickView, 'scale' | 'x' | 'y'> | null;\n  /** The asking view's painted alpha per node — its `alphaFor` times any\n   *  per-node override alpha. A node the view paints at alpha 0 is not on\n   *  screen, so picking must not answer for it. */\n  alphaOf?: (id: string) => number;\n  /** The asking view's answer to \"does this scene layer reach the screen\".\n   *  `layerVisibility` and `layerOrder` both gate a layer out of the paint\n   *  (`drawLayers` drops any layer missing from a supplied order), and an\n   *  undrawn layer must not claim clicks. */\n  layerIsPainted?: (layer: string) => boolean;\n  selectTool?: {\n    move?: UseMoveOptions<TPose>;\n    resize?: UseResizeOptions<TPose>;\n    snap?: SnapStrategy<TPose>;\n    /** Override the body-pick used on click/pointerdown. Alt-aware: receives\n     *  the live alt state + current selection so consumers can implement\n     *  alt-cycling through an overlapping stack. Default: top-most hit\n     *  (alt ignored). Forwarded verbatim to `useSelectTool`. */\n    pickBest?: (worldX: number, worldY: number, alt: boolean, sel: readonly string[]) => string | null;\n    /** Forwarded verbatim to `useSelectTool`. See\n     *  `UseSelectToolOptions.extendClickLocked`. */\n    extendClickLocked?: () => boolean;\n  };\n}\n\nexport interface UseSceneSelectToolReturn<TData, TLayer extends string, TPose> {\n  selectTool: ReturnType<typeof useSelectTool<Node<TData, TLayer, TPose>, TPose>>;\n  /** Hit-test resolved with the caller's `geometry.pickEvery` (or the\n   *  pose-walk default). Forward this to `<Canvas pickEvery={...}>` so the\n   *  dispatcher's `getNodeAtPoint` returns the same node the select tool\n   *  picked — drag routes keyed on `target.kind` then resolve to `'*'`\n   *  (move) instead of `'empty'` (marquee). */\n  pickEvery: (worldX: number, worldY: number, view?: PickView | null) => string[];\n  /** Single-best hit under the world point, or null. Runs `pickEvery` then\n   *  collapses parent/child overlap via `pickTopMostHit` — matches the id\n   *  the select tool's pointerdown classifier would settle on for a bare\n   *  click. Exposed so debug HUDs can highlight the would-be selection. */\n  pickBest: (worldX: number, worldY: number, view?: PickView | null) => string | null;\n  /** World-space AABB of `id`, or null. Same as what the selection overlay +\n   *  affordance hit-test need. Exposed so SceneCanvas can pass it to the\n   *  `affordanceAt` thunk without re-deriving it. `view` is the camera the\n   *  box is drawn under — a plane node sits somewhere else in each — and\n   *  defaults to the surface's. */\n  boundsOf: (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) =>\n    import('core/viewport/fitViewToBounds').Bounds | null;\n  /** How `view`'s world (the surface's camera by default) maps into the plane\n   *  `id` is drawn through, or null when its layer moves with the camera. */\n  planeOfNode: (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) => PlaneMap | null;\n  /** `boundsOf` for `id` drawn at `pose` rather than its own — how chrome\n   *  boxes an in-flight preview. Ignores a `geometry.boundsOf` override, which\n   *  answers only for a node's own pose. */\n  boundsOfPose: (id: string, pose: TPose, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) =>\n    import('core/viewport/fitViewToBounds').Bounds | null;\n  /** `selectTool.move` with `selectTool.snap` folded into its behaviors — what\n   *  the `move` preset's bindings carry. */\n  moveOptions: UseMoveOptions<TPose>;\n}\n\nexport function useSceneSelectTool<TData, TLayer extends string, TPose>(\n  args: UseSceneSelectToolArgs<TData, TLayer, TPose>,\n): UseSceneSelectToolReturn<TData, TLayer, TPose> {\n  const { scene, adapter, geometry, selectTool: opts, getView, alphaOf, layerIsPainted } = args;\n  const d = (args.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n\n  const pickEveryProp = geometry?.pickEvery;\n  const boundsOfProp = geometry?.boundsOf;\n  // Default. The pose rect is the wrong answer for anything that isn't a\n  // rectangle, so `'pose'` is the opt-out rather than the baseline. Cheap to\n  // leave on: the rect pre-filter runs first and rejects every node the\n  // pointer isn't over, and the survivors' silhouettes are memoized per node.\n  const shapePicking = (geometry?.picking ?? 'shape') === 'shape';\n  const pickTolerancePx = geometry?.pickTolerancePx ?? DEFAULT_PICK_TOLERANCE_PX;\n  const moveOptions = opts?.move;\n  const snap = opts?.snap;\n\n  const wiredMoveOptions = useMemo<UseMoveOptions<TPose>>(() => {\n    const merged: UseMoveOptions<TPose> = { ...(moveOptions ?? {}) };\n    if (snap) {\n      const existing = merged.behaviors ?? [];\n      merged.behaviors = [snapBehavior(snap), ...existing];\n    }\n    return merged;\n  }, [moveOptions, snap]);\n\n  // Default pickEvery: walk renderOrder() forward (back-to-front) and collect\n  // every node whose pose contains the world point. Order matches the\n  // `useSelectTool` contract — last element is the topmost — so `pickTopMostHit`\n  // picks correctly. Wraps the caller's `pickEvery` (string-or-null) into the\n  // array form `useSelectTool` expects. `poseContainsRotated` reads\n  // `pose.rotation` directly (the kit's one rotation convention), so rotated\n  // shapes pick against their rendered, rotated body without a per-demo override.\n  const wiredHitBody = useMemo(() => {\n    return (wx: number, wy: number, view?: PickView | null): string[] => {\n      if (pickEveryProp) {\n        const r = pickEveryProp(wx, wy);\n        if (r == null) return [];\n        return Array.isArray(r) ? r : [r];\n      }\n      const asked = view ?? getView?.() ?? null;\n      const viewAlpha = view?.alphaOf ?? alphaOf;\n      const viewLayers = view?.layerIsPainted ?? layerIsPainted;\n      const camera = cameraOf(asked);\n      // Through the adapter, not `n.pose`: an ephemeral override is the pose\n      // the renderer draws, so it has to be the one picking tests. World, not\n      // local, for the same reason — a framed child is drawn in its parent's\n      // frame, not where its own pose says.\n      const src = scenePickSource<TData, TLayer, TPose>(scene, {\n        getPose: (id) => adapter.getWorldPose(id),\n        ...(viewAlpha ? { alphaOf: viewAlpha } : {}),\n        ...(viewLayers ? { layerIsPainted: viewLayers } : {}),\n        ...(camera ? { camera } : {}),\n      });\n      // `s` makes the slop a screen distance, so the grab zone stays the same\n      // apparent thickness at any zoom and on every axis. A stroke's `{px}`\n      // width resolves through the mean scale because that is what the\n      // renderer paints it at.\n      const pointQuery = (px: number, py: number, s: { x: number; y: number }): PickQuery<TPose> => {\n        const scale = meanScale(s);\n        const tolerance = { px: pickTolerancePx, scale: s };\n        return {\n          hits: (n, pose, derived) => {\n            // The pre-filter has to be at least as generous as the refinement\n            // that follows it, or it rejects points the refinement would have\n            // claimed. A stroke reaches past the pose box by `outset` — a whole\n            // stroke width for an outer align — on top of the pointer slop.\n            const outset = shapePicking\n              ? (findShapeInk(n as never, pose, { scale })?.outset ?? 0)\n              : 0;\n            // A derived node's pose is a placeholder — typically zero-sized at\n            // the origin — so its own box rejects every point the path covers.\n            // The path is the region to test instead, and `poseContains` already\n            // reads a path-like pose as one.\n            const slop = { ...tolerance, reach: outset };\n            const admitted = derived\n              ? poseContains(derived as never, px, py, slop, d as PoseDescriptor<unknown>)\n              : poseContainsRotated(pose, px, py, slop, d as PoseDescriptor<unknown>);\n            if (!admitted) return false;\n            // `shapeCoversPoint` narrows the rect to the ink the painter actually\n            // lays down (and answers `true` for painters that have no silhouette,\n            // so nothing becomes unpickable).\n            return !shapePicking\n              || shapeCoversPoint(n as never, pose, px, py, {\n                tolerance, scale, derivedPath: derived,\n              });\n          },\n          clipAdmits: (clip) => pathContainsPoint(clip, px, py),\n          inPlane: (m) => {\n            const p = toPlane(m, { x: px, y: py });\n            return pointQuery(p.x, p.y, { x: s.x / m.scale.x, y: s.y / m.scale.y });\n          },\n        };\n      };\n      return pickWalk<TPose>(src, pointQuery(wx, wy, asked?.scale ?? { x: 1, y: 1 }));\n    };\n  }, [scene, adapter, pickEveryProp, shapePicking, pickTolerancePx, getView,\n      alphaOf, layerIsPainted, d]);\n\n  // Read through a ref: this is the chrome's bounds source, and a caller's\n  // inline `getView` would otherwise rebuild it, and everything keyed on it,\n  // every render.\n  const getViewRef = useLatest(getView);\n  const wiredPlaneOfNode = useMemo(() => {\n    return (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): PlaneMap | null => {\n      const n = scene.get(asNodeId(id));\n      const camera = cameraOf(view ?? getViewRef.current?.() ?? null);\n      if (!n || !camera) return null;\n      return scenePlaneOf(scene.layers, camera)?.(n.layer) ?? null;\n    };\n  }, [scene, getViewRef]);\n\n  const wiredBoundsOfPose = useMemo(() => {\n    return (id: string, pose: TPose, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): Bounds | null => {\n      const n = scene.get(asNodeId(id));\n      if (!n) return null;\n      const g = poseDescriptorForNode(d, n);\n      const b = g.getBounds(pose);\n      const rot = g.getRotation?.(pose) ?? (b as { rotation?: number }).rotation ?? 0;\n      const own = rot ? { ...b, rotation: rot } : b;\n      // A plane node is drawn where its plane puts it, and the chrome has to\n      // follow it there.\n      const plane = wiredPlaneOfNode(id, view);\n      return plane ? rectFromPlane(plane, own) : own;\n    };\n  }, [scene, d, wiredPlaneOfNode]);\n\n  const wiredBoundsOf = useMemo(() => {\n    return (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): Bounds | null => {\n      if (boundsOfProp) return boundsOfProp(id);\n      if (!scene.get(asNodeId(id))) return null;\n      // World, not local: a framed child is drawn in its parent's frame, and\n      // the chrome has to land on the ink.\n      return wiredBoundsOfPose(id, adapter.getWorldPose(id), view);\n    };\n  }, [scene, adapter, boundsOfProp, wiredBoundsOfPose]);\n\n  const selectTool = useSelectTool<Node<TData, TLayer, TPose>, TPose>(adapter, {\n    pickEvery: wiredHitBody,\n    ...(opts?.pickBest ? { pickBest: opts.pickBest } : {}),\n    ...(opts?.extendClickLocked ? { extendClickLocked: opts.extendClickLocked } : {}),\n  });\n\n\n  const wiredPickBest = useMemo(() => {\n    return (wx: number, wy: number, view?: PickView | null): string | null => {\n      const ids = wiredHitBody(wx, wy, view);\n      return pickTopMostHit(ids, adapter as unknown as PickTopMostHitAdapter);\n    };\n  }, [wiredHitBody, adapter]);\n\n  return {\n    selectTool,\n    pickEvery: wiredHitBody,\n    pickBest: wiredPickBest,\n    boundsOf: wiredBoundsOf,\n    boundsOfPose: wiredBoundsOfPose,\n    planeOfNode: wiredPlaneOfNode,\n    moveOptions: wiredMoveOptions,\n  };\n}\n"],"mappings":"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"}

package/dist/canvas/SceneCanvas/useViewportActions.js

@@ -0,0 +1,30 @@
+import { makeViewportZoomAction as e } from "../../interactions/actions/defaults/viewportZoom.js";
+import { makeViewportWheelPanAction as t } from "../../interactions/actions/defaults/viewportWheelPan.js";
+import { makePinchZoomAction as n } from "../../interactions/actions/defaults/pinchZoom.js";
+import { useEffect as r } from "react";
+import { useLatest as i } from "@weasel-js/react";
+import { useActionsRegistry as a } from "@weasel-js/routing/react";
+//#region src/canvas/SceneCanvas/useViewportActions.ts
+function o(o) {
+	let { pan: s, zoom: c, pinchZoom: l } = o, u = a(), d = i(u), f = typeof s == "object" ? JSON.stringify(s) : String(s), p = typeof c == "object" ? JSON.stringify(c) : String(c), m = typeof l == "object" ? JSON.stringify(l) : String(l);
+	r(() => {
+		let r = d.current;
+		if (!r) return;
+		let i = [];
+		if (s && i.push(r.register(t(typeof s == "object" ? s : {}))), c) {
+			let t = typeof c == "object" ? e(c) : e();
+			i.push(r.register(t));
+		}
+		return l ? i.push(r.register(n(typeof l == "object" ? l : {}))) : i.push(r.mute("viewport.pinchZoom")), () => {
+			for (let e of i) e();
+		};
+	}, [
+		f,
+		p,
+		m
+	]);
+}
+//#endregion
+export { o as useViewportActions };
+
+//# sourceMappingURL=useViewportActions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useViewportActions.js","names":["useViewportActions","args","reg","useActionsRegistry","regRef","useLatest","panKey","pan","zoomKey","zoom","pinchKey","pinchZoom","unregisters","makeViewportWheelPanAction","zoomAction","makeViewportZoomAction","makePinchZoomAction","u"],"sources":["../../../src/canvas/SceneCanvas/useViewportActions.ts"],"sourcesContent":["/**\n * `useViewportActions` — register the `viewport.pan`, `viewport.zoom` and\n * `viewport.pinchZoom` action descriptors from SceneCanvas's `viewport` prop.\n *\n * All three need the `view` dep that only SceneCanvas publishes via\n * `useViewDepSource`. `pan` and `zoom` live outside `KIT_STANDARD_DESCRIPTORS`\n * entirely and are registered here; `pinchZoom` is in that list (bare\n * `useStandardActions` consumers get it too), so this hook only re-registers a\n * clamp-configured one over it, or takes it away.\n *\n * Defaults: all three ON when omitted. Pass `pan: false` / `zoom: false` /\n * `pinchZoom: false` on the `viewport` prop to disable. Disabling mutes rather\n * than unregisters, so a sibling canvas sharing the registry keeps its own.\n *\n * Runs after `useStandardActions` in the same component, so the registry's\n * last-writer-wins ordering resolves the `pinchZoom` overlap.\n */\nimport { useEffect } from 'react';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport {\n  makeViewportWheelPanAction,\n  type WheelPanOptions,\n} from 'interactions/actions/defaults/viewportWheelPan';\nimport {\n  makeViewportZoomAction,\n  type ViewportZoomOptions,\n} from 'interactions/actions/defaults/viewportZoom';\nimport {\n  makePinchZoomAction,\n  type PinchZoomOptions,\n} from 'interactions/actions/defaults/pinchZoom';\n\nexport function useViewportActions(args: {\n  /** `true`/`false` toggles wheel pan; an object locks its axis (see\n   *  {@link WheelPanOptions}). */\n  pan: boolean | WheelPanOptions;\n  /** `true`/`false` toggles the default Cmd+wheel zoom; an object tunes the\n   *  wheel trigger + scale clamp (see {@link ViewportZoomOptions}). */\n  zoom: boolean | ViewportZoomOptions;\n  /** `true`/`false` toggles two-finger pinch zoom; an object sets its scale\n   *  clamp (see {@link PinchZoomOptions}). */\n  pinchZoom: boolean | PinchZoomOptions;\n}): void {\n  const { pan, zoom, pinchZoom } = args;\n  const reg = useActionsRegistry();\n  const regRef = useLatest(reg);\n\n  // Serialize the object configs so the effect re-runs when their fields change\n  // (object identity isn't stable across renders for inline literals).\n  // JSON.stringify drops function-valued fields, so changing only\n  // `animate.easing` does not re-register — pass a stable easing.\n  const panKey = typeof pan === 'object' ? JSON.stringify(pan) : String(pan);\n  const zoomKey = typeof zoom === 'object' ? JSON.stringify(zoom) : String(zoom);\n  const pinchKey = typeof pinchZoom === 'object' ? JSON.stringify(pinchZoom) : String(pinchZoom);\n\n  useEffect(() => {\n    const r = regRef.current;\n    if (!r) return;\n    const unregisters: Array<() => void> = [];\n    if (pan) {\n      unregisters.push(\n        r.register(makeViewportWheelPanAction(typeof pan === 'object' ? pan : {})),\n      );\n    }\n    if (zoom) {\n      const zoomAction =\n        typeof zoom === 'object' ? makeViewportZoomAction(zoom) : makeViewportZoomAction();\n      unregisters.push(r.register(zoomAction));\n    }\n    if (pinchZoom) {\n      unregisters.push(\n        r.register(makePinchZoomAction(typeof pinchZoom === 'object' ? pinchZoom : {})),\n      );\n    } else {\n      unregisters.push(r.mute('viewport.pinchZoom'));\n    }\n    return () => { for (const u of unregisters) u(); };\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- configs tracked via zoomKey / pinchKey\n  }, [panKey, zoomKey, pinchKey]);\n}\n"],"mappings":";;;;;;;AAiCA,SAAgBA,EAAmB,GAU1B;CACP,IAAM,EAAE,QAAK,SAAM,iBAAcC,GAC3BC,IAAMC,EAAmB,GACzBC,IAASC,EAAUH,CAAG,GAMtBI,IAAS,OAAOC,KAAQ,WAAW,KAAK,UAAUA,CAAG,IAAI,OAAOA,CAAG,GACnEC,IAAU,OAAOC,KAAS,WAAW,KAAK,UAAUA,CAAI,IAAI,OAAOA,CAAI,GACvEC,IAAW,OAAOC,KAAc,WAAW,KAAK,UAAUA,CAAS,IAAI,OAAOA,CAAS;CAE7F,QAAgB;EACd,IAAM,IAAIP,EAAO;EACjB,IAAI,CAAC,GAAG;EACR,IAAMQ,IAAiC,CAAC;EAMxC,IALIL,KACFK,EAAY,KACV,EAAE,SAASC,EAA2B,OAAON,KAAQ,WAAWA,IAAM,CAAC,CAAC,CAAC,CAC3E,GAEEE,GAAM;GACR,IAAMK,IACJ,OAAOL,KAAS,WAAWM,EAAuBN,CAAI,IAAIM,EAAuB;GACnF,EAAY,KAAK,EAAE,SAASD,CAAU,CAAC;EACzC;EAQA,OAPIH,IACFC,EAAY,KACV,EAAE,SAASI,EAAoB,OAAOL,KAAc,WAAWA,IAAY,CAAC,CAAC,CAAC,CAChF,IAEAC,EAAY,KAAK,EAAE,KAAK,oBAAoB,CAAC,SAElC;GAAE,KAAK,IAAMK,KAAKL,GAAa,EAAE;EAAG;CAEnD,GAAG;EAACN;EAAQE;EAASE;CAAQ,CAAC;AAChC"}