@weasel-js/core 1.10.1 → 1.11.0

package/dist/canvas/SceneCanvas/usePreviewGhostLayer.js

@@ -1,77 +1,109 @@
-import { deriveParallaxView as e } from "../../core/viewport/parallax.js";
-import { planeTransform as t } from "../planeClips.js";
-import { wrapWithPoseRotation as n } from "../poseRotation.js";
-import { findShapeSilhouette as r } from "../NodeShape.js";
-import { scenePaintedPoseOf as i } from "../derivedPath.js";
-import { scenePlaneOf as a } from "../pickWalk.js";
-import { copiesAbove as o } from "../copiesAbove.js";
-import { previewSourcesFrom as s } from "../drawEnvelope.js";
-import { isCustomEntry as c } from "../layerSlots.js";
-import { resolvePreviews as l } from "../../interactions/actions/resolvePreviews.js";
+import { deriveParallaxView } from "../../core/viewport/parallax.js";
+import { findShapeSilhouette } from "../NodeShape.js";
+import { planeTransform } from "../planeClips.js";
+import { wrapWithPoseRotation } from "../poseRotation.js";
+import { scenePaintedPoseOf } from "../derivedPath.js";
+import { scenePlaneOf } from "../pickWalk.js";
+import { copiesAbove } from "../copiesAbove.js";
+import { isCustomEntry } from "../layerSlots.js";
+import { previewSourcesFrom } from "../drawEnvelope.js";
+import { resolvePreviews } from "../../interactions/actions/resolvePreviews.js";
 import "@weasel-js/renderer";
-import { mat3 as u } from "@weasel-js/geom";
-import { useEffect as d, useMemo as f, useReducer as p } from "react";
-import { useLatest as m } from "@weasel-js/react";
+import { mat3 as mat3$1 } from "@weasel-js/geom";
+import { useEffect, useMemo, useReducer } from "react";
+import { useLatest } from "@weasel-js/react";
+
 //#region src/canvas/SceneCanvas/usePreviewGhostLayer.ts
