@weasel-js/core 1.9.4 → 1.10.1

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) — `<SceneCanvas>` only\n * registers the ones requested via `defaultTools`.\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 { AnyTool } 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, AnyTool>;\n\n/** Synthesize the full shape-tool registry. Hooks always run; consumers\n *  decide via `wants(...)` which to register with `useTools`. */\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":["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"}

package/dist/canvas/SceneCanvas/useBuiltinTools.js

@@ -0,0 +1,21 @@
+import { useHandTool as e } from "../../tools/builtin/hand/useHandTool.js";
+import { resolveToolRegistry as t } from "./toolRegistry.js";
+import { useBuiltinShapeTools as n } 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({
+		builtins: {
+			select: i,
+			hand: u,
+			...d
+		},
+		defaultTools: o,
+		enabled: a,
+		patch: s
+	});
+}
+//#endregion
+export { r as useBuiltinTools };
+
+//# sourceMappingURL=useBuiltinTools.js.map

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

@@ -0,0 +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"}

package/dist/canvas/SceneCanvas/useCanvasCamera.js

@@ -0,0 +1,46 @@
+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";
+//#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);
+		},
+		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);
+		}
+	}), [x, S]), T = t(w, b);
+	r(() => {
+		_.current = T;
+	});
+	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])
+	};
+}
+//#endregion
+export { c as useCanvasCamera };
+
+//# sourceMappingURL=useCanvasCamera.js.map

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

@@ -0,0 +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"}

package/dist/canvas/SceneCanvas/useCanvasDispatcher.js

@@ -0,0 +1,20 @@
+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";
+//#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));
+	return {
+		dispatcher: l,
+		gestureSource: u,
+		previewIdsExtra: d,
+		previewPoseExtra: f
+	};
+}
+//#endregion
+export { o as useCanvasDispatcher };
+
+//# sourceMappingURL=useCanvasDispatcher.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasDispatcher.js","names":["useCanvasDispatcher","registryRef","useLatest","registry","dispatcherRef","useRef","createDispatcher","a","id","dispatcher","gestureSource","useState","createGestureSource","createDispatcherPreviewSources"],"sources":["../../../src/canvas/SceneCanvas/useCanvasDispatcher.ts"],"sourcesContent":["import { useRef, useState } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { createDispatcher, type ActionsRegistry, type Dispatcher } from '@weasel-js/routing';\nimport type { GestureSource } from '../gestureBounds';\nimport { createDispatcherPreviewSources, createGestureSource } from './dispatcherGestureBounds';\n\n/**\n * One `Dispatcher` for the life of a `<SceneCanvas>`, shared by the gesture\n * mounter that pumps input into it and the layers that walk its in-flight\n * handles, with the lookups those layers and `<Canvas>` read it through. It\n * resolves an action id in `registry`, read at call time.\n */\nexport function useCanvasDispatcher(registry: ActionsRegistry | null): {\n  dispatcher: Dispatcher;\n  /** In-flight preview ids, nascent-insert bounds, and the pump signal. */\n  gestureSource: GestureSource;\n  /** Ids whose committed paint an in-flight ghost hides. */\n  previewIdsExtra: () => string[];\n  /** The pose an in-flight handle proposes for an id. */\n  previewPoseExtra: (id: string) => unknown;\n} {\n  const registryRef = useLatest(registry);\n  const dispatcherRef = useRef<Dispatcher | null>(null);\n  if (!dispatcherRef.current) {\n    dispatcherRef.current = createDispatcher({\n      getAction: (id) => registryRef.current?.list().find((a) => a.id === id),\n    });\n  }\n  const dispatcher = dispatcherRef.current;\n  const [gestureSource] = useState(() => createGestureSource(() => dispatcherRef.current));\n  const [{ previewIdsExtra, previewPoseExtra }] = useState(\n    () => createDispatcherPreviewSources(() => dispatcherRef.current),\n  );\n  return { dispatcher, gestureSource, previewIdsExtra, previewPoseExtra };\n}\n"],"mappings":";;;;;AAYA,SAAgBA,EAAoB,GAQlC;CACA,IAAMC,IAAcC,EAAUC,CAAQ,GAChCC,IAAgBC,EAA0B,IAAI;CACpD,AACED,EAAc,YAAUE,EAAiB,EACvC,YAAY,MAAOL,EAAY,SAAS,KAAK,CAAC,CAAC,MAAM,MAAMM,EAAE,OAAOC,CAAE,EACxE,CAAC;CAEH,IAAMC,IAAaL,EAAc,SAC3B,CAACM,KAAiBC,QAAeC,QAA0BR,EAAc,OAAO,CAAC,GACjF,CAAC,EAAE,oBAAiB,yBAAsBO,QACxCE,QAAqCT,EAAc,OAAO,CAClE;CACA,OAAO;EAAE;EAAY;EAAe;EAAiB;CAAiB;AACxE"}

package/dist/canvas/SceneCanvas/useCanvasSelection.js

@@ -0,0 +1,16 @@
+import { useSelection as e } from "../../core/selection/useSelection.js";
+import { readOnlySelection as t } from "../../core/selection/readOnlySelection.js";
+import { usePublishSceneSelection as n } from "../../core/selection/usePublishSceneSelection.js";
+import { useMemo as r } from "react";
+//#region src/canvas/SceneCanvas/useCanvasSelection.ts
+function i(i) {
+	let { scene: a, supplied: o, options: s, selectable: c, describeKind: l } = i, u = r(() => ({
+		scene: a,
+		...s ?? {}
+	}), [a, s]), d = e(u), f = o ?? d, p = c ? f : t(f);
+	return n(a, p.current, l), p;
+}
+//#endregion
+export { i as useCanvasSelection };
+
+//# sourceMappingURL=useCanvasSelection.js.map

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

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

package/dist/canvas/SceneCanvas/useCanvasTools.js

