@weasel-js/core 1.10.1 → 1.11.0

package/dist/canvas/SceneCanvas/useActionsPropResolver.js

@@ -1,53 +1,86 @@
-import { useEffect as e } from "react";
-import { useLatest as t } from "@weasel-js/react";
-import { useActionsRegistry as n } from "@weasel-js/routing/react";
+import { useEffect } from "react";
+import { useLatest } from "@weasel-js/react";
+import { useActionsRegistry } from "@weasel-js/routing/react";
+
 //#region src/canvas/SceneCanvas/useActionsPropResolver.ts
-function r(r, i) {
-	let a = n(), o = t(r);
-	e(() => {
-		if (!a) return;
-		let e = o.current, t = [];
-		if (e === null) {
-			for (let e of a.list().map((e) => e.id)) t.push(a.mute(e));
+/**
+* Applies the `actions` prop overrides on top of whatever is already
+* registered, so the caller mounts this hook last.
+*
+*   actions === null           → mute every currently-registered action
+*   actions[id] === null       → mute that id
+*   actions[id] = partial      → merge onto the existing descriptor (slot wins
+*                                over entry.id; warns once on mismatch)
+*   actions[id] = full (new)   → register alongside defaults
+*
+* `null` mutes rather than unregisters: the opt-out belongs to this canvas, so
+* a sibling sharing the registry keeps the action and this canvas's unmount
+* gives it back.
+*/
+/** `rev` re-applies the overrides when it changes — pass whatever changes when
+*  the set they sit on is re-registered. */
+function useActionsPropResolver(actions, rev) {
+	const reg = useActionsRegistry();
+	const actionsRef = useLatest(actions);
+	useEffect(() => {
+		if (!reg) return;
+		const prop = actionsRef.current;
+		const unregisters = [];
+		if (prop === null) {
+			for (const id of reg.list().map((a) => a.id)) unregisters.push(reg.mute(id));
 			return () => {
-				for (let e of t) e();
+				for (const u of unregisters) u();
 			};
 		}
-		if (!e) return;
-		let n = /* @__PURE__ */ new Set();
-		for (let [r, i] of Object.entries(e)) {
-			if (i === null) {
-				t.push(a.mute(r));
+		if (!prop) return;
+		const warnedIds = /* @__PURE__ */ new Set();
+		for (const [slotId, entry] of Object.entries(prop)) {
+			if (entry === null) {
+				unregisters.push(reg.mute(slotId));
 				continue;
 			}
-			let e = (e) => typeof e.id == "string" && typeof e.label == "string" && !!e.invoker, o = a.list().find((e) => e.id === r);
-			if (!o) {
-				e(i) ? t.push(a.register(i)) : n.has(r) || (n.add(r), console.warn(`weasel actions resolver: actions["${r}"] is a partial Action but no default with this id exists. Pass a complete {id, label, invoker} descriptor.`));
+			const isFull = (e) => typeof e.id === "string" && typeof e.label === "string" && !!e.invoker;
+			const existing = reg.list().find((a) => a.id === slotId);
+			if (!existing) {
+				if (isFull(entry)) unregisters.push(reg.register(entry));
+				else if (!warnedIds.has(slotId)) {
+					warnedIds.add(slotId);
+					console.warn(`weasel actions resolver: actions["${slotId}"] is a partial Action but no default with this id exists. Pass a complete {id, label, invoker} descriptor.`);
+				}
 				continue;
 			}
-			i.id !== void 0 && i.id !== r && !n.has(`mismatch:${r}`) && (n.add(`mismatch:${r}`), console.warn(`weasel actions resolver: actions["${r}"].id="${i.id}" mismatches the slot key. Ignoring the id field; the action remains at id="${r}".`));
-			let { id: s, ...c } = i, l = {
-				...o,
-				...c
+			if (entry.id !== void 0 && entry.id !== slotId && !warnedIds.has(`mismatch:${slotId}`)) {
+				warnedIds.add(`mismatch:${slotId}`);
+				console.warn(`weasel actions resolver: actions["${slotId}"].id="${entry.id}" mismatches the slot key. Ignoring the id field; the action remains at id="${slotId}".`);
+			}
+			const { id: _drop, ...rest } = entry;
+			const merged = {
+				...existing,
+				...rest
 			};
-			t.push(a.register(l));
+			unregisters.push(reg.register(merged));
 		}
 		return () => {
-			for (let e of t) e();
+			for (const u of unregisters) u();
 		};
 	}, [
-		a,
-		r,
-		o,
-		i
+		reg,
+		actions,
+		actionsRef,
+		rev
 	]);
 }
-function i(e, t) {
-	if (e === null) return null;
-	let n = { ...e ?? {} };
-	return t in n || (n[t] = null), n;
+/**
+* `actions` with `id` muted. A caller's own entry for `id` still wins, and
+* `null` (every default muted) is left as it is.
+*/
+function actionsMuting(actions, id) {
+	if (actions === null) return null;
+	const merged = { ...actions ?? {} };
+	if (!(id in merged)) merged[id] = null;
+	return merged;
 }
-//#endregion
-export { i as actionsMuting, r as useActionsPropResolver };
 
+//#endregion
+export { actionsMuting, useActionsPropResolver };
 //# sourceMappingURL=useActionsPropResolver.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useActionsPropResolver.js","names":["useActionsPropResolver","reg","useActionsRegistry","actionsRef","useLatest","actions","prop","unregisters","id","a","u","warnedIds","slotId","entry","isFull","existing","_drop","rest","merged","rev","actionsMuting"],"sources":["../../../src/canvas/SceneCanvas/useActionsPropResolver.ts"],"sourcesContent":["/**\n * Applies the `actions` prop overrides on top of whatever is already\n * registered, so the caller mounts this hook last.\n *\n *   actions === null           → mute every currently-registered action\n *   actions[id] === null       → mute that id\n *   actions[id] = partial      → merge onto the existing descriptor (slot wins\n *                                over entry.id; warns once on mismatch)\n *   actions[id] = full (new)   → register alongside defaults\n *\n * `null` mutes rather than unregisters: the opt-out belongs to this canvas, so\n * a sibling sharing the registry keeps the action and this canvas's unmount\n * gives it back.\n */\nimport { useEffect } from 'react';\nimport type { ActionsProp } from '@weasel-js/routing';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Action } from '@weasel-js/routing';\n\n/** `rev` re-applies the overrides when it changes — pass whatever changes when\n *  the set they sit on is re-registered. */\nexport function useActionsPropResolver(actions: ActionsProp | undefined, rev?: string): void {\n  const reg = useActionsRegistry();\n  const actionsRef = useLatest(actions);\n\n  useEffect(() => {\n    if (!reg) return;\n    const prop = actionsRef.current;\n\n    const unregisters: Array<() => void> = [];\n\n    if (prop === null) {\n      for (const id of reg.list().map((a) => a.id)) unregisters.push(reg.mute(id));\n      return () => { for (const u of unregisters) u(); };\n    }\n\n    if (!prop) return;\n\n    const warnedIds = new Set<string>();\n\n    for (const [slotId, entry] of Object.entries(prop)) {\n      if (entry === null) {\n        unregisters.push(reg.mute(slotId));\n        continue;\n      }\n\n      const isFull = (e: Partial<Action>): e is Action =>\n        typeof e.id === 'string' && typeof e.label === 'string' && !!e.invoker;\n      const existing = reg.list().find((a) => a.id === slotId);\n\n      if (!existing) {\n        if (isFull(entry)) {\n          unregisters.push(reg.register(entry));\n        } else if (!warnedIds.has(slotId)) {\n          warnedIds.add(slotId);\n          console.warn(\n            `weasel actions resolver: actions[\"${slotId}\"] is a partial Action but no default ` +\n            `with this id exists. Pass a complete {id, label, invoker} descriptor.`,\n          );\n        }\n        continue;\n      }\n\n      if (entry.id !== undefined && entry.id !== slotId && !warnedIds.has(`mismatch:${slotId}`)) {\n        warnedIds.add(`mismatch:${slotId}`);\n        console.warn(\n          `weasel actions resolver: actions[\"${slotId}\"].id=\"${entry.id as string}\" mismatches the slot key. ` +\n          `Ignoring the id field; the action remains at id=\"${slotId}\".`,\n        );\n      }\n      const { id: _drop, ...rest } = entry;\n      void _drop;\n      const merged: Action = { ...existing, ...rest };\n      // No explicit restore: `register` stacks, so popping `merged` uncovers\n      // the descriptor it displaced. Re-registering `existing` here would push\n      // a stale snapshot back on top and never take it off again.\n      unregisters.push(reg.register(merged));\n    }\n\n    return () => { for (const u of unregisters) u(); };\n  }, [reg, actions, actionsRef, rev]);\n}\n\n/**\n * `actions` with `id` muted. A caller's own entry for `id` still wins, and\n * `null` (every default muted) is left as it is.\n */\nexport function actionsMuting(actions: ActionsProp | undefined, id: string): ActionsProp {\n  if (actions === null) return null;\n  const merged = { ...(actions ?? {}) } as Record<string, unknown>;\n  if (!(id in merged)) merged[id] = null;\n  return merged as ActionsProp;\n}\n"],"mappings":";;;;AAsBA,SAAgBA,EAAuB,GAAkC,GAAoB;CAC3F,IAAMC,IAAMC,EAAmB,GACzBC,IAAaC,EAAUC,CAAO;CAEpC,QAAgB;EACd,IAAI,CAACJ,GAAK;EACV,IAAMK,IAAOH,EAAW,SAElBI,IAAiC,CAAC;EAExC,IAAID,MAAS,MAAM;GACjB,KAAK,IAAME,KAAMP,EAAI,KAAK,CAAC,CAAC,KAAK,MAAMQ,EAAE,EAAE,GAAG,EAAY,KAAKR,EAAI,KAAKO,CAAE,CAAC;GAC3E,aAAa;IAAE,KAAK,IAAME,KAAKH,GAAa,EAAE;GAAG;EACnD;EAEA,IAAI,CAACD,GAAM;EAEX,IAAMK,oBAAY,IAAI,IAAY;EAElC,KAAK,IAAM,CAACC,GAAQC,MAAU,OAAO,QAAQP,CAAI,GAAG;GAClD,IAAIO,MAAU,MAAM;IAClB,EAAY,KAAKZ,EAAI,KAAKW,CAAM,CAAC;IACjC;GACF;GAEA,IAAME,KAAU,MACd,OAAO,EAAE,MAAO,YAAY,OAAO,EAAE,SAAU,YAAY,CAAC,CAAC,EAAE,SAC3DC,IAAWd,EAAI,KAAK,CAAC,CAAC,MAAM,MAAMQ,EAAE,OAAOG,CAAM;GAEvD,IAAI,CAACG,GAAU;IACb,AAAID,EAAOD,CAAK,IACdN,EAAY,KAAKN,EAAI,SAASY,CAAK,CAAC,IAC1BF,EAAU,IAAIC,CAAM,MAC9BD,EAAU,IAAIC,CAAM,GACpB,QAAQ,KACN,qCAAqCA,EAAO,4GAE9C;IAEF;GACF;GAEA,AAAIC,EAAM,OAAO,KAAA,KAAaA,EAAM,OAAOD,KAAU,CAACD,EAAU,IAAI,YAAYC,GAAQ,MACtFD,EAAU,IAAI,YAAYC,GAAQ,GAClC,QAAQ,KACN,qCAAqCA,EAAO,SAASC,EAAM,GAAa,8EACpBD,EAAO,GAC7D;GAEF,IAAM,EAAE,IAAII,GAAO,GAAGC,MAASJ,GAEzBK,IAAiB;IAAE,GAAGH;IAAU,GAAGE;GAAK;GAI9C,EAAY,KAAKhB,EAAI,SAASiB,CAAM,CAAC;EACvC;EAEA,aAAa;GAAE,KAAK,IAAMR,KAAKH,GAAa,EAAE;EAAG;CACnD,GAAG;EAACN;EAAKI;EAASF;EAAYgB;CAAG,CAAC;AACpC;AAMA,SAAgBC,EAAc,GAAkC,GAAyB;CACvF,IAAIf,MAAY,MAAM,OAAO;CAC7B,IAAMa,IAAS,EAAE,GAAIb,KAAW,CAAC,EAAG;CAEpC,OADMG,KAAMU,MAAS,EAAOV,KAAM,OAC3BU;AACT"}
+{"version":3,"file":"useActionsPropResolver.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useActionsPropResolver.ts"],"sourcesContent":["/**\n * Applies the `actions` prop overrides on top of whatever is already\n * registered, so the caller mounts this hook last.\n *\n *   actions === null           → mute every currently-registered action\n *   actions[id] === null       → mute that id\n *   actions[id] = partial      → merge onto the existing descriptor (slot wins\n *                                over entry.id; warns once on mismatch)\n *   actions[id] = full (new)   → register alongside defaults\n *\n * `null` mutes rather than unregisters: the opt-out belongs to this canvas, so\n * a sibling sharing the registry keeps the action and this canvas's unmount\n * gives it back.\n */\nimport { useEffect } from 'react';\nimport type { ActionsProp } from '@weasel-js/routing';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Action } from '@weasel-js/routing';\n\n/** `rev` re-applies the overrides when it changes — pass whatever changes when\n *  the set they sit on is re-registered. */\nexport function useActionsPropResolver(actions: ActionsProp | undefined, rev?: string): void {\n  const reg = useActionsRegistry();\n  const actionsRef = useLatest(actions);\n\n  useEffect(() => {\n    if (!reg) return;\n    const prop = actionsRef.current;\n\n    const unregisters: Array<() => void> = [];\n\n    if (prop === null) {\n      for (const id of reg.list().map((a) => a.id)) unregisters.push(reg.mute(id));\n      return () => { for (const u of unregisters) u(); };\n    }\n\n    if (!prop) return;\n\n    const warnedIds = new Set<string>();\n\n    for (const [slotId, entry] of Object.entries(prop)) {\n      if (entry === null) {\n        unregisters.push(reg.mute(slotId));\n        continue;\n      }\n\n      const isFull = (e: Partial<Action>): e is Action =>\n        typeof e.id === 'string' && typeof e.label === 'string' && !!e.invoker;\n      const existing = reg.list().find((a) => a.id === slotId);\n\n      if (!existing) {\n        if (isFull(entry)) {\n          unregisters.push(reg.register(entry));\n        } else if (!warnedIds.has(slotId)) {\n          warnedIds.add(slotId);\n          console.warn(\n            `weasel actions resolver: actions[\"${slotId}\"] is a partial Action but no default ` +\n            `with this id exists. Pass a complete {id, label, invoker} descriptor.`,\n          );\n        }\n        continue;\n      }\n\n      if (entry.id !== undefined && entry.id !== slotId && !warnedIds.has(`mismatch:${slotId}`)) {\n        warnedIds.add(`mismatch:${slotId}`);\n        console.warn(\n          `weasel actions resolver: actions[\"${slotId}\"].id=\"${entry.id as string}\" mismatches the slot key. ` +\n          `Ignoring the id field; the action remains at id=\"${slotId}\".`,\n        );\n      }\n      const { id: _drop, ...rest } = entry;\n      void _drop;\n      const merged: Action = { ...existing, ...rest };\n      // No explicit restore: `register` stacks, so popping `merged` uncovers\n      // the descriptor it displaced. Re-registering `existing` here would push\n      // a stale snapshot back on top and never take it off again.\n      unregisters.push(reg.register(merged));\n    }\n\n    return () => { for (const u of unregisters) u(); };\n  }, [reg, actions, actionsRef, rev]);\n}\n\n/**\n * `actions` with `id` muted. A caller's own entry for `id` still wins, and\n * `null` (every default muted) is left as it is.\n */\nexport function actionsMuting(actions: ActionsProp | undefined, id: string): ActionsProp {\n  if (actions === null) return null;\n  const merged = { ...(actions ?? {}) } as Record<string, unknown>;\n  if (!(id in merged)) merged[id] = null;\n  return merged as ActionsProp;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,uBAAuB,SAAkC,KAAoB;CAC3F,MAAM,MAAM,mBAAmB;CAC/B,MAAM,aAAa,UAAU,OAAO;CAEpC,gBAAgB;EACd,IAAI,CAAC,KAAK;EACV,MAAM,OAAO,WAAW;EAExB,MAAM,cAAiC,CAAC;EAExC,IAAI,SAAS,MAAM;GACjB,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,CAAC,KAAK,MAAM,EAAE,EAAE,GAAG,YAAY,KAAK,IAAI,KAAK,EAAE,CAAC;GAC3E,aAAa;IAAE,KAAK,MAAM,KAAK,aAAa,EAAE;GAAG;EACnD;EAEA,IAAI,CAAC,MAAM;EAEX,MAAM,4BAAY,IAAI,IAAY;EAElC,KAAK,MAAM,CAAC,QAAQ,UAAU,OAAO,QAAQ,IAAI,GAAG;GAClD,IAAI,UAAU,MAAM;IAClB,YAAY,KAAK,IAAI,KAAK,MAAM,CAAC;IACjC;GACF;GAEA,MAAM,UAAU,MACd,OAAO,EAAE,OAAO,YAAY,OAAO,EAAE,UAAU,YAAY,CAAC,CAAC,EAAE;GACjE,MAAM,WAAW,IAAI,KAAK,CAAC,CAAC,MAAM,MAAM,EAAE,OAAO,MAAM;GAEvD,IAAI,CAAC,UAAU;IACb,IAAI,OAAO,KAAK,GACd,YAAY,KAAK,IAAI,SAAS,KAAK,CAAC;SAC/B,IAAI,CAAC,UAAU,IAAI,MAAM,GAAG;KACjC,UAAU,IAAI,MAAM;KACpB,QAAQ,KACN,qCAAqC,OAAO,4GAE9C;IACF;IACA;GACF;GAEA,IAAI,MAAM,OAAO,UAAa,MAAM,OAAO,UAAU,CAAC,UAAU,IAAI,YAAY,QAAQ,GAAG;IACzF,UAAU,IAAI,YAAY,QAAQ;IAClC,QAAQ,KACN,qCAAqC,OAAO,SAAS,MAAM,GAAa,8EACpB,OAAO,GAC7D;GACF;GACA,MAAM,EAAE,IAAI,OAAO,GAAG,SAAS;GAE/B,MAAM,SAAiB;IAAE,GAAG;IAAU,GAAG;GAAK;GAI9C,YAAY,KAAK,IAAI,SAAS,MAAM,CAAC;EACvC;EAEA,aAAa;GAAE,KAAK,MAAM,KAAK,aAAa,EAAE;EAAG;CACnD,GAAG;EAAC;EAAK;EAAS;EAAY;CAAG,CAAC;AACpC;;;;;AAMA,SAAgB,cAAc,SAAkC,IAAyB;CACvF,IAAI,YAAY,MAAM,OAAO;CAC7B,MAAM,SAAS,EAAE,GAAI,WAAW,CAAC,EAAG;CACpC,IAAI,EAAE,MAAM,SAAS,OAAO,MAAM;CAClC,OAAO;AACT"}

package/dist/canvas/SceneCanvas/useBakedScene.js

@@ -0,0 +1,17 @@
+import { isSerializedScene } from "../../core/scene/serialization.js";
+import { sceneFromJSON } from "../../core/scene/scene.js";
+import { useState } from "react";
+
+//#region src/canvas/SceneCanvas/useBakedScene.ts
+/**
+* `scene` accepts either a live `Scene` or a `SerializedScene` JSON object. JSON is baked
+* once; later prop changes are ignored (use a `key` on `<SceneCanvas>` to force a fresh canvas).
+*/
+function useBakedScene(sceneInput) {
+	const [bakedScene] = useState(() => isSerializedScene(sceneInput) ? sceneFromJSON(sceneInput, {}) : null);
+	return bakedScene ?? sceneInput;
+}
+
+//#endregion
+export { useBakedScene };
+//# sourceMappingURL=useBakedScene.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useBakedScene.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useBakedScene.ts"],"sourcesContent":["import { useState } from 'react';\nimport { sceneFromJSON } from 'core/scene/scene';\nimport { isSerializedScene } from 'core/scene/serialization';\nimport type { Scene } from 'core/scene/types';\nimport type { SceneCanvasProps } from './props';\n\n/**\n * `scene` accepts either a live `Scene` or a `SerializedScene` JSON object. JSON is baked\n * once; later prop changes are ignored (use a `key` on `<SceneCanvas>` to force a fresh canvas).\n */\nexport function useBakedScene<TData, TLayer extends string, TPose>(\n  sceneInput: SceneCanvasProps<TData, TLayer, TPose>['scene'],\n): Scene<TData, TLayer, TPose> {\n  const [bakedScene] = useState<Scene<TData, TLayer, TPose> | null>(\n    () => (isSerializedScene<TData, TLayer, TPose>(sceneInput) ? sceneFromJSON(sceneInput, {}) : null),\n  );\n  return bakedScene ?? (sceneInput as Scene<TData, TLayer, TPose>);\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,cACd,YAC6B;CAC7B,MAAM,CAAC,cAAc,eACZ,kBAAwC,UAAU,IAAI,cAAc,YAAY,CAAC,CAAC,IAAI,IAC/F;CACA,OAAO,cAAe;AACxB"}

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,46 +1,61 @@
-import { sameView as e } from "../../core/viewport/view.js";
-import { useViewAnimationOn as t } from "../../core/viewport/useViewAnimation.js";
-import { useCanvasView as n } from "../useCanvasView.js";
-import { useInsertionEffect as r, useMemo as i, useRef as a } from "react";
-import { useLatest as o } from "@weasel-js/react";
-import { useAnimator as s } 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 c(c) {
-	let { view: l, defaultView: u, onViewChange: d, viewBounds: f, width: p, height: m, requestRedraw: h } = c, g = o({
-		width: p,
-		height: m
-	}), _ = a(null), v = a(!1), y = n({
-		view: l,
-		defaultView: u,
-		onViewChange: (e) => {
-			_.current?.stopIfExternal(), d?.(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: f,
-		dims: () => g.current,
-		requestRedraw: h
-	}), b = s(), { viewRef: x, setViewFromInput: S, controlled: C } = y, w = i(() => ({
-		get: () => x.current,
-		set: (e) => {
-			v.current = !0, S(e);
+		viewBounds,
+		dims,
+		requestRedraw
+	});
+	const animator = useAnimator();
+	const { viewRef, setViewFromInput, controlled } = viewState;
+	const channel = useMemo(() => ({
+		get: () => viewRef.current,
+		set: (next) => {
+			runnerWroteRef.current = true;
+			setViewFromInput(next);
 		}
-	}), [x, S]), T = t(w, b);
-	r(() => {
-		_.current = T;
+	}), [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();
 	});
-	let E = a(C);
-	return r(() => {
-		let t = E.current;
-		E.current = C, C && t && !e(t, C) && (v.current ? v.current = !1 : T.stopIfExternal());
-	}), {
-		viewState: y,
-		viewAnimation: T,
-		camera: i(() => ({
-			target: T.viewTarget,
-			animator: b
-		}), [T, b])
+	return {
+		viewState,
+		viewAnimation,
+		camera: useMemo(() => ({
+			target: viewAnimation.viewTarget,
+			animator
+		}), [viewAnimation, animator])
 	};
 }
-//#endregion
-export { c 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","runnerWroteRef","viewState","useCanvasView","onViewChange","next","animator","useAnimator","channel","useMemo","viewRef","setViewFromInput","viewAnimation","useViewAnimationOn","lastControlledRef","controlled","useInsertionEffect","was"],"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 { sameView, type View } from 'core/viewport/view';\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  /** 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: () => 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, 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,SAAgBA,EAAgB,GAS9B;CACA,IAAM,EAAE,SAAM,gBAAa,iBAAc,eAAY,UAAO,WAAQ,qBAAkBC,GAChFC,IAAOC,EAAU;EAAE;EAAO;CAAO,CAAC,GAClCC,IAAeC,EAAgC,IAAI,GAEnDC,IAAiBD,EAAO,EAAK,GAC7BE,IAAYC,EAAc;EAC9B;EACA;EAGA,eAAe,MAAS;GAEtB,AADAJ,EAAa,SAAS,eAAe,GACrCK,IAAeC,CAAI;EACrB;EACA;EACA,YAAYR,EAAK;EACjB;CACF,CAAC,GAKKS,IAAWC,EAAY,GACvB,EAAE,YAAS,qBAAkB,kBAAeL,GAC5CM,IAAUC,SACP;EACL,WAAWC,EAAQ;EACnB,MAAM,MAAe;GAEnB,AADA,EAAe,UAAU,IACzBC,EAAiBN,CAAI;EACvB;CACF,IACA,CAACK,GAASC,CAAgB,CAC5B,GACMC,IAAgBC,EAAmBL,GAASF,CAAQ;CAC1D,QAAyB;EAAE,EAAa,UAAUM;CAAe,CAAC;CAOlE,IAAME,IAAoBd,EAAOe,CAAU;CAS3C,OARAC,QAAyB;EACvB,IAAMC,IAAMH,EAAkB;EAE9B,AADA,EAAkB,UAAUC,GACvBA,KAAeE,KAAO,GAASA,GAAKF,CAAU,MAC/Cd,EAAe,UAAS,EAAe,UAAU,KAChDW,EAAc,eAAe;CACpC,CAAC,GAEM;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 { useLatest as i } from "@weasel-js/react";
-import { createDispatcher as a } 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 o(o) {
-	let s = i(o), c = n(null);
-	c.current ||= a({ getAction: (e) => s.current?.list().find((t) => t.id === e) });
-	let l = c.current, [u] = r(() => t(() => c.current)), [{ previewIdsExtra: d, previewPoseExtra: f }] = r(() => e(() => c.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: l,
-		gestureSource: u,
-		previewIdsExtra: d,
-		previewPoseExtra: f
+		dispatcher,
+		gestureSource,
+		previewIdsExtra,
+		previewPoseExtra
 	};
 }
-//#endregion
-export { o as useCanvasDispatcher };
 
+//#endregion
+export { useCanvasDispatcher };
 //# sourceMappingURL=useCanvasDispatcher.js.map