@weasel-js/core 1.10.0 → 1.11.0

package/dist/canvas/SceneCanvas/useBuiltinRigTools.js

@@ -0,0 +1,65 @@
+import { createRigEditState } from "../../tools/builtin/bone/rigEditState.js";
+import { useBoneTool } from "../../tools/builtin/bone/useBoneTool.js";
+import { useWeightTool } from "../../tools/builtin/weight/useWeightTool.js";
+import { useMemo } from "react";
+import { useLatest } from "@weasel-js/react";
+
+//#region src/canvas/SceneCanvas/useBuiltinRigTools.ts
+/**
+* The bone and weight tools as `<SceneCanvas>` mounts them: on the canvas's
+* own scene, sharing one `RigEditState`, and acting on the rig the selection
+* names unless `toolOptions.rig` fixes one.
+*
+* Both hooks always run (React rules of hooks); `resolveToolRegistry` decides
+* which the canvas registers.
+*/
+/**
+* The rig a selection names: with one node selected, the nearest of it and its
+* ancestors whose `data.skeleton` exists, else that node itself, so a first
+* bone can be drawn onto it. With none or several selected, `null`.
+*/
+function rigOfSelection(scene, ids) {
+	if (ids.length !== 1) return null;
+	const own = ids[0];
+	for (let id = own; id !== null;) {
+		const node = scene.get(id);
+		if (!node) break;
+		if (node.data?.skeleton) return id;
+		id = node.parent;
+	}
+	return scene.get(own) ? own : null;
+}
+function useBuiltinRigTools(args) {
+	const { scene, options } = args;
+	const latest = useLatest({
+		scene,
+		selection: args.selection,
+		rig: options?.rig?.rig
+	});
+	const rig = useMemo(() => () => {
+		const { scene: s, selection, rig: fixed } = latest.current;
+		return fixed ? fixed() : rigOfSelection(s, selection());
+	}, [latest]);
+	const ownState = useMemo(() => createRigEditState(), []);
+	const state = options?.rig?.state ?? ownState;
+	const reach = options?.rig?.reach;
+	return {
+		bone: useBoneTool({
+			scene,
+			rig,
+			state,
+			reach
+		}),
+		weight: useWeightTool({
+			scene,
+			rig,
+			state,
+			reach,
+			radius: options?.weight?.radius
+		})
+	};
+}
+
+//#endregion
+export { rigOfSelection, useBuiltinRigTools };
+//# sourceMappingURL=useBuiltinRigTools.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useBuiltinRigTools.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useBuiltinRigTools.ts"],"sourcesContent":["/**\n * The bone and weight tools as `<SceneCanvas>` mounts them: on the canvas's\n * own scene, sharing one `RigEditState`, and acting on the rig the selection\n * names unless `toolOptions.rig` fixes one.\n *\n * Both hooks always run (React rules of hooks); `resolveToolRegistry` decides\n * which the canvas registers.\n */\nimport { useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { RigNodeData } from '../../animation/rig/rigNode';\nimport { useBoneTool } from 'tools/builtin/bone/useBoneTool';\nimport { createRigEditState } from 'tools/builtin/bone/rigEditState';\nimport { useWeightTool } from 'tools/builtin/weight/useWeightTool';\nimport type { Tool } from 'tools/overlayBinding';\nimport type { BuiltinToolOptions } from './useBuiltinShapeTools';\n\n/**\n * The rig a selection names: with one node selected, the nearest of it and its\n * ancestors whose `data.skeleton` exists, else that node itself, so a first\n * bone can be drawn onto it. With none or several selected, `null`.\n */\nexport function rigOfSelection(\n  scene: { get(id: NodeId): { parent: NodeId | null; data?: unknown } | undefined },\n  ids: readonly NodeId[],\n): NodeId | null {\n  if (ids.length !== 1) return null;\n  const own = ids[0];\n  for (let id: NodeId | null = own; id !== null;) {\n    const node = scene.get(id);\n    if (!node) break;\n    if ((node.data as RigNodeData | null | undefined)?.skeleton) return id;\n    id = node.parent;\n  }\n  return scene.get(own) ? own : null;\n}\n\nexport interface UseBuiltinRigToolsArgs {\n  scene: Scene<unknown, string, unknown>;\n  /** The canvas's selection, read when a tool acts. */\n  selection: () => readonly NodeId[];\n  options?: BuiltinToolOptions;\n}\n\nexport function useBuiltinRigTools(args: UseBuiltinRigToolsArgs): { bone: Tool; weight: Tool } {\n  const { scene, options } = args;\n  const latest = useLatest({ scene, selection: args.selection, rig: options?.rig?.rig });\n  const rig = useMemo(() => (): NodeId | null => {\n    const { scene: s, selection, rig: fixed } = latest.current;\n    return fixed ? fixed() : rigOfSelection(s, selection());\n  }, [latest]);\n  const ownState = useMemo(() => createRigEditState(), []);\n  const state = options?.rig?.state ?? ownState;\n  const reach = options?.rig?.reach;\n  const bone = useBoneTool({ scene, rig, state, reach });\n  const weight = useWeightTool({ scene, rig, state, reach, radius: options?.weight?.radius });\n  return { bone, weight };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,eACd,OACA,KACe;CACf,IAAI,IAAI,WAAW,GAAG,OAAO;CAC7B,MAAM,MAAM,IAAI;CAChB,KAAK,IAAI,KAAoB,KAAK,OAAO,OAAO;EAC9C,MAAM,OAAO,MAAM,IAAI,EAAE;EACzB,IAAI,CAAC,MAAM;EACX,IAAK,KAAK,MAAyC,UAAU,OAAO;EACpE,KAAK,KAAK;CACZ;CACA,OAAO,MAAM,IAAI,GAAG,IAAI,MAAM;AAChC;AASA,SAAgB,mBAAmB,MAA4D;CAC7F,MAAM,EAAE,OAAO,YAAY;CAC3B,MAAM,SAAS,UAAU;EAAE;EAAO,WAAW,KAAK;EAAW,KAAK,SAAS,KAAK;CAAI,CAAC;CACrF,MAAM,MAAM,oBAAmC;EAC7C,MAAM,EAAE,OAAO,GAAG,WAAW,KAAK,UAAU,OAAO;EACnD,OAAO,QAAQ,MAAM,IAAI,eAAe,GAAG,UAAU,CAAC;CACxD,GAAG,CAAC,MAAM,CAAC;CACX,MAAM,WAAW,cAAc,mBAAmB,GAAG,CAAC,CAAC;CACvD,MAAM,QAAQ,SAAS,KAAK,SAAS;CACrC,MAAM,QAAQ,SAAS,KAAK;CAG5B,OAAO;EAAE,MAFI,YAAY;GAAE;GAAO;GAAK;GAAO;EAAM,CAE3C;EAAM,QADA,cAAc;GAAE;GAAO;GAAK;GAAO;GAAO,QAAQ,SAAS,QAAQ;EAAO,CAC1E;CAAO;AACxB"}

package/dist/canvas/SceneCanvas/useBuiltinShapeTools.js