@@ -0,0 +1,67 @@
+import { createLongPressFeedbackContribution as e } from "../../features/longPress/longPressFeedback.js";
+import { KIT_STANDARD_ACTION_IDS as t } from "../../interactions/actions/useStandardActions.js";
+import { useTools as n } from "../../tools/overlayBinding.js";
+import { featureActionIds as r, featureAmbient as i, resolveFeatures as a } from "./features.js";
+import { useBuiltinTools as o } from "./useBuiltinTools.js";
+import { useEffect as s, useMemo as c } from "react";
+import { useLatest as l } from "@weasel-js/react";
+//#region src/canvas/SceneCanvas/useCanvasTools.ts
+function u(e) {
+	return typeof e.setActive == "function";
+}
+function d(e, t) {
+	let n = (e ?? []).join("|");
+	return c(() => a(e, { viewport: t }), [n, t]);
+}
+function f(t) {
+	let { select: r, enabled: i, tools: a, defaultTools: d, toolOptions: f, inertia: p, ambient: m, initialActiveTool: h, modes: g, onToolsCreated: _ } = t, v = a && u(a) ? a : null, y = o({
+		select: r,
+		enabled: i,
+		defaultTools: d,
+		patch: a && !u(a) ? a : null,
+		toolOptions: f,
+		inertia: p
+	}), b = c(() => e(), []), x = t.pressFeedback ?? !0, S = x === !0 ? b : x || null, C = c(() => S ? [...m ?? [], S] : m ?? [], [m, S]), w = n({
+		active: h ?? ("select" in y ? "select" : null),
+		registry: y,
+		...C.length ? { ambient: C } : {},
+		...g ? { modes: g } : {}
+	}), T = v ?? w, E = l(_);
+	return s(() => {
+		E.current?.(T);
+	}, [T, E]), {
+		tools: T,
+		internal: w,
+		takeover: v
+	};
+}
+function p(e) {
+	let { enabled: n, tools: a, move: o, rotate: s } = e, l = c(() => i(n, {
+		move: o,
+		rotate: s
+	}), [
+		n,
+		o,
+		s
+	]);
+	return {
+		contributions: l,
+		standardActionsExclude: c(() => {
+			let e = r(n), i = [
+				...Object.values(a.registry),
+				...a.ambient,
+				...l
+			];
+			for (let t of i) for (let n of t.bindings ?? []) e.add(n.actionId);
+			return t.filter((t) => !e.has(t));
+		}, [
+			n,
+			a,
+			l
+		])
+	};
+}
+//#endregion
+export { f as useCanvasTools, d as useEnabledFeatures, p as useFeatureBindings };
+
+//# sourceMappingURL=useCanvasTools.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasTools.js","names":["isToolsApi","tools","useEnabledFeatures","featuresKey","features","useMemo","resolveFeatures","hasViewport","useCanvasTools","toolsProp","args","takeover","registry","useBuiltinTools","defaultPressFeedback","createLongPressFeedbackContribution","feedbackOpt","pressFeedback","mergedAmbient","ambient","internal","useTools","initialActiveTool","modes","onToolsCreatedRef","useLatest","onToolsCreated","useEffect","useFeatureBindings","contributions","featureAmbient","enabled","move","rotate","include","featureActionIds","bound","entry","b","KIT_STANDARD_ACTION_IDS","id"],"sources":["../../../src/canvas/SceneCanvas/useCanvasTools.ts"],"sourcesContent":["import { useEffect, useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { KIT_STANDARD_ACTION_IDS } from 'interactions/actions/useStandardActions';\nimport { createLongPressFeedbackContribution } from '../../features/longPress/longPressFeedback';\nimport { useTools, type Contribution, type Tool, type ToolsApi } from '../../tools/overlayBinding';\nimport {\n  featureActionIds,\n  featureAmbient,\n  resolveFeatures,\n  type BaseFeature,\n  type Feature,\n  type FeatureBindingOptions,\n} from './features';\nimport type { SceneCanvasProps } from './props';\nimport type { ToolsPatch } from './toolRegistry';\nimport { useBuiltinTools } from './useBuiltinTools';\n\ntype Props = SceneCanvasProps<unknown, string, unknown>;\n\n/** Discriminate the polymorphic `tools` prop: `ToolsApi` has `setActive`\n *  / `active` / `registry`; the patch record shape has none of those. */\nfunction isToolsApi(tools: ToolsApi | ToolsPatch): tools is ToolsApi {\n  return typeof (tools as ToolsApi).setActive === 'function';\n}\n\n/** The presets a canvas runs with. Keyed on the ids, not the array, so an\n *  inline `features={['draw']}` does not re-derive every render. */\nexport function useEnabledFeatures(\n  features: readonly Feature[] | undefined,\n  hasViewport: boolean,\n): ReadonlySet<BaseFeature> {\n  const featuresKey = (features ?? []).join('|');\n  return useMemo(\n    () => resolveFeatures(features, { viewport: hasViewport }),\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [featuresKey, hasViewport],\n  );\n}\n\n/**\n * The canvas's tools: a caller's own `ToolsApi` when the `tools` prop is one\n * (the takeover form), and otherwise the built-ins the presets and\n * `defaultTools` name, patched by a `tools` record.\n */\nexport function useCanvasTools(args: {\n  /** The canvas's select tool, which is built from its scene and pickers. */\n  select: Tool;\n  enabled: ReadonlySet<BaseFeature>;\n  tools: Props['tools'];\n  defaultTools: Props['defaultTools'];\n  toolOptions: Props['toolOptions'];\n  /** `viewport.inertia`, which is the hand tool's. */\n  inertia: NonNullable<Props['viewport']>['inertia'];\n  ambient: Props['ambient'];\n  /** `longPress.feedback`. Default true, which installs the kit's own. */\n  pressFeedback: NonNullable<Props['longPress']>['feedback'];\n  initialActiveTool: Props['initialActiveTool'];\n  modes: Props['modes'];\n  onToolsCreated: Props['onToolsCreated'];\n}): {\n  /** What the canvas routes input through: the takeover, or `internal`. */\n  tools: ToolsApi;\n  /** The canvas's own api, built whether or not a takeover replaces it. */\n  internal: ToolsApi;\n  takeover: ToolsApi | null;\n} {\n  const { select, enabled, tools: toolsProp, defaultTools, toolOptions, inertia, ambient, initialActiveTool, modes, onToolsCreated } = args;\n\n  const takeover = toolsProp && isToolsApi(toolsProp) ? toolsProp : null;\n  const registry = useBuiltinTools({\n    select,\n    enabled,\n    defaultTools,\n    patch: toolsProp && !isToolsApi(toolsProp) ? toolsProp : null,\n    toolOptions,\n    inertia,\n  });\n\n  const defaultPressFeedback = useMemo(() => createLongPressFeedbackContribution(), []);\n  const feedbackOpt = args.pressFeedback ?? true;\n  const pressFeedback = feedbackOpt === true ? defaultPressFeedback : feedbackOpt || null;\n  const mergedAmbient = useMemo(\n    () => (pressFeedback ? [...(ambient ?? []), pressFeedback] : (ambient ?? [])),\n    [ambient, pressFeedback],\n  );\n\n  const internal = useTools({\n    active: initialActiveTool ?? ('select' in registry ? 'select' : null),\n    registry,\n    ...(mergedAmbient.length ? { ambient: mergedAmbient } : {}),\n    ...(modes ? { modes } : {}),\n  });\n  const tools = takeover ?? internal;\n\n  const onToolsCreatedRef = useLatest(onToolsCreated);\n  useEffect(() => { onToolsCreatedRef.current?.(tools); }, [tools, onToolsCreatedRef]);\n\n  return { tools, internal, takeover };\n}\n\n/**\n * The presets' ambient bindings, and the kit-standard actions the canvas\n * leaves unregistered. The bindings are not tools and sit outside `tools`, so\n * they apply under a takeover too. An action is registered when a preset\n * names it or a tool or contribution on this canvas binds it: a tool brings\n * the actions it routes to, so `defaultTools={['rect']}` works under any preset.\n */\nexport function useFeatureBindings(args: {\n  enabled: ReadonlySet<BaseFeature>;\n  tools: Pick<ToolsApi, 'registry' | 'ambient'>;\n  move: FeatureBindingOptions['move'];\n  rotate: FeatureBindingOptions['rotate'];\n}): { contributions: Contribution[]; standardActionsExclude: string[] } {\n  const { enabled, tools, move, rotate } = args;\n  const contributions = useMemo<Contribution[]>(\n    () => featureAmbient(enabled, { move, rotate }),\n    [enabled, move, rotate],\n  );\n  const standardActionsExclude = useMemo(() => {\n    const include = featureActionIds(enabled);\n    const bound = [...Object.values(tools.registry), ...tools.ambient, ...contributions];\n    for (const entry of bound) {\n      for (const b of entry.bindings ?? []) include.add(b.actionId);\n    }\n    return KIT_STANDARD_ACTION_IDS.filter((id) => !include.has(id));\n  }, [enabled, tools, contributions]);\n  return { contributions, standardActionsExclude };\n}\n"],"mappings":";;;;;;;;AAqBA,SAASA,EAAW,GAAiD;CACnE,OAAO,OAAQC,EAAmB,aAAc;AAClD;AAIA,SAAgBC,EACd,GACA,GAC0B;CAC1B,IAAMC,KAAeC,KAAY,CAAC,EAAA,CAAG,KAAK,GAAG;CAC7C,OAAOC,QACCC,EAAgBF,GAAU,EAAE,UAAUG,EAAY,CAAC,GAEzD,CAACJ,GAAaI,CAAW,CAC3B;AACF;AAOA,SAAgBC,EAAe,GAqB7B;CACA,IAAM,EAAE,WAAQ,YAAS,OAAOC,GAAW,iBAAc,gBAAa,YAAS,YAAS,sBAAmB,UAAO,sBAAmBC,GAE/HC,IAAWF,KAAaT,EAAWS,CAAS,IAAIA,IAAY,MAC5DG,IAAWC,EAAgB;EAC/B;EACA;EACA;EACA,OAAOJ,KAAa,CAACT,EAAWS,CAAS,IAAIA,IAAY;EACzD;EACA;CACF,CAAC,GAEKK,IAAuBT,QAAcU,EAAoC,GAAG,CAAC,CAAC,GAC9EC,IAAcN,EAAK,iBAAiB,IACpCO,IAAgBD,MAAgB,KAAOF,IAAuBE,KAAe,MAC7EE,IAAgBb,QACbY,IAAgB,CAAC,GAAIE,KAAW,CAAC,GAAIF,CAAa,IAAKE,KAAW,CAAC,GAC1E,CAACA,GAASF,CAAa,CACzB,GAEMG,IAAWC,EAAS;EACxB,QAAQC,MAAsB,YAAYV,IAAW,WAAW;EAChE;EACA,GAAIM,EAAc,SAAS,EAAE,SAASA,EAAc,IAAI,CAAC;EACzD,GAAIK,IAAQ,EAAE,SAAM,IAAI,CAAC;CAC3B,CAAC,GACKtB,IAAQU,KAAYS,GAEpBI,IAAoBC,EAAUC,CAAc;CAGlD,OAFAC,QAAgB;EAAE,EAAkB,UAAU1B,CAAK;CAAG,GAAG,CAACA,GAAOuB,CAAiB,CAAC,GAE5E;EAAE;EAAO;EAAU;CAAS;AACrC;AASA,SAAgBI,EAAmB,GAKqC;CACtE,IAAM,EAAE,YAAS,UAAO,SAAM,cAAWlB,GACnCmB,IAAgBxB,QACdyB,EAAeC,GAAS;EAAE;EAAM;CAAO,CAAC,GAC9C;EAACA;EAASC;EAAMC;CAAM,CACxB;CASA,OAAO;EAAE;EAAe,wBARO5B,QAAc;GAC3C,IAAM6B,IAAUC,EAAiBJ,CAAO,GAClCK,IAAQ;IAAC,GAAG,OAAO,OAAOnC,EAAM,QAAQ;IAAG,GAAGA,EAAM;IAAS,GAAG4B;GAAa;GACnF,KAAK,IAAMQ,KAASD,GAClB,KAAK,IAAME,KAAKD,EAAM,YAAY,CAAC,GAAG,EAAQ,IAAIC,EAAE,QAAQ;GAE9D,OAAOC,EAAwB,QAAQ,MAAO,CAACL,EAAQ,IAAIM,CAAE,CAAC;EAChE,GAAG;GAACT;GAAS9B;GAAO4B;EAAa,CACT;CAAuB;AACjD"}

