@weasel-js/core 1.10.1 → 1.11.0

package/dist/canvas/SceneCanvas/useSceneCanvasTools.js

@@ -0,0 +1,40 @@
+import { useCanvasTools, useFeatureBindings } from "./useCanvasTools.js";
+
+//#region src/canvas/SceneCanvas/useSceneCanvasTools.ts
+/** The canvas's tools, and the contributions and standard actions its presets bring. */
+function useSceneCanvasTools(args) {
+	const { props, select, scene, selection, enabled } = args;
+	const { tools, internal, takeover } = useCanvasTools({
+		select,
+		scene,
+		selection,
+		enabled,
+		tools: props.tools,
+		defaultTools: props.defaultTools,
+		toolOptions: props.toolOptions,
+		inertia: props.viewport?.inertia,
+		ambient: props.ambient,
+		pressFeedback: props.longPress?.feedback,
+		initialActiveTool: props.initialActiveTool,
+		modes: props.modes,
+		onToolsCreated: props.onToolsCreated
+	});
+	const { contributions, standardActions } = useFeatureBindings({
+		enabled,
+		pool: args.presetSource.pool,
+		tools,
+		move: args.move,
+		rotate: props.selectTool?.rotate || void 0
+	});
+	return {
+		tools,
+		internal,
+		takeover,
+		contributions,
+		standardActions
+	};
+}
+
+//#endregion
+export { useSceneCanvasTools };
+//# sourceMappingURL=useSceneCanvasTools.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSceneCanvasTools.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useSceneCanvasTools.ts"],"sourcesContent":["import type { Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Tool } from '../../tools/overlayBinding';\nimport type { EnabledPresets, FeatureBindingOptions, PresetSource } from './features';\nimport type { SceneCanvasProps } from './props';\nimport { useCanvasTools, useFeatureBindings } from './useCanvasTools';\n\ntype Props = SceneCanvasProps<unknown, string, unknown>;\n\n/** The `<SceneCanvas>` props its tools and preset bindings read. */\nexport type SceneCanvasToolProps = Pick<\n  Props,\n  | 'tools' | 'defaultTools' | 'toolOptions' | 'viewport' | 'ambient' | 'longPress'\n  | 'initialActiveTool' | 'modes' | 'onToolsCreated' | 'selectTool'\n>;\n\n/** The canvas's tools, and the contributions and standard actions its presets bring. */\nexport function useSceneCanvasTools(args: {\n  props: SceneCanvasToolProps;\n  select: Tool;\n  /** The select tool's move options, which the selection's `move` binding takes. */\n  move: unknown;\n  scene: Scene<unknown, string, unknown>;\n  selection: SelectionApi;\n  enabled: EnabledPresets;\n  presetSource: PresetSource;\n}) {\n  const { props, select, scene, selection, enabled } = args;\n  const { tools, internal, takeover } = useCanvasTools({\n    select, scene, selection,\n    enabled,\n    tools: props.tools,\n    defaultTools: props.defaultTools,\n    toolOptions: props.toolOptions,\n    inertia: props.viewport?.inertia,\n    ambient: props.ambient,\n    pressFeedback: props.longPress?.feedback,\n    initialActiveTool: props.initialActiveTool,\n    modes: props.modes,\n    onToolsCreated: props.onToolsCreated,\n  });\n  const { contributions, standardActions } = useFeatureBindings({\n    enabled, pool: args.presetSource.pool,\n    tools,\n    move: args.move as FeatureBindingOptions['move'],\n    rotate: (props.selectTool?.rotate || undefined) as FeatureBindingOptions['rotate'],\n  });\n  return { tools, internal, takeover, contributions, standardActions };\n}\n"],"mappings":";;;;AAiBA,SAAgB,oBAAoB,MASjC;CACD,MAAM,EAAE,OAAO,QAAQ,OAAO,WAAW,YAAY;CACrD,MAAM,EAAE,OAAO,UAAU,aAAa,eAAe;EACnD;EAAQ;EAAO;EACf;EACA,OAAO,MAAM;EACb,cAAc,MAAM;EACpB,aAAa,MAAM;EACnB,SAAS,MAAM,UAAU;EACzB,SAAS,MAAM;EACf,eAAe,MAAM,WAAW;EAChC,mBAAmB,MAAM;EACzB,OAAO,MAAM;EACb,gBAAgB,MAAM;CACxB,CAAC;CACD,MAAM,EAAE,eAAe,oBAAoB,mBAAmB;EAC5D;EAAS,MAAM,KAAK,aAAa;EACjC;EACA,MAAM,KAAK;EACX,QAAS,MAAM,YAAY,UAAU;CACvC,CAAC;CACD,OAAO;EAAE;EAAO;EAAU;EAAU;EAAe;CAAgB;AACrE"}

package/dist/canvas/SceneCanvas/useSceneChrome.js

@@ -1,59 +1,115 @@
-import { useOptionalViewRegistry as e } from "../viewRegistry.js";
-import { worldPointAt as t } from "./worldPointAt.js";
-import { never as n } from "../../features/chrome-caps/conditions.js";
-import { featureChromeRules as r } from "./features.js";
-import { useHoverTracking as i } from "../../features/chrome-caps/useHoverTracking.js";
-import { useChromeCaps as a } from "../../features/chrome-caps/useChromeCaps.js";
-import { useCallback as o, useMemo as s } from "react";
-import { useLatest as c } from "@weasel-js/react";
+import { useOptionalViewRegistry } from "../viewRegistry.js";
+import { worldPointAt } from "./worldPointAt.js";
+import { PRESET_OWNED_CHROME } from "./presets/chrome.js";
+import { never } from "../../features/chrome-caps/conditions.js";
+import { presetChromeRules } from "./features.js";
+import { useHoverTracking } from "../../features/chrome-caps/useHoverTracking.js";
+import { useChromeCaps } from "../../features/chrome-caps/useChromeCaps.js";
+import { useCallback, useMemo } from "react";
+import { useLatest } from "@weasel-js/react";
+
 //#region src/canvas/SceneCanvas/useSceneChrome.ts