-var h = .85;
-function g(g) {
-	let { scene: _, sceneSlot: v, dispatcher: y } = g, b = m(_), x = m(v), [, S] = p((e) => e + 1, 0);
-	return d(() => {
-		if (y) return y.subscribe(S);
-	}, [y]), f(() => ({
+/**
+* Preview-ghost render layer for `<SceneCanvas>`. Renders in-flight gesture
+* poses on top of the committed scene by reusing the scene slot's `drawOne`.
+* Which ids are displaced (`previewIds`) and where (`previewPose`) comes from
+* the drawing view's preview sources on the draw envelope: that view's
+* in-flight handles.
+*
+* This replaces the per-tool `drawGhost` fold-in — a single SceneCanvas
+* concern instead of every consumer wiring it.
+*/
+var GHOST_ALPHA = .85;
+function usePreviewGhostLayer(args) {
+	const { scene, sceneSlot, dispatcher } = args;
+	const sceneRef = useLatest(scene);
+	const sceneSlotRef = useLatest(sceneSlot);
+	const [, forceRerender] = useReducer((n) => n + 1, 0);
+	useEffect(() => {
+		if (!dispatcher) return;
+		return dispatcher.subscribe(forceRerender);
+	}, [dispatcher]);
+	return useMemo(() => ({
 		id: "preview-ghost",
 		label: "Preview ghost",
-		draw: (d, f) => {
-			let p = x.current;
-			if (!p || c(p) || !p.drawOne) return [];
-			let m = p.drawOne, g = s(d), _ = b.current, v = l(g, _);
-			if (v.length === 0) return [];
-			let y = a(_.layers, f), S = (e) => y?.(e) ?? null, C = (t) => {
-				let n = y ? _.layers.find((e) => e.id === t)?.parallax : void 0;
-				return n ? e(f, n) : f;
-			}, w = (e, i) => {
-				let a = e.data === e.node.data ? e.node : {
-					...e.node,
-					data: e.data
-				}, o = S(e.node.layer), s = m(a, e.pose, C(e.node.layer)), c = [...n(s, e.pose)];
-				for (let t of e.children) for (let e of w(t, o)) c.push(e);
-				let l = t(o, i), u = l ? {
+		draw: (data, view) => {
+			const slot = sceneSlotRef.current;
+			if (!slot || isCustomEntry(slot) || !slot.drawOne) return [];
+			const drawOne = slot.drawOne;
+			const sources = previewSourcesFrom(data);
+			const sc = sceneRef.current;
+			const roots = resolvePreviews(sources, sc);
+			if (roots.length === 0) return [];
+			const planeOf = scenePlaneOf(sc.layers, view);
+			const mapOf = (layer) => planeOf?.(layer) ?? null;
+			const viewOf = (layer) => {
+				const parallax = planeOf ? sc.layers.find((l) => l.id === layer)?.parallax : void 0;
+				return parallax ? deriveParallaxView(view, parallax) : view;
+			};
+			const drawEntry = (entry, parentPlane) => {
+				const effNode = entry.data === entry.node.data ? entry.node : {
+					...entry.node,
+					data: entry.data
+				};
+				const plane = mapOf(entry.node.layer);
+				const self = drawOne(effNode, entry.pose, viewOf(entry.node.layer));
+				const children = [...wrapWithPoseRotation(self, entry.pose)];
+				for (const child of entry.children) for (const cmd of drawEntry(child, plane)) children.push(cmd);
+				const transform = planeTransform(plane, parentPlane);
+				const group = transform ? {
 					kind: "group",
-					transform: l,
-					children: c
+					transform,
+					children
 				} : {
 					kind: "group",
-					children: c
+					children
 				};
-				if (a.kind === "container") {
-					let t = r(a, e.pose, { derivedPath: p.derivedPathOf?.(a, e.pose) ?? null });
-					t && (u.clip = t);
+				if (effNode.kind === "container") {
+					const clip = findShapeSilhouette(effNode, entry.pose, { derivedPath: slot.derivedPathOf?.(effNode, entry.pose) ?? null });
+					if (clip) group.clip = clip;
 				}
-				return [u];
-			}, T = [], E = [], D = i(_);
-			for (let e of v) {
-				let t = e.opaque ? E : T, n = w(e, null);
-				for (let e of n) t.push(e);
-				for (let r of o(_, e.node.id, D)) t.push({
+				return [group];
+			};
+			const ghosted = [];
+			const settled = [];
+			const paintedPose = scenePaintedPoseOf(sc);
+			for (const root of roots) {
+				const sink = root.opaque ? settled : ghosted;
+				const cmds = drawEntry(root, null);
+				for (const cmd of cmds) sink.push(cmd);
+				for (const m of copiesAbove(sc, root.node.id, paintedPose)) sink.push({
 					kind: "group",
-					transform: u.fromAffine(r),
-					children: n
+					transform: mat3$1.fromAffine(m),
+					children: cmds
 				});
 			}
-			if (T.length === 0 && E.length === 0) return [];
-			let O = [];
-			return E.length > 0 && O.push({
+			if (ghosted.length === 0 && settled.length === 0) return [];
+			const out = [];
+			if (settled.length > 0) out.push({
 				kind: "group",
-				children: E
-			}), T.length > 0 && O.push({
+				children: settled
+			});
+			if (ghosted.length > 0) out.push({
 				kind: "group",
-				alpha: h,
-				children: T
-			}), O;
+				alpha: GHOST_ALPHA,
+				children: ghosted
+			});
+			return out;
 		}
-	}), [b, x]);
+	}), [sceneRef, sceneSlotRef]);
 }
-//#endregion
-export { g as usePreviewGhostLayer };
 
+//#endregion
+export { usePreviewGhostLayer };
 //# sourceMappingURL=usePreviewGhostLayer.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"usePreviewGhostLayer.js","names":["mat3","mat3$1","GHOST_ALPHA","usePreviewGhostLayer","args","sceneRef","useLatest","scene","sceneSlotRef","sceneSlot","forceRerender","useReducer","n","useEffect","dispatcher","useMemo","slot","isCustomEntry","drawOne","sources","previewSourcesFrom","data","sc","roots","resolvePreviews","planeOf","scenePlaneOf","view","mapOf","layer","viewOf","parallax","l","deriveParallaxView","drawEntry","effNode","entry","plane","self","children","wrapWithPoseRotation","child","cmd","transform","planeTransform","parentPlane","group","clip","findShapeSilhouette","ghosted","settled","paintedPose","scenePaintedPoseOf","root","sink","cmds","m","copiesAbove","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: that view's\n * 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 '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { isCustomEntry, type LayersMap } from '../layerSlots';\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 { scenePlaneOf } from '../pickWalk';\nimport { planeTransform } from '../planeClips';\nimport { deriveParallaxView } from 'core/viewport/parallax';\nimport type { PlaneMap } from 'core/viewport/parallax';\nimport { mat3 } from '@weasel-js/geom';\nimport { copiesAbove } from '../copiesAbove';\nimport { scenePaintedPoseOf } from '../derivedPath';\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      if (!slot || isCustomEntry(slot) || !slot.drawOne) return [];\n      const drawOne = slot.drawOne;\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      // 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: slot.derivedPathOf?.(effNode, entry.pose) ?? null },\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      // A node an ancestor draws copies of is ghosted in each copy too, or\n      // the copies vanish for the length of the gesture.\n      const paintedPose = scenePaintedPoseOf(sc);\n      for (const root of roots) {\n        const sink = root.opaque ? settled : ghosted;\n        const cmds = drawEntry(root, null);\n        for (const cmd of cmds) sink.push(cmd);\n        for (const m of copiesAbove(sc, root.node.id, paintedPose)) {\n          sink.push({ kind: 'group', transform: mat3.fromAffine(m), children: cmds });\n        }\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":";;;;;;;;;;;;;;;AA6BA,IAAME,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;GAC1B,IAAI,CAACQ,KAAQC,EAAcD,CAAI,KAAK,CAACA,EAAK,SAAS,OAAO,CAAC;GAC3D,IAAME,IAAUF,EAAK,SAGfG,IAAUC,EAAmBC,CAAI,GACjCC,IAAKjB,EAAS,SACdkB,IAAQC,EAAgBL,GAASG,CAAE;GACzC,IAAIC,EAAM,WAAW,GAAG,OAAO,CAAC;GAIhC,IAAME,IAAUC,EAAaJ,EAAG,QAAQK,CAAI,GACtCC,KAAS,MAAmCH,IAAUI,CAAK,KAAK,MAChEC,KAAU,MAAkB;IAChC,IAAMC,IAAWN,IAAUH,EAAG,OAAO,MAAM,MAAMU,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,IAAOpB,EAAQiB,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,aAAapB,EAAK,gBAAgBmB,GAASC,EAAM,IAAI,KAAK,KAAK,CACnE;KACA,AAAIW,MAAM,EAAM,OAAOA;IACzB;IACA,OAAO,CAACD,CAAK;GACf,GAIMG,IAAyB,CAAC,GAC1BC,IAAyB,CAAC,GAG1BC,IAAcC,EAAmB9B,CAAE;GACzC,KAAK,IAAM+B,KAAQ9B,GAAO;IACxB,IAAM+B,IAAOD,EAAK,SAASH,IAAUD,GAC/BM,IAAOrB,EAAUmB,GAAM,IAAI;IACjC,KAAK,IAAMX,KAAOa,GAAM,EAAK,KAAKb,CAAG;IACrC,KAAK,IAAMc,KAAKC,EAAYnC,GAAI+B,EAAK,KAAK,IAAIF,CAAW,GACvD,EAAK,KAAK;KAAE,MAAM;KAAS,WAAWnD,EAAK,WAAWwD,CAAC;KAAG,UAAUD;IAAK,CAAC;GAE9E;GACA,IAAIN,EAAQ,WAAW,KAAKC,EAAQ,WAAW,GAAG,OAAO,CAAC;GAE1D,IAAMQ,IAAqB,CAAC;GAG5B,OAFIR,EAAQ,SAAS,KAAGQ,EAAI,KAAK;IAAE,MAAM;IAAS,UAAUR;GAAQ,CAAC,GACjED,EAAQ,SAAS,KAAGS,EAAI,KAAK;IAAE,MAAM;IAAS,OAAOxD;IAAa,UAAU+C;GAAQ,CAAC,GAClFS;EACT;CACF,IAAI,CAACrD,GAAUG,CAAY,CAAC;AAC9B"}
+{"version":3,"file":"usePreviewGhostLayer.js","names":["mat3"],"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: that view's\n * 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 '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { isCustomEntry, type LayersMap } from '../layerSlots';\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 { scenePlaneOf } from '../pickWalk';\nimport { planeTransform } from '../planeClips';\nimport { deriveParallaxView } from 'core/viewport/parallax';\nimport type { PlaneMap } from 'core/viewport/parallax';\nimport { mat3 } from '@weasel-js/geom';\nimport { copiesAbove } from '../copiesAbove';\nimport { scenePaintedPoseOf } from '../derivedPath';\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      if (!slot || isCustomEntry(slot) || !slot.drawOne) return [];\n      const drawOne = slot.drawOne;\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      // 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: slot.derivedPathOf?.(effNode, entry.pose) ?? null },\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      // A node an ancestor draws copies of is ghosted in each copy too, or\n      // the copies vanish for the length of the gesture.\n      const paintedPose = scenePaintedPoseOf(sc);\n      for (const root of roots) {\n        const sink = root.opaque ? settled : ghosted;\n        const cmds = drawEntry(root, null);\n        for (const cmd of cmds) sink.push(cmd);\n        for (const m of copiesAbove(sc, root.node.id, paintedPose)) {\n          sink.push({ kind: 'group', transform: mat3.fromAffine(m), children: cmds });\n        }\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":";;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAM,cAAc;AAEpB,SAAgB,qBAA0D,MASjD;CACvB,MAAM,EAAE,OAAO,WAAW,eAAe;CAIzC,MAAM,WAAW,UAAU,KAAK;CAChC,MAAM,eAAe,UAAU,SAAS;CAKxC,MAAM,GAAG,iBAAiB,YAAY,MAAc,IAAI,GAAG,CAAC;CAC5D,gBAAgB;EACd,IAAI,CAAC,YAAY;EAEjB,OADc,WAAW,UAAU,aAC5B;CACT,GAAG,CAAC,UAAU,CAAC;CAEf,OAAO,eAAqC;EAC1C,IAAI;EACJ,OAAO;EACP,OAAO,MAAM,SAAS;GACpB,MAAM,OAAO,aAAa;GAC1B,IAAI,CAAC,QAAQ,cAAc,IAAI,KAAK,CAAC,KAAK,SAAS,OAAO,CAAC;GAC3D,MAAM,UAAU,KAAK;GAGrB,MAAM,UAAU,mBAAmB,IAAI;GACvC,MAAM,KAAK,SAAS;GACpB,MAAM,QAAQ,gBAAgB,SAAS,EAAE;GACzC,IAAI,MAAM,WAAW,GAAG,OAAO,CAAC;GAIhC,MAAM,UAAU,aAAa,GAAG,QAAQ,IAAI;GAC5C,MAAM,SAAS,UAAmC,UAAU,KAAK,KAAK;GACtE,MAAM,UAAU,UAAkB;IAChC,MAAM,WAAW,UAAU,GAAG,OAAO,MAAM,MAAM,EAAE,OAAO,KAAK,CAAC,EAAE,WAAW;IAC7E,OAAO,WAAW,mBAAmB,MAAM,QAAQ,IAAI;GACzD;GAKA,MAAM,aACJ,OACA,gBACkB;IAClB,MAAM,UAAU,MAAM,SAAS,MAAM,KAAK,OACtC,MAAM,OACL;KAAE,GAAG,MAAM;KAAM,MAAM,MAAM;IAAK;IACvC,MAAM,QAAQ,MAAM,MAAM,KAAK,KAAK;IACpC,MAAM,OAAO,QAAQ,SAAS,MAAM,MAAM,OAAO,MAAM,KAAK,KAAK,CAAC;IAClE,MAAM,WAA0B,CAAC,GAAG,qBAAqB,MAAM,MAAM,IAAe,CAAC;IACrF,KAAK,MAAM,SAAS,MAAM,UACxB,KAAK,MAAM,OAAO,UAAU,OAAO,KAAK,GAAG,SAAS,KAAK,GAAG;IAE9D,MAAM,YAAY,eAAe,OAAO,WAAW;IACnD,MAAM,QAA0B,YAAY;KAAE,MAAM;KAAS;KAAW;IAAS,IAAI;KAAE,MAAM;KAAS;IAAS;IAC/G,IAAI,QAAQ,SAAS,aAAa;KAChC,MAAM,OAAO,oBACX,SACA,MAAM,MACN,EAAE,aAAa,KAAK,gBAAgB,SAAS,MAAM,IAAI,KAAK,KAAK,CACnE;KACA,IAAI,MAAM,MAAM,OAAO;IACzB;IACA,OAAO,CAAC,KAAK;GACf;GAIA,MAAM,UAAyB,CAAC;GAChC,MAAM,UAAyB,CAAC;GAGhC,MAAM,cAAc,mBAAmB,EAAE;GACzC,KAAK,MAAM,QAAQ,OAAO;IACxB,MAAM,OAAO,KAAK,SAAS,UAAU;IACrC,MAAM,OAAO,UAAU,MAAM,IAAI;IACjC,KAAK,MAAM,OAAO,MAAM,KAAK,KAAK,GAAG;IACrC,KAAK,MAAM,KAAK,YAAY,IAAI,KAAK,KAAK,IAAI,WAAW,GACvD,KAAK,KAAK;KAAE,MAAM;KAAS,WAAWA,OAAK,WAAW,CAAC;KAAG,UAAU;IAAK,CAAC;GAE9E;GACA,IAAI,QAAQ,WAAW,KAAK,QAAQ,WAAW,GAAG,OAAO,CAAC;GAE1D,MAAM,MAAqB,CAAC;GAC5B,IAAI,QAAQ,SAAS,GAAG,IAAI,KAAK;IAAE,MAAM;IAAS,UAAU;GAAQ,CAAC;GACrE,IAAI,QAAQ,SAAS,GAAG,IAAI,KAAK;IAAE,MAAM;IAAS,OAAO;IAAa,UAAU;GAAQ,CAAC;GACzF,OAAO;EACT;CACF,IAAI,CAAC,UAAU,YAAY,CAAC;AAC9B"}

package/dist/canvas/SceneCanvas/useSceneCanvasHandle.js

@@ -1,47 +1,74 @@
-import { useOptionalViewRegistry as e } from "../viewRegistry.js";
-import { useCallback as t, useState as n } from "react";
-import { assignRef as r } from "@weasel-js/react";
+import { IDENTITY_VIEW, useOptionalViewRegistry } from "../viewRegistry.js";
+import { useCallback, useState } from "react";
+import { assignRef } from "@weasel-js/react";
+
 //#region src/canvas/SceneCanvas/useSceneCanvasHandle.ts
-function i() {
-	let r = e(), [i, a] = n([]);
+/** Views added through the handle rather than declared as props or children. */
+function useAddedViews() {
+	const surfaceViewRegistry = useOptionalViewRegistry();
+	const [views, setViews] = useState([]);
 	return {
-		views: i,
-		addView: t((e) => (a((t) => [...t.filter((t) => t.id !== e.id), e]), {
-			id: e.id,
-			draw: (t, n, i) => r?.list().find((t) => t.id === e.id)?.layer.draw(t, n, i) ?? [],
-			remove: () => a((t) => t.filter((t) => t !== e))
-		}), [r])
+		views,
+		addView: useCallback((props) => {
+			setViews((list) => [...list.filter((v) => v.id !== props.id), props]);
+			return {
+				id: props.id,
+				draw: (data, outer, dims) => surfaceViewRegistry?.list().find((r) => r.id === props.id)?.layer.draw(data, outer, dims) ?? [],
+				remove: () => setViews((list) => list.filter((v) => v !== props))
+			};
+		}, [surfaceViewRegistry]),
+		viewAt: useCallback((at, opts) => surfaceViewRegistry?.viewAt(at, opts) ?? {
+			id: null,
+			view: IDENTITY_VIEW,
+			rect: {
+				x: 0,
+				y: 0,
+				w: 0,
+				h: 0
+			}
+		}, [surfaceViewRegistry])
 	};
 }
-function a(e) {
-	let { ref: i, elementRef: a, apiRef: o, onElement: s, ingest: c, viewAnimation: l, camera: u, addView: d } = e, [f, p] = n(!1);
+/**
+* The ref callback `<SceneCanvas>` hands `<Canvas>`. It extends the
+* primitive's handle into the `SceneCanvasApi` the consumer's ref receives,
+* and keeps the canvas's own copies of the element and the handle current.
+*/
+function useSceneCanvasHandle(args) {
+	const { ref, elementRef, apiRef, onElement, ingest, viewAnimation, camera, addView, viewAt } = args;
+	const [ready, setReady] = useState(false);
 	return {
-		handleRef: t((e) => {
-			a.current = e?.element ?? null, s(a.current);
-			let t = e ? {
-				...e,
-				ingest: c,
-				animateView: l.animate,
-				stopViewAnimation: l.stop,
-				isViewAnimating: l.isAnimating,
-				camera: u,
-				addView: d
+		handleRef: useCallback((node) => {
+			elementRef.current = node?.element ?? null;
+			onElement(elementRef.current);
+			const extended = node ? {
+				...node,
+				ingest,
+				animateView: viewAnimation.animate,
+				stopViewAnimation: viewAnimation.stop,
+				isViewAnimating: viewAnimation.isAnimating,
+				camera,
+				addView,
+				viewAt
 			} : null;
-			o.current = t, p(t !== null), r(i, t);
+			apiRef.current = extended;
+			setReady(extended !== null);
+			assignRef(ref, extended);
 		}, [
-			i,
-			a,
-			o,
-			c,
-			l,
-			u,
-			d,
-			s
+			ref,
+			elementRef,
+			apiRef,
+			ingest,
+			viewAnimation,
+			camera,
+			addView,
+			viewAt,
+			onElement
 		]),
-		ready: f
+		ready
 	};
 }
-//#endregion
-export { i as useAddedViews, a as useSceneCanvasHandle };
 
+//#endregion
+export { useAddedViews, useSceneCanvasHandle };
 //# sourceMappingURL=useSceneCanvasHandle.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useSceneCanvasHandle.js","names":["useAddedViews","surfaceViewRegistry","useOptionalViewRegistry","views","setViews","useState","useCallback","list","v","props","r","data","outer","dims","useSceneCanvasHandle","args","ready","setReady","node","onElement","elementRef","extended","viewAnimation","assignRef","ref","apiRef","ingest","camera","addView"],"sources":["../../../src/canvas/SceneCanvas/useSceneCanvasHandle.ts"],"sourcesContent":["import { useCallback, useState, type ForwardedRef, type MutableRefObject } from 'react';\nimport { assignRef } from '@weasel-js/react';\nimport type { ViewAnimationApi } from 'core/viewport/useViewAnimation';\nimport type { CanvasViewProps } from '../CanvasView';\nimport type { CanvasExtensionApi, CanvasViewHandle, SceneCanvasApi } from '../canvasExtension';\nimport { useOptionalViewRegistry } from '../viewRegistry';\n\n/** Views added through the handle rather than declared as props or children. */\nexport function useAddedViews(): {\n  views: readonly CanvasViewProps[];\n  addView: SceneCanvasApi['addView'];\n} {\n  const surfaceViewRegistry = useOptionalViewRegistry();\n  const [views, setViews] = useState<readonly CanvasViewProps[]>([]);\n  const addView = useCallback((props: CanvasViewProps): CanvasViewHandle => {\n    setViews((list) => [...list.filter((v) => v.id !== props.id), props]);\n    return {\n      id: props.id,\n      draw: (data, outer, dims) =>\n        surfaceViewRegistry?.list().find((r) => r.id === props.id)?.layer.draw(data, outer, dims) ?? [],\n      remove: () => setViews((list) => list.filter((v) => v !== props)),\n    };\n  }, [surfaceViewRegistry]);\n  return { views, addView };\n}\n\n/**\n * The ref callback `<SceneCanvas>` hands `<Canvas>`. It extends the\n * primitive's handle into the `SceneCanvasApi` the consumer's ref receives,\n * and keeps the canvas's own copies of the element and the handle current.\n */\nexport function useSceneCanvasHandle(args: {\n  ref: ForwardedRef<SceneCanvasApi>;\n  /** Written with the canvas element, for the input listeners. */\n  elementRef: MutableRefObject<HTMLElement | null>;\n  /** Written with the extended handle, for `requestRedraw` and point conversion. */\n  apiRef: MutableRefObject<CanvasExtensionApi | null>;\n  /** Told the element whenever it attaches or detaches. */\n  onElement: (element: HTMLElement | null) => void;\n  ingest: SceneCanvasApi['ingest'];\n  viewAnimation: Pick<ViewAnimationApi, 'animate' | 'stop' | 'isAnimating'>;\n  camera: SceneCanvasApi['camera'];\n  addView: SceneCanvasApi['addView'];\n}): {\n  handleRef: (node: CanvasExtensionApi | null) => void;\n  /** Whether the handle is attached, as state: an effect needing the handle\n   *  keys off this instead of assuming when React attaches it. */\n  ready: boolean;\n} {\n  const { ref, elementRef, apiRef, onElement, ingest, viewAnimation, camera, addView } = args;\n  const [ready, setReady] = useState(false);\n  const handleRef = useCallback(\n    (node: CanvasExtensionApi | null) => {\n      elementRef.current = node?.element ?? null;\n      onElement(elementRef.current);\n      const extended: SceneCanvasApi | null = node\n        ? {\n            ...node,\n            ingest,\n            animateView: viewAnimation.animate,\n            stopViewAnimation: viewAnimation.stop,\n            isViewAnimating: viewAnimation.isAnimating,\n            camera,\n            addView,\n          }\n        : null;\n      apiRef.current = extended;\n      setReady(extended !== null);\n      assignRef(ref, extended);\n    },\n    [ref, elementRef, apiRef, ingest, viewAnimation, camera, addView, onElement],\n  );\n  return { handleRef, ready };\n}\n"],"mappings":";;;;AAQA,SAAgBA,IAGd;CACA,IAAMC,IAAsBC,EAAwB,GAC9C,CAACC,GAAOC,KAAYC,EAAqC,CAAC,CAAC;CAUjE,OAAO;EAAE;EAAO,SATAC,GAAa,OAC3BF,GAAU,MAAS,CAAC,GAAGG,EAAK,QAAQ,MAAMC,EAAE,OAAOC,EAAM,EAAE,GAAGA,CAAK,CAAC,GAC7D;GACL,IAAIA,EAAM;GACV,OAAO,GAAM,GAAO,MAClBR,GAAqB,KAAK,CAAC,CAAC,MAAM,MAAMS,EAAE,OAAOD,EAAM,EAAE,CAAC,EAAE,MAAM,KAAKE,GAAMC,GAAOC,CAAI,KAAK,CAAC;GAChG,cAAcT,GAAU,MAASG,EAAK,QAAQ,MAAMC,MAAMC,CAAK,CAAC;EAClE,IACC,CAACR,CAAmB,CACP;CAAQ;AAC1B;AAOA,SAAgBa,EAAqB,GAiBnC;CACA,IAAM,EAAE,QAAK,eAAY,WAAQ,cAAW,WAAQ,kBAAe,WAAQ,eAAYC,GACjF,CAACC,GAAOC,KAAYZ,EAAS,EAAK;CAsBxC,OAAO;EAAE,WArBSC,GACf,MAAoC;GAEnC,AADA,EAAW,UAAUY,GAAM,WAAW,MACtCC,EAAUC,EAAW,OAAO;GAC5B,IAAMC,IAAkCH,IACpC;IACE,GAAGA;IACH;IACA,aAAaI,EAAc;IAC3B,mBAAmBA,EAAc;IACjC,iBAAiBA,EAAc;IAC/B;IACA;GACF,IACA;GAGJ,AAFA,EAAO,UAAUD,GACjBJ,EAASI,MAAa,IAAI,GAC1BE,EAAUC,GAAKH,CAAQ;EACzB,GACA;GAACG;GAAKJ;GAAYK;GAAQC;GAAQJ;GAAeK;GAAQC;GAAST;EAAS,CAEpE;EAAW;CAAM;AAC5B"}
+{"version":3,"file":"useSceneCanvasHandle.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useSceneCanvasHandle.ts"],"sourcesContent":["import { useCallback, useState, type ForwardedRef, type MutableRefObject } from 'react';\nimport { assignRef } from '@weasel-js/react';\nimport type { ViewAnimationApi } from 'core/viewport/useViewAnimation';\nimport type { CanvasViewProps } from '../CanvasView';\nimport type { CanvasExtensionApi, CanvasViewHandle, SceneCanvasApi } from '../canvasExtension';\nimport { IDENTITY_VIEW, useOptionalViewRegistry } from '../viewRegistry';\n\n/** Views added through the handle rather than declared as props or children. */\nexport function useAddedViews(): {\n  views: readonly CanvasViewProps[];\n  addView: SceneCanvasApi['addView'];\n  viewAt: SceneCanvasApi['viewAt'];\n} {\n  const surfaceViewRegistry = useOptionalViewRegistry();\n  const [views, setViews] = useState<readonly CanvasViewProps[]>([]);\n  const addView = useCallback((props: CanvasViewProps): CanvasViewHandle => {\n    setViews((list) => [...list.filter((v) => v.id !== props.id), props]);\n    return {\n      id: props.id,\n      draw: (data, outer, dims) =>\n        surfaceViewRegistry?.list().find((r) => r.id === props.id)?.layer.draw(data, outer, dims) ?? [],\n      remove: () => setViews((list) => list.filter((v) => v !== props)),\n    };\n  }, [surfaceViewRegistry]);\n  const viewAt = useCallback<SceneCanvasApi['viewAt']>((at, opts) => (\n    surfaceViewRegistry?.viewAt(at, opts) ?? { id: null, view: IDENTITY_VIEW, rect: { x: 0, y: 0, w: 0, h: 0 } }\n  ), [surfaceViewRegistry]);\n  return { views, addView, viewAt };\n}\n\n/**\n * The ref callback `<SceneCanvas>` hands `<Canvas>`. It extends the\n * primitive's handle into the `SceneCanvasApi` the consumer's ref receives,\n * and keeps the canvas's own copies of the element and the handle current.\n */\nexport function useSceneCanvasHandle(args: {\n  ref: ForwardedRef<SceneCanvasApi>;\n  /** Written with the canvas element, for the input listeners. */\n  elementRef: MutableRefObject<HTMLElement | null>;\n  /** Written with the extended handle, for `requestRedraw` and point conversion. */\n  apiRef: MutableRefObject<CanvasExtensionApi | null>;\n  /** Told the element whenever it attaches or detaches. */\n  onElement: (element: HTMLElement | null) => void;\n  ingest: SceneCanvasApi['ingest'];\n  viewAnimation: Pick<ViewAnimationApi, 'animate' | 'stop' | 'isAnimating'>;\n  camera: SceneCanvasApi['camera'];\n  addView: SceneCanvasApi['addView'];\n  viewAt: SceneCanvasApi['viewAt'];\n}): {\n  handleRef: (node: CanvasExtensionApi | null) => void;\n  /** Whether the handle is attached, as state: an effect needing the handle\n   *  keys off this instead of assuming when React attaches it. */\n  ready: boolean;\n} {\n  const { ref, elementRef, apiRef, onElement, ingest, viewAnimation, camera, addView, viewAt } = args;\n  const [ready, setReady] = useState(false);\n  const handleRef = useCallback(\n    (node: CanvasExtensionApi | null) => {\n      elementRef.current = node?.element ?? null;\n      onElement(elementRef.current);\n      const extended: SceneCanvasApi | null = node\n        ? {\n            ...node,\n            ingest,\n            animateView: viewAnimation.animate,\n            stopViewAnimation: viewAnimation.stop,\n            isViewAnimating: viewAnimation.isAnimating,\n            camera,\n            addView,\n            viewAt,\n          }\n        : null;\n      apiRef.current = extended;\n      setReady(extended !== null);\n      assignRef(ref, extended);\n    },\n    [ref, elementRef, apiRef, ingest, viewAnimation, camera, addView, viewAt, onElement],\n  );\n  return { handleRef, ready };\n}\n"],"mappings":";;;;;;AAQA,SAAgB,gBAId;CACA,MAAM,sBAAsB,wBAAwB;CACpD,MAAM,CAAC,OAAO,YAAY,SAAqC,CAAC,CAAC;CAajE,OAAO;EAAE;EAAO,SAZA,aAAa,UAA6C;GACxE,UAAU,SAAS,CAAC,GAAG,KAAK,QAAQ,MAAM,EAAE,OAAO,MAAM,EAAE,GAAG,KAAK,CAAC;GACpE,OAAO;IACL,IAAI,MAAM;IACV,OAAO,MAAM,OAAO,SAClB,qBAAqB,KAAK,CAAC,CAAC,MAAM,MAAM,EAAE,OAAO,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC;IAChG,cAAc,UAAU,SAAS,KAAK,QAAQ,MAAM,MAAM,KAAK,CAAC;GAClE;EACF,GAAG,CAAC,mBAAmB,CAIP;EAAS,QAHV,aAAuC,IAAI,SACxD,qBAAqB,OAAO,IAAI,IAAI,KAAK;GAAE,IAAI;GAAM,MAAM;GAAe,MAAM;IAAE,GAAG;IAAG,GAAG;IAAG,GAAG;IAAG,GAAG;GAAE;EAAE,GAC1G,CAAC,mBAAmB,CACE;CAAO;AAClC;;;;;;AAOA,SAAgB,qBAAqB,MAkBnC;CACA,MAAM,EAAE,KAAK,YAAY,QAAQ,WAAW,QAAQ,eAAe,QAAQ,SAAS,WAAW;CAC/F,MAAM,CAAC,OAAO,YAAY,SAAS,KAAK;CAuBxC,OAAO;EAAE,WAtBS,aACf,SAAoC;GACnC,WAAW,UAAU,MAAM,WAAW;GACtC,UAAU,WAAW,OAAO;GAC5B,MAAM,WAAkC,OACpC;IACE,GAAG;IACH;IACA,aAAa,cAAc;IAC3B,mBAAmB,cAAc;IACjC,iBAAiB,cAAc;IAC/B;IACA;IACA;GACF,IACA;GACJ,OAAO,UAAU;GACjB,SAAS,aAAa,IAAI;GAC1B,UAAU,KAAK,QAAQ;EACzB,GACA;GAAC;GAAK;GAAY;GAAQ;GAAQ;GAAe;GAAQ;GAAS;GAAQ;EAAS,CAE5E;EAAW;CAAM;AAC5B"}

package/dist/canvas/SceneCanvas/useSceneCanvasLayers.js

@@ -1,66 +1,126 @@
-import { usePathEditOverlayLayer as e } from "../../features/paths/usePathEdit.js";
-import { builtLayersOf as t } from "../layerSlots.js";
-import { mergeLayersWithDefaults as n } from "./props.js";
-import { createSlopsDebugLayer as r } from "../slopsDebugLayer.js";
-import { useDispatcherOverlayLayer as i } from "./useDispatcherOverlayLayer.js";
-import { usePreviewGhostLayer as a } from "./usePreviewGhostLayer.js";
-import { useSceneSlotLayers as o } from "./useSceneSlotLayers.js";
-import { useSelectionOverlayLayer as s } from "./useSelectionOverlayLayer.js";
-import { useMemo as c, useRef as l } from "react";
+import { targetSizesPx } from "../../core/device/targets.js";
+import { createSnapOutcomeStore } from "../../features/snap/outcomeStore.js";
+import { builtLayersOf, isCustomEntry } from "../layerSlots.js";
+import { useTargetBasePx } from "../../core/device/useTargetBasePx.js";
+import { usePathEditOverlayLayer } from "../../features/paths/usePathEdit.js";
+import { createSlopsDebugLayer } from "../slopsDebugLayer.js";
+import { mergeLayersWithDefaults } from "./mergeLayers.js";
+import { useDispatcherOverlayLayer } from "./useDispatcherOverlayLayer.js";
+import { usePreviewGhostLayer } from "./usePreviewGhostLayer.js";
+import { useDepartureGhostLayer } from "./useDepartureGhostLayer.js";
+import { usePoseTransition } from "../../animation/poseTransition.js";
+import { useSceneSlotLayers } from "./useSceneSlotLayers.js";
+import { useSelectionOverlayLayer } from "./useSelectionOverlayLayer.js";
+import { createSnapReadoutLayer } from "../../features/snap/readoutLayer.js";
+import { useMemo, useRef, useState } from "react";
+
 //#region src/canvas/SceneCanvas/useSceneCanvasLayers.ts
-function u(u) {
-	let { scene: d, adapter: f, poseDescriptor: p, alphaFor: m, dispatcher: h, pathEditState: g, slops: _, targetScale: v } = u, y = c(() => n(u.layers, v), [u.layers, v]), { config: b, layers: x } = o({
-		slot: y.scene,
-		scene: d,
-		adapter: f,
-		alphaFor: m,
-		colorOverrides: u.colorOverrides,
-		boundsOf: u.boundsOf,
-		previewIds: u.previewIds
-	}), S = a({
-		scene: d,
-		sceneSlot: b,
-		dispatcher: h
-	}), C = i({ dispatcher: h }), w = l([]), T = c(() => r({ getAffordances: () => w.current }), []), E = e(g, {
-		nodeOf: (e) => d.get(e),
-		planeOfNode: u.planeOfNode
-	}), { layer: D, rotationBadge: O } = s(y.selectionOverlay, g.getEditingIds, p);
+/**
+* The layer map `<SceneCanvas>` hands `<Canvas>`: the caller's `layers` over
+* the kit defaults, with the scene and selection-overlay slots built, and the
+* canvas's own layers anchored around them. Removed nodes leave just above
+* the scene, the preview ghost above them, the dispatcher's overlay (marquee, lasso) above the ghost, and the
+* anchor overlay above the selection chrome.
+*/
+function useSceneCanvasLayers(args) {
+	const { scene, adapter, poseDescriptor, alphaFor, dispatcher, pathEditState, slops, targetScale } = args;
+	const baseSizes = useTargetBasePx();
+	const merged = useMemo(() => mergeLayersWithDefaults(args.layers, targetScale, baseSizes), [
+		args.layers,
+		targetScale,
+		baseSizes
+	]);
+	const { config: sceneSlot, layers: sceneLayers } = useSceneSlotLayers({
+		slot: merged.scene,
+		scene,
+		adapter,
+		alphaFor,
+		colorOverrides: args.colorOverrides,
+		boundsOf: args.boundsOf,
+		previewIds: args.previewIds
+	});
+	const previewLayer = usePreviewGhostLayer({
+		scene,
+		sceneSlot,
+		dispatcher
+	});
+	const departures = usePoseTransition(scene, args.poseTransition);
+	const departureLayer = useDepartureGhostLayer({
+		scene,
+		sceneSlot,
+		departures
+	});
+	const dispatcherOverlay = useDispatcherOverlayLayer({ dispatcher });
+	const hitRadiusPx = args.selectTool?.handleHitRadius ?? targetSizesPx(targetScale, baseSizes).handle;
+	const edges = args.selectTool?.resize?.edgeHandles ?? true;
+	const resizeHandles = useMemo(() => ({
+		edges,
+		hitRadiusPx
+	}), [edges, hitRadiusPx]);
+	const chromeAffordancesRef = useRef([]);
+	const slopsLayer = useMemo(() => createSlopsDebugLayer({ getAffordances: () => chromeAffordancesRef.current }), []);
+	const [snapStore] = useState(() => createSnapOutcomeStore());
+	const snapReadoutLayer = useMemo(() => createSnapReadoutLayer(snapStore, args.snapReadoutStyle), [snapStore, args.snapReadoutStyle]);
+	const overlaySlot = merged.pathEditingOverlay;
+	const overlayConfig = overlaySlot && !isCustomEntry(overlaySlot) ? overlaySlot : void 0;
+	const overlayAnchor = overlaySlot === null ? "dispatcherOverlay" : "pathEditingOverlay";
+	const pathEditingOverlayLayer = usePathEditOverlayLayer(pathEditState, {
+		nodeOf: (id) => scene.get(id),
+		planeOfNode: args.planeOfNode
+	}, overlayConfig);
+	const { layer: selectionOverlayLayer, rotationBadge } = useSelectionOverlayLayer(merged.selectionOverlay, pathEditState.getEditingIds, poseDescriptor, args.boundsIncludeStroke ? scene : void 0, resizeHandles);
 	return {
-		layers: c(() => ({
-			...t(y),
-			scene: x,
-			selectionOverlay: D ? { layer: D } : null,
-			previewGhost: {
-				layer: S,
+		layers: useMemo(() => ({
+			...builtLayersOf(merged),
+			scene: sceneLayers,
+			selectionOverlay: selectionOverlayLayer ? { layer: selectionOverlayLayer } : null,
+			departureGhost: {
+				layer: departureLayer,
 				after: "scene"
 			},
+			previewGhost: {
+				layer: previewLayer,
+				after: "departureGhost"
+			},
 			dispatcherOverlay: {
-				layer: C,
+				layer: dispatcherOverlay,
 				after: "previewGhost"
 			},
-			pathEditingOverlay: {
-				layer: E,
+			pathEditingOverlay: overlaySlot === null || isCustomEntry(overlaySlot) ? overlaySlot : {
+				layer: pathEditingOverlayLayer,
 				after: "selectionOverlay"
 			},
-			..._ ? { slopsDebug: {
-				layer: T,
-				after: "pathEditingOverlay"
+			...args.snapReadout ? { snapReadout: {
+				layer: snapReadoutLayer,
+				after: overlayAnchor
+			} } : {},
+			...slops ? { slopsDebug: {
+				layer: slopsLayer,
+				after: args.snapReadout ? "snapReadout" : overlayAnchor
 			} } : {}
 		}), [
-			y,
-			x,
-			D,
-			S,
-			C,
-			E,
-			_,
-			T
+			merged,
+			sceneLayers,
+			selectionOverlayLayer,
+			departureLayer,
+			previewLayer,
+			dispatcherOverlay,
+			pathEditingOverlayLayer,
+			overlaySlot,
+			overlayAnchor,
+			snapReadoutLayer,
+			args.snapReadout,
+			slops,
+			slopsLayer
 		]),
-		rotationBadge: O,
-		chromeAffordancesRef: w
+		rotationBadge,
+		resizeHandles,
+		chromeAffordancesRef,
+		snapStore,
+		departures
 	};
 }
-//#endregion
-export { u as useSceneCanvasLayers };
 
+//#endregion
+export { useSceneCanvasLayers };
 //# sourceMappingURL=useSceneCanvasLayers.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useSceneCanvasLayers.js","names":["useSceneCanvasLayers","args","merged","useMemo","mergeLayersWithDefaults","targetScale","sceneSlot","sceneLayers","useSceneSlotLayers","previewLayer","usePreviewGhostLayer","dispatcherOverlay","useDispatcherOverlayLayer","chromeAffordancesRef","useRef","slopsLayer","createSlopsDebugLayer","pathEditingOverlayLayer","usePathEditOverlayLayer","pathEditState","scene","id","selectionOverlayLayer","useSelectionOverlayLayer","poseDescriptor","builtLayersOf","slops"],"sources":["../../../src/canvas/SceneCanvas/useSceneCanvasLayers.ts"],"sourcesContent":["import { useMemo, useRef, type MutableRefObject } from 'react';\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport type { Affordance } from 'affordances/types';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport type { PathEditState } from 'features/paths/pathEditState';\nimport { usePathEditOverlayLayer } from 'features/paths/usePathEdit';\nimport type { rotationBadgeOf } from 'features/selection/overlay';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { HierarchicalAdapter } from '../buildSceneTree';\nimport { builtLayersOf, type CanvasLayers } from '../layerSlots';\nimport { createSlopsDebugLayer } from '../slopsDebugLayer';\nimport { mergeLayersWithDefaults, type SceneCanvasLayers } from './props';\nimport { useDispatcherOverlayLayer } from './useDispatcherOverlayLayer';\nimport { usePreviewGhostLayer } from './usePreviewGhostLayer';\nimport { useSceneSlotLayers } from './useSceneSlotLayers';\nimport { useSelectionOverlayLayer } from './useSelectionOverlayLayer';\n\n/**\n * The layer map `<SceneCanvas>` hands `<Canvas>`: the caller's `layers` over\n * the kit defaults, with the scene and selection-overlay slots built, and the\n * canvas's own layers anchored around them. The preview ghost sits above the\n * scene, the dispatcher's overlay (marquee, lasso) above the ghost, and the\n * anchor overlay above the selection chrome.\n */\nexport function useSceneCanvasLayers<TData, TLayer extends string, TPose>(args: {\n  /** `<SceneCanvas layers>`. Omitted, the result is the full default set. */\n  layers: SceneCanvasLayers<Node<TData, TLayer, TPose>, TPose> | undefined;\n  /** The device profile's, which sizes the default handles. */\n  targetScale: number;\n  scene: Scene<TData, TLayer, TPose>;\n  adapter: HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose>;\n  poseDescriptor: PoseDescriptor<TPose>;\n  alphaFor: ((id: string) => number) | undefined;\n  colorOverrides: ColorOverrideRegistry | undefined;\n  boundsOf: (id: string) => Bounds | null;\n  planeOfNode: (id: string, view: View) => PlaneMap | null;\n  /** Ids an in-flight gesture is ghosting. */\n  previewIds: () => Iterable<string> | null;\n  dispatcher: Dispatcher;\n  pathEditState: PathEditState;\n  /** `debug.slops`: paint the hit regions of the chrome affordances. */\n  slops: boolean;\n}): {\n  layers: CanvasLayers;\n  /** Where the selection overlay paints its rotate badge, or null. */\n  rotationBadge: ReturnType<typeof rotationBadgeOf>;\n  /** The affordances the gesture mounter hit-tests, which it publishes here\n   *  so the slops halos are the hit regions rather than a copy of them. */\n  chromeAffordancesRef: MutableRefObject<readonly Affordance[]>;\n} {\n  const { scene, adapter, poseDescriptor, alphaFor, dispatcher, pathEditState, slops, targetScale } = args;\n\n  const merged = useMemo(\n    () => mergeLayersWithDefaults(args.layers, targetScale),\n    [args.layers, targetScale],\n  );\n\n  const { config: sceneSlot, layers: sceneLayers } = useSceneSlotLayers({\n    slot: merged.scene,\n    scene,\n    adapter,\n    alphaFor,\n    colorOverrides: args.colorOverrides,\n    boundsOf: args.boundsOf,\n    previewIds: args.previewIds,\n  });\n  // Takes the scene-wired slot, so a ghosted derived node still resolves its path.\n  const previewLayer = usePreviewGhostLayer<TData, TLayer, TPose>({ scene, sceneSlot, dispatcher });\n  const dispatcherOverlay = useDispatcherOverlayLayer({ dispatcher });\n\n  const chromeAffordancesRef = useRef<readonly Affordance[]>([]);\n  const slopsLayer = useMemo(\n    () => createSlopsDebugLayer({ getAffordances: () => chromeAffordancesRef.current }),\n    [],\n  );\n\n  const pathEditingOverlayLayer = usePathEditOverlayLayer(pathEditState, {\n    nodeOf: (id) => scene.get(id as NodeId),\n    planeOfNode: args.planeOfNode,\n  });\n\n  const { layer: selectionOverlayLayer, rotationBadge } = useSelectionOverlayLayer<TPose>(\n    merged.selectionOverlay,\n    pathEditState.getEditingIds,\n    poseDescriptor,\n  );\n\n  const layers = useMemo<CanvasLayers>(() => ({\n    ...builtLayersOf(merged),\n    scene: sceneLayers,\n    selectionOverlay: selectionOverlayLayer ? { layer: selectionOverlayLayer } : null,\n    previewGhost: { layer: previewLayer, after: 'scene' },\n    dispatcherOverlay: { layer: dispatcherOverlay, after: 'previewGhost' },\n    pathEditingOverlay: { layer: pathEditingOverlayLayer, after: 'selectionOverlay' },\n    ...(slops ? { slopsDebug: { layer: slopsLayer, after: 'pathEditingOverlay' } } : {}),\n  }), [merged, sceneLayers, selectionOverlayLayer, previewLayer, dispatcherOverlay, pathEditingOverlayLayer, slops, slopsLayer]);\n\n  return { layers, rotationBadge, chromeAffordancesRef };\n}\n"],"mappings":";;;;;;;;;;AA4BA,SAAgBA,EAA0D,GAyBxE;CACA,IAAM,EAAE,UAAO,YAAS,mBAAgB,aAAU,eAAY,kBAAe,UAAO,mBAAgBC,GAE9FC,IAASC,QACPC,EAAwBH,EAAK,QAAQI,CAAW,GACtD,CAACJ,EAAK,QAAQI,CAAW,CAC3B,GAEM,EAAE,QAAQC,GAAW,QAAQC,MAAgBC,EAAmB;EACpE,MAAMN,EAAO;EACb;EACA;EACA;EACA,gBAAgBD,EAAK;EACrB,UAAUA,EAAK;EACf,YAAYA,EAAK;CACnB,CAAC,GAEKQ,IAAeC,EAA2C;EAAE;EAAO;EAAW;CAAW,CAAC,GAC1FC,IAAoBC,EAA0B,EAAE,cAAW,CAAC,GAE5DC,IAAuBC,EAA8B,CAAC,CAAC,GACvDC,IAAaZ,QACXa,EAAsB,EAAE,sBAAsBH,EAAqB,QAAQ,CAAC,GAClF,CAAC,CACH,GAEMI,IAA0BC,EAAwBC,GAAe;EACrE,SAAS,MAAOC,EAAM,IAAIC,CAAY;EACtC,aAAapB,EAAK;CACpB,CAAC,GAEK,EAAE,OAAOqB,GAAuB,qBAAkBC,EACtDrB,EAAO,kBACPiB,EAAc,eACdK,CACF;CAYA,OAAO;EAAE,QAVMrB,SAA6B;GAC1C,GAAGsB,EAAcvB,CAAM;GACvB,OAAOK;GACP,kBAAkBe,IAAwB,EAAE,OAAOA,EAAsB,IAAI;GAC7E,cAAc;IAAE,OAAOb;IAAc,OAAO;GAAQ;GACpD,mBAAmB;IAAE,OAAOE;IAAmB,OAAO;GAAe;GACrE,oBAAoB;IAAE,OAAOM;IAAyB,OAAO;GAAmB;GAChF,GAAIS,IAAQ,EAAE,YAAY;IAAE,OAAOX;IAAY,OAAO;GAAqB,EAAE,IAAI,CAAC;EACpF,IAAI;GAACb;GAAQK;GAAae;GAAuBb;GAAcE;GAAmBM;GAAyBS;GAAOX;EAAU,CAEnH;EAAQ;EAAe;CAAqB;AACvD"}
+{"version":3,"file":"useSceneCanvasLayers.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useSceneCanvasLayers.ts"],"sourcesContent":["import { useMemo, useRef, useState, type MutableRefObject } from 'react';\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport type { Affordance } from 'affordances/types';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport type { PathEditState } from 'features/paths/pathEditState';\nimport { usePathEditOverlayLayer } from 'features/paths/usePathEdit';\nimport type { rotationBadgeOf } from 'features/selection/overlay';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { HierarchicalAdapter } from '../buildSceneTree';\nimport { builtLayersOf, isCustomEntry, type CanvasLayers } from '../layerSlots';\nimport { createSlopsDebugLayer } from '../slopsDebugLayer';\nimport { useTargetBasePx } from 'core/device/useTargetBasePx';\nimport { targetSizesPx } from 'core/device/targets';\nimport type { ResizeHandleLayout } from 'interactions/actions/resize/cornerHandles';\nimport { mergeLayersWithDefaults } from './mergeLayers';\nimport type { SceneCanvasLayers } from './props';\nimport { useDispatcherOverlayLayer } from './useDispatcherOverlayLayer';\nimport { usePreviewGhostLayer } from './usePreviewGhostLayer';\nimport { useDepartureGhostLayer } from './useDepartureGhostLayer';\nimport type { Departures } from '../../animation/departures';\nimport { usePoseTransition, type PoseTransitionSeat } from '../../animation/poseTransition';\nimport { useSceneSlotLayers } from './useSceneSlotLayers';\nimport { useSelectionOverlayLayer } from './useSelectionOverlayLayer';\nimport type { DrawnBoundsScene } from '../drawnBounds';\nimport { createSnapOutcomeStore, type SnapOutcomeStore } from 'features/snap/outcomeStore';\nimport { createSnapReadoutLayer, type SnapReadoutStyle } from 'features/snap/readoutLayer';\n\n/**\n * The layer map `<SceneCanvas>` hands `<Canvas>`: the caller's `layers` over\n * the kit defaults, with the scene and selection-overlay slots built, and the\n * canvas's own layers anchored around them. Removed nodes leave just above\n * the scene, the preview ghost above them, the dispatcher's overlay (marquee, lasso) above the ghost, and the\n * anchor overlay above the selection chrome.\n */\nexport function useSceneCanvasLayers<TData, TLayer extends string, TPose>(args: {\n  /** `<SceneCanvas layers>`. Omitted, the result is the full default set. */\n  layers: SceneCanvasLayers<Node<TData, TLayer, TPose>, TPose> | undefined;\n  /** The device profile's, which sizes the default handles. */\n  targetScale: number;\n  scene: Scene<TData, TLayer, TPose>;\n  adapter: HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose>;\n  poseDescriptor: PoseDescriptor<TPose>;\n  alphaFor: ((id: string) => number) | undefined;\n  colorOverrides: ColorOverrideRegistry | undefined;\n  boundsOf: (id: string) => Bounds | null;\n  planeOfNode: (id: string, view: View) => PlaneMap | null;\n  /** `<SceneCanvas poseTransition>`, whose ghosts of removed nodes this draws. */\n  poseTransition: PoseTransitionSeat<TPose> | null | undefined;\n  /** Ids an in-flight gesture is ghosting. */\n  previewIds: () => Iterable<string> | null;\n  dispatcher: Dispatcher;\n  /** Whether to mount the snap readout layer. */\n  snapReadout: boolean;\n  snapReadoutStyle?: SnapReadoutStyle;\n  pathEditState: PathEditState;\n  /** `debug.slops`: paint the hit regions of the chrome affordances. */\n  slops: boolean;\n  /** `geometry.boundsIncludeStroke`: whether chrome sits on the stroke. */\n  boundsIncludeStroke: boolean;\n  /** `selectTool`'s `handleHitRadius` and `resize.edgeHandles`, resolved here into\n   *  the one {@link ResizeHandleLayout} the overlay paints and the hit-test reads. */\n  selectTool?: { handleHitRadius?: number; resize?: { edgeHandles?: boolean } };\n}): {\n  layers: CanvasLayers;\n  /** Where the selection overlay paints its rotate badge, or null. */\n  rotationBadge: ReturnType<typeof rotationBadgeOf>;\n  /** Which resize handles exist and their hit radius, for every hit-test of this canvas. */\n  resizeHandles: ResizeHandleLayout;\n  /** The affordances the gesture mounter hit-tests, which it publishes here\n   *  so the slops halos are the hit regions rather than a copy of them. */\n  chromeAffordancesRef: MutableRefObject<readonly Affordance[]>;\n  /** The marks the readout layer draws; the canvas's snap dep writes them. */\n  snapStore: SnapOutcomeStore;\n  /** The removed nodes the seat is seeing off. */\n  departures: Departures<TPose, Node<TData, TLayer, TPose>>;\n} {\n  const { scene, adapter, poseDescriptor, alphaFor, dispatcher, pathEditState, slops, targetScale } = args;\n\n  const baseSizes = useTargetBasePx();\n  const merged = useMemo(\n    () => mergeLayersWithDefaults(args.layers, targetScale, baseSizes),\n    [args.layers, targetScale, baseSizes],\n  );\n\n  const { config: sceneSlot, layers: sceneLayers } = useSceneSlotLayers({\n    slot: merged.scene,\n    scene,\n    adapter,\n    alphaFor,\n    colorOverrides: args.colorOverrides,\n    boundsOf: args.boundsOf,\n    previewIds: args.previewIds,\n  });\n  // Takes the scene-wired slot, so a ghosted derived node still resolves its path.\n  const previewLayer = usePreviewGhostLayer<TData, TLayer, TPose>({ scene, sceneSlot, dispatcher });\n  const departures = usePoseTransition(scene, args.poseTransition);\n  const departureLayer = useDepartureGhostLayer({ scene, sceneSlot, departures });\n  const dispatcherOverlay = useDispatcherOverlayLayer({ dispatcher });\n\n  const hitRadiusPx = args.selectTool?.handleHitRadius ?? targetSizesPx(targetScale, baseSizes).handle;\n  const edges = args.selectTool?.resize?.edgeHandles ?? true;\n  const resizeHandles = useMemo<ResizeHandleLayout>(() => ({ edges, hitRadiusPx }), [edges, hitRadiusPx]);\n\n  const chromeAffordancesRef = useRef<readonly Affordance[]>([]);\n  const slopsLayer = useMemo(\n    () => createSlopsDebugLayer({ getAffordances: () => chromeAffordancesRef.current }),\n    [],\n  );\n\n  const [snapStore] = useState(() => createSnapOutcomeStore());\n  const snapReadoutLayer = useMemo(() => createSnapReadoutLayer(snapStore, args.snapReadoutStyle), [snapStore, args.snapReadoutStyle]);\n  const overlaySlot = merged.pathEditingOverlay;\n  const overlayConfig = overlaySlot && !isCustomEntry(overlaySlot) ? overlaySlot : undefined;\n  const overlayAnchor = overlaySlot === null ? 'dispatcherOverlay' : 'pathEditingOverlay';\n  const pathEditingOverlayLayer = usePathEditOverlayLayer(pathEditState, {\n    nodeOf: (id) => scene.get(id as NodeId),\n    planeOfNode: args.planeOfNode,\n  }, overlayConfig);\n\n  const { layer: selectionOverlayLayer, rotationBadge } = useSelectionOverlayLayer<TPose>(\n    merged.selectionOverlay,\n    pathEditState.getEditingIds,\n    poseDescriptor,\n    args.boundsIncludeStroke ? (scene as unknown as DrawnBoundsScene) : undefined,\n    resizeHandles,\n  );\n\n  const layers = useMemo<CanvasLayers>(() => ({\n    ...builtLayersOf(merged),\n    scene: sceneLayers,\n    selectionOverlay: selectionOverlayLayer ? { layer: selectionOverlayLayer } : null,\n    departureGhost: { layer: departureLayer, after: 'scene' },\n    previewGhost: { layer: previewLayer, after: 'departureGhost' },\n    dispatcherOverlay: { layer: dispatcherOverlay, after: 'previewGhost' },\n    pathEditingOverlay: overlaySlot === null || isCustomEntry(overlaySlot)\n      ? overlaySlot\n      : { layer: pathEditingOverlayLayer, after: 'selectionOverlay' },\n    ...(args.snapReadout ? { snapReadout: { layer: snapReadoutLayer, after: overlayAnchor } } : {}),\n    ...(slops ? { slopsDebug: { layer: slopsLayer, after: args.snapReadout ? 'snapReadout' : overlayAnchor } } : {}),\n  }), [\n    merged, sceneLayers, selectionOverlayLayer, departureLayer, previewLayer, dispatcherOverlay, pathEditingOverlayLayer, overlaySlot, overlayAnchor,\n    snapReadoutLayer, args.snapReadout, slops, slopsLayer,\n  ]);\n\n  return { layers, rotationBadge, resizeHandles, chromeAffordancesRef, snapStore, departures };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,qBAA0D,MAyCxE;CACA,MAAM,EAAE,OAAO,SAAS,gBAAgB,UAAU,YAAY,eAAe,OAAO,gBAAgB;CAEpG,MAAM,YAAY,gBAAgB;CAClC,MAAM,SAAS,cACP,wBAAwB,KAAK,QAAQ,aAAa,SAAS,GACjE;EAAC,KAAK;EAAQ;EAAa;CAAS,CACtC;CAEA,MAAM,EAAE,QAAQ,WAAW,QAAQ,gBAAgB,mBAAmB;EACpE,MAAM,OAAO;EACb;EACA;EACA;EACA,gBAAgB,KAAK;EACrB,UAAU,KAAK;EACf,YAAY,KAAK;CACnB,CAAC;CAED,MAAM,eAAe,qBAA2C;EAAE;EAAO;EAAW;CAAW,CAAC;CAChG,MAAM,aAAa,kBAAkB,OAAO,KAAK,cAAc;CAC/D,MAAM,iBAAiB,uBAAuB;EAAE;EAAO;EAAW;CAAW,CAAC;CAC9E,MAAM,oBAAoB,0BAA0B,EAAE,WAAW,CAAC;CAElE,MAAM,cAAc,KAAK,YAAY,mBAAmB,cAAc,aAAa,SAAS,CAAC,CAAC;CAC9F,MAAM,QAAQ,KAAK,YAAY,QAAQ,eAAe;CACtD,MAAM,gBAAgB,eAAmC;EAAE;EAAO;CAAY,IAAI,CAAC,OAAO,WAAW,CAAC;CAEtG,MAAM,uBAAuB,OAA8B,CAAC,CAAC;CAC7D,MAAM,aAAa,cACX,sBAAsB,EAAE,sBAAsB,qBAAqB,QAAQ,CAAC,GAClF,CAAC,CACH;CAEA,MAAM,CAAC,aAAa,eAAe,uBAAuB,CAAC;CAC3D,MAAM,mBAAmB,cAAc,uBAAuB,WAAW,KAAK,gBAAgB,GAAG,CAAC,WAAW,KAAK,gBAAgB,CAAC;CACnI,MAAM,cAAc,OAAO;CAC3B,MAAM,gBAAgB,eAAe,CAAC,cAAc,WAAW,IAAI,cAAc;CACjF,MAAM,gBAAgB,gBAAgB,OAAO,sBAAsB;CACnE,MAAM,0BAA0B,wBAAwB,eAAe;EACrE,SAAS,OAAO,MAAM,IAAI,EAAY;EACtC,aAAa,KAAK;CACpB,GAAG,aAAa;CAEhB,MAAM,EAAE,OAAO,uBAAuB,kBAAkB,yBACtD,OAAO,kBACP,cAAc,eACd,gBACA,KAAK,sBAAuB,QAAwC,QACpE,aACF;CAmBA,OAAO;EAAE,QAjBM,eAA6B;GAC1C,GAAG,cAAc,MAAM;GACvB,OAAO;GACP,kBAAkB,wBAAwB,EAAE,OAAO,sBAAsB,IAAI;GAC7E,gBAAgB;IAAE,OAAO;IAAgB,OAAO;GAAQ;GACxD,cAAc;IAAE,OAAO;IAAc,OAAO;GAAiB;GAC7D,mBAAmB;IAAE,OAAO;IAAmB,OAAO;GAAe;GACrE,oBAAoB,gBAAgB,QAAQ,cAAc,WAAW,IACjE,cACA;IAAE,OAAO;IAAyB,OAAO;GAAmB;GAChE,GAAI,KAAK,cAAc,EAAE,aAAa;IAAE,OAAO;IAAkB,OAAO;GAAc,EAAE,IAAI,CAAC;GAC7F,GAAI,QAAQ,EAAE,YAAY;IAAE,OAAO;IAAY,OAAO,KAAK,cAAc,gBAAgB;GAAc,EAAE,IAAI,CAAC;EAChH,IAAI;GACF;GAAQ;GAAa;GAAuB;GAAgB;GAAc;GAAmB;GAAyB;GAAa;GACnI;GAAkB,KAAK;GAAa;GAAO;EAC7C,CAES;EAAQ;EAAe;EAAe;EAAsB;EAAW;CAAW;AAC7F"}

package/dist/canvas/SceneCanvas/useSceneCanvasPathEdit.js

@@ -0,0 +1,30 @@
+import { isSelectedNode } from "../../features/paths/pathEditState.js";
+import { usePathEditState } from "../../features/paths/usePathEdit.js";
+import { useMemo } from "react";
+
+//#region src/canvas/SceneCanvas/useSceneCanvasPathEdit.ts
+/**
+* The canvas's path-edit state, and the select tool options that defer shift-click to it while
+* a path is being anchor-edited.
+*/
+function useSceneCanvasPathEdit(args) {
+	const { getActiveMode, scene, selection, selectTool } = args;
+	const pathEditState = usePathEditState({
+		host: args.host,
+		opening: args.opening,
+		isAllowed: getActiveMode ? () => getActiveMode().allowedCapabilities.has("edits-anchors") : void 0,
+		isSelectedNode: (id) => isSelectedNode(scene, selection, id),
+		extensions: args.extensions
+	});
+	return {
+		pathEditState,
+		selectToolWithDefaults: useMemo(() => ({
+			extendClickLocked: () => pathEditState.getEditingId() !== "",
+			...selectTool
+		}), [selectTool, pathEditState])
+	};
+}
+
+//#endregion
+export { useSceneCanvasPathEdit };
+//# sourceMappingURL=useSceneCanvasPathEdit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSceneCanvasPathEdit.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useSceneCanvasPathEdit.ts"],"sourcesContent":["import type { ActiveMode } from '@weasel-js/modes';\nimport { useMemo } from 'react';\nimport type { Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { isSelectedNode } from 'features/paths/pathEditState';\nimport { usePathEditState, type UsePathEditStateOptions } from 'features/paths/usePathEdit';\nimport type { SceneCanvasProps } from './props';\n\n/**\n * The canvas's path-edit state, and the select tool options that defer shift-click to it while\n * a path is being anchor-edited.\n */\nexport function useSceneCanvasPathEdit<TData, TLayer extends string, TPose>(args: {\n  host: UsePathEditStateOptions['host'];\n  opening: UsePathEditStateOptions['opening'];\n  getActiveMode: (() => ActiveMode) | undefined;\n  scene: Scene<TData, TLayer, TPose>;\n  selection: SelectionApi;\n  extensions: UsePathEditStateOptions['extensions'];\n  selectTool: SceneCanvasProps<TData, TLayer, TPose>['selectTool'];\n}) {\n  const { getActiveMode, scene, selection, selectTool } = args;\n  // `isAllowed` is absent, not a predicate, when no mode registry is wired: see `PathEditSource.isAllowed`.\n  const pathEditState = usePathEditState({\n    host: args.host, opening: args.opening,\n    isAllowed: getActiveMode\n      ? () => getActiveMode().allowedCapabilities.has('edits-anchors')\n      : undefined,\n    isSelectedNode: (id) => isSelectedNode(scene, selection, id),\n    extensions: args.extensions,\n  });\n\n  const selectToolWithDefaults = useMemo(() => ({\n    // Shift-click belongs to the anchor selection while a path is being\n    // anchor-edited; see `UseSelectToolOptions.extendClickLocked`.\n    extendClickLocked: () => pathEditState.getEditingId() !== '',\n    ...selectTool,\n  }), [selectTool, pathEditState]);\n\n  return { pathEditState, selectToolWithDefaults };\n}\n"],"mappings":";;;;;;;;;AAYA,SAAgB,uBAA4D,MAQzE;CACD,MAAM,EAAE,eAAe,OAAO,WAAW,eAAe;CAExD,MAAM,gBAAgB,iBAAiB;EACrC,MAAM,KAAK;EAAM,SAAS,KAAK;EAC/B,WAAW,sBACD,cAAc,CAAC,CAAC,oBAAoB,IAAI,eAAe,IAC7D;EACJ,iBAAiB,OAAO,eAAe,OAAO,WAAW,EAAE;EAC3D,YAAY,KAAK;CACnB,CAAC;CASD,OAAO;EAAE;EAAe,wBAPO,eAAe;GAG5C,yBAAyB,cAAc,aAAa,MAAM;GAC1D,GAAG;EACL,IAAI,CAAC,YAAY,aAAa,CAEN;CAAuB;AACjD"}