package/dist/canvas/SceneCanvas/useDispatcherOverlayLayer.js

@@ -1,128 +1,64 @@
 import { viewToTransform as e } from "../../core/viewport/view.js";
 import { worldToScreen as t } from "../../core/viewport/viewTransform.js";
-import { getImageBitmap as n } from "../../features/images/imageCache.js";
-import { OVERLAY_ROLE_STROKES as r } from "../overlayRoleStrokes.js";
-import { gestureOverlaysFrom as i, isVisibleFrom as a } from "../drawEnvelope.js";
-import { resolveOverlays as o } from "../../interactions/actions/resolveOverlays.js";
-import { ellipsePath as s, linePath as c, polygonFromPoints as l, polylineFromPoints as u, rectPath as d, regularPolygonPath as f, starPath as p } from "@weasel-js/geom";
-import { useEffect as m, useMemo as h, useReducer as g } from "react";
-import { useLatest as _ } from "@weasel-js/react";
+import { OVERLAY_ROLE_STROKES as n } from "../overlayRoleStrokes.js";
+import { gestureOverlaysFrom as r, isVisibleFrom as i } from "../drawEnvelope.js";
+import { resolveOverlays as a } from "../../interactions/actions/resolveOverlays.js";
+import { insertPreviewCommands as o } from "./insertPreviewCommands.js";
+import { polygonFromPoints as s, polylineFromPoints as c } from "@weasel-js/geom";
+import { useEffect as l, useMemo as u, useReducer as d } from "react";
+import { useLatest as f } from "@weasel-js/react";
 //#region src/canvas/SceneCanvas/useDispatcherOverlayLayer.ts