@@ -1,29 +1,53 @@
-import "../../core/shapeKinds.js";
-import { useTextTool as e } from "../../tools/builtin/text/useTextTool.js";
-import { usePenTool as t } from "../../tools/builtin/pen/usePenTool.js";
-import { useRectTool as n } from "../../tools/builtin/rect/useRectTool.js";
-import { useEllipseTool as r } from "../../tools/builtin/ellipse/useEllipseTool.js";
-import { useLineTool as i } from "../../tools/builtin/line/useLineTool.js";
-import { useLassoTool as a } from "../../tools/builtin/lasso/useLassoTool.js";
-import { usePolygonTool as o } from "../../tools/builtin/polygon/usePolygonTool.js";
-import { useStarTool as s } from "../../tools/builtin/star/useStarTool.js";
-import { usePencilTool as c } from "../../tools/builtin/pencil/usePencilTool.js";
+import { KIT_SHAPE_KINDS } from "../../core/shapeKinds.js";
+import { useTextTool } from "../../tools/builtin/text/useTextTool.js";
+import { useStickyTool } from "../../tools/builtin/sticky/useStickyTool.js";
+import { usePenTool } from "../../tools/builtin/pen/usePenTool.js";
+import { useRectTool } from "../../tools/builtin/rect/useRectTool.js";
+import { useEllipseTool } from "../../tools/builtin/ellipse/useEllipseTool.js";
+import { useLineTool } from "../../tools/builtin/line/useLineTool.js";
+import { useLassoTool } from "../../tools/builtin/lasso/useLassoTool.js";
+import { usePolygonTool } from "../../tools/builtin/polygon/usePolygonTool.js";
+import { useStarTool } from "../../tools/builtin/star/useStarTool.js";
+import { usePencilTool } from "../../tools/builtin/pencil/usePencilTool.js";
+
 //#region src/canvas/SceneCanvas/useBuiltinShapeTools.tsx