-function l(n) {
-	let { canvasApiRef: r, viewRef: a, nodeAtPointRef: o, enabled: s } = n, c = e();
-	return i({
-		nodeAtClientPoint: (e, n) => {
-			let i = r.current;
-			if (!i) return null;
-			let s = c?.resolver.at(null, e, n), l = s?.view ?? a.current, [u, d] = t(i, s, e, n), f = s?.id == null ? void 0 : c?.list().find((e) => e.id === s.id), p = o.current?.(u, d, f ? {
-				scale: l.scale,
-				layerIsPainted: f.layerIsPainted
-			} : l);
-			return p ? { id: p.id } : null;
+/**
+* The node under the pointer, for `RuleCtx.hover`. One lookup, not a
+* client-to-world thunk beside a picker: the point and the camera its
+* tolerance converts against have to come from the same view. Hover has no
+* pointer to capture, so whichever view is under the cursor owns the point.
+*/
+function useSceneHover(args) {
+	const { canvasApiRef, viewRef, nodeAtPointRef, enabled } = args;
+	const surfaceViewRegistry = useOptionalViewRegistry();
+	return useHoverTracking({
+		nodeAtClientPoint: (clientX, clientY) => {
+			const api = canvasApiRef.current;
+			if (!api) return null;
+			const target = surfaceViewRegistry?.resolver.at(null, clientX, clientY);
+			const view = target?.view ?? viewRef.current;
+			const [x, y] = worldPointAt(api, target, clientX, clientY);
+			const reg = target?.id != null ? surfaceViewRegistry?.list().find((r) => r.id === target.id) : void 0;
+			const hit = nodeAtPointRef.current?.(x, y, reg ? {
+				scale: view.scale,
+				layerIsPainted: reg.layerIsPainted
+			} : view);
+			return hit ? { id: hit.id } : null;
 		},
-		enabled: s
+		enabled
 	});
 }
-function u(e) {
-	let { enabled: t, selectable: i, rotateOff: a, chromeVisibility: o } = e;
-	return s(() => {
-		let e = r(t);
-		return i || (e["action.marquee"] = n, e["action.lasso"] = n), a && (e["selection.rotation-handle"] = n), {
-			...e,
-			...o
+/**
+* The surface's chrome-visibility rules: the presets' defaults under the
+* consumer's `chromeVisibility`, which wins.
+*
+* An unselectable canvas hides the marquee and lasso by default: every
+* selection write no-ops there, so the select tool's empty-drag binding still
+* claims the gesture, keeping it from falling through to an ambient drag such
+* as insert, but paints nothing. `rotateOff` hides the rotation handle.
+*/
+function useChromeRules(args) {
+	const { enabled, selectable, rotateOff, chromeVisibility } = args;
+	return useMemo(() => {
+		const defaults = presetChromeRules(enabled, PRESET_OWNED_CHROME);
+		if (!selectable) {
+			defaults["action.marquee"] = never;
+			defaults["action.lasso"] = never;
+		}
+		if (rotateOff) defaults["selection.rotation-handle"] = never;
+		return {
+			...defaults,
+			...chromeVisibility
 		};
 	}, [
-		o,
-		i,
-		a,
-		t
+		chromeVisibility,
+		selectable,
+		rotateOff,
+		enabled
 	]);
 }
-function d(e) {
-	let { viewRef: t, dispatcher: n } = e, r = a(e.source), i = c(e.selection), s = o(() => ({
-		selection: i.current,
-		view: t.current,
-		action: n.getActiveAction()
+/** The chrome-caps answers for the surface's own view. */
+function useSurfaceChromeCaps(args) {
+	const { viewRef, dispatcher } = args;
+	const chromeCaps = useChromeCaps(args.source);
+	const committedSelectionRef = useLatest(args.selection);
+	const currentRuleInputs = useCallback(() => ({
+		selection: committedSelectionRef.current,
+		view: viewRef.current,
+		action: dispatcher.getActiveAction()
 	}), [
-		n,
-		i,
-		t
+		dispatcher,
+		committedSelectionRef,
+		viewRef
 	]);
 	return {
-		chromeCaps: r,
-		getIsVisible: o(() => r.isVisible(s()), [r, s]),
-		getRuleCtx: o(() => r.ruleCtx(s()), [r, s])
+		chromeCaps,
+		getIsVisible: useCallback(() => chromeCaps.isVisible(currentRuleInputs()), [chromeCaps, currentRuleInputs]),
+		getRuleCtx: useCallback(() => chromeCaps.ruleCtx(currentRuleInputs()), [chromeCaps, currentRuleInputs])
+	};
+}
+/**
+* The surface's chrome: hover tracking, the visibility rules, and the chrome-caps answers they
+* feed. `source` is the chrome-caps source minus the parts built here.
+*/
+function useSceneCanvasChrome(args) {
+	const { rules, viewRef } = args;
+	const { getHover, canvasRef: trackHoverOn } = useSceneHover({
+		...args.hover,
+		viewRef,
+		enabled: rules.chromeVisibility !== void 0
+	});
+	return {
+		...useSurfaceChromeCaps({
+			source: {
+				rules: useChromeRules(rules),
+				getHover,
+				...args.source
+			},
+			selection: args.selection,
+			viewRef,
+			dispatcher: args.dispatcher
+		}),
+		trackHoverOn
 	};
 }
-//#endregion
-export { u as useChromeRules, l as useSceneHover, d as useSurfaceChromeCaps };
 
+//#endregion
+export { useChromeRules, useSceneCanvasChrome, useSceneHover, useSurfaceChromeCaps };
 //# sourceMappingURL=useSceneChrome.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useSceneChrome.js","names":["useSceneHover","args","surfaceViewRegistry","useOptionalViewRegistry","useHoverTracking","api","canvasApiRef","target","clientX","clientY","view","viewRef","x","y","worldPointAt","reg","r","hit","nodeAtPointRef","useChromeRules","useMemo","defaults","featureChromeRules","enabled","selectable","never","rotateOff","chromeVisibility","useSurfaceChromeCaps","chromeCaps","useChromeCaps","committedSelectionRef","useLatest","currentRuleInputs","useCallback","dispatcher"],"sources":["../../../src/canvas/SceneCanvas/useSceneChrome.ts"],"sourcesContent":["import { useCallback, useMemo, type RefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Dispatcher, RuleCtx } from '@weasel-js/routing';\nimport type { NodeId } from 'core/scene/types';\nimport type { View } from 'core/viewport/view';\nimport { never, useHoverTracking, type HoverTracking, type VisibilityRules } from 'features/chrome-caps';\nimport {\n  useChromeCaps,\n  type ChromeCaps,\n  type ChromeCapsSource,\n  type ViewRuleInputs,\n} from 'features/chrome-caps/useChromeCaps';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport { useOptionalViewRegistry } from '../viewRegistry';\nimport { featureChromeRules, type BaseFeature } from './features';\nimport type { NodeAtPoint } from './useNodeAtPoint';\nimport { worldPointAt } from './worldPointAt';\n\n/**\n * The node under the pointer, for `RuleCtx.hover`. One lookup, not a\n * client-to-world thunk beside a picker: the point and the camera its\n * tolerance converts against have to come from the same view. Hover has no\n * pointer to capture, so whichever view is under the cursor owns the point.\n */\nexport function useSceneHover(args: {\n  canvasApiRef: RefObject<Pick<CanvasExtensionApi, 'clientToWorld'> | null>;\n  /** The surface's own camera, for a point no declared view claims. */\n  viewRef: { readonly current: View };\n  nodeAtPointRef: { readonly current: NodeAtPoint | undefined };\n  enabled: boolean;\n}): HoverTracking {\n  const { canvasApiRef, viewRef, nodeAtPointRef, enabled } = args;\n  const surfaceViewRegistry = useOptionalViewRegistry();\n  return useHoverTracking({\n    nodeAtClientPoint: (clientX, clientY) => {\n      const api = canvasApiRef.current;\n      if (!api) return null;\n      const target = surfaceViewRegistry?.resolver.at(null, clientX, clientY);\n      const view = target?.view ?? viewRef.current;\n      const [x, y] = worldPointAt(api, target, clientX, clientY);\n      // A view judges its own layers; the surface's gate is the picker's default.\n      const reg = target?.id != null\n        ? surfaceViewRegistry?.list().find((r) => r.id === target.id)\n        : undefined;\n      const hit = nodeAtPointRef.current?.(\n        x, y, reg ? { scale: view.scale, layerIsPainted: reg.layerIsPainted } : view,\n      );\n      return hit ? { id: hit.id as NodeId } : null;\n    },\n    enabled,\n  });\n}\n\n/**\n * The surface's chrome-visibility rules: the presets' defaults under the\n * consumer's `chromeVisibility`, which wins.\n *\n * An unselectable canvas hides the marquee and lasso by default: every\n * selection write no-ops there, so the select tool's empty-drag binding still\n * claims the gesture, keeping it from falling through to an ambient drag such\n * as insert, but paints nothing. `rotateOff` hides the rotation handle.\n */\nexport function useChromeRules(args: {\n  enabled: ReadonlySet<BaseFeature>;\n  selectable: boolean;\n  /** `selectTool.rotate === false`. */\n  rotateOff: boolean;\n  chromeVisibility: VisibilityRules | undefined;\n}): VisibilityRules {\n  const { enabled, selectable, rotateOff, chromeVisibility } = args;\n  return useMemo(() => {\n    const defaults = featureChromeRules(enabled);\n    if (!selectable) {\n      defaults['action.marquee'] = never;\n      defaults['action.lasso'] = never;\n    }\n    if (rotateOff) defaults['selection.rotation-handle'] = never;\n    return { ...defaults, ...chromeVisibility };\n  }, [chromeVisibility, selectable, rotateOff, enabled]);\n}\n\n/** The chrome-caps answers for the surface's own view. */\nexport function useSurfaceChromeCaps(args: {\n  source: ChromeCapsSource;\n  /** The selection as rendered. `SelectionApi.current` can be a live getter\n   *  that runs ahead of the commit the painted chrome was built from. */\n  selection: readonly NodeId[];\n  viewRef: { readonly current: View };\n  dispatcher: Pick<Dispatcher, 'getActiveAction'>;\n}): {\n  chromeCaps: ChromeCaps;\n  getIsVisible: () => (id: string) => boolean;\n  getRuleCtx: () => RuleCtx | undefined;\n} {\n  const { viewRef, dispatcher } = args;\n  const chromeCaps = useChromeCaps(args.source);\n  const committedSelectionRef = useLatest(args.selection);\n  const currentRuleInputs = useCallback((): ViewRuleInputs => ({\n    selection: committedSelectionRef.current,\n    view: viewRef.current,\n    action: dispatcher.getActiveAction(),\n  }), [dispatcher, committedSelectionRef, viewRef]);\n  const getIsVisible = useCallback(\n    (): ((id: string) => boolean) => chromeCaps.isVisible(currentRuleInputs()),\n    [chromeCaps, currentRuleInputs],\n  );\n  const getRuleCtx = useCallback(\n    () => chromeCaps.ruleCtx(currentRuleInputs()),\n    [chromeCaps, currentRuleInputs],\n  );\n  return { chromeCaps, getIsVisible, getRuleCtx };\n}\n"],"mappings":";;;;;;;;;AAwBA,SAAgBA,EAAc,GAMZ;CAChB,IAAM,EAAE,iBAAc,YAAS,mBAAgB,eAAYC,GACrDC,IAAsBC,EAAwB;CACpD,OAAOC,EAAiB;EACtB,oBAAoB,GAAS,MAAY;GACvC,IAAMC,IAAMC,EAAa;GACzB,IAAI,CAACD,GAAK,OAAO;GACjB,IAAME,IAASL,GAAqB,SAAS,GAAG,MAAMM,GAASC,CAAO,GAChEC,IAAOH,GAAQ,QAAQI,EAAQ,SAC/B,CAACC,GAAGC,KAAKC,EAAaT,GAAKE,GAAQC,GAASC,CAAO,GAEnDM,IAAMR,GAAQ,MAAM,OAEtB,KAAA,IADAL,GAAqB,KAAK,CAAC,CAAC,MAAM,MAAMc,EAAE,OAAOT,EAAO,EAAE,GAExDU,IAAMC,EAAe,UACzBN,GAAGC,GAAGE,IAAM;IAAE,OAAOL,EAAK;IAAO,gBAAgBK,EAAI;GAAe,IAAIL,CAC1E;GACA,OAAOO,IAAM,EAAE,IAAIA,EAAI,GAAa,IAAI;EAC1C;EACA;CACF,CAAC;AACH;AAWA,SAAgBE,EAAe,GAMX;CAClB,IAAM,EAAE,YAAS,eAAY,cAAW,wBAAqBlB;CAC7D,OAAOmB,QAAc;EACnB,IAAMC,IAAWC,EAAmBC,CAAO;EAM3C,OALKC,MACH,EAAS,oBAAoBC,GAC7B,EAAS,kBAAkBA,IAEzBC,MAAW,EAAS,+BAA+BD,IAChD;GAAE,GAAGJ;GAAU,GAAGM;EAAiB;CAC5C,GAAG;EAACA;EAAkBH;EAAYE;EAAWH;CAAO,CAAC;AACvD;AAGA,SAAgBK,EAAqB,GAWnC;CACA,IAAM,EAAE,YAAS,kBAAe3B,GAC1B4B,IAAaC,EAAc7B,EAAK,MAAM,GACtC8B,IAAwBC,EAAU/B,EAAK,SAAS,GAChDgC,IAAoBC,SAAmC;EAC3D,WAAWH,EAAsB;EACjC,MAAMpB,EAAQ;EACd,QAAQwB,EAAW,gBAAgB;CACrC,IAAI;EAACA;EAAYJ;EAAuBpB;CAAO,CAAC;CAShD,OAAO;EAAE;EAAY,cARAuB,QACcL,EAAW,UAAUI,EAAkB,CAAC,GACzE,CAACJ,GAAYI,CAAiB,CAMX;EAAc,YAJhBC,QACXL,EAAW,QAAQI,EAAkB,CAAC,GAC5C,CAACJ,GAAYI,CAAiB,CAEG;CAAW;AAChD"}
+{"version":3,"file":"useSceneChrome.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useSceneChrome.ts"],"sourcesContent":["import { useCallback, useMemo, type RefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Dispatcher, RuleCtx } from '@weasel-js/routing';\nimport type { NodeId } from 'core/scene/types';\nimport type { View } from 'core/viewport/view';\nimport { never, useHoverTracking, type HoverTracking, type VisibilityRules } from 'features/chrome-caps';\nimport {\n  useChromeCaps,\n  type ChromeCaps,\n  type ChromeCapsSource,\n  type ViewRuleInputs,\n} from 'features/chrome-caps/useChromeCaps';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport { useOptionalViewRegistry } from '../viewRegistry';\nimport { presetChromeRules, type EnabledPresets } from './features';\nimport { PRESET_OWNED_CHROME } from './presets/chrome';\nimport type { NodeAtPoint } from './useNodeAtPoint';\nimport { worldPointAt } from './worldPointAt';\n\n/**\n * The node under the pointer, for `RuleCtx.hover`. One lookup, not a\n * client-to-world thunk beside a picker: the point and the camera its\n * tolerance converts against have to come from the same view. Hover has no\n * pointer to capture, so whichever view is under the cursor owns the point.\n */\nexport function useSceneHover(args: {\n  canvasApiRef: RefObject<Pick<CanvasExtensionApi, 'clientToWorld'> | null>;\n  /** The surface's own camera, for a point no declared view claims. */\n  viewRef: { readonly current: View };\n  nodeAtPointRef: { readonly current: NodeAtPoint | undefined };\n  enabled: boolean;\n}): HoverTracking {\n  const { canvasApiRef, viewRef, nodeAtPointRef, enabled } = args;\n  const surfaceViewRegistry = useOptionalViewRegistry();\n  return useHoverTracking({\n    nodeAtClientPoint: (clientX, clientY) => {\n      const api = canvasApiRef.current;\n      if (!api) return null;\n      const target = surfaceViewRegistry?.resolver.at(null, clientX, clientY);\n      const view = target?.view ?? viewRef.current;\n      const [x, y] = worldPointAt(api, target, clientX, clientY);\n      // A view judges its own layers; the surface's gate is the picker's default.\n      const reg = target?.id != null\n        ? surfaceViewRegistry?.list().find((r) => r.id === target.id)\n        : undefined;\n      const hit = nodeAtPointRef.current?.(\n        x, y, reg ? { scale: view.scale, layerIsPainted: reg.layerIsPainted } : view,\n      );\n      return hit ? { id: hit.id as NodeId } : null;\n    },\n    enabled,\n  });\n}\n\n/**\n * The surface's chrome-visibility rules: the presets' defaults under the\n * consumer's `chromeVisibility`, which wins.\n *\n * An unselectable canvas hides the marquee and lasso by default: every\n * selection write no-ops there, so the select tool's empty-drag binding still\n * claims the gesture, keeping it from falling through to an ambient drag such\n * as insert, but paints nothing. `rotateOff` hides the rotation handle.\n */\nexport function useChromeRules(args: {\n  enabled: EnabledPresets;\n  selectable: boolean;\n  /** `selectTool.rotate === false`. */\n  rotateOff: boolean;\n  chromeVisibility: VisibilityRules | undefined;\n}): VisibilityRules {\n  const { enabled, selectable, rotateOff, chromeVisibility } = args;\n  return useMemo(() => {\n    const defaults = presetChromeRules(enabled, PRESET_OWNED_CHROME);\n    if (!selectable) {\n      defaults['action.marquee'] = never;\n      defaults['action.lasso'] = never;\n    }\n    if (rotateOff) defaults['selection.rotation-handle'] = never;\n    return { ...defaults, ...chromeVisibility };\n  }, [chromeVisibility, selectable, rotateOff, enabled]);\n}\n\n/** The chrome-caps answers for the surface's own view. */\nexport function useSurfaceChromeCaps(args: {\n  source: ChromeCapsSource;\n  /** The selection as rendered. `SelectionApi.current` can be a live getter\n   *  that runs ahead of the commit the painted chrome was built from. */\n  selection: readonly NodeId[];\n  viewRef: { readonly current: View };\n  dispatcher: Pick<Dispatcher, 'getActiveAction'>;\n}): {\n  chromeCaps: ChromeCaps;\n  getIsVisible: () => (id: string) => boolean;\n  getRuleCtx: () => RuleCtx | undefined;\n} {\n  const { viewRef, dispatcher } = args;\n  const chromeCaps = useChromeCaps(args.source);\n  const committedSelectionRef = useLatest(args.selection);\n  const currentRuleInputs = useCallback((): ViewRuleInputs => ({\n    selection: committedSelectionRef.current,\n    view: viewRef.current,\n    action: dispatcher.getActiveAction(),\n  }), [dispatcher, committedSelectionRef, viewRef]);\n  const getIsVisible = useCallback(\n    (): ((id: string) => boolean) => chromeCaps.isVisible(currentRuleInputs()),\n    [chromeCaps, currentRuleInputs],\n  );\n  const getRuleCtx = useCallback(\n    () => chromeCaps.ruleCtx(currentRuleInputs()),\n    [chromeCaps, currentRuleInputs],\n  );\n  return { chromeCaps, getIsVisible, getRuleCtx };\n}\n\n/**\n * The surface's chrome: hover tracking, the visibility rules, and the chrome-caps answers they\n * feed. `source` is the chrome-caps source minus the parts built here.\n */\nexport function useSceneCanvasChrome(args: {\n  source: Omit<ChromeCapsSource, 'rules' | 'getHover'>;\n  rules: Parameters<typeof useChromeRules>[0];\n  hover: Omit<Parameters<typeof useSceneHover>[0], 'enabled' | 'viewRef'>;\n  selection: readonly NodeId[];\n  viewRef: { readonly current: View };\n  dispatcher: Pick<Dispatcher, 'getActiveAction'>;\n}) {\n  const { rules, viewRef } = args;\n  const { getHover, canvasRef: trackHoverOn } = useSceneHover({\n    ...args.hover, viewRef, enabled: rules.chromeVisibility !== undefined,\n  });\n  const chromeRules = useChromeRules(rules);\n  const caps = useSurfaceChromeCaps({\n    source: { rules: chromeRules, getHover, ...args.source },\n    selection: args.selection,\n    viewRef,\n    dispatcher: args.dispatcher,\n  });\n  return { ...caps, trackHoverOn };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAyBA,SAAgB,cAAc,MAMZ;CAChB,MAAM,EAAE,cAAc,SAAS,gBAAgB,YAAY;CAC3D,MAAM,sBAAsB,wBAAwB;CACpD,OAAO,iBAAiB;EACtB,oBAAoB,SAAS,YAAY;GACvC,MAAM,MAAM,aAAa;GACzB,IAAI,CAAC,KAAK,OAAO;GACjB,MAAM,SAAS,qBAAqB,SAAS,GAAG,MAAM,SAAS,OAAO;GACtE,MAAM,OAAO,QAAQ,QAAQ,QAAQ;GACrC,MAAM,CAAC,GAAG,KAAK,aAAa,KAAK,QAAQ,SAAS,OAAO;GAEzD,MAAM,MAAM,QAAQ,MAAM,OACtB,qBAAqB,KAAK,CAAC,CAAC,MAAM,MAAM,EAAE,OAAO,OAAO,EAAE,IAC1D;GACJ,MAAM,MAAM,eAAe,UACzB,GAAG,GAAG,MAAM;IAAE,OAAO,KAAK;IAAO,gBAAgB,IAAI;GAAe,IAAI,IAC1E;GACA,OAAO,MAAM,EAAE,IAAI,IAAI,GAAa,IAAI;EAC1C;EACA;CACF,CAAC;AACH;;;;;;;;;;AAWA,SAAgB,eAAe,MAMX;CAClB,MAAM,EAAE,SAAS,YAAY,WAAW,qBAAqB;CAC7D,OAAO,cAAc;EACnB,MAAM,WAAW,kBAAkB,SAAS,mBAAmB;EAC/D,IAAI,CAAC,YAAY;GACf,SAAS,oBAAoB;GAC7B,SAAS,kBAAkB;EAC7B;EACA,IAAI,WAAW,SAAS,+BAA+B;EACvD,OAAO;GAAE,GAAG;GAAU,GAAG;EAAiB;CAC5C,GAAG;EAAC;EAAkB;EAAY;EAAW;CAAO,CAAC;AACvD;;AAGA,SAAgB,qBAAqB,MAWnC;CACA,MAAM,EAAE,SAAS,eAAe;CAChC,MAAM,aAAa,cAAc,KAAK,MAAM;CAC5C,MAAM,wBAAwB,UAAU,KAAK,SAAS;CACtD,MAAM,oBAAoB,mBAAmC;EAC3D,WAAW,sBAAsB;EACjC,MAAM,QAAQ;EACd,QAAQ,WAAW,gBAAgB;CACrC,IAAI;EAAC;EAAY;EAAuB;CAAO,CAAC;CAShD,OAAO;EAAE;EAAY,cARA,kBACc,WAAW,UAAU,kBAAkB,CAAC,GACzE,CAAC,YAAY,iBAAiB,CAMX;EAAc,YAJhB,kBACX,WAAW,QAAQ,kBAAkB,CAAC,GAC5C,CAAC,YAAY,iBAAiB,CAEG;CAAW;AAChD;;;;;AAMA,SAAgB,qBAAqB,MAOlC;CACD,MAAM,EAAE,OAAO,YAAY;CAC3B,MAAM,EAAE,UAAU,WAAW,iBAAiB,cAAc;EAC1D,GAAG,KAAK;EAAO;EAAS,SAAS,MAAM,qBAAqB;CAC9D,CAAC;CAQD,OAAO;EAAE,GANI,qBAAqB;GAChC,QAAQ;IAAE,OAFQ,eAAe,KAEhB;IAAa;IAAU,GAAG,KAAK;GAAO;GACvD,WAAW,KAAK;GAChB;GACA,YAAY,KAAK;EACnB,CACY;EAAM;CAAa;AACjC"}

package/dist/canvas/SceneCanvas/useSceneGestureDispatcher.js

@@ -0,0 +1,163 @@
+import { EMPTY_CHROME_STATE } from "../../core/selection/chromeState.js";
+import { useDispatchDepSources } from "../deps/dispatchSources.js";
+import { anchorStateFrom, buildAffordanceAt, buildClassifyTarget, layerAffordance } from "../affordanceAt.js";
+import { pathFromPlane } from "../planeClips.js";
+import { useOptionalViewRegistry } from "../viewRegistry.js";
+import { useKitSettingsDepSource } from "../deps/kitSettings.js";
+import { useChromeAffordances } from "./useChromeAffordances.js";
+import { useSurfaceRouting } from "./useSurfaceRouting.js";
+import { traceConversion } from "./coordTrace.js";
+import { useCallback, useInsertionEffect, useMemo, useState } from "react";
+import { useLatest } from "@weasel-js/react";
+import { createLongPressStore } from "@weasel-js/routing";
+import { useActionsRegistry, useDepRegistry, useGestureDispatcher } from "@weasel-js/routing/react";
+
+//#region src/canvas/SceneCanvas/useSceneGestureDispatcher.ts
+/** What a press on the canvas grabs: a registered layer's widget, else a piece of the
+*  selection chrome. */
+function useAffordanceAt(inputs, depRegistry, viewRegistry) {
+	const { canvasApiRef, selectionRef, boundsOf, planeOfNode, viewRef, getIsVisibleForCanvas, targetScale, handleHitRadius, edgeHandles, rotationBadge, chromeAffordancesRef } = inputs;
+	const depRegistryRef = useLatest(depRegistry);
+	const planeOfNodeRef = useLatest(planeOfNode);
+	const getAnchorState = useMemo(() => anchorStateFrom(() => depRegistryRef.current, (id, path) => pathFromPlane(path, planeOfNodeRef.current?.(id) ?? null)), [depRegistryRef, planeOfNodeRef]);
+	const affordances = useChromeAffordances({
+		targetScale,
+		handleHitRadius,
+		edgeHandles,
+		rotationBadge,
+		getAnchorState
+	});
+	useInsertionEffect(() => {
+		if (chromeAffordancesRef) chromeAffordancesRef.current = affordances;
+	});
+	const affordanceAt = useMemo(() => {
+		if (!selectionRef || !boundsOf || !viewRef) return void 0;
+		return buildAffordanceAt({
+			getChromeState: () => viewRegistry?.surface()?.chromeState() ?? EMPTY_CHROME_STATE,
+			getView: () => viewRef.current ?? {
+				x: 0,
+				y: 0,
+				scale: {
+					x: 1,
+					y: 1
+				}
+			},
+			affordances,
+			...getIsVisibleForCanvas ? { getIsVisible: () => getIsVisibleForCanvas() } : {}
+		});
+	}, [
+		selectionRef,
+		boundsOf,
+		viewRef,
+		affordances,
+		getIsVisibleForCanvas,
+		viewRegistry
+	]);
+	return useMemo(() => {
+		return (worldPoint) => {
+			const extra = canvasApiRef.current?.hitTestExtras?.(worldPoint.x, worldPoint.y);
+			if (extra) return layerAffordance(extra.layerId, extra.hit);
+			return affordanceAt ? affordanceAt(worldPoint) : null;
+		};
+	}, [affordanceAt, canvasApiRef]);
+}
+/** Which body a world point lands on, its selection state, and its routing kind. */
+function useClassifyTarget(inputs, kindOfNodeRef) {
+	const { selectionRef, pickEvery, pickBest, viewRef } = inputs;
+	const pickEveryRef = useLatest(pickEvery);
+	const pickBestRef = useLatest(pickBest);
+	const doubleClickNamesRef = useLatest(inputs.doubleClickNames);
+	return useMemo(() => {
+		if (!selectionRef || !pickEvery || !viewRef) return void 0;
+		return buildClassifyTarget(() => selectionRef.current?.current ?? [], (wx, wy) => {
+			if (pickBestRef.current) return pickBestRef.current(wx, wy);
+			const ids = pickEveryRef.current?.(wx, wy) ?? [];
+			return ids.length > 0 ? ids[ids.length - 1] : null;
+		}, (id) => kindOfNodeRef.current?.(id), (id) => doubleClickNamesRef.current?.(id) ?? id);
+	}, [
+		selectionRef,
+		pickEvery,
+		viewRef,
+		pickBestRef,
+		pickEveryRef,
+		kindOfNodeRef,
+		doubleClickNamesRef
+	]);
+}
+/** Runs this canvas's gesture dispatcher over its tools, contributions, and chrome. */
+function useSceneGestureDispatcher(inputs) {
+	const { canvasRef, canvasApiRef, tools, contributions, enabled, keyboard, claimKeys, viewRef, kindOfNode, dispatcher, getRuleCtx, onDoubleClick, onClick, longPress: { duration: longPressDuration, haptics: longPressHaptics } = {} } = inputs;
+	const registry = useActionsRegistry();
+	const depRegistry = useDepRegistry();
+	const viewRegistry = useOptionalViewRegistry();
+	const entriesById = useMemo(() => {
+		const m = /* @__PURE__ */ new Map();
+		for (const [id, tool] of Object.entries(tools.registry)) m.set(id, tool);
+		for (const entry of contributions) m.set(entry.id, entry);
+		for (const entry of tools.ambient) m.set(entry.id, entry);
+		return m;
+	}, [
+		tools.registry,
+		tools.ambient,
+		contributions
+	]);
+	const kindOfNodeRef = useLatest(kindOfNode);
+	const affordanceWithLayers = useAffordanceAt(inputs, depRegistry, viewRegistry);
+	const classifyTarget = useClassifyTarget(inputs, kindOfNodeRef);
+	const clientToWorld = useCallback((clientX, clientY) => {
+		const api = canvasApiRef.current;
+		const [x, y] = api ? api.clientToWorld(clientX, clientY) : [clientX, clientY];
+		const world = {
+			x,
+			y
+		};
+		traceConversion(clientX, clientY, api ? canvasRef.current : null, viewRef?.current, world);
+		return world;
+	}, [
+		canvasRef,
+		canvasApiRef,
+		viewRef
+	]);
+	const requestRedraw = useCallback(() => {
+		canvasApiRef.current?.requestRedraw?.();
+	}, [canvasApiRef]);
+	const paintedCursor = useCallback(() => canvasApiRef.current?.paintedCursor, [canvasApiRef]);
+	const cursorSink = useCallback(() => canvasApiRef.current?.cursorSink, [canvasApiRef]);
+	const [longPressState] = useState(createLongPressStore);
+	const longPress = useMemo(() => ({
+		state: longPressState,
+		...longPressDuration !== void 0 ? { duration: longPressDuration } : {},
+		...longPressHaptics !== void 0 ? { haptics: longPressHaptics } : {}
+	}), [
+		longPressState,
+		longPressDuration,
+		longPressHaptics
+	]);
+	const routing = useSurfaceRouting(viewRegistry);
+	useGestureDispatcher({
+		canvasRef,
+		actions: registry,
+		entriesById,
+		enabled,
+		keyboard,
+		claimKeys,
+		affordanceAt: affordanceWithLayers,
+		classifyTarget,
+		dispatcher,
+		clientToWorld,
+		requestRedraw,
+		paintedCursor,
+		cursorSink,
+		getRuleCtx,
+		onClick,
+		onDoubleClick,
+		longPress,
+		...routing
+	});
+	useDispatchDepSources(longPressState, classifyTarget, kindOfNodeRef);
+	useKitSettingsDepSource();
+}
+
+//#endregion
+export { useSceneGestureDispatcher };
+//# sourceMappingURL=useSceneGestureDispatcher.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSceneGestureDispatcher.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useSceneGestureDispatcher.ts"],"sourcesContent":["import { useLatest } from '@weasel-js/react';\nimport { createLongPressStore, type Dispatcher } from '@weasel-js/routing';\nimport { useActionsRegistry, useDepRegistry, useGestureDispatcher, type DepRegistry } from '@weasel-js/routing/react';\nimport type { Affordance } from 'affordances/types';\nimport { EMPTY_CHROME_STATE } from 'core/selection/chromeState';\nimport type { View } from 'core/viewport/view';\nimport type { RuleCtx } from 'features/chrome-caps';\nimport type React from 'react';\nimport { useCallback, useInsertionEffect, useMemo, useState } from 'react';\nimport type { Contribution } from '../../tools/overlayBinding';\nimport type { ToolsApi } from '../../tools/overlayBinding';\nimport { useDispatchDepSources } from '../deps/dispatchSources';\nimport { anchorStateFrom, buildAffordanceAt, buildClassifyTarget, layerAffordance } from '../affordanceAt';\nimport { useChromeAffordances } from './useChromeAffordances';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport { useKitSettingsDepSource } from '../deps/kitSettings';\nimport { pathFromPlane } from '../planeClips';\nimport { useOptionalViewRegistry, type ViewRegistry } from '../viewRegistry';\nimport { useSurfaceRouting } from './useSurfaceRouting';\nimport { traceConversion } from './coordTrace';\nimport type { SceneCanvasLongPress } from './props';\n\n/** What `<SceneCanvas>` hands {@link useSceneGestureDispatcher}. */\nexport interface SceneGestureDispatcherInputs {\n  canvasRef: React.RefObject<HTMLElement | null>;\n  /** Holds the full `CanvasExtensionApi` so the gesture dispatcher can call\n   *  `requestRedraw()` between pointer events. */\n  canvasApiRef: React.RefObject<CanvasExtensionApi | null>;\n  tools: ToolsApi;\n  /** Always-live entries the canvas installs beside `tools` — the selection's\n   *  `move` / `transform` bindings. Ahead of the tools' ambient entries, so a\n   *  tie at one specificity goes to the kit's. */\n  contributions: readonly Contribution[];\n  enabled: boolean;\n  /** When false, the dispatcher leaves keyboard listeners unattached so\n   *  keyboard-bound actions never fire. Wired to `enableKeybindings`. */\n  keyboard: boolean;\n  /** Take the keyboard on mount. Wired to `claimKeys`. */\n  claimKeys: boolean;\n  selectionRef?: React.RefObject<import('core/selection/useSelection').SelectionApi>;\n  boundsOf?: (id: string) => import('core/viewport/fitViewToBounds').Bounds | null;\n  /** The parallax plane a node is drawn through, under the surface's camera —\n   *  so path anchors are hit where the plane draws them. */\n  planeOfNode?: (id: string) => import('core/viewport/parallax').PlaneMap | null;\n  pickEvery?: (worldX: number, worldY: number) => string[];\n  /** Single topmost hit (collapses parent/child via `pickTopMostHit`), used to\n   *  classify the body under the pointer. Must match the select tool's own\n   *  resolution so a child node isn't misclassified by its parent's selection.\n   *  Falls back to `pickEvery`'s last id when absent. */\n  pickBest?: (worldX: number, worldY: number) => string | null;\n  /** Resolves a hit node id to its routing-trait kind, so the body\n   *  classification carries `kind` alongside `bodyTarget` and the\n   *  `kind:<k>` / `kind:<k>:selected` target forms can match. Absent when\n   *  the consumer opted out of routing (`routing={[]}`). */\n  kindOfNode?: (id: string) => string | undefined;\n  /** The node a double-click on a hit names (`doubleClickTarget`), for the classification. */\n  doubleClickNames?: (hitId: string) => string;\n  viewRef?: React.RefObject<View>;\n  /** Pre-created dispatcher to pump events into. When omitted,\n   *  `useGestureDispatcher` creates one internally (legacy path). */\n  dispatcher?: Dispatcher;\n  /** Chrome-caps visibility resolver factory. Threaded into\n   *  `buildAffordanceAt` so the hit-test pipeline gates corner / rotate /\n   *  anchor affordances on the same chrome ids the renderer uses. */\n  getIsVisibleForCanvas?: () => (id: string) => boolean;\n  /** Live RuleCtx factory. Threaded into `useGestureDispatcher` so the\n   *  dispatcher's eligibility filter sees the same mode/capabilities/selection\n   *  view of the world that chrome-caps does. */\n  getRuleCtx?: () => RuleCtx | undefined;\n  /** `DeviceProfile.targetScale`, so the affordance grab zones resolve to the\n   *  same sizes the chrome paints at. */\n  targetScale?: number;\n  /** Consumer override for the corner-handle grab radius\n   *  (`selectTool.handleHitRadius`). Undefined takes the device-scaled size. */\n  handleHitRadius?: number;\n  /** `selectTool.resize.edgeHandles`: resize handles at the edge midpoints. Default true. */\n  edgeHandles?: boolean;\n  /** The rotate badge the selection overlay paints, grabbable where drawn. */\n  rotationBadge?: { distancePx: number; sizePx: number } | null;\n  /** Receives the affordances this mounter hit-tests, for the slops overlay. */\n  chromeAffordancesRef?: React.MutableRefObject<readonly Affordance[]>;\n  /** Fires on every synthesized double click, in world coords. Backs the\n   *  `onDoubleClick` prop — see the option's doc on\n   *  `UseGestureDispatcherOptions` for why it's an observer, not a binding. */\n  onDoubleClick?: (world: { x: number; y: number }) => void;\n  /** Fires after every synthesized click. Backs the `onClick` prop. */\n  onClick?: (world: { x: number; y: number }) => void;\n  /** Backs `<SceneCanvas longPress>`. */\n  longPress?: SceneCanvasLongPress;\n}\n\ntype AffordanceInputs = Pick<\n  SceneGestureDispatcherInputs,\n  | 'canvasApiRef' | 'selectionRef' | 'boundsOf' | 'planeOfNode' | 'viewRef' | 'getIsVisibleForCanvas'\n  | 'targetScale' | 'handleHitRadius' | 'edgeHandles' | 'rotationBadge' | 'chromeAffordancesRef'\n>;\n\n/** What a press on the canvas grabs: a registered layer's widget, else a piece of the\n *  selection chrome. */\nfunction useAffordanceAt(inputs: AffordanceInputs, depRegistry: DepRegistry, viewRegistry: ViewRegistry | null) {\n  const {\n    canvasApiRef, selectionRef, boundsOf, planeOfNode, viewRef, getIsVisibleForCanvas,\n    targetScale, handleHitRadius, edgeHandles, rotationBadge, chromeAffordancesRef,\n  } = inputs;\n  // `getAnchorState` thunk for `buildAffordanceAt` — reads the live\n  // `editAnchors` dep from the registry at call time.\n  const depRegistryRef = useLatest(depRegistry);\n  const planeOfNodeRef = useLatest(planeOfNode);\n  const getAnchorState = useMemo(() => anchorStateFrom(\n    () => depRegistryRef.current,\n    (id, path) => pathFromPlane(path, planeOfNodeRef.current?.(id) ?? null),\n  ), [depRegistryRef, planeOfNodeRef]);\n\n  // Build the `affordanceAt` thunk. Takes world coords and delegates to\n  // `buildAffordanceAt` for handle hit-testing.\n  const affordances = useChromeAffordances({ targetScale, handleHitRadius, edgeHandles, rotationBadge, getAnchorState });\n  useInsertionEffect(() => {\n    if (chromeAffordancesRef) chromeAffordancesRef.current = affordances;\n  });\n  const affordanceAt = useMemo(() => {\n    if (!selectionRef || !boundsOf || !viewRef) return undefined;\n    return buildAffordanceAt({\n      // The canvas's own view chrome, built once by its helpers — not a\n      // second construction here that has to agree with the painted one.\n      getChromeState: () => viewRegistry?.surface()?.chromeState() ?? EMPTY_CHROME_STATE,\n      // Radii are declared in screen pixels and converted against this view.\n      getView: () => viewRef.current ?? { x: 0, y: 0, scale: { x: 1, y: 1 } },\n      affordances,\n      // Chrome-caps resolver: keep the affordance hit-test in sync with what\n      // the renderer is actually painting. Without this, a click on a (no\n      // longer visible) resize handle position still classifies as a resize\n      // handle — e.g. an anchor drag in path-edit mode resizes the path's\n      // bounding box instead of moving the anchor.\n      ...(getIsVisibleForCanvas ? { getIsVisible: () => getIsVisibleForCanvas() } : {}),\n    });\n  }, [selectionRef, boundsOf, viewRef, affordances, getIsVisibleForCanvas, viewRegistry]);\n\n  return useMemo(() => {\n    // Note this is NOT gated on `affordanceAt` being built: registered layers\n    // produce affordances of their own, and a consumer with no selection\n    // chrome (a canvas that is nothing but a HUD, say) still needs those.\n    return (worldPoint: { x: number; y: number }) => {\n      // Registered layers first: they draw on top of the kit's own chrome, so\n      // they get first refusal on the point. A hit becomes an `AffordanceHit`\n      // whose kind names the layer, carrying whatever the layer's hit-test\n      // resolved — which is how `@weasel-js/hud` routes a press on one of its\n      // widgets to its own action instead of the active tool.\n      const extra = canvasApiRef.current?.hitTestExtras?.(worldPoint.x, worldPoint.y);\n      if (extra) return layerAffordance(extra.layerId, extra.hit);\n      return affordanceAt ? affordanceAt(worldPoint) : null;\n    };\n  }, [affordanceAt, canvasApiRef]);\n}\n\n/** Which body a world point lands on, its selection state, and its routing kind. */\nfunction useClassifyTarget(\n  inputs: Pick<SceneGestureDispatcherInputs, 'selectionRef' | 'pickEvery' | 'pickBest' | 'viewRef' | 'doubleClickNames'>,\n  kindOfNodeRef: { readonly current: SceneGestureDispatcherInputs['kindOfNode'] },\n) {\n  const { selectionRef, pickEvery, pickBest, viewRef } = inputs;\n  // Stable refs for the optional thunk inputs so the thunks themselves are\n  // stable function identities across renders (no need to pass them as deps).\n  const pickEveryRef = useLatest(pickEvery);\n  const pickBestRef = useLatest(pickBest);\n  const doubleClickNamesRef = useLatest(inputs.doubleClickNames);\n  // Build the `classifyTarget` thunk. Takes world coords and delegates to\n  // `buildClassifyTarget`.\n  return useMemo(() => {\n    if (!selectionRef || !pickEvery || !viewRef) return undefined;\n    return buildClassifyTarget(\n      () => selectionRef.current?.current ?? [],\n      // Use the select tool's own topmost-hit resolution (`pickTopMostHit`,\n      // which collapses parent/child) so a child body is classified by ITS\n      // OWN selection — not its parent's.\n      (wx: number, wy: number) => {\n        if (pickBestRef.current) return pickBestRef.current(wx, wy);\n        const ids = pickEveryRef.current?.(wx, wy) ?? [];\n        return ids.length > 0 ? ids[ids.length - 1] : null;\n      },\n      // Node kind comes from the routing trait — the same classifier that\n      // names `Hit.kind` — so `target: 'kind:text'` on a binding speaks the\n      // vocabulary the consumer already declared in `routing`, rather than a\n      // second one invented for bindings. `routing={[]}` opts out and leaves\n      // every `kind:` target unmatchable.\n      (id: string) => kindOfNodeRef.current?.(id),\n      (id: string) => doubleClickNamesRef.current?.(id) ?? id,\n    );\n  }, [selectionRef, pickEvery, viewRef, pickBestRef, pickEveryRef, kindOfNodeRef, doubleClickNamesRef]);\n}\n\n/** Runs this canvas's gesture dispatcher over its tools, contributions, and chrome. */\nexport function useSceneGestureDispatcher(inputs: SceneGestureDispatcherInputs): void {\n  const {\n    canvasRef, canvasApiRef, tools, contributions, enabled, keyboard, claimKeys, viewRef,\n    kindOfNode, dispatcher, getRuleCtx, onDoubleClick, onClick,\n    longPress: { duration: longPressDuration, haptics: longPressHaptics } = {},\n  } = inputs;\n  const registry = useActionsRegistry();\n  const depRegistry = useDepRegistry();\n  const viewRegistry = useOptionalViewRegistry();\n  const entriesById = useMemo<ReadonlyMap<string, Contribution>>(() => {\n    const m = new Map<string, Contribution>();\n    for (const [id, tool] of Object.entries(tools.registry)) {\n      m.set(id, tool);\n    }\n    for (const entry of contributions) m.set(entry.id, entry);\n    // Ambient entries too — their bindings assemble at ambient scope, and the\n    // dispatcher resolves them through this same map.\n    for (const entry of tools.ambient) m.set(entry.id, entry);\n    return m;\n  }, [tools.registry, tools.ambient, contributions]);\n\n  const kindOfNodeRef = useLatest(kindOfNode);\n\n  const affordanceWithLayers = useAffordanceAt(inputs, depRegistry, viewRegistry);\n  const classifyTarget = useClassifyTarget(inputs, kindOfNodeRef);\n\n  // Through the handle, so a `clientToWorld` override on the canvas applies.\n  const clientToWorld = useCallback((clientX: number, clientY: number): { x: number; y: number } => {\n    const api = canvasApiRef.current;\n    const [x, y] = api ? api.clientToWorld(clientX, clientY) : [clientX, clientY];\n    const world = { x, y };\n    traceConversion(clientX, clientY, api ? canvasRef.current : null, viewRef?.current, world);\n    return world;\n  }, [canvasRef, canvasApiRef, viewRef]);\n\n  // Stable callback that asks the canvas to redraw. Reads via ref so the\n  // identity stays stable while the underlying API binds after mount.\n  const requestRedraw = useCallback(() => {\n    canvasApiRef.current?.requestRedraw?.();\n  }, [canvasApiRef]);\n\n  // The painted tier's channel, read live for the same reason — the handle it\n  // lives on binds after mount.\n  const paintedCursor = useCallback(() => canvasApiRef.current?.paintedCursor, [canvasApiRef]);\n  const cursorSink = useCallback(() => canvasApiRef.current?.cursorSink, [canvasApiRef]);\n\n  // The pending long-press, published as the `longPress` dep for feedback.\n  const [longPressState] = useState(createLongPressStore);\n  const longPress = useMemo(() => ({\n    state: longPressState,\n    ...(longPressDuration !== undefined ? { duration: longPressDuration } : {}),\n    ...(longPressHaptics !== undefined ? { haptics: longPressHaptics } : {}),\n  }), [longPressState, longPressDuration, longPressHaptics]);\n\n  const routing = useSurfaceRouting(viewRegistry);\n\n  // Hover cursors live in `useGestureDispatcher`'s hover-cursor pump:\n  // affordance hits carry `AffordanceHit.cursor` (set by `buildAffordanceAt`),\n  // and everything else is predicted via `Dispatcher.resolveOnly` +\n  // `Action.cursor`. Nothing SceneCanvas-specific remains here.\n  useGestureDispatcher({\n    canvasRef,\n    actions: registry!,\n    entriesById,\n    enabled,\n    keyboard,\n    claimKeys,\n    affordanceAt: affordanceWithLayers,\n    classifyTarget,\n    dispatcher,\n    clientToWorld,\n    requestRedraw,\n    paintedCursor,\n    cursorSink,\n    getRuleCtx,\n    onClick,\n    onDoubleClick,\n    longPress,\n    ...routing,\n  });\n  useDispatchDepSources(longPressState, classifyTarget, kindOfNodeRef);\n  useKitSettingsDepSource();\n}\n"],"mappings":"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"}

package/dist/canvas/SceneCanvas/useScenePicking.js

@@ -0,0 +1,69 @@
+import { useOptionalViewRegistry } from "../viewRegistry.js";
+import { asNodeId } from "../../core/scene/types.js";
+import { useViewLayerGate } from "../useViewLayerGate.js";
+import { composeAlphaFor } from "../sceneSlotWiring.js";
+import { doubleClickTarget } from "../doubleClickTarget.js";
+import { useSceneAdapter } from "../useSceneAdapter.js";
+import { useNodeAtPoint } from "./useNodeAtPoint.js";
+import { useNodeKinds } from "./useNodeKinds.js";
+import { useSceneSelectTool } from "./useSceneSelectTool.js";
+import { useMemo } from "react";
+import { useLatest } from "@weasel-js/react";
+
+//#region src/canvas/SceneCanvas/useScenePicking.ts
+/**
+* The canvas's adapter and everything that answers "what is under this point": the select
+* tool's pickers and bounds, the node kinds, and the paint gates picking shares with the painter.
+*/
+function useScenePicking(args) {
+	const { scene, selection, descriptor, viewRef } = args;
+	const { geometry, routing, alphaFor, layerVisibility, layerOrder, isPointerInteractive } = args.props;
+	const { kindOf, kindOfNode } = useNodeKinds(scene, routing);
+	const composedAlphaFor = useMemo(() => composeAlphaFor(scene, alphaFor), [scene, alphaFor]);
+	const surfaceViewRegistry = useOptionalViewRegistry();
+	const viewLayerGate = useViewLayerGate(layerVisibility, layerOrder, () => surfaceViewRegistry?.surface()?.layers() ?? []);
+	const adapter = useSceneAdapter(scene, {
+		selection: selection.adapterMethods,
+		poseDescriptor: descriptor
+	});
+	const selectTool = useSceneSelectTool({
+		scene,
+		adapter,
+		poseDescriptor: descriptor,
+		geometry,
+		getView: () => viewRef.current,
+		...alphaFor ? { alphaOf: composedAlphaFor } : {},
+		...viewLayerGate ? { layerIsPainted: viewLayerGate } : {},
+		...isPointerInteractive ? { isPointerInteractive } : {},
+		selectTool: args.selectTool
+	});
+	const getNodeAtPoint = useNodeAtPoint({
+		pickBest: selectTool.pickBest,
+		nodes: adapter,
+		kindOf
+	});
+	const isolatedGroup = useLatest(args.props.isolatedGroup);
+	const doubleClickNames = useMemo(() => kindOfNode && ((hitId) => doubleClickTarget(hitId, {
+		parentOf: (id) => scene.get(asNodeId(id))?.parent ?? null,
+		kindOf: kindOfNode,
+		scope: isolatedGroup.current?.() ?? null
+	})), [
+		scene,
+		kindOfNode,
+		isolatedGroup
+	]);
+	return {
+		...selectTool,
+		adapter,
+		kindOfNode,
+		doubleClickNames,
+		getNodeAtPoint,
+		viewLayerGate,
+		/** The composed paint alpha, only when the consumer fades anything. */
+		alphaOf: alphaFor ? composedAlphaFor : void 0
+	};
+}
+
+//#endregion
+export { useScenePicking };
+//# sourceMappingURL=useScenePicking.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useScenePicking.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useScenePicking.ts"],"sourcesContent":["import { useMemo, type RefObject } from 'react';\nimport { asNodeId, type Scene } from 'core/scene/types';\nimport { useLatest } from '@weasel-js/react';\nimport { doubleClickTarget } from '../doubleClickTarget';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { View } from 'core/viewport/view';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { composeAlphaFor } from '../sceneSlotWiring';\nimport { useSceneAdapter } from '../useSceneAdapter';\nimport type { SceneCanvasProps } from './props';\nimport { useNodeAtPoint } from './useNodeAtPoint';\nimport { useNodeKinds } from './useNodeKinds';\nimport { useSceneSelectTool, type UseSceneSelectToolArgs } from './useSceneSelectTool';\nimport { useOptionalViewRegistry } from '../viewRegistry';\nimport { useViewLayerGate } from '../useViewLayerGate';\n\ntype PickingProps<TData, TLayer extends string, TPose> = Pick<\n  SceneCanvasProps<TData, TLayer, TPose>,\n  'geometry' | 'routing' | 'alphaFor' | 'layerVisibility' | 'layerOrder' | 'isPointerInteractive' | 'isolatedGroup'\n>;\n\n/**\n * The canvas's adapter and everything that answers \"what is under this point\": the select\n * tool's pickers and bounds, the node kinds, and the paint gates picking shares with the painter.\n */\nexport function useScenePicking<TData, TLayer extends string, TPose>(args: {\n  scene: Scene<TData, TLayer, TPose>;\n  selection: SelectionApi;\n  descriptor: PoseDescriptor<TPose>;\n  props: PickingProps<TData, TLayer, TPose>;\n  viewRef: RefObject<View>;\n  selectTool: UseSceneSelectToolArgs<TData, TLayer, TPose>['selectTool'];\n}) {\n  const { scene, selection, descriptor, viewRef } = args;\n  const { geometry, routing, alphaFor, layerVisibility, layerOrder, isPointerInteractive } = args.props;\n  const { kindOf, kindOfNode } = useNodeKinds(scene, routing);\n\n  // The painted alpha of a node in this view: the caller's `alphaFor` times any per-node\n  // override alpha. The pick path reads the same number the painter does, or a node faded\n  // to nothing stays clickable.\n  const composedAlphaFor = useMemo(\n    () => composeAlphaFor(scene, alphaFor),\n    [scene, alphaFor],\n  );\n  const surfaceViewRegistry = useOptionalViewRegistry();\n  const viewLayerGate = useViewLayerGate(\n    layerVisibility, layerOrder, () => surfaceViewRegistry?.surface()?.layers() ?? [],\n  );\n\n  const adapter = useSceneAdapter(scene, {\n    // `adapterMethods` is memoized; `selection` itself is a fresh object each render.\n    selection: selection.adapterMethods,\n    poseDescriptor: descriptor,\n  });\n\n  const selectTool = useSceneSelectTool({\n    scene,\n    adapter,\n    poseDescriptor: descriptor,\n    geometry,\n    // The pick tolerance is declared in screen pixels; this is what converts it.\n    getView: () => viewRef.current,\n    // Only when the consumer actually fades something. Without a prop the\n    // composed function is just the override lookup, and the source resolves\n    // that once per walk instead of once per candidate.\n    ...(alphaFor ? { alphaOf: composedAlphaFor } : {}),\n    ...(viewLayerGate ? { layerIsPainted: viewLayerGate } : {}),\n    ...(isPointerInteractive ? { isPointerInteractive } : {}),\n    selectTool: args.selectTool,\n  });\n\n  const getNodeAtPoint = useNodeAtPoint({\n    pickBest: selectTool.pickBest, nodes: adapter, kindOf,\n  });\n\n  const isolatedGroup = useLatest(args.props.isolatedGroup);\n  const doubleClickNames = useMemo(() => kindOfNode && ((hitId: string) => doubleClickTarget(hitId, {\n    parentOf: (id) => scene.get(asNodeId(id))?.parent ?? null,\n    kindOf: kindOfNode,\n    scope: isolatedGroup.current?.() ?? null,\n  })), [scene, kindOfNode, isolatedGroup]);\n\n  return {\n    ...selectTool, adapter, kindOfNode, doubleClickNames, getNodeAtPoint, viewLayerGate,\n    /** The composed paint alpha, only when the consumer fades anything. */\n    alphaOf: alphaFor ? composedAlphaFor : undefined,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAyBA,SAAgB,gBAAqD,MAOlE;CACD,MAAM,EAAE,OAAO,WAAW,YAAY,YAAY;CAClD,MAAM,EAAE,UAAU,SAAS,UAAU,iBAAiB,YAAY,yBAAyB,KAAK;CAChG,MAAM,EAAE,QAAQ,eAAe,aAAa,OAAO,OAAO;CAK1D,MAAM,mBAAmB,cACjB,gBAAgB,OAAO,QAAQ,GACrC,CAAC,OAAO,QAAQ,CAClB;CACA,MAAM,sBAAsB,wBAAwB;CACpD,MAAM,gBAAgB,iBACpB,iBAAiB,kBAAkB,qBAAqB,QAAQ,CAAC,EAAE,OAAO,KAAK,CAAC,CAClF;CAEA,MAAM,UAAU,gBAAgB,OAAO;EAErC,WAAW,UAAU;EACrB,gBAAgB;CAClB,CAAC;CAED,MAAM,aAAa,mBAAmB;EACpC;EACA;EACA,gBAAgB;EAChB;EAEA,eAAe,QAAQ;EAIvB,GAAI,WAAW,EAAE,SAAS,iBAAiB,IAAI,CAAC;EAChD,GAAI,gBAAgB,EAAE,gBAAgB,cAAc,IAAI,CAAC;EACzD,GAAI,uBAAuB,EAAE,qBAAqB,IAAI,CAAC;EACvD,YAAY,KAAK;CACnB,CAAC;CAED,MAAM,iBAAiB,eAAe;EACpC,UAAU,WAAW;EAAU,OAAO;EAAS;CACjD,CAAC;CAED,MAAM,gBAAgB,UAAU,KAAK,MAAM,aAAa;CACxD,MAAM,mBAAmB,cAAc,gBAAgB,UAAkB,kBAAkB,OAAO;EAChG,WAAW,OAAO,MAAM,IAAI,SAAS,EAAE,CAAC,CAAC,EAAE,UAAU;EACrD,QAAQ;EACR,OAAO,cAAc,UAAU,KAAK;CACtC,CAAC,IAAI;EAAC;EAAO;EAAY;CAAa,CAAC;CAEvC,OAAO;EACL,GAAG;EAAY;EAAS;EAAY;EAAkB;EAAgB;;EAEtE,SAAS,WAAW,mBAAmB;CACzC;AACF"}

package/dist/canvas/SceneCanvas/useSceneRedrawSources.js

@@ -1,23 +1,34 @@
-import { useMemo as e } from "react";
+import { useMemo } from "react";
+
 //#region src/canvas/SceneCanvas/useSceneRedrawSources.ts
-function t(t) {
-	let { supplied: n, scene: r, heldModifiers: i, animator: a, modes: o } = t;
-	return e(() => [
-		...n ?? [],
-		r,
-		r.overrides,
-		i,
-		...a ? [{ subscribe: (e) => a.onTick(e) }] : [],
-		...o ? [o] : []
+/**
+* What repaints a `<SceneCanvas>` besides its own render: the caller's
+* sources, then the canvas's. Neither a scene write nor an override write
+* renders the component, and an override write does not bump the scene version
+* either. An animator frame repaints for a `drawOne` reading
+* `animator.colorOverrides`.
+*/
+function useSceneRedrawSources(args) {
+	const { scene, heldModifiers, departures } = args;
+	const { redrawOn: supplied, animator, modes } = args.props;
+	return useMemo(() => [
+		...supplied ?? [],
+		scene,
+		scene.overrides,
+		heldModifiers,
+		...animator ? [{ subscribe: (repaint) => animator.onTick(repaint) }] : [],
+		...modes ? [modes] : [],
+		departures
 	], [
-		r,
-		i,
-		a,
-		o,
-		n
+		scene,
+		heldModifiers,
+		animator,
+		modes,
+		supplied,
+		departures
 	]);
 }
-//#endregion
-export { t as useSceneRedrawSources };
 
+//#endregion
+export { useSceneRedrawSources };
 //# sourceMappingURL=useSceneRedrawSources.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useSceneRedrawSources.js","names":["useSceneRedrawSources","args","useMemo","supplied","scene","heldModifiers","animator","repaint","modes"],"sources":["../../../src/canvas/SceneCanvas/useSceneRedrawSources.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport type { RedrawSource } from '../../core/layers/render';\n\n/**\n * What repaints a `<SceneCanvas>` besides its own render: the caller's\n * sources, then the canvas's. Neither a scene write nor an override write\n * renders the component, and an override write does not bump the scene version\n * either. An animator frame repaints for a `drawOne` reading\n * `animator.colorOverrides`.\n */\nexport function useSceneRedrawSources(args: {\n  /** `<SceneCanvas redrawOn>`. */\n  supplied: readonly RedrawSource[] | undefined;\n  scene: RedrawSource & { overrides: RedrawSource };\n  heldModifiers: RedrawSource;\n  animator: { onTick(listener: () => void): () => void } | undefined;\n  modes: RedrawSource | undefined;\n}): readonly RedrawSource[] {\n  const { supplied, scene, heldModifiers, animator, modes } = args;\n  return useMemo((): readonly RedrawSource[] => [\n    ...(supplied ?? []),\n    scene,\n    scene.overrides,\n    heldModifiers,\n    ...(animator ? [{ subscribe: (repaint: () => void) => animator.onTick(repaint) }] : []),\n    ...(modes ? [modes] : []),\n  ], [scene, heldModifiers, animator, modes, supplied]);\n}\n"],"mappings":";;AAUA,SAAgBA,EAAsB,GAOV;CAC1B,IAAM,EAAE,aAAU,UAAO,kBAAe,aAAU,aAAUC;CAC5D,OAAOC,QAAuC;EAC5C,GAAIC,KAAY,CAAC;EACjBC;EACAA,EAAM;EACNC;EACA,GAAIC,IAAW,CAAC,EAAE,YAAY,MAAwBA,EAAS,OAAOC,CAAO,EAAE,CAAC,IAAI,CAAC;EACrF,GAAIC,IAAQ,CAACA,CAAK,IAAI,CAAC;CACzB,GAAG;EAACJ;EAAOC;EAAeC;EAAUE;EAAOL;CAAQ,CAAC;AACtD"}
+{"version":3,"file":"useSceneRedrawSources.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useSceneRedrawSources.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport type { RedrawSource } from '../../core/layers/render';\n\n/**\n * What repaints a `<SceneCanvas>` besides its own render: the caller's\n * sources, then the canvas's. Neither a scene write nor an override write\n * renders the component, and an override write does not bump the scene version\n * either. An animator frame repaints for a `drawOne` reading\n * `animator.colorOverrides`.\n */\nexport function useSceneRedrawSources(args: {\n  /** `<SceneCanvas>`'s own `redrawOn`, `animator` and `modes`. */\n  props: {\n    redrawOn?: readonly RedrawSource[];\n    animator?: { onTick(listener: () => void): () => void };\n    modes?: RedrawSource;\n  };\n  scene: RedrawSource & { overrides: RedrawSource };\n  heldModifiers: RedrawSource;\n  /** The ghosts `poseTransition` shows leaving, which move each frame. */\n  departures: RedrawSource;\n}): readonly RedrawSource[] {\n  const { scene, heldModifiers, departures } = args;\n  const { redrawOn: supplied, animator, modes } = args.props;\n  return useMemo((): readonly RedrawSource[] => [\n    ...(supplied ?? []),\n    scene,\n    scene.overrides,\n    heldModifiers,\n    ...(animator ? [{ subscribe: (repaint: () => void) => animator.onTick(repaint) }] : []),\n    ...(modes ? [modes] : []),\n    departures,\n  ], [scene, heldModifiers, animator, modes, supplied, departures]);\n}\n"],"mappings":";;;;;;;;;;AAUA,SAAgB,sBAAsB,MAWV;CAC1B,MAAM,EAAE,OAAO,eAAe,eAAe;CAC7C,MAAM,EAAE,UAAU,UAAU,UAAU,UAAU,KAAK;CACrD,OAAO,cAAuC;EAC5C,GAAI,YAAY,CAAC;EACjB;EACA,MAAM;EACN;EACA,GAAI,WAAW,CAAC,EAAE,YAAY,YAAwB,SAAS,OAAO,OAAO,EAAE,CAAC,IAAI,CAAC;EACrF,GAAI,QAAQ,CAAC,KAAK,IAAI,CAAC;EACvB;CACF,GAAG;EAAC;EAAO;EAAe;EAAU;EAAO;EAAU;CAAU,CAAC;AAClE"}