-var v = {
+var p = {
 	fill: "rgba(164, 139, 212, 0.18)",
 	stroke: "#a48bd4",
 	dash: [3, 3],
 	lineWidth: 1
-}, y = .85;
-function b(b) {
-	let { dispatcher: x, style: S } = b, C = _(S), [, w] = g((e) => e + 1, 0);
-	return m(() => {
-		if (x) return x.subscribe(w);
-	}, [x]), h(() => ({
+};
+function m(m) {
+	let { dispatcher: h, style: g } = m, _ = f(g), [, v] = d((e) => e + 1, 0);
+	return l(() => {
+		if (h) return h.subscribe(v);
+	}, [h]), u(() => ({
 		id: "dispatcher-overlay",
 		label: "Dispatcher overlay",
 		space: "screen",
-		draw: (m, h) => {
-			let g = {
-				...v,
-				...C.current ?? {}
-			}, _ = {
-				...r,
-				...C.current?.roles ?? {}
-			}, b = e(h), x = [], S = a(m), w = (e) => !S || S(e);
-			for (let e of o(i(m))) if (w(e.visibilityId)) {
+		draw: (l, u) => {
+			let d = {
+				...p,
+				..._.current ?? {}
+			}, f = {
+				...n,
+				..._.current?.roles ?? {}
+			}, m = e(u), h = [], g = i(l), v = (e) => !g || g(e);
+			for (let e of a(r(l))) if (v(e.visibilityId)) {
 				if (e.kind === "marquee") {
-					let n = e.bounds, [r, i] = t(n.x, n.y, b), a = {
+					let n = e.bounds, [r, i] = t(n.x, n.y, m), a = {
 						kind: "path",
 						path: {
 							kind: "rect",
 							x: r,
 							y: i,
-							width: n.width * h.scale.x,
-							height: n.height * h.scale.y
+							width: n.width * u.scale.x,
+							height: n.height * u.scale.y
 						},
-						fill: { color: g.fill },
+						fill: { paint: { color: d.fill } },
 						stroke: {
-							paint: { color: g.stroke },
-							width: g.lineWidth,
-							dash: g.dash
+							paint: { color: d.stroke },
+							width: d.lineWidth,
+							dash: d.dash
 						}
 					};
-					x.push(a);
+					h.push(a);
 					continue;
 				}
 				if (e.kind === "insertPreview") {
-					let r = e.bounds, i = (e, n) => {
-						let [r, i] = t(e, n, b);
-						return {
-							x: r,
-							y: i
-						};
-					}, a = (e) => e.map((e) => i(e.x, e.y)), o = (h.scale.x + h.scale.y) / 2, l = null, m = e.geometry;
-					switch (m.kind) {
-						case "box": {
-							let [i, a] = t(r.x, r.y, b), o = r.width * h.scale.x, c = r.height * h.scale.y;
-							if (e.shape === "image") {
-								let t = e.extras, r = t.preview === "outline" || !t.src ? void 0 : n(t.src);
-								r && x.push({
-									kind: "image",
-									image: r,
-									x: i,
-									y: a,
-									w: o,
-									h: c,
-									opacity: y
-								});
-							}
-							l = e.shape === "ellipse" ? s({
-								x: i,
-								y: a,
-								width: o,
-								height: c
-							}) : d(i, a, o, c);
-							break;
-						}
-						case "line":
-							l = c(i(m.a.x, m.a.y), i(m.b.x, m.b.y));
-							break;
-						case "polygon":
-							l = f(i(m.center.x, m.center.y), m.radius * o, m.sides, m.rotation);
-							break;
-						case "star":
-							l = p(i(m.center.x, m.center.y), m.outerRadius * o, m.points, m.innerRadius * o, m.rotation);
-							break;
-						case "pencil": l = u(a(m.samples));
-					}
-					if (!l) continue;
-					let _ = {
-						kind: "path",
-						path: l,
-						fill: e.shape === "line" || e.shape === "pencil" || e.shape === "image" ? void 0 : { color: g.fill },
-						stroke: {
-							paint: { color: g.stroke },
-							width: g.lineWidth,
-							dash: g.dash
-						}
-					};
-					if (x.push(_), e.anchorPoint) {
-						let t = i(e.anchorPoint.x, e.anchorPoint.y);
-						x.push({
-							kind: "path",
-							path: s({
-								x: t.x - 4,
-								y: t.y - 4,
-								width: 8,
-								height: 8
-							}),
-							fill: { color: g.stroke }
-						});
-					}
+					for (let t of o(e, u, d)) h.push(t);
 					continue;
 				}
 				if (e.kind === "lasso") {
 					let n = [];
 					for (let r of e.vertices) {
-						let [e, i] = t(r.x, r.y, b);
+						let [e, i] = t(r.x, r.y, m);
 						n.push({
 							x: e,
 							y: i
@@ -130,43 +66,43 @@ function b(b) {
 					}
 					let r = {
 						kind: "path",
-						path: l(n),
-						fill: { color: g.fill },
+						path: s(n),
+						fill: { paint: { color: d.fill } },
 						stroke: {
-							paint: { color: g.stroke },
-							width: g.lineWidth,
-							dash: g.dash
+							paint: { color: d.stroke },
+							width: d.lineWidth,
+							dash: d.dash
 						}
 					};
-					x.push(r);
+					h.push(r);
 					continue;
 				}
 				if (e.kind === "polyline") {
-					let n = _[e.role] ?? {
-						paint: { color: g.stroke },
-						width: g.lineWidth,
-						dash: g.dash
+					let n = f[e.role] ?? {
+						paint: { color: d.stroke },
+						width: d.lineWidth,
+						dash: d.dash
 					}, r = [];
 					for (let n of e.points) {
-						let [e, i] = t(n.x, n.y, b);
+						let [e, i] = t(n.x, n.y, m);
 						r.push({
 							x: e,
 							y: i
 						});
 					}
-					x.push({
+					h.push({
 						kind: "path",
-						path: u(r),
+						path: c(r),
 						stroke: n
 					});
 					continue;
 				}
 			}
-			return x.length === 0 ? [] : x;
+			return h.length === 0 ? [] : h;
 		}
-	}), [C]);
+	}), [_]);
 }
 //#endregion
-export { b as useDispatcherOverlayLayer };
+export { m as useDispatcherOverlayLayer };
 
 //# sourceMappingURL=useDispatcherOverlayLayer.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDispatcherOverlayLayer.js","names":["DEFAULT_STYLE","PREVIEW_CONTENT_OPACITY","useDispatcherOverlayLayer","args","styleRef","useLatest","style","forceRerender","useReducer","n","useEffect","dispatcher","useMemo","cfg","roles","OVERLAY_ROLE_STROKES","t","viewToTransform","view","out","isVisible","isVisibleFrom","data","passes","id","ov","resolveOverlays","gestureOverlaysFrom","b","sx","sy","worldToScreen","cmd","projectPoint","wx","wy","projectPoints","pts","p","radialScale","pathCmd","geom","sw","sh","e","bmp","getImageBitmap","ellipsePath","rectPath","linePath","regularPolygonPath","starPath","polylineFromPoints","anchorScreen","screenPts","v","polygonFromPoints","stroke","pt"],"sources":["../../../src/canvas/SceneCanvas/useDispatcherOverlayLayer.ts"],"sourcesContent":["/**\n * Dispatcher overlay render layer for `<SceneCanvas>`.\n *\n * Paints the overlay shapes the drawing view's in-flight handles publish,\n * taken off the draw envelope so a panel shows its own gesture rather than\n * the surface's. `resolveOverlays` does the reading — normalizing the drag,\n * sizing the nascent shape, dropping what is degenerate — and everything left\n * here is painting: projection into screen coordinates, the chrome-caps gate,\n * fill/stroke policy, the stroke each overlay role reads as, the anchor dot's\n * size, and the image bitmap.\n *\n * Distinct from `usePreviewGhostLayer`, which paints displaced scene-node\n * silhouettes via `previewIds()` / `previewPose(id)`. The dispatcher\n * overlay layer is for gestures whose visual feedback isn't a moved scene\n * node — marquee rect (area-select), polyline + dashed close-line (lasso),\n * and any future overlay-only chrome an action wants to render.\n *\n * Replaces the per-tool `select-overlay` rendering for the same gestures\n * once the dispatcher path is the sole driver. Until\n * then both run side-by-side; the visuals overlap exactly so the\n * user-visible result is identical.\n */\nimport { useEffect, useMemo, useReducer } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { DrawCommand, PathDrawCommand } from '../../renderer';\nimport type { CommandStroke } from '@weasel-js/paint';\nimport type { RenderLayer } from 'core/layers/render';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport {\n  polygonFromPoints,\n  polylineFromPoints,\n  rectPath,\n  ellipsePath,\n  linePath,\n  regularPolygonPath,\n  starPath,\n} from '@weasel-js/geom';\nimport { getImageBitmap } from 'features/images/imageCache';\nimport { resolveOverlays } from 'interactions/actions/resolveOverlays';\nimport { gestureOverlaysFrom, isVisibleFrom } from '../drawEnvelope';\nimport { OVERLAY_ROLE_STROKES } from '../overlayRoleStrokes';\n\n/** Style knobs for the dispatcher-overlay layer's marquee + lasso paints.\n *  Defaults match the legacy `useSelectTool` `areaSelectOverlayStyle`\n *  defaults so the visual swap is invisible to users. */\nexport interface DispatcherOverlayStyle {\n  fill?: string;\n  stroke?: string;\n  dash?: number[];\n  lineWidth?: number;\n  /** Stroke per `polyline` overlay role, merged over the kit's. A role with\n   *  no entry here and none of the kit's paints as plain chrome — the\n   *  `stroke` / `lineWidth` / `dash` above. */\n  roles?: Readonly<Record<string, CommandStroke>>;\n}\n\nconst DEFAULT_STYLE: Required<Omit<DispatcherOverlayStyle, 'roles'>> = {\n  fill: 'rgba(164, 139, 212, 0.18)',\n  stroke: '#a48bd4',\n  dash: [3, 3],\n  lineWidth: 1,\n};\n\n/** Alpha for content previewed inside an in-flight gesture. Matches the\n *  preview-ghost layer, so a dragged node and an uncommitted insert read as\n *  equally provisional. */\nconst PREVIEW_CONTENT_OPACITY = 0.85;\n\n\nexport function useDispatcherOverlayLayer(args: {\n  /** The surface's dispatcher, subscribed to only so a pump repaints. What\n   *  gets painted is the drawing view's own `getGestureOverlays()`. */\n  dispatcher: Dispatcher | null | undefined;\n  style?: DispatcherOverlayStyle;\n}): RenderLayer<unknown> {\n  const { dispatcher, style } = args;\n\n  const styleRef = useLatest(style);\n\n  // Re-render on every dispatcher pump so live overlay (marquee, lasso\n  // polyline) tracks pointermove instead of freezing on the first frame.\n  const [, forceRerender] = useReducer((n: number) => n + 1, 0);\n  useEffect(() => {\n    if (!dispatcher) return;\n    return dispatcher.subscribe(forceRerender);\n  }, [dispatcher]);\n\n  return useMemo<RenderLayer<unknown>>(\n    () => ({\n      id: 'dispatcher-overlay',\n      label: 'Dispatcher overlay',\n      space: 'screen',\n      draw: (data, view) => {\n        const cfg = { ...DEFAULT_STYLE, ...(styleRef.current ?? {}) };\n        // Merged rather than replaced: naming one role must not delete the\n        // kit's others.\n        const roles = { ...OVERLAY_ROLE_STROKES, ...(styleRef.current?.roles ?? {}) };\n        const t = viewToTransform(view);\n        const out: DrawCommand[] = [];\n\n        // Chrome-caps gate. Mirrors `composeAffordanceLayer` /\n        // `createSelectionOverlayLayer`: pull a visibility predicate off\n        // the data envelope and consult it per overlay before pushing draw\n        // commands. Absent envelope → every overlay paints. This stays on the\n        // painting side: the predicate is a property of the view's envelope,\n        // and two views of one surface may answer differently for the same\n        // in-flight gesture.\n        const isVisible = isVisibleFrom(data);\n        const passes = (id: string) => (isVisible ? isVisible(id) : true);\n\n        for (const ov of resolveOverlays(gestureOverlaysFrom(data))) {\n          if (!passes(ov.visibilityId)) continue;\n\n          if (ov.kind === 'marquee') {\n            const b = ov.bounds;\n            const [sx, sy] = worldToScreen(b.x, b.y, t);\n            const sw = b.width * view.scale.x;\n            const sh = b.height * view.scale.y;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: { kind: 'rect', x: sx, y: sy, width: sw, height: sh },\n              fill: { color: cfg.fill },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'insertPreview') {\n            const b = ov.bounds;\n            const projectPoint = (wx: number, wy: number): { x: number; y: number } => {\n              const [sx, sy] = worldToScreen(wx, wy, t);\n              return { x: sx, y: sy };\n            };\n            const projectPoints = (\n              pts: ReadonlyArray<{ x: number; y: number }>,\n            ): { x: number; y: number }[] => pts.map((p) => projectPoint(p.x, p.y));\n            // Radial shapes inscribe in a square, so a single screen-space\n            // radius needs one scale factor; average the axes.\n            const radialScale = (view.scale.x + view.scale.y) / 2;\n\n            let pathCmd: PathDrawCommand['path'] | null = null;\n            const geom = ov.geometry;\n            switch (geom.kind) {\n              case 'box': {\n                const [sx, sy] = worldToScreen(b.x, b.y, t);\n                const sw = b.width * view.scale.x;\n                const sh = b.height * view.scale.y;\n                if (ov.shape === 'image') {\n                  const e = ov.extras as Partial<{ src: string; preview: string }>;\n                  // The bitmap when it has decoded, the bare outline until then\n                  // (or when the tool opted out) — the outline is drawn either\n                  // way, so the drag always has an edge to read.\n                  const bmp = e.preview === 'outline' || !e.src\n                    ? undefined\n                    : getImageBitmap(e.src);\n                  if (bmp) {\n                    out.push({\n                      kind: 'image',\n                      image: bmp,\n                      x: sx, y: sy, w: sw, h: sh,\n                      opacity: PREVIEW_CONTENT_OPACITY,\n                    });\n                  }\n                }\n                pathCmd = ov.shape === 'ellipse'\n                  ? ellipsePath({ x: sx, y: sy, width: sw, height: sh })\n                  : rectPath(sx, sy, sw, sh);\n                break;\n              }\n              case 'line':\n                pathCmd = linePath(projectPoint(geom.a.x, geom.a.y), projectPoint(geom.b.x, geom.b.y));\n                break;\n              case 'polygon':\n                pathCmd = regularPolygonPath(\n                  projectPoint(geom.center.x, geom.center.y),\n                  geom.radius * radialScale,\n                  geom.sides,\n                  geom.rotation,\n                );\n                break;\n              case 'star':\n                pathCmd = starPath(\n                  projectPoint(geom.center.x, geom.center.y),\n                  geom.outerRadius * radialScale,\n                  geom.points,\n                  geom.innerRadius * radialScale,\n                  geom.rotation,\n                );\n                break;\n              case 'pencil':\n                // Genuinely open: `polygonFromPoints` closes the path, and the\n                // closing edge from the last sample back to the first reads as\n                // a marquee rather than as the stroke being drawn.\n                pathCmd = polylineFromPoints(projectPoints(geom.samples));\n                break;\n            }\n\n            if (!pathCmd) continue;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: pathCmd,\n              fill: ov.shape === 'line' || ov.shape === 'pencil' || ov.shape === 'image'\n                ? undefined\n                : { color: cfg.fill },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            // Anchor dot at the drag's click point. Sells the anchoring\n            // visually for radial shapes (polygon/star — no vertex sits\n            // at the AABB corner) and for center mode (dot marks the\n            // growth axis). 4 CSS-px radius, same stroke color as the\n            // ghost so it reads as part of the chrome.\n            if (ov.anchorPoint) {\n              const anchorScreen = projectPoint(ov.anchorPoint.x, ov.anchorPoint.y);\n              out.push({\n                kind: 'path',\n                path: ellipsePath({\n                  x: anchorScreen.x - 4,\n                  y: anchorScreen.y - 4,\n                  width: 8,\n                  height: 8,\n                }),\n                fill: { color: cfg.stroke },\n              });\n            }\n            continue;\n          }\n\n          if (ov.kind === 'lasso') {\n            // Project every vertex to screen coords; build a single polygon\n            // path. The polygon already closes (polygonFromPoints adds Z),\n            // which renders as the dashed \"close-line\" implicit in the\n            // legacy hook's visual. Fill paints the would-be selection\n            // region; stroke paints the polyline + close-line.\n            const screenPts: { x: number; y: number }[] = [];\n            for (const v of ov.vertices) {\n              const [sx, sy] = worldToScreen(v.x, v.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: polygonFromPoints(screenPts),\n              fill: { color: cfg.fill },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'polyline') {\n            const stroke =\n              roles[ov.role] ??\n              { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash };\n            const screenPts: { x: number; y: number }[] = [];\n            for (const pt of ov.points) {\n              const [sx, sy] = worldToScreen(pt.x, pt.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            out.push({\n              kind: 'path',\n              path: polylineFromPoints(screenPts),\n              stroke,\n            } satisfies PathDrawCommand);\n            continue;\n          }\n        }\n\n        if (out.length === 0) return [];\n        // Screen-space layer: emit commands directly. The worldToScreen\n        // projection above has already mapped every coord into CSS pixels.\n        return out;\n      },\n    }),\n    [styleRef],\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"useDispatcherOverlayLayer.js","names":["DEFAULT_STYLE","useDispatcherOverlayLayer","args","styleRef","useLatest","style","forceRerender","useReducer","n","useEffect","dispatcher","useMemo","cfg","roles","OVERLAY_ROLE_STROKES","t","viewToTransform","view","out","isVisible","isVisibleFrom","data","passes","id","ov","resolveOverlays","gestureOverlaysFrom","b","sx","sy","worldToScreen","cmd","insertPreviewCommands","screenPts","v","polygonFromPoints","stroke","pt","polylineFromPoints"],"sources":["../../../src/canvas/SceneCanvas/useDispatcherOverlayLayer.ts"],"sourcesContent":["/**\n * Dispatcher overlay render layer for `<SceneCanvas>`.\n *\n * Paints the overlay shapes the drawing view's in-flight handles publish,\n * taken off the draw envelope so a panel shows its own gesture rather than\n * the surface's. `resolveOverlays` does the reading; everything here is\n * painting.\n *\n * Distinct from `usePreviewGhostLayer`, which paints displaced scene-node\n * silhouettes. This layer is for gestures whose visual feedback isn't a moved\n * scene node — a marquee rect, a lasso polyline, an insert preview.\n */\nimport { useEffect, useMemo, useReducer } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { DrawCommand, PathDrawCommand } from '@weasel-js/renderer';\nimport type { CommandStroke } from '@weasel-js/paint';\nimport type { RenderLayer } from 'core/layers/render';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport { polygonFromPoints, polylineFromPoints } from '@weasel-js/geom';\nimport { resolveOverlays } from 'interactions/actions/resolveOverlays';\nimport { gestureOverlaysFrom, isVisibleFrom } from '../drawEnvelope';\nimport { insertPreviewCommands } from './insertPreviewCommands';\nimport { OVERLAY_ROLE_STROKES } from '../overlayRoleStrokes';\n\n/** Style knobs for the dispatcher-overlay layer's marquee + lasso paints. */\nexport interface DispatcherOverlayStyle {\n  fill?: string;\n  stroke?: string;\n  dash?: number[];\n  lineWidth?: number;\n  /** Stroke per `polyline` overlay role, merged over the kit's. A role with\n   *  no entry here and none of the kit's paints as plain chrome — the\n   *  `stroke` / `lineWidth` / `dash` above. */\n  roles?: Readonly<Record<string, CommandStroke>>;\n}\n\nconst DEFAULT_STYLE: Required<Omit<DispatcherOverlayStyle, 'roles'>> = {\n  fill: 'rgba(164, 139, 212, 0.18)',\n  stroke: '#a48bd4',\n  dash: [3, 3],\n  lineWidth: 1,\n};\n\n\n\nexport function useDispatcherOverlayLayer(args: {\n  /** The surface's dispatcher, subscribed to only so a pump repaints. What\n   *  gets painted is the drawing view's own `getGestureOverlays()`. */\n  dispatcher: Dispatcher | null | undefined;\n  style?: DispatcherOverlayStyle;\n}): RenderLayer<unknown> {\n  const { dispatcher, style } = args;\n\n  const styleRef = useLatest(style);\n\n  // Re-render on every dispatcher pump so live overlay (marquee, lasso\n  // polyline) tracks pointermove instead of freezing on the first frame.\n  const [, forceRerender] = useReducer((n: number) => n + 1, 0);\n  useEffect(() => {\n    if (!dispatcher) return;\n    return dispatcher.subscribe(forceRerender);\n  }, [dispatcher]);\n\n  return useMemo<RenderLayer<unknown>>(\n    () => ({\n      id: 'dispatcher-overlay',\n      label: 'Dispatcher overlay',\n      space: 'screen',\n      draw: (data, view) => {\n        const cfg = { ...DEFAULT_STYLE, ...(styleRef.current ?? {}) };\n        // Merged rather than replaced: naming one role must not delete the\n        // kit's others.\n        const roles = { ...OVERLAY_ROLE_STROKES, ...(styleRef.current?.roles ?? {}) };\n        const t = viewToTransform(view);\n        const out: DrawCommand[] = [];\n\n        // Chrome-caps gate. Absent envelope → every overlay paints. This stays\n        // on the painting side: the predicate is a property of the view's\n        // envelope, and two views of one surface may answer differently for\n        // the same in-flight gesture.\n        const isVisible = isVisibleFrom(data);\n        const passes = (id: string) => (isVisible ? isVisible(id) : true);\n\n        for (const ov of resolveOverlays(gestureOverlaysFrom(data))) {\n          if (!passes(ov.visibilityId)) continue;\n\n          if (ov.kind === 'marquee') {\n            const b = ov.bounds;\n            const [sx, sy] = worldToScreen(b.x, b.y, t);\n            const sw = b.width * view.scale.x;\n            const sh = b.height * view.scale.y;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: { kind: 'rect', x: sx, y: sy, width: sw, height: sh },\n              fill: { paint: { color: cfg.fill } },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'insertPreview') {\n            for (const cmd of insertPreviewCommands(ov, view, cfg)) out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'lasso') {\n            // `polygonFromPoints` closes the path, which draws the dashed\n            // close-line back to the first vertex.\n            const screenPts: { x: number; y: number }[] = [];\n            for (const v of ov.vertices) {\n              const [sx, sy] = worldToScreen(v.x, v.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: polygonFromPoints(screenPts),\n              fill: { paint: { color: cfg.fill } },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'polyline') {\n            const stroke =\n              roles[ov.role] ??\n              { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash };\n            const screenPts: { x: number; y: number }[] = [];\n            for (const pt of ov.points) {\n              const [sx, sy] = worldToScreen(pt.x, pt.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            out.push({\n              kind: 'path',\n              path: polylineFromPoints(screenPts),\n              stroke,\n            } satisfies PathDrawCommand);\n            continue;\n          }\n        }\n\n        if (out.length === 0) return [];\n        return out;\n      },\n    }),\n    [styleRef],\n  );\n}\n"],"mappings":"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"}

package/dist/canvas/SceneCanvas/useHeldModifiers.js

@@ -0,0 +1,20 @@
+import { useKeyState as e } from "../../input/useKeyState.js";
+import { useMemo as t } from "react";
+//#region src/canvas/SceneCanvas/useHeldModifiers.ts
+function n() {
+	let n = e({ skipInEditable: !1 });
+	return t(() => ({
+		get: n.modifiers,
+		subscribe(e) {
+			let t = n.modifiers();
+			return n.subscribe(() => {
+				let r = n.modifiers();
+				r !== t && (t = r, e());
+			});
+		}
+	}), [n]);
+}
+//#endregion
+export { n as useHeldModifiers };
+
+//# sourceMappingURL=useHeldModifiers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useHeldModifiers.js","names":["useHeldModifiers","keys","useKeyState","useMemo","held","now","listener"],"sources":["../../../src/canvas/SceneCanvas/useHeldModifiers.ts"],"sourcesContent":["/** The modifier keys held, for a surface's rule context. */\nimport { useMemo } from 'react';\nimport type { ModifierState } from '../../core/modifierState';\nimport type { RedrawSource } from '../../core/layers/render';\nimport { useKeyState } from '../../input/useKeyState';\n\nexport interface HeldModifiers extends RedrawSource {\n  /** Read when a rule is evaluated. The same object until a modifier changes. */\n  get(): ModifierState;\n}\n\n/** The modifiers held anywhere in the window, a text field included: a rule\n *  is asked about the keyboard, not about where focus is. `subscribe` reports\n *  a modifier going down or up and no other key. */\nexport function useHeldModifiers(): HeldModifiers {\n  const keys = useKeyState({ skipInEditable: false });\n  return useMemo(() => ({\n    get: keys.modifiers,\n    subscribe(listener) {\n      let held = keys.modifiers();\n      return keys.subscribe(() => {\n        const now = keys.modifiers();\n        if (now === held) return;\n        held = now;\n        listener();\n      });\n    },\n  }), [keys]);\n}\n"],"mappings":";;;AAcA,SAAgBA,IAAkC;CAChD,IAAMC,IAAOC,EAAY,EAAE,gBAAgB,GAAM,CAAC;CAClD,OAAOC,SAAe;EACpB,KAAKF,EAAK;EACV,UAAU,GAAU;GAClB,IAAIG,IAAOH,EAAK,UAAU;GAC1B,OAAOA,EAAK,gBAAgB;IAC1B,IAAMI,IAAMJ,EAAK,UAAU;IAC3B,AAAII,MAAQD,MACZ,IAAOC,GACPC,EAAS;GACX,CAAC;EACH;CACF,IAAI,CAACL,CAAI,CAAC;AACZ"}

package/dist/canvas/SceneCanvas/useNodeAtPoint.js

@@ -0,0 +1,26 @@
+import { makeGetNodeAtPoint as e } from "../getNodeAtPoint.js";
+import { useMemo as t } from "react";
+//#region src/canvas/SceneCanvas/useNodeAtPoint.ts
+function n(n) {
+	let { pickBest: r, nodes: i, kindOfData: a, isPointerInteractive: o } = n;
+	return t(() => {
+		if (!r) return;
+		let t = e(r, (e) => {
+			let t = i.getNode(e);
+			return t ? { kind: a ? a(t.data) : "unknown" } : null;
+		});
+		return o ? (e, n, r) => {
+			let i = t(e, n, r);
+			return i == null || o(i.id) === !1 ? null : i;
+		} : t;
+	}, [
+		i,
+		r,
+		o,
+		a
+	]);
+}
+//#endregion
+export { n as useNodeAtPoint };
+
+//# sourceMappingURL=useNodeAtPoint.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useNodeAtPoint.js","names":["useNodeAtPoint","args","useMemo","pickBest","base","makeGetNodeAtPoint","node","nodes","id","kindOfData","isPointerInteractive","hit","wx","wy","view"],"sources":["../../../src/canvas/SceneCanvas/useNodeAtPoint.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { makeGetNodeAtPoint, type NodeAtPointHit } from '../getNodeAtPoint';\nimport type { PickView } from './useSceneSelectTool';\n\nexport type NodeAtPoint = (wx: number, wy: number, view?: PickView | null) => NodeAtPointHit | null;\n\n/**\n * The node under a world point with its routing kind, resolved through the\n * select tool's own single-hit picker, so `onClick`, `onDoubleClick`, hover,\n * and tool routing all name the node a click selects. A hit whose id\n * `isPointerInteractive` rejects comes back null.\n */\nexport function useNodeAtPoint<TData>(args: {\n  pickBest: ((wx: number, wy: number, view?: PickView | null) => string | null) | undefined;\n  /** A caller's `geometry.pickEvery` can answer an id the scene does not hold. */\n  nodes: { getNode(id: string): { data: TData } | null | undefined };\n  kindOfData: ((data: TData) => string) | undefined;\n  isPointerInteractive: ((id: string) => boolean) | undefined;\n}): NodeAtPoint | undefined {\n  const { pickBest, nodes, kindOfData, isPointerInteractive } = args;\n  return useMemo(() => {\n    if (!pickBest) return undefined;\n    const base = makeGetNodeAtPoint(pickBest, (id) => {\n      const node = nodes.getNode(id);\n      if (!node) return null;\n      return { kind: kindOfData ? kindOfData(node.data) : 'unknown' };\n    });\n    if (!isPointerInteractive) return base;\n    return (wx, wy, view) => {\n      const hit = base(wx, wy, view);\n      if (hit == null) return null;\n      if (isPointerInteractive(hit.id) === false) return null;\n      return hit;\n    };\n  }, [nodes, pickBest, isPointerInteractive, kindOfData]);\n}\n"],"mappings":";;;AAYA,SAAgBA,EAAsB,GAMV;CAC1B,IAAM,EAAE,aAAU,UAAO,eAAY,4BAAyBC;CAC9D,OAAOC,QAAc;EACnB,IAAI,CAACC,GAAU;EACf,IAAMC,IAAOC,EAAmBF,IAAW,MAAO;GAChD,IAAMG,IAAOC,EAAM,QAAQC,CAAE;GAE7B,OADKF,IACE,EAAE,MAAMG,IAAaA,EAAWH,EAAK,IAAI,IAAI,UAAU,IAD5C;EAEpB,CAAC;EAED,OADKI,KACG,GAAI,GAAI,MAAS;GACvB,IAAMC,IAAMP,EAAKQ,GAAIC,GAAIC,CAAI;GAG7B,OAFIH,KAAO,QACPD,EAAqBC,EAAI,EAAE,MAAM,KAAc,OAC5CA;EACT,IANkCP;CAOpC,GAAG;EAACG;EAAOJ;EAAUO;EAAsBD;CAAU,CAAC;AACxD"}