@weasel-js/core 1.10.1 → 1.11.1

package/dist/canvas/SceneCanvas/useActionsPropResolver.js

@@ -1,53 +1,76 @@
-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;
-}
-//#endregion
-export { i as actionsMuting, r as useActionsPropResolver };
 
+//#endregion
+export { 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"],"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"}

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/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';\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}\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":";;;;;;;;;;;;;;;;;;;;;;;;AA0DA,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,29 @@
-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 { 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, enabled, defaultTools, patch, toolOptions, inertia } = args;
+	const hand = useHandTool({ inertia });
+	const shapes = useBuiltinShapeTools({ options: toolOptions });
+	const slice = useSliceTool(toolOptions?.slice);
+	return resolveToolRegistry({
 		builtins: {
-			select: i,
-			hand: u,
-			...d
+			select,
+			hand,
+			...shapes,
+			slice
 		},
-		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 { 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 type { ToolEntry } from '@weasel-js/routing';\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: EnabledPresets;\n  defaultTools?: readonly ToolEntry<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  const slice = useSliceTool(toolOptions?.slice);\n  return resolveToolRegistry({\n    builtins: { select, hand, ...shapes, slice },\n    defaultTools,\n    enabled,\n    patch,\n  });\n}\n"],"mappings":";;;;;;;;AAuBA,SAAgB,gBAAgB,MAAiD;CAC/E,MAAM,EAAE,QAAQ,SAAS,cAAc,OAAO,aAAa,YAAY;CACvE,MAAM,OAAO,YAAY,EAAE,QAAQ,CAAC;CACpC,MAAM,SAAS,qBAAqB,EAAE,SAAS,YAAY,CAAC;CAC5D,MAAM,QAAQ,aAAa,aAAa,KAAK;CAC7C,OAAO,oBAAoB;EACzB,UAAU;GAAE;GAAQ;GAAM,GAAG;GAAQ;EAAM;EAC3C;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/useCanvasDevtoolsRoot.js

@@ -0,0 +1,93 @@
+import { parseDebugFlags } from "../../debug/parseDebugFlags.js";
+import { recordHistory } from "../../devtools/history.js";
+import { useDevtoolsLabel } from "../../devtools/label.js";
+import { describeRegistry } from "../../devtools/registry.js";
+import { useDevtoolsRoot } from "../../devtools/useDevtoolsRoot.js";
+import { inferredNodeRouting } from "./defaultNodeRouting.js";
+import { useEffect, useState } from "react";
+import { createDispatchTrace, createTraceRing } from "@weasel-js/routing";
+import { useActionsRegistry, useDepRegistry } from "@weasel-js/routing/react";
+
+//#region src/canvas/SceneCanvas/useCanvasDevtoolsRoot.ts
+function resolved(debug) {
+	if (debug === false) return null;
+	if (debug !== void 0) return debug;
+	return typeof window === "undefined" ? null : parseDebugFlags(window.location.search);
+}
+/** What `get-registry` reports of `deps`, as one comparable string; null for a registry that cannot list itself. */
+function depListingKey(deps) {
+	return deps.list?.().map((d) => `${d.name}:${d.depth}:${d.stacked}`).join("\0") ?? null;
+}
+/** This canvas's trace buffers and its devtools root, read from the latest render. */
+function useCanvasDevtoolsRoot(c) {
+	const [traces] = useState(() => ({
+		dispatch: createDispatchTrace(),
+		coords: createTraceRing(),
+		history: createTraceRing()
+	}));
+	const actions = useActionsRegistry();
+	const deps = useDepRegistry();
+	const framed = useDevtoolsLabel();
+	const root = useDevtoolsRoot({
+		label: () => {
+			const el = c.element.current;
+			return el?.getAttribute("aria-label") || el?.id || framed || el?.parentElement?.closest("[aria-label]")?.getAttribute("aria-label") || "";
+		},
+		scene: () => c.scene,
+		selection: () => c.selection.current,
+		select: (ids) => c.selection.set([...ids]),
+		view: () => c.viewState.getView(),
+		activeTool: () => c.tools.active ?? null,
+		tools: () => Object.keys(c.tools.registry),
+		setTool: (id) => c.tools.setActive(id),
+		trace: traces.dispatch,
+		coords: traces.coords,
+		frame: () => c.api.current?.getDebug()?.snapshot().frame ?? null,
+		overlays: () => resolved(c.devtools.debug),
+		setOverride: (o) => c.devtools.setOverride(o),
+		subscribeView: c.viewState.subscribeView,
+		registry: () => describeRegistry({
+			tools: c.tools,
+			contributions: c.contributions,
+			actions,
+			deps,
+			routingKinds: (c.routing ?? inferredNodeRouting).map((k) => k.name)
+		}),
+		subscribeRegistry(listener) {
+			let listed = depListingKey(deps);
+			const onDeps = () => {
+				const next = depListingKey(deps);
+				if (next !== null && next === listed) return;
+				listed = next;
+				listener();
+			};
+			const offs = [actions?.subscribe(listener), deps.subscribe?.(onDeps)];
+			return () => {
+				for (const off of offs) off?.();
+			};
+		},
+		history: traces.history
+	}, {
+		selection: c.selection.current,
+		tool: c.tools.active ?? null
+	});
+	useEffect(() => recordHistory(c.scene.history, traces.history), [c.scene, traces.history]);
+	const { registry, ambient } = c.tools;
+	useEffect(() => {
+		root.notify("registry");
+	}, [
+		root,
+		registry,
+		ambient,
+		c.contributions,
+		c.routing
+	]);
+	return {
+		root,
+		traces
+	};
+}
+
+//#endregion
+export { useCanvasDevtoolsRoot };
+//# sourceMappingURL=useCanvasDevtoolsRoot.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasDevtoolsRoot.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useCanvasDevtoolsRoot.ts"],"sourcesContent":["import { useEffect, useState, type MutableRefObject, type RefObject } from 'react';\nimport {\n  createDispatchTrace, createTraceRing, type Contribution, type DepRegistry, type DispatchTrace, type TraceRing,\n} from '@weasel-js/routing';\nimport { useActionsRegistry, useDepRegistry } from '@weasel-js/routing/react';\nimport type { NodeRoutingEntry } from 'core/scene/NodeRouting';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { DebugConfig } from '../../debug/types';\nimport { parseDebugFlags } from '../../debug/parseDebugFlags';\nimport { recordHistory } from '../../devtools/history';\nimport type { DevtoolsHistoryRecord } from '../../devtools/protocol';\nimport { useDevtoolsLabel } from '../../devtools/label';\nimport { describeRegistry } from '../../devtools/registry';\nimport type { DevtoolsRoot } from '../../devtools/root';\nimport { useDevtoolsRoot, type DevtoolsOverride } from '../../devtools/useDevtoolsRoot';\nimport type { ToolsApi } from '../../tools/overlayBinding';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport type { CanvasViewState } from '../useCanvasView';\nimport type { CoordTraceEntry } from './coordTrace';\nimport { inferredNodeRouting } from './defaultNodeRouting';\n\n/** A canvas's trace buffers: its dispatchers' decisions, its `clientToWorld` conversions, and its scene's history steps. */\nexport interface CanvasTraces {\n  dispatch: DispatchTrace;\n  coords: TraceRing<CoordTraceEntry>;\n  history: TraceRing<DevtoolsHistoryRecord>;\n}\n\n/** What `<SceneCanvas>` hands its input wiring for devtools: the `debug` in effect and the override's setter. */\nexport interface CanvasDevtools {\n  debug: DebugConfig | false | undefined;\n  setOverride(override: DevtoolsOverride | null): void;\n}\n\nfunction resolved(debug: DebugConfig | false | undefined): DebugConfig | null {\n  if (debug === false) return null;\n  if (debug !== undefined) return debug;\n  return typeof window === 'undefined' ? null : parseDebugFlags(window.location.search);\n}\n\n/** What `get-registry` reports of `deps`, as one comparable string; null for a registry that cannot list itself. */\nfunction depListingKey(deps: DepRegistry): string | null {\n  return deps.list?.().map((d) => `${d.name}:${d.depth}:${d.stacked}`).join('\\u0000') ?? null;\n}\n\n/** This canvas's trace buffers and its devtools root, read from the latest render. */\nexport function useCanvasDevtoolsRoot(c: {\n  scene: Scene<unknown, string, unknown>;\n  selection: SelectionApi;\n  viewState: CanvasViewState;\n  tools: ToolsApi;\n  /** The entries the canvas's `features` presets brought beside its tools. */\n  contributions: readonly Contribution<unknown>[];\n  routing: readonly NodeRoutingEntry[] | undefined;\n  element: MutableRefObject<HTMLElement | null>;\n  api: RefObject<CanvasExtensionApi | null>;\n  devtools: CanvasDevtools;\n}): { root: DevtoolsRoot; traces: CanvasTraces } {\n  const [traces] = useState<CanvasTraces>(() => ({\n    dispatch: createDispatchTrace(),\n    coords: createTraceRing<CoordTraceEntry>(),\n    history: createTraceRing<DevtoolsHistoryRecord>(),\n  }));\n  const actions = useActionsRegistry();\n  const deps = useDepRegistry();\n  const framed = useDevtoolsLabel();\n  const root = useDevtoolsRoot({\n    label: () => {\n      const el = c.element.current;\n      return el?.getAttribute('aria-label') || el?.id || framed\n        || el?.parentElement?.closest('[aria-label]')?.getAttribute('aria-label') || '';\n    },\n    scene: () => c.scene,\n    selection: () => c.selection.current,\n    select: (ids) => c.selection.set([...ids] as NodeId[]),\n    view: () => c.viewState.getView(),\n    activeTool: () => c.tools.active ?? null,\n    tools: () => Object.keys(c.tools.registry),\n    setTool: (id) => c.tools.setActive(id),\n    trace: traces.dispatch,\n    coords: traces.coords,\n    frame: () => c.api.current?.getDebug()?.snapshot().frame ?? null,\n    overlays: () => resolved(c.devtools.debug),\n    setOverride: (o) => c.devtools.setOverride(o),\n    subscribeView: c.viewState.subscribeView,\n    registry: () => describeRegistry({\n      tools: c.tools, contributions: c.contributions, actions, deps,\n      routingKinds: (c.routing ?? inferredNodeRouting).map((k) => k.name),\n    }),\n    subscribeRegistry(listener) {\n      // The dep registry also notifies when a source's value changes, as every selection does; only the listing is ours.\n      let listed = depListingKey(deps);\n      const onDeps = (): void => {\n        const next = depListingKey(deps);\n        if (next !== null && next === listed) return;\n        listed = next;\n        listener();\n      };\n      const offs = [actions?.subscribe(listener), deps.subscribe?.(onDeps)];\n      return () => { for (const off of offs) off?.(); };\n    },\n    history: traces.history,\n  }, { selection: c.selection.current, tool: c.tools.active ?? null });\n  useEffect(() => recordHistory(c.scene.history, traces.history), [c.scene, traces.history]);\n  const { registry, ambient } = c.tools;\n  useEffect(() => { root.notify('registry'); }, [root, registry, ambient, c.contributions, c.routing]);\n  return { root, traces };\n}\n"],"mappings":";;;;;;;;;;;AAmCA,SAAS,SAAS,OAA4D;CAC5E,IAAI,UAAU,OAAO,OAAO;CAC5B,IAAI,UAAU,QAAW,OAAO;CAChC,OAAO,OAAO,WAAW,cAAc,OAAO,gBAAgB,OAAO,SAAS,MAAM;AACtF;;AAGA,SAAS,cAAc,MAAkC;CACvD,OAAO,KAAK,OAAO,CAAC,CAAC,KAAK,MAAM,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,GAAG,EAAE,SAAS,CAAC,CAAC,KAAK,IAAQ,KAAK;AACzF;;AAGA,SAAgB,sBAAsB,GAWW;CAC/C,MAAM,CAAC,UAAU,gBAA8B;EAC7C,UAAU,oBAAoB;EAC9B,QAAQ,gBAAiC;EACzC,SAAS,gBAAuC;CAClD,EAAE;CACF,MAAM,UAAU,mBAAmB;CACnC,MAAM,OAAO,eAAe;CAC5B,MAAM,SAAS,iBAAiB;CAChC,MAAM,OAAO,gBAAgB;EAC3B,aAAa;GACX,MAAM,KAAK,EAAE,QAAQ;GACrB,OAAO,IAAI,aAAa,YAAY,KAAK,IAAI,MAAM,UAC9C,IAAI,eAAe,QAAQ,cAAc,CAAC,EAAE,aAAa,YAAY,KAAK;EACjF;EACA,aAAa,EAAE;EACf,iBAAiB,EAAE,UAAU;EAC7B,SAAS,QAAQ,EAAE,UAAU,IAAI,CAAC,GAAG,GAAG,CAAa;EACrD,YAAY,EAAE,UAAU,QAAQ;EAChC,kBAAkB,EAAE,MAAM,UAAU;EACpC,aAAa,OAAO,KAAK,EAAE,MAAM,QAAQ;EACzC,UAAU,OAAO,EAAE,MAAM,UAAU,EAAE;EACrC,OAAO,OAAO;EACd,QAAQ,OAAO;EACf,aAAa,EAAE,IAAI,SAAS,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,SAAS;EAC5D,gBAAgB,SAAS,EAAE,SAAS,KAAK;EACzC,cAAc,MAAM,EAAE,SAAS,YAAY,CAAC;EAC5C,eAAe,EAAE,UAAU;EAC3B,gBAAgB,iBAAiB;GAC/B,OAAO,EAAE;GAAO,eAAe,EAAE;GAAe;GAAS;GACzD,eAAe,EAAE,WAAW,oBAAA,CAAqB,KAAK,MAAM,EAAE,IAAI;EACpE,CAAC;EACD,kBAAkB,UAAU;GAE1B,IAAI,SAAS,cAAc,IAAI;GAC/B,MAAM,eAAqB;IACzB,MAAM,OAAO,cAAc,IAAI;IAC/B,IAAI,SAAS,QAAQ,SAAS,QAAQ;IACtC,SAAS;IACT,SAAS;GACX;GACA,MAAM,OAAO,CAAC,SAAS,UAAU,QAAQ,GAAG,KAAK,YAAY,MAAM,CAAC;GACpE,aAAa;IAAE,KAAK,MAAM,OAAO,MAAM,MAAM;GAAG;EAClD;EACA,SAAS,OAAO;CAClB,GAAG;EAAE,WAAW,EAAE,UAAU;EAAS,MAAM,EAAE,MAAM,UAAU;CAAK,CAAC;CACnE,gBAAgB,cAAc,EAAE,MAAM,SAAS,OAAO,OAAO,GAAG,CAAC,EAAE,OAAO,OAAO,OAAO,CAAC;CACzF,MAAM,EAAE,UAAU,YAAY,EAAE;CAChC,gBAAgB;EAAE,KAAK,OAAO,UAAU;CAAG,GAAG;EAAC;EAAM;EAAU;EAAS,EAAE;EAAe,EAAE;CAAO,CAAC;CACnG,OAAO;EAAE;EAAM;CAAO;AACxB"}

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