-function l(l = {}) {
-	let { options: u } = l, d = u?.snapPoint, f = u?.insert ?? {}, p = n(f), m = r(f), h = i(f), g = o(f), _ = s(f), v = c(f);
+/**
+* Shape-tool synthesis for `<SceneCanvas>` — calls the kit's per-shape tool
+* hooks; the `insert` dep mints each tool's node. Lets consumers opt into
+* a complete drawing toolset via `<SceneCanvas defaultTools={['rect', 'ellipse']}>`
+* without writing per-tool factory code.
+*
+* All hooks are always called (React rules of hooks) — `resolveToolRegistry`
+* decides which the canvas registers.
+*/
+/** Synthesize the full shape-tool registry. Hooks always run;
+*  `useBuiltinTools` registers the ones asked for. */
+function useBuiltinShapeTools(args = {}) {
+	const { options } = args;
+	const insert = options?.insert ?? {};
+	const rect = useRectTool(insert);
+	const ellipse = useEllipseTool(insert);
+	const line = useLineTool(insert);
+	const polygon = usePolygonTool(insert);
+	const star = useStarTool(insert);
+	const pencil = usePencilTool(insert);
 	return {
-		rect: p,
-		ellipse: m,
-		line: h,
-		polygon: g,
-		star: _,
-		pen: t({ snapPoint: d }),
-		pencil: v,
-		lasso: a(u?.lasso ?? {}),
-		text: e(f)
+		rect,
+		ellipse,
+		line,
+		polygon,
+		star,
+		pen: usePenTool(),
+		pencil,
+		lasso: useLassoTool(options?.lasso ?? {}),
+		text: useTextTool(insert),
+		sticky: useStickyTool({
+			...insert,
+			...options?.sticky
+		})
 	};
 }
-//#endregion
-export { l as useBuiltinShapeTools };
 
+//#endregion
+export { useBuiltinShapeTools };
 //# sourceMappingURL=useBuiltinShapeTools.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useBuiltinShapeTools.js","names":["useBuiltinShapeTools","args","snapPoint","options","insert","rect","useRectTool","ellipse","useEllipseTool","line","useLineTool","polygon","usePolygonTool","star","useStarTool","pencil","usePencilTool","usePenTool","useLassoTool","useTextTool"],"sources":["../../../src/canvas/SceneCanvas/useBuiltinShapeTools.tsx"],"sourcesContent":["/**\n * Shape-tool synthesis for `<SceneCanvas>` — calls the kit's per-shape tool\n * hooks; the `insert` dep mints each tool's node. Lets consumers opt into\n * a complete drawing toolset via `<SceneCanvas defaultTools={['rect', 'ellipse']}>`\n * without writing per-tool factory code.\n *\n * All hooks are always called (React rules of hooks) — `resolveToolRegistry`\n * decides which the canvas registers.\n */\nimport { useEllipseTool } from 'tools/builtin/ellipse/useEllipseTool';\nimport { useLassoTool } from 'tools/builtin/lasso/useLassoTool';\nimport { useLineTool } from 'tools/builtin/line/useLineTool';\nimport { usePencilTool } from 'tools/builtin/pencil/usePencilTool';\nimport { usePenTool } from 'tools/builtin/pen/usePenTool';\nimport { usePolygonTool } from 'tools/builtin/polygon/usePolygonTool';\nimport { useRectTool } from 'tools/builtin/rect/useRectTool';\nimport { useStarTool } from 'tools/builtin/star/useStarTool';\nimport { useTextTool } from 'tools/builtin/text/useTextTool';\nimport type { Tool } from 'tools/overlayBinding';\nimport type { InsertToolOptions } from 'tools/builtin/shared/insertToolOptions';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport type { BuiltinShapeToolId } from 'core/shapeKinds';\n\n/** Per-tool option overrides for the built-in shape/lasso tools.\n *  Each entry is a narrow subset of the underlying hook's options surface\n *  — just the knobs that need consumer control under the bundle pattern. */\nexport interface BuiltinToolOptions {\n  lasso?: { mode?: LassoHitMode };\n  /** Insert-action options for every drag-to-insert tool (rect / ellipse /\n   *  line / polygon / star / pencil / text): `behaviors` become each insert\n   *  binding's `opts.behaviors`, the way `selectTool.move.behaviors` do for\n   *  move. */\n  insert?: InsertToolOptions;\n  /** Snap world-space points to the active grid (or any other snap target).\n   *\n   *  Registered as the `snap` dep, which `insertAction` applies to the\n   *  drag start and current point — so the live preview and the committed\n   *  geometry agree — and which the pen tool reads for its own anchor\n   *  placement. Covers every drag-to-insert tool (rect / ellipse / line /\n   *  polygon / star / text); freehand pencil samples are deliberately left\n   *  unsnapped. */\n  snapPoint?: (p: { x: number; y: number }) => { x: number; y: number };\n}\n\n// `BuiltinShapeToolId` / `KIT_SHAPE_KINDS` derive from the `core/shapeKinds`\n// table, a dependency-free module, so barrel-reachable code can reach them\n// without entering this file's `@weasel-js/core` self-import cycle.\n// Re-exported here so existing importers of this module keep working.\nexport { KIT_SHAPE_KINDS } from 'core/shapeKinds';\nexport type { BuiltinShapeToolId } from 'core/shapeKinds';\n\nexport interface UseBuiltinShapeToolsArgs {\n  /** Per-tool option overrides (lasso mode, etc.). */\n  options?: BuiltinToolOptions;\n}\n\nexport type BuiltinShapeTools = Record<BuiltinShapeToolId, Tool>;\n\n/** Synthesize the full shape-tool registry. Hooks always run;\n *  `useBuiltinTools` registers the ones asked for. */\nexport function useBuiltinShapeTools(args: UseBuiltinShapeToolsArgs = {}): BuiltinShapeTools {\n  const { options } = args;\n\n  const snapPoint = options?.snapPoint;\n  // Every tool here is a declarative shell: the `insert` dep\n  // (`useInsertDepSource`) mints the node, so a consumer wanting its own node\n  // shape overrides the dep, not the tool.\n  const insert = options?.insert ?? {};\n  const rect = useRectTool(insert);\n  const ellipse = useEllipseTool(insert);\n  const line = useLineTool(insert);\n  const polygon = usePolygonTool(insert);\n  const star = useStarTool(insert);\n  const pencil = usePencilTool(insert);\n  const pen = usePenTool({ snapPoint });\n  const lasso = useLassoTool(options?.lasso ?? {});\n  const text = useTextTool(insert);\n  return { rect, ellipse, line, polygon, star, pen, pencil, lasso, text };\n}\n"],"mappings":";;;;;;;;;;;AA4DA,SAAgBA,EAAqB,IAAiC,CAAC,GAAsB;CAC3F,IAAM,EAAE,eAAYC,GAEdC,IAAYC,GAAS,WAIrBC,IAASD,GAAS,UAAU,CAAC,GAC7BE,IAAOC,EAAYF,CAAM,GACzBG,IAAUC,EAAeJ,CAAM,GAC/BK,IAAOC,EAAYN,CAAM,GACzBO,IAAUC,EAAeR,CAAM,GAC/BS,IAAOC,EAAYV,CAAM,GACzBW,IAASC,EAAcZ,CAAM;CAInC,OAAO;EAAE;EAAM;EAAS;EAAM;EAAS;EAAM,KAHjCa,EAAW,EAAE,aAAU,CAGU;EAAK;EAAQ,OAF5CC,EAAaf,GAAS,SAAS,CAAC,CAEY;EAAO,MADpDgB,EAAYf,CACwC;CAAK;AACxE"}
+{"version":3,"file":"useBuiltinShapeTools.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useBuiltinShapeTools.tsx"],"sourcesContent":["/**\n * Shape-tool synthesis for `<SceneCanvas>` — calls the kit's per-shape tool\n * hooks; the `insert` dep mints each tool's node. Lets consumers opt into\n * a complete drawing toolset via `<SceneCanvas defaultTools={['rect', 'ellipse']}>`\n * without writing per-tool factory code.\n *\n * All hooks are always called (React rules of hooks) — `resolveToolRegistry`\n * decides which the canvas registers.\n */\nimport { useEllipseTool } from 'tools/builtin/ellipse/useEllipseTool';\nimport { useLassoTool } from 'tools/builtin/lasso/useLassoTool';\nimport { useLineTool } from 'tools/builtin/line/useLineTool';\nimport { usePencilTool } from 'tools/builtin/pencil/usePencilTool';\nimport { usePenTool } from 'tools/builtin/pen/usePenTool';\nimport { usePolygonTool } from 'tools/builtin/polygon/usePolygonTool';\nimport { useRectTool } from 'tools/builtin/rect/useRectTool';\nimport { useStarTool } from 'tools/builtin/star/useStarTool';\nimport { useTextTool } from 'tools/builtin/text/useTextTool';\nimport { useStickyTool } from 'tools/builtin/sticky/useStickyTool';\nimport type { StickyStyle } from 'tools/builtin/sticky/stickyNode';\nimport type { Tool } from 'tools/overlayBinding';\nimport type { InsertToolOptions } from 'tools/builtin/shared/insertToolOptions';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport type { BuiltinShapeToolId } from 'core/shapeKinds';\nimport type { NodeId } from 'core/scene/types';\nimport type { RigEditState } from 'tools/builtin/bone/rigEditState';\n\n/** Per-tool option overrides for the built-in tools.\n *  Each entry is a narrow subset of the underlying hook's options surface\n *  — just the knobs that need consumer control under the bundle pattern. */\nexport interface BuiltinToolOptions {\n  lasso?: { mode?: LassoHitMode };\n  /** Insert-action options for every drag-to-insert tool (rect / ellipse /\n   *  line / polygon / star / pencil / text / sticky): `behaviors` become each insert\n   *  binding's `opts.behaviors`, the way `selectTool.move.behaviors` do for\n   *  move. */\n  insert?: InsertToolOptions;\n  /** The look of the notes the sticky tool makes: paper, ink, padding,\n   *  typography, and the size a click places. */\n  sticky?: StickyStyle;\n  /** The knife: screen px around the first point within which a click closes the cut. */\n  slice?: { closeHitRadius?: number };\n  /** The bone and weight tools. `rig` names the node they edit; by default the one\n   *  selected node, or the nearest ancestor of it holding `data.skeleton`. `state` is the\n   *  joint they share, which a canvas otherwise makes for itself; pass the one handed to\n   *  `useRigNode` as `painting` so a stroke shows as it is painted. `reach` is the screen\n   *  px around a joint within which a press takes it. */\n  rig?: { rig?: () => NodeId | null; state?: RigEditState; reach?: number };\n  /** The weight tool's brush radius, in screen px. */\n  weight?: { radius?: number };\n}\n\n// `BuiltinShapeToolId` / `KIT_SHAPE_KINDS` derive from the `core/shapeKinds`\n// table, a dependency-free module, so barrel-reachable code can reach them\n// without entering this file's `@weasel-js/core` self-import cycle.\n// Re-exported here so existing importers of this module keep working.\nexport { KIT_SHAPE_KINDS } from 'core/shapeKinds';\nexport type { BuiltinShapeToolId } from 'core/shapeKinds';\n\nexport interface UseBuiltinShapeToolsArgs {\n  /** Per-tool option overrides (lasso mode, etc.). */\n  options?: BuiltinToolOptions;\n}\n\nexport type BuiltinShapeTools = Record<BuiltinShapeToolId, Tool>;\n\n/** Synthesize the full shape-tool registry. Hooks always run;\n *  `useBuiltinTools` registers the ones asked for. */\nexport function useBuiltinShapeTools(args: UseBuiltinShapeToolsArgs = {}): BuiltinShapeTools {\n  const { options } = args;\n\n  // Every tool here is a declarative shell: the `insert` dep\n  // (`useInsertDepSource`) mints the node, so a consumer wanting its own node\n  // shape overrides the dep, not the tool.\n  const insert = options?.insert ?? {};\n  const rect = useRectTool(insert);\n  const ellipse = useEllipseTool(insert);\n  const line = useLineTool(insert);\n  const polygon = usePolygonTool(insert);\n  const star = useStarTool(insert);\n  const pencil = usePencilTool(insert);\n  const pen = usePenTool();\n  const lasso = useLassoTool(options?.lasso ?? {});\n  const text = useTextTool(insert);\n  const sticky = useStickyTool({ ...insert, ...options?.sticky });\n  return { rect, ellipse, line, polygon, star, pen, pencil, lasso, text, sticky };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAoEA,SAAgB,qBAAqB,OAAiC,CAAC,GAAsB;CAC3F,MAAM,EAAE,YAAY;CAKpB,MAAM,SAAS,SAAS,UAAU,CAAC;CACnC,MAAM,OAAO,YAAY,MAAM;CAC/B,MAAM,UAAU,eAAe,MAAM;CACrC,MAAM,OAAO,YAAY,MAAM;CAC/B,MAAM,UAAU,eAAe,MAAM;CACrC,MAAM,OAAO,YAAY,MAAM;CAC/B,MAAM,SAAS,cAAc,MAAM;CAKnC,OAAO;EAAE;EAAM;EAAS;EAAM;EAAS;EAAM,KAJjC,WAIiC;EAAK;EAAQ,OAH5C,aAAa,SAAS,SAAS,CAAC,CAGY;EAAO,MAFpD,YAAY,MAEwC;EAAM,QADxD,cAAc;GAAE,GAAG;GAAQ,GAAG,SAAS;EAAO,CACU;CAAO;AAChF"}

package/dist/canvas/SceneCanvas/useBuiltinTools.js

@@ -1,21 +1,36 @@
-import { useHandTool as e } from "../../tools/builtin/hand/useHandTool.js";
-import { resolveToolRegistry as t } from "./toolRegistry.js";
-import { useBuiltinShapeTools as n } from "./useBuiltinShapeTools.js";
+import { useHandTool } from "../../tools/builtin/hand/useHandTool.js";
+import { useSliceTool } from "../../tools/builtin/slice/useSliceTool.js";
+import { resolveToolRegistry } from "./toolRegistry.js";
+import { useBuiltinRigTools } from "./useBuiltinRigTools.js";
+import { useBuiltinShapeTools } from "./useBuiltinShapeTools.js";
+
 //#region src/canvas/SceneCanvas/useBuiltinTools.ts
-function r(r) {
-	let { select: i, enabled: a, defaultTools: o, patch: s, toolOptions: c, inertia: l } = r, u = e({ inertia: l }), d = n({ options: c });
-	return t({
+/** The registry of tools `<SceneCanvas>` mounts for itself. Every built-in's
+*  hook runs on every render; `resolveToolRegistry` decides which are in. */
+function useBuiltinTools(args) {
+	const { select, scene, selection, enabled, defaultTools, patch, toolOptions, inertia } = args;
+	const hand = useHandTool({ inertia });
+	const shapes = useBuiltinShapeTools({ options: toolOptions });
+	const slice = useSliceTool(toolOptions?.slice);
+	const rig = useBuiltinRigTools({
+		scene,
+		selection,
+		options: toolOptions
+	});
+	return resolveToolRegistry({
 		builtins: {
-			select: i,
-			hand: u,
-			...d
+			select,
+			hand,
+			...shapes,
+			slice,
+			...rig
 		},
-		defaultTools: o,
-		enabled: a,
-		patch: s
+		defaultTools,
+		enabled,
+		patch
 	});
 }
-//#endregion
-export { r as useBuiltinTools };
 
+//#endregion
+export { useBuiltinTools };
 //# sourceMappingURL=useBuiltinTools.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useBuiltinTools.js","names":["useBuiltinTools","args","hand","useHandTool","shapes","useBuiltinShapeTools","toolOptions","resolveToolRegistry"],"sources":["../../../src/canvas/SceneCanvas/useBuiltinTools.ts"],"sourcesContent":["import type { InertiaConfig } from 'core/viewport/useDecayLoop';\nimport { useHandTool } from 'tools/builtin/hand';\nimport type { Tool } from 'tools/overlayBinding';\nimport type { BaseFeature } from './features';\nimport type { BuiltinToolId } from './props';\nimport { resolveToolRegistry, type ToolsPatch } from './toolRegistry';\nimport { useBuiltinShapeTools, type BuiltinToolOptions } from './useBuiltinShapeTools';\n\nexport interface UseBuiltinToolsArgs {\n  /** The canvas's select tool, which is built from its scene and pickers. */\n  select: Tool;\n  enabled: ReadonlySet<BaseFeature>;\n  defaultTools?: readonly BuiltinToolId[];\n  patch: ToolsPatch | null;\n  toolOptions?: BuiltinToolOptions;\n  /** `viewport.inertia`, which is the hand tool's. */\n  inertia?: boolean | InertiaConfig;\n}\n\n/** The registry of tools `<SceneCanvas>` mounts for itself. Every built-in's\n *  hook runs on every render; `resolveToolRegistry` decides which are in. */\nexport function useBuiltinTools(args: UseBuiltinToolsArgs): Record<string, Tool> {\n  const { select, enabled, defaultTools, patch, toolOptions, inertia } = args;\n  const hand = useHandTool({ inertia });\n  const shapes = useBuiltinShapeTools({ options: toolOptions });\n  return resolveToolRegistry({\n    builtins: { select, hand, ...shapes },\n    defaultTools,\n    enabled,\n    patch,\n  });\n}\n"],"mappings":";;;;AAqBA,SAAgBA,EAAgB,GAAiD;CAC/E,IAAM,EAAE,WAAQ,YAAS,iBAAc,UAAO,gBAAa,eAAYC,GACjEC,IAAOC,EAAY,EAAE,WAAQ,CAAC,GAC9BC,IAASC,EAAqB,EAAE,SAASC,EAAY,CAAC;CAC5D,OAAOC,EAAoB;EACzB,UAAU;GAAE;GAAQ;GAAM,GAAGH;EAAO;EACpC;EACA;EACA;CACF,CAAC;AACH"}
+{"version":3,"file":"useBuiltinTools.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useBuiltinTools.ts"],"sourcesContent":["import type { InertiaConfig } from 'core/viewport/useDecayLoop';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { useHandTool } from 'tools/builtin/hand';\nimport { useSliceTool } from 'tools/builtin/slice';\nimport type { Tool } from 'tools/overlayBinding';\nimport type { EnabledPresets } from './features';\nimport type { BuiltinToolId } from './props';\nimport { resolveToolRegistry, type ToolsPatch } from './toolRegistry';\nimport { useBuiltinRigTools } from './useBuiltinRigTools';\nimport { useBuiltinShapeTools, type BuiltinToolOptions } from './useBuiltinShapeTools';\n\nexport interface UseBuiltinToolsArgs {\n  /** The canvas's select tool, which is built from its scene and pickers. */\n  select: Tool;\n  /** The canvas's scene, which the rig tools edit. */\n  scene: Scene<unknown, string, unknown>;\n  /** The canvas's selection, which names the rig the rig tools edit. */\n  selection: () => readonly NodeId[];\n  enabled: EnabledPresets;\n  defaultTools?: readonly BuiltinToolId[];\n  patch: ToolsPatch | null;\n  toolOptions?: BuiltinToolOptions;\n  /** `viewport.inertia`, which is the hand tool's. */\n  inertia?: boolean | InertiaConfig;\n}\n\n/** The registry of tools `<SceneCanvas>` mounts for itself. Every built-in's\n *  hook runs on every render; `resolveToolRegistry` decides which are in. */\nexport function useBuiltinTools(args: UseBuiltinToolsArgs): Record<string, Tool> {\n  const { select, scene, selection, enabled, defaultTools, patch, toolOptions, inertia } = args;\n  const hand = useHandTool({ inertia });\n  const shapes = useBuiltinShapeTools({ options: toolOptions });\n  const slice = useSliceTool(toolOptions?.slice);\n  const rig = useBuiltinRigTools({ scene, selection, options: toolOptions });\n  return resolveToolRegistry({\n    builtins: { select, hand, ...shapes, slice, ...rig },\n    defaultTools,\n    enabled,\n    patch,\n  });\n}\n"],"mappings":";;;;;;;;;AA4BA,SAAgB,gBAAgB,MAAiD;CAC/E,MAAM,EAAE,QAAQ,OAAO,WAAW,SAAS,cAAc,OAAO,aAAa,YAAY;CACzF,MAAM,OAAO,YAAY,EAAE,QAAQ,CAAC;CACpC,MAAM,SAAS,qBAAqB,EAAE,SAAS,YAAY,CAAC;CAC5D,MAAM,QAAQ,aAAa,aAAa,KAAK;CAC7C,MAAM,MAAM,mBAAmB;EAAE;EAAO;EAAW,SAAS;CAAY,CAAC;CACzE,OAAO,oBAAoB;EACzB,UAAU;GAAE;GAAQ;GAAM,GAAG;GAAQ;GAAO,GAAG;EAAI;EACnD;EACA;EACA;CACF,CAAC;AACH"}

package/dist/canvas/SceneCanvas/useCanvasCamera.js

@@ -1,38 +1,61 @@
-import { useViewAnimationOn as e } from "../../core/viewport/useViewAnimation.js";
-import { useCanvasView as t } from "../useCanvasView.js";
-import { useInsertionEffect as n, useMemo as r, useRef as i } from "react";
-import { useLatest as a } from "@weasel-js/react";
-import { useAnimator as o } from "@weasel-js/animator";
+import { sameView } from "../../core/viewport/view.js";
+import { useViewAnimationOn } from "../../core/viewport/useViewAnimation.js";
+import { useCanvasView } from "../useCanvasView.js";
+import { useInsertionEffect, useMemo, useRef } from "react";
+import { useAnimator } from "@weasel-js/animator/react";
+
 //#region src/canvas/SceneCanvas/useCanvasCamera.ts
-function s(s) {
-	let { view: c, defaultView: l, onViewChange: u, viewBounds: d, width: f, height: p, requestRedraw: m } = s, h = a({
-		width: f,
-		height: p
-	}), g = i(null), _ = t({
-		view: c,
-		defaultView: l,
-		onViewChange: (e) => {
-			g.current?.stopIfExternal(), u?.(e);
+/**
+* The canvas's camera: the view `<Canvas>` looks through, the runner behind
+* `animateView`, and the target and animator it runs on.
+*/
+function useCanvasCamera(opts) {
+	const { view, defaultView, onViewChange, viewBounds, dims, requestRedraw } = opts;
+	const animationRef = useRef(null);
+	/** The runner has written a frame since the controlled view last moved. */
+	const runnerWroteRef = useRef(false);
+	const viewState = useCanvasView({
+		view,
+		defaultView,
+		onViewChange: (next) => {
+			animationRef.current?.stopIfExternal();
+			onViewChange?.(next);
 		},
-		viewBounds: d,
-		dims: () => h.current,
-		requestRedraw: m
-	}), v = o(), { viewRef: y, setViewFromInput: b } = _, x = r(() => ({
-		get: () => y.current,
-		set: b
-	}), [y, b]), S = e(x, v);
-	return n(() => {
-		g.current = S;
-	}), {
-		viewState: _,
-		viewAnimation: S,
-		camera: r(() => ({
-			target: S.viewTarget,
-			animator: v
-		}), [S, v])
+		viewBounds,
+		dims,
+		requestRedraw
+	});
+	const animator = useAnimator();
+	const { viewRef, setViewFromInput, controlled } = viewState;
+	const channel = useMemo(() => ({
+		get: () => viewRef.current,
+		set: (next) => {
+			runnerWroteRef.current = true;
+			setViewFromInput(next);
+		}
+	}), [viewRef, setViewFromInput]);
+	const viewAnimation = useViewAnimationOn(channel, animator);
+	useInsertionEffect(() => {
+		animationRef.current = viewAnimation;
+	});
+	const lastControlledRef = useRef(controlled);
+	useInsertionEffect(() => {
+		const was = lastControlledRef.current;
+		lastControlledRef.current = controlled;
+		if (!controlled || !was || sameView(was, controlled)) return;
+		if (runnerWroteRef.current) runnerWroteRef.current = false;
+		else viewAnimation.stopIfExternal();
+	});
+	return {
+		viewState,
+		viewAnimation,
+		camera: useMemo(() => ({
+			target: viewAnimation.viewTarget,
+			animator
+		}), [viewAnimation, animator])
 	};
 }
-//#endregion
-export { s as useCanvasCamera };
 
+//#endregion
+export { useCanvasCamera };
 //# sourceMappingURL=useCanvasCamera.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useCanvasCamera.js","names":["useCanvasCamera","opts","size","useLatest","animationRef","useRef","viewState","useCanvasView","onViewChange","next","animator","useAnimator","channel","useMemo","viewRef","setViewFromInput","viewAnimation","useViewAnimationOn","useInsertionEffect"],"sources":["../../../src/canvas/SceneCanvas/useCanvasCamera.ts"],"sourcesContent":["import { useInsertionEffect, useMemo, useRef } from 'react';\nimport { useAnimator } from '@weasel-js/animator';\nimport { useLatest } from '@weasel-js/react';\nimport { useViewAnimationOn, type ViewAnimationApi } from 'core/viewport/useViewAnimation';\nimport type { SceneCanvasApi } from '../canvasExtension';\nimport { useCanvasView, type CameraProps, type CanvasViewState } from '../useCanvasView';\n\n/**\n * The canvas's camera: the view `<Canvas>` looks through, the runner behind\n * `animateView`, and the target and animator it runs on.\n */\nexport function useCanvasCamera(opts: CameraProps & {\n  /** The size the camera looks through, which `viewBounds` clamps against. */\n  width: number;\n  height: number;\n  requestRedraw: () => void;\n}): {\n  viewState: CanvasViewState;\n  viewAnimation: ViewAnimationApi;\n  camera: SceneCanvasApi['camera'];\n} {\n  const { view, defaultView, onViewChange, viewBounds, width, height, requestRedraw } = opts;\n  const size = useLatest({ width, height });\n  const animationRef = useRef<ViewAnimationApi | null>(null);\n  const viewState = useCanvasView({\n    view,\n    defaultView,\n    // Every write to the view is reported here, so it is the runner's one\n    // interrupt feed.\n    onViewChange: (next) => {\n      animationRef.current?.stopIfExternal();\n      onViewChange?.(next);\n    },\n    viewBounds,\n    dims: () => size.current,\n    requestRedraw,\n  });\n\n  // The camera runs on its own animator, never the `animator` prop's: that prop\n  // is the consumer's scene animator, and their `cancelAll()` or `pause()` must\n  // not strand a zoom half-finished or freeze the camera.\n  const animator = useAnimator();\n  const { viewRef, setViewFromInput } = viewState;\n  const channel = useMemo(\n    () => ({ get: () => viewRef.current, set: setViewFromInput }),\n    [viewRef, setViewFromInput],\n  );\n  const viewAnimation = useViewAnimationOn(channel, animator);\n  useInsertionEffect(() => { animationRef.current = viewAnimation; });\n  const camera = useMemo(() => ({ target: viewAnimation.viewTarget, animator }), [viewAnimation, animator]);\n  return { viewState, viewAnimation, camera };\n}\n"],"mappings":";;;;;;AAWA,SAAgBA,EAAgB,GAS9B;CACA,IAAM,EAAE,SAAM,gBAAa,iBAAc,eAAY,UAAO,WAAQ,qBAAkBC,GAChFC,IAAOC,EAAU;EAAE;EAAO;CAAO,CAAC,GAClCC,IAAeC,EAAgC,IAAI,GACnDC,IAAYC,EAAc;EAC9B;EACA;EAGA,eAAe,MAAS;GAEtB,AADAH,EAAa,SAAS,eAAe,GACrCI,IAAeC,CAAI;EACrB;EACA;EACA,YAAYP,EAAK;EACjB;CACF,CAAC,GAKKQ,IAAWC,EAAY,GACvB,EAAE,YAAS,wBAAqBL,GAChCM,IAAUC,SACP;EAAE,WAAWC,EAAQ;EAAS,KAAKC;CAAiB,IAC3D,CAACD,GAASC,CAAgB,CAC5B,GACMC,IAAgBC,EAAmBL,GAASF,CAAQ;CAG1D,OAFAQ,QAAyB;EAAE,EAAa,UAAUF;CAAe,CAAC,GAE3D;EAAE;EAAW;EAAe,QADpBH,SAAe;GAAE,QAAQG,EAAc;GAAY;EAAS,IAAI,CAACA,GAAeN,CAAQ,CACpE;CAAO;AAC5C"}
+{"version":3,"file":"useCanvasCamera.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useCanvasCamera.ts"],"sourcesContent":["import { useInsertionEffect, useMemo, useRef } from 'react';\nimport { useAnimator } from '@weasel-js/animator/react';\nimport { useViewAnimationOn, type ViewAnimationApi } from 'core/viewport/useViewAnimation';\nimport { sameView, type View } from 'core/viewport/view';\nimport type { Dims } from 'core/layers/render';\nimport type { SceneCanvasApi } from '../canvasExtension';\nimport { useCanvasView, type CameraProps, type CanvasViewState } from '../useCanvasView';\n\n/**\n * The canvas's camera: the view `<Canvas>` looks through, the runner behind\n * `animateView`, and the target and animator it runs on.\n */\nexport function useCanvasCamera(opts: CameraProps & {\n  /** The size the camera looks through, which `viewBounds` clamps against.\n   *  Read live: a filling canvas learns it only once measured. */\n  dims: () => Dims;\n  requestRedraw: () => void;\n}): {\n  viewState: CanvasViewState;\n  viewAnimation: ViewAnimationApi;\n  camera: SceneCanvasApi['camera'];\n} {\n  const { view, defaultView, onViewChange, viewBounds, dims, requestRedraw } = opts;\n  const animationRef = useRef<ViewAnimationApi | null>(null);\n  /** The runner has written a frame since the controlled view last moved. */\n  const runnerWroteRef = useRef(false);\n  const viewState = useCanvasView({\n    view,\n    defaultView,\n    // Every write to the view is reported here, so it is the runner's one\n    // interrupt feed.\n    onViewChange: (next) => {\n      animationRef.current?.stopIfExternal();\n      onViewChange?.(next);\n    },\n    viewBounds,\n    dims,\n    requestRedraw,\n  });\n\n  // The camera runs on its own animator, never the `animator` prop's: that prop\n  // is the consumer's scene animator, and their `cancelAll()` or `pause()` must\n  // not strand a zoom half-finished or freeze the camera.\n  const animator = useAnimator();\n  const { viewRef, setViewFromInput, controlled } = viewState;\n  const channel = useMemo(\n    () => ({\n      get: () => viewRef.current,\n      set: (next: View) => {\n        runnerWroteRef.current = true;\n        setViewFromInput(next);\n      },\n    }),\n    [viewRef, setViewFromInput],\n  );\n  const viewAnimation = useViewAnimationOn(channel, animator);\n  useInsertionEffect(() => { animationRef.current = viewAnimation; });\n\n  // A controlled consumer writing `view` in their own state never passes\n  // through `onViewChange`. Their handling of a frame cannot be told from such\n  // a write by value, since they may clamp or round what they are handed, so it\n  // is told by order: a prop that moves with no frame written since it last\n  // moved is theirs. One that lands in the same render as a frame's is missed.\n  const lastControlledRef = useRef(controlled);\n  useInsertionEffect(() => {\n    const was = lastControlledRef.current;\n    lastControlledRef.current = controlled;\n    if (!controlled || !was || sameView(was, controlled)) return;\n    if (runnerWroteRef.current) runnerWroteRef.current = false;\n    else viewAnimation.stopIfExternal();\n  });\n  const camera = useMemo(() => ({ target: viewAnimation.viewTarget, animator }), [viewAnimation, animator]);\n  return { viewState, viewAnimation, camera };\n}\n"],"mappings":";;;;;;;;;;;AAYA,SAAgB,gBAAgB,MAS9B;CACA,MAAM,EAAE,MAAM,aAAa,cAAc,YAAY,MAAM,kBAAkB;CAC7E,MAAM,eAAe,OAAgC,IAAI;;CAEzD,MAAM,iBAAiB,OAAO,KAAK;CACnC,MAAM,YAAY,cAAc;EAC9B;EACA;EAGA,eAAe,SAAS;GACtB,aAAa,SAAS,eAAe;GACrC,eAAe,IAAI;EACrB;EACA;EACA;EACA;CACF,CAAC;CAKD,MAAM,WAAW,YAAY;CAC7B,MAAM,EAAE,SAAS,kBAAkB,eAAe;CAClD,MAAM,UAAU,eACP;EACL,WAAW,QAAQ;EACnB,MAAM,SAAe;GACnB,eAAe,UAAU;GACzB,iBAAiB,IAAI;EACvB;CACF,IACA,CAAC,SAAS,gBAAgB,CAC5B;CACA,MAAM,gBAAgB,mBAAmB,SAAS,QAAQ;CAC1D,yBAAyB;EAAE,aAAa,UAAU;CAAe,CAAC;CAOlE,MAAM,oBAAoB,OAAO,UAAU;CAC3C,yBAAyB;EACvB,MAAM,MAAM,kBAAkB;EAC9B,kBAAkB,UAAU;EAC5B,IAAI,CAAC,cAAc,CAAC,OAAO,SAAS,KAAK,UAAU,GAAG;EACtD,IAAI,eAAe,SAAS,eAAe,UAAU;OAChD,cAAc,eAAe;CACpC,CAAC;CAED,OAAO;EAAE;EAAW;EAAe,QADpB,eAAe;GAAE,QAAQ,cAAc;GAAY;EAAS,IAAI,CAAC,eAAe,QAAQ,CACpE;CAAO;AAC5C"}

package/dist/canvas/SceneCanvas/useCanvasDispatcher.js

@@ -1,20 +1,30 @@
-import { createDispatcherPreviewSources as e, createGestureSource as t } from "./dispatcherGestureBounds.js";
-import { useRef as n, useState as r } from "react";
-import { createDispatcher as i } from "@weasel-js/routing";
+import { createDispatcherPreviewSources, createGestureSource } from "./dispatcherGestureBounds.js";
+import { useRef, useState } from "react";
+import { useLatest } from "@weasel-js/react";
+import { createDispatcher } from "@weasel-js/routing";
+
 //#region src/canvas/SceneCanvas/useCanvasDispatcher.ts
-function a() {
-	let a = n(null), o = n(null);
-	o.current ||= i({ getAction: (e) => a.current?.(e) });
-	let s = o.current, [c] = r(() => t(() => o.current)), [{ previewIdsExtra: l, previewPoseExtra: u }] = r(() => e(() => o.current));
+/**
+* One `Dispatcher` for the life of a `<SceneCanvas>`, shared by the gesture
+* mounter that pumps input into it and the layers that walk its in-flight
+* handles, with the lookups those layers and `<Canvas>` read it through. It
+* resolves an action id in `registry`, read at call time.
+*/
+function useCanvasDispatcher(registry) {
+	const registryRef = useLatest(registry);
+	const dispatcherRef = useRef(null);
+	if (!dispatcherRef.current) dispatcherRef.current = createDispatcher({ getAction: (id) => registryRef.current?.list().find((a) => a.id === id) });
+	const dispatcher = dispatcherRef.current;
+	const [gestureSource] = useState(() => createGestureSource(() => dispatcherRef.current));
+	const [{ previewIdsExtra, previewPoseExtra }] = useState(() => createDispatcherPreviewSources(() => dispatcherRef.current));
 	return {
-		dispatcher: s,
-		getActionRef: a,
-		gestureSource: c,
-		previewIdsExtra: l,
-		previewPoseExtra: u
+		dispatcher,
+		gestureSource,
+		previewIdsExtra,
+		previewPoseExtra
 	};
 }
-//#endregion
-export { a as useCanvasDispatcher };
 
+//#endregion
+export { useCanvasDispatcher };
 //# sourceMappingURL=useCanvasDispatcher.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useCanvasDispatcher.js","names":["useCanvasDispatcher","getActionRef","useRef","dispatcherRef","createDispatcher","id","dispatcher","gestureSource","useState","createGestureSource","createDispatcherPreviewSources"],"sources":["../../../src/canvas/SceneCanvas/useCanvasDispatcher.ts"],"sourcesContent":["import { useRef, useState, type MutableRefObject } from 'react';\nimport { createDispatcher, type Action, type Dispatcher } from '@weasel-js/routing';\nimport type { GestureSource } from '../gestureBounds';\nimport { createDispatcherPreviewSources, createGestureSource } from './dispatcherGestureBounds';\n\n/**\n * One `Dispatcher` for the life of a `<SceneCanvas>`, shared by the gesture\n * mounter that pumps input into it and the layers that walk its in-flight\n * handles, with the lookups those layers and `<Canvas>` read it through.\n */\nexport function useCanvasDispatcher(): {\n  dispatcher: Dispatcher;\n  /** How the dispatcher resolves an action id at call time. Populated by\n   *  `StandardActionsRegistrar` once it has the registry in scope. */\n  getActionRef: MutableRefObject<((id: string) => Action | undefined) | null>;\n  /** In-flight preview ids, nascent-insert bounds, and the pump signal. */\n  gestureSource: GestureSource;\n  /** Ids whose committed paint an in-flight ghost hides. */\n  previewIdsExtra: () => string[];\n  /** The pose an in-flight handle proposes for an id. */\n  previewPoseExtra: (id: string) => unknown;\n} {\n  const getActionRef = useRef<((id: string) => Action | undefined) | null>(null);\n  const dispatcherRef = useRef<Dispatcher | null>(null);\n  if (!dispatcherRef.current) {\n    dispatcherRef.current = createDispatcher({\n      getAction: (id) => getActionRef.current?.(id),\n    });\n  }\n  const dispatcher = dispatcherRef.current;\n  const [gestureSource] = useState(() => createGestureSource(() => dispatcherRef.current));\n  const [{ previewIdsExtra, previewPoseExtra }] = useState(\n    () => createDispatcherPreviewSources(() => dispatcherRef.current),\n  );\n  return { dispatcher, getActionRef, gestureSource, previewIdsExtra, previewPoseExtra };\n}\n"],"mappings":";;;;AAUA,SAAgBA,IAWd;CACA,IAAMC,IAAeC,EAAoD,IAAI,GACvEC,IAAgBD,EAA0B,IAAI;CACpD,AACEC,EAAc,YAAUC,EAAiB,EACvC,YAAY,MAAOH,EAAa,UAAUI,CAAE,EAC9C,CAAC;CAEH,IAAMC,IAAaH,EAAc,SAC3B,CAACI,KAAiBC,QAAeC,QAA0BN,EAAc,OAAO,CAAC,GACjF,CAAC,EAAE,oBAAiB,yBAAsBK,QACxCE,QAAqCP,EAAc,OAAO,CAClE;CACA,OAAO;EAAE;EAAY;EAAc;EAAe;EAAiB;CAAiB;AACtF"}
+{"version":3,"file":"useCanvasDispatcher.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useCanvasDispatcher.ts"],"sourcesContent":["import { useRef, useState } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { createDispatcher, type ActionsRegistry, type Dispatcher } from '@weasel-js/routing';\nimport type { GestureSource } from '../gestureBounds';\nimport { createDispatcherPreviewSources, createGestureSource } from './dispatcherGestureBounds';\n\n/**\n * One `Dispatcher` for the life of a `<SceneCanvas>`, shared by the gesture\n * mounter that pumps input into it and the layers that walk its in-flight\n * handles, with the lookups those layers and `<Canvas>` read it through. It\n * resolves an action id in `registry`, read at call time.\n */\nexport function useCanvasDispatcher(registry: ActionsRegistry | null): {\n  dispatcher: Dispatcher;\n  /** In-flight preview ids, nascent-insert bounds, and the pump signal. */\n  gestureSource: GestureSource;\n  /** Ids whose committed paint an in-flight ghost hides. */\n  previewIdsExtra: () => string[];\n  /** The pose an in-flight handle proposes for an id. */\n  previewPoseExtra: (id: string) => unknown;\n} {\n  const registryRef = useLatest(registry);\n  const dispatcherRef = useRef<Dispatcher | null>(null);\n  if (!dispatcherRef.current) {\n    dispatcherRef.current = createDispatcher({\n      getAction: (id) => registryRef.current?.list().find((a) => a.id === id),\n    });\n  }\n  const dispatcher = dispatcherRef.current;\n  const [gestureSource] = useState(() => createGestureSource(() => dispatcherRef.current));\n  const [{ previewIdsExtra, previewPoseExtra }] = useState(\n    () => createDispatcherPreviewSources(() => dispatcherRef.current),\n  );\n  return { dispatcher, gestureSource, previewIdsExtra, previewPoseExtra };\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgB,oBAAoB,UAQlC;CACA,MAAM,cAAc,UAAU,QAAQ;CACtC,MAAM,gBAAgB,OAA0B,IAAI;CACpD,IAAI,CAAC,cAAc,SACjB,cAAc,UAAU,iBAAiB,EACvC,YAAY,OAAO,YAAY,SAAS,KAAK,CAAC,CAAC,MAAM,MAAM,EAAE,OAAO,EAAE,EACxE,CAAC;CAEH,MAAM,aAAa,cAAc;CACjC,MAAM,CAAC,iBAAiB,eAAe,0BAA0B,cAAc,OAAO,CAAC;CACvF,MAAM,CAAC,EAAE,iBAAiB,sBAAsB,eACxC,qCAAqC,cAAc,OAAO,CAClE;CACA,OAAO;EAAE;EAAY;EAAe;EAAiB;CAAiB;AACxE"}

package/dist/canvas/SceneCanvas/useCanvasSelection.js

@@ -1,16 +1,34 @@
-import { useSelection as e } from "../../core/selection/useSelection.js";
-import { readOnlySelection as t } from "../../core/selection/readOnlySelection.js";
-import { usePublishSceneSelection as n } from "../../core/selection/usePublishSceneSelection.js";
-import { useMemo as r } from "react";
+import { useSelection } from "../../core/selection/useSelection.js";
+import { readOnlySelection } from "../../core/selection/readOnlySelection.js";
+import { usePublishSceneSelection } from "../../core/selection/usePublishSceneSelection.js";
+import { useMemo } from "react";
+
 //#region src/canvas/SceneCanvas/useCanvasSelection.ts
-function i(i) {
-	let { scene: a, supplied: o, options: s, selectable: c, describeKind: l } = i, u = r(() => ({
-		scene: a,
-		...s ?? {}
-	}), [a, s]), d = e(u), f = o ?? d, p = c ? f : t(f);
-	return n(a, p.current, l), p;
+/**
+* The canvas's selection, published to any surrounding selection context.
+*
+* A caller-supplied api wins, and the one built here is then unused. The
+* built one is bound to the scene, so the selection an edit was made under
+* rides on the scene's history entries and undo can put it back.
+*
+* Everything the kit writes selection through (the `selection` dep, the
+* adapter's `setSelection`, ops committed through either) reads the returned
+* api, so on an unselectable canvas every write path here is closed. The
+* caller's own api is not wrapped and still writes.
+*/
+function useCanvasSelection(args) {
+	const { scene, supplied, options, selectable, describeKind } = args;
+	const derivedOptions = useMemo(() => ({
+		scene,
+		...options ?? {}
+	}), [scene, options]);
+	const internal = useSelection(derivedOptions);
+	const base = supplied ?? internal;
+	const selection = selectable ? base : readOnlySelection(base);
+	usePublishSceneSelection(scene, selection.current, describeKind);
+	return selection;
 }
-//#endregion
-export { i as useCanvasSelection };
 
+//#endregion
+export { useCanvasSelection };
 //# sourceMappingURL=useCanvasSelection.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useCanvasSelection.js","names":["useCanvasSelection","args","derivedOptions","useMemo","options","scene","internal","useSelection","base","supplied","selection","selectable","readOnlySelection","usePublishSceneSelection","describeKind"],"sources":["../../../src/canvas/SceneCanvas/useCanvasSelection.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { readOnlySelection } from 'core/selection/readOnlySelection';\nimport { usePublishSceneSelection } from 'core/selection/usePublishSceneSelection';\nimport { useSelection, type SelectionApi, type UseSelectionOptions } from 'core/selection/useSelection';\n\n/**\n * The canvas's selection, published to any surrounding selection context.\n *\n * A caller-supplied api wins, and the one built here is then unused. The\n * built one is bound to the scene, so the selection an edit was made under\n * rides on the scene's history entries and undo can put it back.\n *\n * Everything the kit writes selection through (the `selection` dep, the\n * adapter's `setSelection`, ops committed through either) reads the returned\n * api, so on an unselectable canvas every write path here is closed. The\n * caller's own api is not wrapped and still writes.\n */\nexport function useCanvasSelection<TData, TLayer extends string, TPose>(args: {\n  scene: Scene<TData, TLayer, TPose>;\n  /** `<SceneCanvas selection>`. */\n  supplied: SelectionApi | undefined;\n  options: UseSelectionOptions | undefined;\n  selectable: boolean;\n  describeKind: ((node: Node<TData, TLayer, TPose>) => string | undefined) | undefined;\n}): SelectionApi {\n  const { scene, supplied, options, selectable, describeKind } = args;\n  const derivedOptions = useMemo<UseSelectionOptions>(\n    () => ({ scene, ...(options ?? {}) }),\n    [scene, options],\n  );\n  const internal = useSelection(derivedOptions);\n  const base = supplied ?? internal;\n  const selection = selectable ? base : readOnlySelection(base);\n  usePublishSceneSelection(scene, selection.current as readonly NodeId[], describeKind);\n  return selection;\n}\n"],"mappings":";;;;;AAkBA,SAAgBA,EAAwD,GAOvD;CACf,IAAM,EAAE,UAAO,aAAU,YAAS,eAAY,oBAAiBC,GACzDC,IAAiBC,SACd;EAAE;EAAO,GAAIC,KAAW,CAAC;CAAG,IACnC,CAACC,GAAOD,CAAO,CACjB,GACME,IAAWC,EAAaL,CAAc,GACtCM,IAAOC,KAAYH,GACnBI,IAAYC,IAAaH,IAAOI,EAAkBJ,CAAI;CAE5D,OADAK,EAAyBR,GAAOK,EAAU,SAA8BI,CAAY,GAC7EJ;AACT"}
+{"version":3,"file":"useCanvasSelection.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useCanvasSelection.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { readOnlySelection } from 'core/selection/readOnlySelection';\nimport { usePublishSceneSelection } from 'core/selection/usePublishSceneSelection';\nimport { useSelection, type SelectionApi, type UseSelectionOptions } from 'core/selection/useSelection';\n\n/**\n * The canvas's selection, published to any surrounding selection context.\n *\n * A caller-supplied api wins, and the one built here is then unused. The\n * built one is bound to the scene, so the selection an edit was made under\n * rides on the scene's history entries and undo can put it back.\n *\n * Everything the kit writes selection through (the `selection` dep, the\n * adapter's `setSelection`, ops committed through either) reads the returned\n * api, so on an unselectable canvas every write path here is closed. The\n * caller's own api is not wrapped and still writes.\n */\nexport function useCanvasSelection<TData, TLayer extends string, TPose>(args: {\n  scene: Scene<TData, TLayer, TPose>;\n  /** `<SceneCanvas selection>`. */\n  supplied: SelectionApi | undefined;\n  options: UseSelectionOptions | undefined;\n  selectable: boolean;\n  describeKind: ((node: Node<TData, TLayer, TPose>) => string | undefined) | undefined;\n}): SelectionApi {\n  const { scene, supplied, options, selectable, describeKind } = args;\n  const derivedOptions = useMemo<UseSelectionOptions>(\n    () => ({ scene, ...(options ?? {}) }),\n    [scene, options],\n  );\n  const internal = useSelection(derivedOptions);\n  const base = supplied ?? internal;\n  const selection = selectable ? base : readOnlySelection(base);\n  usePublishSceneSelection(scene, selection.current as readonly NodeId[], describeKind);\n  return selection;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,SAAgB,mBAAwD,MAOvD;CACf,MAAM,EAAE,OAAO,UAAU,SAAS,YAAY,iBAAiB;CAC/D,MAAM,iBAAiB,eACd;EAAE;EAAO,GAAI,WAAW,CAAC;CAAG,IACnC,CAAC,OAAO,OAAO,CACjB;CACA,MAAM,WAAW,aAAa,cAAc;CAC5C,MAAM,OAAO,YAAY;CACzB,MAAM,YAAY,aAAa,OAAO,kBAAkB,IAAI;CAC5D,yBAAyB,OAAO,UAAU,SAA8B,YAAY;CACpF,OAAO;AACT"}