@weasel-js/core 1.9.3 → 1.10.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"poseRegistrars.js","names":["ResizePolicyRegistrar","useResizePolicy","resizePolicyOptions","options","GeometryProjectionRegistrar","useGeometryProjection","projection"],"sources":["../../../src/canvas/SceneCanvas/poseRegistrars.tsx"],"sourcesContent":["import type { GeometryProjection } from 'interactions/actions/geometryProjection';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport {\n  resizePolicyOptions,\n  useGeometryProjection,\n  useResizePolicy\n} from '../deps';\n\n/** Subcomponent so we can conditionally render (and thus conditionally\n *  call) `useResizePolicy`. See parent's comment for why this\n *  must be gated rather than always-on. */\nexport function ResizePolicyRegistrar({\n  options,\n}: {\n  options: UseResizeOptions<unknown>;\n}) {\n  useResizePolicy<unknown>(resizePolicyOptions(options));\n  return null;\n}\n\n/** Subcomponent so we can conditionally render (and thus conditionally\n *  call) `useGeometryProjection`. Mirrors `ResizePolicyRegistrar` — the\n *  conditional mount ensures the dep is registered only when the consumer\n *  supplies a projection, so absent → dep undefined → actions stay pose-only. */\nexport function GeometryProjectionRegistrar({\n  projection,\n}: {\n  projection: GeometryProjection;\n}) {\n  useGeometryProjection(projection);\n  return null;\n}\n"],"mappings":";;;AAWA,SAAgBA,EAAsB,EACpC,cAGC;CAED,OADAC,EAAyBC,EAAoBC,CAAO,CAAC,GAC9C;AACT;AAMA,SAAgBC,EAA4B,EAC1C,iBAGC;CAED,OADAC,EAAsBC,CAAU,GACzB;AACT"}

package/dist/canvas/SceneCanvas/props.js

@@ -0,0 +1,39 @@
+import { HANDLE_BASE_PX as e, targetSizesPx as t } from "../../core/device/targets.js";
+import { defaultDrawOne as n, defaultPaintBounds as r, paintBoundsFor as i } from "../defaultDrawOne.js";
+import { KIT_SHAPE_KINDS as a } from "../../core/shapeKinds.js";
+import { isCustomEntry as o } from "../layerSlots.js";
+import "@weasel-js/routing/react";
+//#region src/canvas/SceneCanvas/props.ts
+var s = e;
+function c(e, a = 1) {
+	let s = {
+		scene: {
+			drawOne: n,
+			paintBounds: r
+		},
+		selectionOverlay: { handles: { size: t(a).handle } }
+	};
+	if (!e) return s;
+	let c = { ...e };
+	if (!("scene" in e)) c.scene = s.scene;
+	else if (e.scene === null || o(e.scene)) c.scene = e.scene;
+	else {
+		let t = {
+			...s.scene,
+			...e.scene
+		};
+		c.scene = e.scene && "paintBounds" in e.scene ? t : {
+			...t,
+			paintBounds: i(t.drawOne)
+		};
+	}
+	return c.selectionOverlay = "selectionOverlay" in e ? e.selectionOverlay === null || o(e.selectionOverlay) ? e.selectionOverlay : {
+		...s.selectionOverlay,
+		...e.selectionOverlay
+	} : s.selectionOverlay, c;
+}
+var l = ["select", "hand"], u = [...l, ...a];
+//#endregion
+export { u as BUILTIN_TOOL_IDS, s as DEFAULT_HANDLE_SIZE, l as NON_SHAPE_BUILTIN_TOOLS, c as mergeLayersWithDefaults };
+
+//# sourceMappingURL=props.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"props.js","names":["DEFAULT_HANDLE_SIZE","HANDLE_BASE_PX","mergeLayersWithDefaults","defaults","defaultDrawOne","defaultPaintBounds","targetSizesPx","targetScale","user","result","isCustomEntry","scene","paintBoundsFor","NON_SHAPE_BUILTIN_TOOLS","BUILTIN_TOOL_IDS","KIT_SHAPE_KINDS"],"sources":["../../../src/canvas/SceneCanvas/props.ts"],"sourcesContent":["import type { ModeRegistry } from '@weasel-js/modes';\nimport type { PathEditHost } from './pathEditHost';\nimport type { Paint } from '@weasel-js/paint';\nimport type { ActionsProp } from '@weasel-js/routing';\nimport { Yoke } from '@weasel-js/routing/react';\nimport type { PasteOmission } from 'core/adapters/types';\nimport type { Op } from 'core/ops/types';\nimport type { Node, Scene, SerializedScene } from 'core/scene/types';\nimport type { SelectionApi, UseSelectionOptions } from 'core/selection/useSelection';\nimport { KIT_SHAPE_KINDS, type BuiltinShapeToolId } from 'core/shapeKinds';\nimport type { InertiaConfig } from 'core/viewport/useDecayLoop';\nimport type { View } from 'core/viewport/view';\nimport type {\n  ContentHandlerEntry\n} from 'features/ingestion';\nimport type { PinchZoomOptions } from 'interactions/actions/defaults/pinchZoom';\nimport type { WheelPanOptions } from 'interactions/actions/defaults/viewportWheelPan';\nimport type { ViewportZoomAnimateOptions, ViewportZoomOptions } from 'interactions/actions/defaults/viewportZoom';\nimport type { SvgIngestOptions } from 'interactions/actions/depSchema';\nimport type { GeometryProjection } from 'interactions/actions/geometryProjection';\nimport type { UseMoveOptions } from 'interactions/actions/move/options';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport type { UseRotateOptions } from 'interactions/actions/rotate/options';\nimport type { SnapStrategy } from 'interactions/gestures/types';\nimport type { ReactNode } from 'react';\nimport type { Bounds } from 'tools/builtin/select';\nimport type { Animator } from '@weasel-js/animator';\nimport { HANDLE_BASE_PX, targetSizesPx } from '../../core/device/targets';\nimport type { DeviceProfile } from '../../core/device/types';\nimport type { NodeRoutingEntry } from '../../core/scene/NodeRouting';\nimport type { DebugConfig } from '../../debug/types';\nimport type { LayoutDropTargetMode, ReflowTransition } from '../../layout/types';\nimport type { DrawCommand, ShaderProgramHandle } from '@weasel-js/renderer';\nimport type { Tool, ToolsApi } from '../../tools/overlayBinding';\nimport type { SceneSlotConfig } from '../buildSceneLayer';\nimport type { CanvasProps } from '../Canvas';\nimport { isCustomEntry, type LayersMap } from '../layerSlots';\nimport type { CanvasViewProps } from '../CanvasView';\nimport { defaultDrawOne, defaultPaintBounds, paintBoundsFor } from '../defaultDrawOne';\nimport type {\n  InsertNodeFactory,\n  InsertPaint\n} from '../deps';\nimport type { SceneToAdapterOptions } from '../sceneAdapter';\nimport type { SurfaceContribution } from '../surfaceContribution';\nimport type { CameraProps } from '../useCanvasView';\nimport type {\n  Feature\n} from './features';\nimport type { BuiltinToolOptions } from './useBuiltinShapeTools';\nimport type { VersionCheck } from './useContributionRoles';\n\n/** The adapter surface delete / duplicate / group / ungroup need, narrowed from\n *  `SceneCanvasAdapter` because `StandardActionsRegistrar` is non-generic. */\nexport interface BridgeAdapter {\n  applyOps(ops: Op[], label?: string): void;\n  insertNode(node: { id: string; [k: string]: unknown }): void;\n  removeNode(id: string): void;\n  setSelection(ids: string[]): void;\n}\n\n/** Default size in CSS pixels for selection corner-handles AND their\n *  hit-test radius, at `targetScale = 1`. Deliberately unscaled; kit-internal\n *  use sites multiply by `DeviceProfile.targetScale`. */\nexport const DEFAULT_HANDLE_SIZE = HANDLE_BASE_PX;\n\n/** `<SceneCanvas longPress>`. */\nexport interface SceneCanvasLongPress {\n  /**\n   * Shown while a long-press is held and some binding would fire on it.\n   * Default: a ring that fills around the press point\n   * (`createLongPressFeedbackContribution()`), static under\n   * `prefers-reduced-motion`. `false` shows nothing; a contribution replaces\n   * it, reading the `longPress` dep. Installed beside `ambient`, so under a\n   * `tools` takeover add it to your own `useTools` call instead.\n   */\n  feedback?: boolean | SurfaceContribution;\n  /** Default true. A long-press some binding handled pulses\n   *  `navigator.vibrate` briefly, for touch and pen, where the API exists. */\n  haptics?: boolean;\n  /** Hold time in ms. Default `LONG_PRESS_MS` (500). */\n  duration?: number;\n}\n\n/** `<SceneCanvas layers>`: a {@link LayersMap} whose scene slot may be partial,\n *  since the defaults fill in whatever it leaves out. */\nexport type SceneCanvasLayers<TNode extends { id: string }, TPose> = LayersMap<\n  TNode,\n  TPose,\n  Partial<SceneSlotConfig<TNode, TPose>>\n>;\n\n/** Deep-merge user-supplied `layers` with kit defaults. Slots the user\n *  doesn't mention get filled with defaults; slots explicitly set to\n *  `null` are dropped. Partial slot configs are shallow-spread on top of the\n *  default slot config. `targetScale` comes from the resolved {@link DeviceProfile}. */\nexport function mergeLayersWithDefaults<TData, TLayer extends string, TPose>(\n  user: SceneCanvasLayers<Node<TData, TLayer, TPose>, TPose> | undefined,\n  targetScale = 1,\n): LayersMap<Node<TData, TLayer, TPose>, TPose> {\n  const defaults = {\n    scene: {\n      drawOne: defaultDrawOne as (\n        node: Node<TData, TLayer, TPose>,\n        pose: TPose,\n      ) => DrawCommand[],\n      paintBounds: defaultPaintBounds<TData, TLayer, TPose>,\n    },\n    selectionOverlay: { handles: { size: targetSizesPx(targetScale).handle } },\n  };\n\n  if (!user) return defaults as LayersMap<Node<TData, TLayer, TPose>, TPose>;\n\n  // Start from a shallow copy of the user map so unknown slots pass through.\n  const result = { ...user } as LayersMap<Node<TData, TLayer, TPose>, TPose>;\n\n  if (!('scene' in user)) {\n    result.scene = defaults.scene;\n  } else if (user.scene === null || isCustomEntry(user.scene)) {\n    result.scene = user.scene;\n  } else {\n    const scene = { ...defaults.scene, ...user.scene };\n    result.scene = user.scene && 'paintBounds' in user.scene\n      ? scene\n      : { ...scene, paintBounds: paintBoundsFor<TData, TLayer, TPose>(scene.drawOne) };\n  }\n\n  if (!('selectionOverlay' in user)) {\n    result.selectionOverlay = defaults.selectionOverlay;\n  } else if (user.selectionOverlay === null || isCustomEntry(user.selectionOverlay)) {\n    result.selectionOverlay = user.selectionOverlay;\n  } else {\n    result.selectionOverlay = { ...defaults.selectionOverlay, ...user.selectionOverlay };\n  }\n\n  return result;\n}\n\n/** Built-in tool ids SceneCanvas knows how to mount when no `tools` prop\n *  is supplied, via `defaultTools`. */\nexport type BuiltinToolId = 'select' | 'hand' | BuiltinShapeToolId;\n\n/** Built-in tool ids that aren't shape tools — the ones with no entry in\n *  the `core/shapeKinds` table. */\nexport const NON_SHAPE_BUILTIN_TOOLS: readonly Exclude<BuiltinToolId, BuiltinShapeToolId>[] = ['select', 'hand'];\n\n/** Every built-in tool id, shape tools included. */\nexport const BUILTIN_TOOL_IDS: readonly BuiltinToolId[] = [...NON_SHAPE_BUILTIN_TOOLS, ...KIT_SHAPE_KINDS];\n\n/** Minimal hit descriptor passed to `onDoubleClick`. Contains the fields\n *  modality dispatch needs; extends as the kit's `Hit` type evolves. */\nexport interface SceneCanvasHit {\n  id: string;\n  kind: string;\n}\n\n/** Props for `<SceneCanvas>`. A scene is the only thing it needs. With nothing\n *  else it renders that scene and keeps a selection no input sets; `features`\n *  turns behavior on by preset, and the rest configures what those turn on. */\nexport type SceneCanvasProps<TData, TLayer extends string, TPose> =\n  Omit<\n    CanvasProps<TPose>,\n    | 'adapter' | 'boundsOf' | 'selection' | 'tools'\n    | 'viewState'       // SceneCanvas makes the camera from the view props below\n    | 'layers'          // stripped so we can re-add as optional below\n    | 'getIsVisible'    // SceneCanvas synthesizes this from chromeVisibility\n    | 'contentVersion'  // SceneCanvas wires this to the scene's own version\n    | 'layerVisibility' | 'layerOrder' // re-declared below: they gate picking here too\n    | 'debug'           // re-declared below with SceneCanvas's own `slops`\n  > & CameraProps\n  & {\n    /** A `Scene` (typically from `useScene`) — or a `SerializedScene` JSON\n     *  object, which SceneCanvas bakes into a Scene on first render. The\n     *  serialized form is read once; pass a `key` on `<SceneCanvas>` to force\n     *  a fresh canvas from updated JSON.\n     *\n     *  The JSON shape is relaxed (`version: number` rather than the `1`\n     *  literal) so an `import json from './x.json'` result satisfies the type\n     *  without an `as` cast. */\n    scene:\n      | Scene<TData, TLayer, TPose>\n      | SerializedScene<TData, TLayer, TPose>\n      | { version: number; systemLayers?: ReadonlyArray<{ id: string }>; nodes: ReadonlyArray<unknown> };\n\n    /** Layer configuration. When omitted, SceneCanvas applies kit defaults\n     *  (a scene slot that paints `node.data.fill` rects + a default\n     *  selection overlay). A partial scene or selection-overlay config is\n     *  spread over that slot's defaults; pass `slot: null` to suppress a\n     *  default explicitly. */\n    layers?: SceneCanvasLayers<Node<TData, TLayer, TPose>, TPose>;\n\n    /** Layout strategies keyed by container node id (or a resolver), for\n     *  containers whose scene node declares none (`ContainerNode.layout`\n     *  wins). Applied to a drag and to every other change to their children,\n     *  through the scene's layout pass. */\n    layouts?: SceneToAdapterOptions<TData, TLayer, TPose>['layouts'];\n\n    /** Which layout container a drag lands in when several contain the drop\n     *  point — the innermost (default), the topmost in paint order, or only\n     *  containers whose strategy declares a `dropRegion`. Decides both the\n     *  drag-time reflow preview and the commit. */\n    layoutDropTarget?: LayoutDropTargetMode;\n\n    /** Carries the siblings a layout reflow displaces to their slots over time\n     *  instead of snapping them — `useAnimatedReflow` builds one. Covers a\n     *  drag's reflow and every one the scene records (an insert, delete,\n     *  reorder or resize inside a laid-out container). Absent or `null`,\n     *  they snap. */\n    reflowTransition?: ReflowTransition<TPose> | null;\n\n    /**\n     * Lets pose-transform actions (move, resize, nudge, flip — NOT rotate) also rewrite a\n     * node's data-held geometry. Given a node and the affine `m` applied to its pose,\n     * `transform(node, m)` returns updated `data`, or `null` for nodes with no data-held\n     * geometry. When absent, the kit emits only the pose op and leaves `data` untouched.\n     *\n     * @see GeometryProjection\n     */\n    geometryProjection?: GeometryProjection;\n\n    /**\n     * Routing-trait classifiers. The kit builds a `NodeRouting` registry per `<SceneCanvas>`\n     * from this prop and uses it to derive each hit's `kind`, which tool routing tables\n     * (e.g. `{ target: 'rect', actionId: 'move' }`) match against. Pass `defaultNodeRouting`\n     * for the kit's built-in shape kinds; spread additional entries for consumer-defined\n     * kinds.\n     *\n     * **Memoize the `routing` value.** The registry is memoized on the prop's reference\n     * identity: a fresh array each render rebuilds it and cascades into a new adapter,\n     * churning gesture state.\n     */\n    routing?: readonly NodeRoutingEntry[];\n\n    /** How to read and rewrite this scene's poses. Every built-in action,\n     *  the selection chrome and picking read it. Default `AUTO_POSE_DESCRIPTOR`\n     *  (rect poses and `Path` poses). */\n    poseDescriptor?: PoseDescriptor<TPose>;\n\n    // --- Geometry: hit-test + bounds overrides consumed by the internal\n    //     `useSelectTool`. Ignored if the consumer passes their own `tools`. ---\n    geometry?: {\n      /** Hit-test override. Return the topmost id, the full back-to-front hit\n       *  stack (`string[]`), or `null` for empty space. The stack form lets a\n       *  consumer with domain overlap ordering (e.g. children over their\n       *  container) feed the kit's `pickTopMostHit` the true order instead of\n       *  pre-collapsing to one id. Matches `Canvas`'s `pickEvery` shape. */\n      pickEvery?: (worldX: number, worldY: number) => string | string[] | null;\n      boundsOf?: (id: string) => Bounds | null;\n      /**\n       * What \"the pointer is on this node\" means for the default body-pick.\n       *\n       * - `'pose'` — the node's pose rect, rotation honored.\n       * - `'shape'` (default) — the pose rect as a pre-filter, then the ink the painter\n       *   actually lays down: its silhouette filled or not per the painter's `ink`, plus\n       *   its outline widened by the stroke half-width and `pickTolerancePx`.\n       *\n       * Painters with no silhouette keep the pose-rect answer either way. Ignored when\n       * `pickEvery` is supplied: that override owns the test.\n       */\n      picking?: 'pose' | 'shape';\n      /**\n       * Grab slop around a shape's outline, in **screen** pixels, so the target keeps\n       * its apparent size at any zoom. Default 4. It widens the outline test under\n       * `picking: 'shape'` and grows the pose-rect pre-filter so those outline hits\n       * survive it. Set `0` for exact geometry.\n       */\n      pickTolerancePx?: number;\n    };\n\n    // --- Selection options. `pickBest` and `handleHitRadius` configure the\n    //     internal select tool, and are ignored under a `tools` takeover;\n    //     `move`, `snap`, `resize` and `rotate` configure the `move`,\n    //     `resize` and `rotate` presets, and apply either way. ---\n    selectTool?: {\n      move?: UseMoveOptions<TPose>;\n      resize?: UseResizeOptions<TPose>;\n      /** Rotation options, or `false` to disable rotation entirely — drops the\n       *  `rotate` action AND hides the selection rotation-handle chrome. */\n      rotate?: UseRotateOptions<TPose> | false;\n      snap?: SnapStrategy<TPose>;\n      handleHitRadius?: number;\n      /** Override the body-pick used on click/pointerdown. Alt-aware: receives\n       *  the live alt state + current selection so consumers can implement\n       *  alt-cycling through an overlapping stack. Default: top-most hit\n       *  (alt ignored). */\n      pickBest?: (worldX: number, worldY: number, alt: boolean, sel: readonly string[]) => string | null;\n    };\n\n    /** Consumer node factories for the `insert` action, keyed by tool `kind`.\n     *  Each factory receives the drag AABB + tool `extras` and returns the\n     *  node's `data` (in this canvas's own data shape) plus an optional `pose`.\n     *  A factory for a kit kind (`rect`, `line`, …) replaces the kit's default\n     *  `{ path, fill }` node for that kind; a factory for a novel kind (e.g.\n     *  `text`) adds insert support the kit doesn't ship. The dep supplies id,\n     *  layer, and the undoable op. Return `null` to reject an insert. */\n    insertNodeFactories?: Record<string, InsertNodeFactory>;\n\n    /** The fill, stroke, and fill rule a kit-built shape is inserted with, by\n     *  tool `kind` and insert count; the kit keeps the geometry. Default\n     *  `paletteInsertPaint`, the kit palette in turn. A kind with a factory in\n     *  `insertNodeFactories` is not asked. */\n    insertPaint?: InsertPaint;\n\n    /** External-content ingestion (OS drop / clipboard paste / picker).\n     *\n     *  - `handlers` — consumer content handlers registered for this canvas's\n     *    lifetime (priority 0 by default — they beat the kit's `image/*` /\n     *    `image/svg+xml` handlers at -100/-90).\n     *  - `resolveSrc` — overrides the image handler's `data:`-URI embed (e.g.\n     *    upload to an asset store, return the URL).\n     *  - `svg.unpack` — makes the kit SVG handler parse dropped SVG files into\n     *    native scene nodes instead of one embedded-image node each.\n     *  - `clipboard` — the kit weasel-JSON paste handler, enabled by default.\n     *    `reviver` restores JSON-unfriendly values the copying side encoded via\n     *    `jsonReplacer`. `enabled: false` opts the canvas out, but the kit\n     *    handler still consumes weasel-matching items and declines them inert\n     *    rather than letting them fall through. Also governs Cmd/Ctrl+V under\n     *    the `edit` preset; the rest takes the `ingest` preset.\n     *\n     *  Memoize `handlers` and `clipboard.reviver`: an inline array literal\n     *  re-registers the handlers on every render. */\n    ingestion?: {\n      handlers?: ContentHandlerEntry[];\n      resolveSrc?: (file: File) => Promise<string>;\n      svg?: SvgIngestOptions;\n      clipboard?: {\n        reviver?: (key: string, value: unknown) => unknown;\n        enabled?: boolean;\n        /** Called when a paste left copied nodes out, with each one and the\n         *  reason. `useClipboardOps` takes the same callback as\n         *  `onPasteOmitted` for a paste from its own in-memory copy. */\n        onOmitted?: (omitted: PasteOmission[]) => void;\n      };\n    };\n\n    selection?: SelectionApi;\n    selectionOptions?: UseSelectionOptions;\n\n    /**\n     * `false` stops the canvas writing the selection: no click, marquee,\n     * lasso, action or tool, and no op committed through the adapter it hands\n     * its tools. The consumer's own `SelectionApi` — the `selection` prop, or\n     * `useSelection({ scene })` — still writes, and the canvas draws what it\n     * holds. Undo and redo still restore the selection each history entry\n     * recorded. Default `true`.\n     *\n     * Click policy (whether shift-click extends) is the selection's `mode`:\n     * `useSelection({ mode: 'multi' })`, or `selectionOptions={{ mode: 'multi' }}`\n     * for the selection the canvas builds itself.\n     */\n    selectable?: boolean;\n\n    /**\n     * Behavior presets to turn on, composable in any combination. A canvas\n     * with none renders its scene and keeps a selection (the `selection` API\n     * works) that no input sets: no tools, no standard actions or their keys,\n     * no clipboard, no drop or paste, and no selection chrome. The dispatcher\n     * is still mounted, so bindings a consumer adds work.\n     *\n     * - `view` — wheel pan and zoom, pinch, the zoom keys, and the hand tool\n     *   (H, or hold Space). Passing `viewport` implies it.\n     * - `select` — the select tool, as the initial active tool and Escape's\n     *   return target: click to pick, drag on empty to marquee, click on empty\n     *   to clear.\n     * - `outline` — the selection outline, whichever tool sets the selection.\n     * - `pick` — `select` and `outline`.\n     * - `move` — drag a body to move it, Alt-drag to clone it. Ambient, so it\n     *   runs under any tool that does not claim the drag.\n     * - `resize` — resize handles, drawn and bound.\n     * - `rotate` — the rotation handle, drawn and bound.\n     * - `transform` — `resize` and `rotate`.\n     * - `edit` — undo/redo, delete, duplicate, group/ungroup, nudge,\n     *   select-all, Escape, cancel-gesture, cut/copy/paste, fill and stroke,\n     *   and their keys. Cmd/Ctrl+V pastes nodes a kit canvas copied, from\n     *   this tab or another, and nothing else.\n     * - `arrange` — align, distribute, reorder, flip.\n     * - `paths` — pathfinder operations, path-edit entry and anchor editing.\n     * - `ingest` — dropped and pasted content: images, SVG, files, and\n     *   whatever `ingestion.handlers` accept, on Cmd/Ctrl+V or an OS drop.\n     * - `draw` — all of the above.\n     *\n     * Tools add the actions they bind — a shape tool brings `insert` — so\n     * `defaultTools` composes with any preset. `actions` then adds, overrides\n     * or removes on top of what the presets registered.\n     */\n    features?: readonly Feature[];\n\n    /** Extra tools or overrides keyed by id, or a full `ToolsApi` takeover.\n     *\n     *  **Patch form** (`Record<string, Tool | true | false>`): merged\n     *  into the built-in registry on top of whatever `defaultTools` and\n     *  `features` already selected.\n     *    - `true` pulls in the built-in for this id (`'pen'`, `'lasso'`,\n     *      `'hand'`, …), the same as listing it in `defaultTools`. Unknown\n     *      built-in ids warn in dev and are ignored.\n     *    - `Tool` adds a new id or replaces an existing one\n     *      (dev-only warning on replace).\n     *    - `false` omits a bundled tool entirely.\n     *  Auto-wiring (keybindings, dispatcher, action registry) still runs.\n     *\n     *  **Takeover form** (`ToolsApi`): the internal registry is bypassed and\n     *  this `tools` value is forwarded to Canvas as-is — the consumer owns\n     *  active-slot management, and `pick`'s select tool is theirs to supply.\n     *  Every other preset still applies. Keybindings are still auto-wired\n     *  against the supplied registry; pass `enableKeybindings={false}` to opt\n     *  out. */\n    tools?: ToolsApi | Record<string, Tool | true | false>;\n\n    /**\n     * Auto-wire keyboard shortcuts. Default `true`. When `false`, SceneCanvas still mounts\n     * its tools but routes no keyboard input to them — neither tool hotkeys nor\n     * keyboard-bound actions like delete / escape / nudge. Pointer, wheel, and contextmenu\n     * interactions are unaffected.\n     */\n    enableKeybindings?: boolean;\n\n    /**\n     * Take the keyboard on mount, as a press in the canvas would. A key that\n     * reaches the page goes to the canvas the user last pressed or scrolled\n     * in, and to no canvas before the first such interaction, so a canvas in a\n     * side panel does not take Space from a page that wants it. An app whose\n     * canvas is the page sets this so its shortcuts work before the first\n     * click. Default `false`.\n     */\n    claimKeys?: boolean;\n\n    /**\n     * Auto-mount the gesture dispatcher (`useGestureDispatcher`). Default `true`. `false` is\n     * for tests or demos that drive actions another way, or that call\n     * `useGestureDispatcher` themselves.\n     */\n    enableGestureDispatcher?: boolean;\n\n    /** Called with the `ToolsApi` SceneCanvas constructs or receives, whenever its identity\n     *  changes. For introspection. */\n    onToolsCreated?: (tools: ToolsApi) => void;\n\n    /**\n     * Built-in tools SceneCanvas registers in its internal `useTools`, on top\n     * of the ones presets bring (`select` from `pick`, `hand` from `view`).\n     * Default: none. Each tool also registers the kit actions it binds, so\n     * `['rect']` brings `insert`. Ignored when the consumer supplies their own\n     * `tools` prop.\n     */\n    defaultTools?: readonly BuiltinToolId[];\n\n    /** Per-tool option overrides for the built-in shape/lasso/clone tools.\n     *  Each entry is a narrow subset of the underlying hook's options\n     *  surface — `lasso.mode`, `clone.cloneSelection`, etc. */\n    toolOptions?: BuiltinToolOptions;\n\n    /** Initial active-slot tool id. Default: `'select'` when it is\n     *  registered, otherwise none — a canvas can run on ambient bindings\n     *  alone. Must be one of the registered tools. Ignored when the consumer\n     *  supplies their own `tools` prop. */\n    initialActiveTool?: string;\n\n    /** Always-on entries to register alongside the internal tools — every one\n     *  a `SurfaceContribution`, whose views, deps, overlay, bindings, actions\n     *  and `attach` all install from this one list, and uninstall when the\n     *  entry leaves it. A tool is a contribution too, so one can go here. If\n     *  you supply your own `tools` prop, this is ignored — wire `ambient`\n     *  through your own `useTools` call instead. */\n    ambient?: readonly SurfaceContribution[];\n\n    /** What an entry's `requires` does when the running kit does not meet\n     *  it: `'warn'` (the default) logs in development, `'strict'` throws,\n     *  `'off'` skips the check. */\n    versionCheck?: VersionCheck;\n\n    /** Touch and pen long-press: its hold time, its haptic, and the\n     *  feedback shown while it is held. */\n    longPress?: SceneCanvasLongPress;\n\n    /** Configures the `view` preset, and implies it: passing this turns\n     *  `view` on.\n     *\n     *  - `inertia` and `animatedZoom` are opt-in: pass `true` for defaults or\n     *    an object to tune. Omitted means off.\n     *  - `pan` (wheel pan), `zoom` (Cmd+wheel + Cmd+=/-/0), and `pinchZoom`\n     *    (two-finger pinch) are on under `view`; pass `false` to disable one.\n     *    Disabling via the `actions` prop\n     *    (`actions: { 'viewport.wheelPan': null }`) also works and runs after\n     *    this. */\n    viewport?: {\n      inertia?: boolean | InertiaConfig;\n      /** Two-finger pinch zoom. `true`/omitted = on with the kit's 0.1–8\n       *  clamp; `false` disables. An object sets the scale clamp. */\n      pinchZoom?: boolean | PinchZoomOptions;\n      /** Glide Cmd+=/-/0 instead of jumping. `true` uses the kit defaults\n       *  (250 ms, ease-out-cubic); a {@link ViewportZoomAnimateOptions} tunes\n       *  duration, easing, interpolator and the reset-branch duration. Wheel\n       *  and pinch are unaffected — their input already samples every frame. */\n      animatedZoom?: boolean | ViewportZoomAnimateOptions;\n      /** Wheel pan. `true`/omitted = on; `false` disables; an object locks the\n       *  axis (`{ axis: 'x' }`) so a single-axis viewport needs no commit clamp. */\n      pan?: boolean | WheelPanOptions;\n      /** Wheel/keyboard zoom. `true`/omitted = default Cmd+wheel zoom with the\n       *  kit's 0.1–8 clamp; `false` disables. Pass a {@link ViewportZoomOptions}\n       *  object to bind zoom to plain wheel (`wheel: 'plain'`, pair with\n       *  `pan: false`) and/or set `min`/`max` scale clamps. */\n      zoom?: boolean | ViewportZoomOptions;\n      /** Callback invoked by Cmd-0 (`viewport.zoom` action's `reset` branch).\n       *  When supplied, replaces the default reset-to-identity behavior —\n       *  consumers typically refit the document page into the workspace via\n       *  `fitViewToBounds`. Return the target `View` to let the kit animate\n       *  there when `animatedZoom` is on; return nothing to dispatch it\n       *  yourself, which is what a controlled canvas does. */\n      recenter?: () => View | void;\n    };\n\n    /**\n     * @experimental\n     * Override / disable / extend the default action set. Pass `null` to disable all\n     * defaults.\n     */\n    actions?: ActionsProp;\n\n    /**\n     * @experimental\n     * Given a scene node, return a short human-readable \"kind\" label (e.g. `'rectangle'`,\n     * `'sticky note'`), which the kit publishes per id into any surrounding\n     * `<SelectionContextProvider>`. Return `undefined` to skip an entry. When omitted,\n     * containers report `'group'`, poses with a `kind` property report `'path'`, and\n     * everything else is left unlabelled.\n     */\n    describeKind?: (node: Node<TData, TLayer, TPose>) => string | undefined;\n\n    /**\n     * Animator to bind for per-frame redraws. SceneCanvas requests a redraw on every active\n     * animation frame and paints `animator.colorOverrides` onto the scene's nodes: the\n     * kit's path and shape painters apply them, and a custom `drawOne` receives them as\n     * `ctx.vertexColors`.\n     */\n    animator?: Animator;\n\n    /**\n     * Extra views on this canvas: each is a camera over a rect of the same\n     * surface, drawn through one GL context, with input routed to it. The flat\n     * `view` / `onViewChange` props above stay the canvas's own camera — view\n     * zero — and are unaffected by anything declared here.\n     *\n     * Order is paint and hit order, low to high. Each entry is a\n     * `<CanvasView>`; mounting one as a child is the same declaration, and\n     * children land after every entry here.\n     */\n    views?: readonly CanvasViewProps[];\n\n    /**\n     * Children rendered alongside the canvas, inside its input scope (e.g.\n     * shortcuts overlays, probes).\n     */\n    children?: ReactNode;\n\n    /**\n     * A yoke to join, from `useYoke()`: canvases on one yoke share the\n     * active tool, the gesture in flight and history. Omitted, this canvas\n     * keeps its own.\n     */\n    yoke?: Yoke;\n\n    /**\n     * Chrome-caps visibility overrides, keyed by chrome id (`selection.outline`,\n     * `selection.rotation-handle`, `gesture.marquee`, …). Each entry is a composable\n     * {@link Condition} built from the `cond()` builder, merged on top of the kit's\n     * `defaultVisibilityRules`. Set an id to `never` to suppress a chrome element\n     * entirely (also unhittable), or to `always` to force-show.\n     */\n    chromeVisibility?: import('features/chrome-caps').VisibilityRules;\n\n    /**\n     * The app's mode registry (`createModeRegistry` in `@weasel-js/modes`).\n     * The canvas reads the active mode from it to gate chrome, tool\n     * activation and the dispatcher's eligibility filter, repaints when it\n     * switches, and hands every registered mode to the dev-time route-conflict\n     * check. Omitted, the canvas behaves as the kit's normal mode and nothing\n     * revokes anchor editing.\n     */\n    modes?: ModeRegistry;\n\n    /** Hands which path is being anchor-edited to the host. See {@link PathEditHost}. */\n    pathEdit?: PathEditHost;\n\n    /**\n     * Override detected device facts. Merged over what `matchMedia` reports;\n     * `targetScale` is re-derived from the merged `coarsePointer` unless you\n     * override it explicitly.\n     */\n    device?: Partial<DeviceProfile>;\n\n    /**\n     * Live focus getter for chrome-caps' `focused` ctx field, for visibility rules that\n     * read the `focused` atom (the kit's default `selection.rotation-handle` rule does).\n     * Omit to default `focused` to `true`.\n     */\n    getFocused?: () => boolean;\n\n    /** Custom shader programs to compile on the renderer. See `CanvasProps.shaders`. */\n    shaders?: ShaderProgramHandle[];\n\n    /** Flatness tolerance for curve tessellation, in world units. See\n     *  `CanvasProps.flattenTolerance`. */\n    flattenTolerance?: number;\n\n    /** Fill for the full canvas behind the scene, drawn as a screen-space layer slotted\n     *  before `'scene'` — independent of pan / zoom. */\n    backgroundFill?: Paint;\n    /** Dev HUD: a fixed-position widget showing live cursor coords in both viewport\n     *  (client) and canvas (world) frames. */\n    cursorCoordsHud?: boolean;\n    /** Dev HUD: a fixed-position widget listing the ids `pickEvery(world)` returns under\n     *  the cursor. */\n    pickHud?: boolean;\n    /**\n     * The debug overlay: `<Canvas debug>`'s config, plus `slops: true` for\n     * translucent halos at every affordance hit zone. `false` turns it off;\n     * absent reads `?debug=…` from the URL, as `<Canvas>` does.\n     */\n    debug?: (DebugConfig & { slops?: boolean }) | false;\n    /**\n     * Dev HUD: when true (or object), mounts a fixed-position widget below\n     * the pick HUD showing the active modality mode, active-slot tool, and\n     * hotkey stack. Pass `{ modeId }` to populate the mode line.\n     */\n    modalityHud?: boolean | { modeId?: string };\n\n    /**\n     * Per-id alpha multiplier for the scene-render slot: each node's draw output is wrapped\n     * in a group with the returned alpha, and 1 emits no wrapper. Typical use: dimming\n     * non-active nodes during a mode transition.\n     */\n    alphaFor?: (id: string) => number;\n\n    /**\n     * Show or hide render layers in this canvas's own view, by id — the map\n     * `<Canvas>` takes. Each scene layer paints as its own render layer, keyed\n     * `scene:<layerId>`, so `{ 'scene:guides': false }` hides one scene layer\n     * here and nowhere else.\n     *\n     * A layer hidden this way is gone from this view: it does not paint, and a\n     * click, a marquee or Cmd+A here passes over it. Another view of the same\n     * scene — a `<CanvasView>`, a second canvas, a minimap — still shows it and\n     * can still take it. It applies on top of the scene's own\n     * `LayerRecord.visible` and cannot show a layer the scene hides.\n     */\n    layerVisibility?: Record<string, boolean>;\n\n    /**\n     * Draw order for this view, by render-layer id, bottom first. A listed\n     * order is the whole list: a scene layer left out of it is neither painted\n     * nor picked here. See `CanvasProps.layerOrder`.\n     */\n    layerOrder?: string[];\n\n    /**\n     * Per-id pointer-interactivity predicate: an id it returns `false` for is excluded from\n     * hit-test results. Typical use: suppressing pointer events for dimmed nodes.\n     */\n    isPointerInteractive?: (id: string) => boolean;\n\n    /**\n     * Called when the user double-clicks the canvas, with the hit node (id + kind) at that\n     * position, or `null` on empty canvas. Typical use: modality dispatch — enter path-edit\n     * on a path node, isolation on a group, text-edit on a text node.\n     */\n    onDoubleClick?: (hit: SceneCanvasHit | null) => void;\n    /** Called on every click — a press and release without a drag — with the\n     *  node under it, or `null` on empty canvas. Fires after the click's own\n     *  behavior, so a pick it made is already in the selection, and fires\n     *  again on a node that was already picked. */\n    onClick?: (hit: SceneCanvasHit | null) => void;\n  };\n"],"mappings":";;;;;;AAiEA,IAAaA,IAAsBC;AAgCnC,SAAgBC,EACd,GACA,IAAc,GACgC;CAC9C,IAAMC,IAAW;EACf,OAAO;GACL,SAASC;GAIT,aAAaC;EACf;EACA,kBAAkB,EAAE,SAAS,EAAE,MAAMC,EAAcC,CAAW,CAAC,CAAC,OAAO,EAAE;CAC3E;CAEA,IAAI,CAACC,GAAM,OAAOL;CAGlB,IAAMM,IAAS,EAAE,GAAGD,EAAK;CAEzB,IAAI,EAAE,WAAWA,IACf,EAAO,QAAQL,EAAS;MACnB,IAAIK,EAAK,UAAU,QAAQE,EAAcF,EAAK,KAAK,GACxD,EAAO,QAAQA,EAAK;MACf;EACL,IAAMG,IAAQ;GAAE,GAAGR,EAAS;GAAO,GAAGK,EAAK;EAAM;EACjD,EAAO,QAAQA,EAAK,SAAS,iBAAiBA,EAAK,QAC/CG,IACA;GAAE,GAAGA;GAAO,aAAaC,EAAqCD,EAAM,OAAO;EAAE;CACnF;CAUA,OARA,AACEF,EAAO,mBADH,sBAAsBD,IAEjBA,EAAK,qBAAqB,QAAQE,EAAcF,EAAK,gBAAgB,IACpDA,EAAK,mBAEL;EAAE,GAAGL,EAAS;EAAkB,GAAGK,EAAK;CAAiB,IAJzDL,EAAS,kBAO9BM;AACT;AAQA,IAAaI,IAAiF,CAAC,UAAU,MAAM,GAGlGC,IAA6C,CAAC,GAAGD,GAAyB,GAAGE,CAAe"}

package/dist/canvas/SceneCanvas/toolRegistry.js

@@ -0,0 +1,23 @@
+import { IS_DEV as e } from "./isDev.js";
+import { featureToolIds as t } from "./features.js";
+import { BUILTIN_TOOL_IDS as n } from "./props.js";
+//#region src/canvas/SceneCanvas/toolRegistry.ts
+function r(r) {
+	let { builtins: i, defaultTools: a = [], enabled: o, patch: s, dev: c = e } = r, l = {}, u = t(o);
+	for (let e of n) {
+		let t = s?.[e];
+		t !== !1 && (t === !0 || a.includes(e) || u.has(e)) && (l[e] = i[e]);
+	}
+	for (let [e, t] of Object.entries(s ?? {})) if (t !== !1) {
+		if (t === !0) {
+			c && !n.includes(e) && console.warn(`[SceneCanvas] tools.${e}=true is not a known built-in id; ignoring`);
+			continue;
+		}
+		c && e in l && console.warn(`[SceneCanvas] tools prop overrides bundled "${e}" tool`), l[e] = t;
+	}
+	return l;
+}
+//#endregion
+export { r as resolveToolRegistry };
+
+//# sourceMappingURL=toolRegistry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolRegistry.js","names":["resolveToolRegistry","IS_DEV","args","registry","preset","featureToolIds","enabled","id","BUILTIN_TOOL_IDS","patched","patch","defaultTools","builtins","value","dev"],"sources":["../../../src/canvas/SceneCanvas/toolRegistry.ts"],"sourcesContent":["import type { Tool } from 'tools/overlayBinding';\nimport { featureToolIds, type BaseFeature } from './features';\nimport { IS_DEV } from './isDev';\nimport { BUILTIN_TOOL_IDS, type BuiltinToolId } from './props';\n\n/** The patch form of `<SceneCanvas tools>`: per id, `true` mounts that\n *  built-in, `false` leaves it out, and a tool adds or replaces one. */\nexport type ToolsPatch = Record<string, Tool | true | false>;\n\n/** One tool per built-in id, mounted or not. */\nexport type BuiltinTools = Record<BuiltinToolId, Tool>;\n\nexport interface ResolveToolRegistryArgs {\n  builtins: BuiltinTools;\n  /** Built-ins asked for by id. */\n  defaultTools?: readonly BuiltinToolId[];\n  /** The presets the canvas runs with, each bringing the tools its\n   *  `FEATURE_PRESETS` row names. */\n  enabled: ReadonlySet<BaseFeature>;\n  patch: ToolsPatch | null;\n  /** Whether to warn about a patch entry that is probably a mistake. */\n  dev?: boolean;\n}\n\n/**\n * The tool registry a canvas mounts when it is not handed a whole `ToolsApi`.\n *\n * Built-ins come first, in `BUILTIN_TOOL_IDS` order whatever order they were\n * asked for in; a patch tool replaces a mounted one where it stands, and any\n * other is appended in patch order. That order is the palette's.\n */\nexport function resolveToolRegistry(args: ResolveToolRegistryArgs): Record<string, Tool> {\n  const { builtins, defaultTools = [], enabled, patch, dev = IS_DEV } = args;\n  const registry: Record<string, Tool> = {};\n  const preset = featureToolIds(enabled);\n  for (const id of BUILTIN_TOOL_IDS) {\n    const patched = patch?.[id];\n    if (patched === false) continue;\n    const asked = patched === true || defaultTools.includes(id) || preset.has(id);\n    if (asked) registry[id] = builtins[id];\n  }\n  for (const [id, value] of Object.entries(patch ?? {})) {\n    if (value === false) continue;\n    if (value === true) {\n      if (dev && !(BUILTIN_TOOL_IDS as readonly string[]).includes(id)) {\n        console.warn(`[SceneCanvas] tools.${id}=true is not a known built-in id; ignoring`);\n      }\n      continue;\n    }\n    if (dev && id in registry) {\n      console.warn(`[SceneCanvas] tools prop overrides bundled \"${id}\" tool`);\n    }\n    registry[id] = value;\n  }\n  return registry;\n}\n"],"mappings":";;;;AA+BA,SAAgBA,EAAoB,GAAqD;CACvF,IAAM,EAAE,aAAU,kBAAe,CAAC,GAAG,YAAS,UAAO,SAAMC,MAAWC,GAChEC,IAAiC,CAAC,GAClCC,IAASC,EAAeC,CAAO;CACrC,KAAK,IAAMC,KAAMC,GAAkB;EACjC,IAAMC,IAAUC,IAAQH;EACxB,AAAIE,MAAY,OACFA,MAAY,MAAQE,EAAa,SAASJ,CAAE,KAAKH,EAAO,IAAIG,CAAE,OACjE,EAASA,KAAMK,EAASL;CACrC;CACA,KAAK,IAAM,CAACA,GAAIM,MAAU,OAAO,QAAQH,KAAS,CAAC,CAAC,GAClD,IAAIG,MAAU,IACd;MAAIA,MAAU,IAAM;GAClB,AAAIC,KAAO,CAAEN,EAAuC,SAASD,CAAE,KAC7D,QAAQ,KAAK,uBAAuBA,EAAG,2CAA2C;GAEpF;EACF;EAIA,AAHIO,KAAOP,KAAMJ,KACf,QAAQ,KAAK,+CAA+CI,EAAG,OAAO,GAExE,EAASA,KAAMM;CAJf;CAMF,OAAOV;AACT"}

package/dist/canvas/SceneCanvas/useActionsPropResolver.js

@@ -42,7 +42,12 @@ function r(r, i) {
 		i
 	]);
 }
+function i(e, t) {
+	if (e === null) return null;
+	let n = { ...e ?? {} };
+	return t in n || (n[t] = null), n;
+}
 //#endregion
-export { r as useActionsPropResolver };
+export { i as actionsMuting, r as useActionsPropResolver };
 
 //# sourceMappingURL=useActionsPropResolver.js.map

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

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

package/dist/canvas/SceneCanvas/useBuiltinShapeTools.js

@@ -1,70 +1,29 @@
-import { asNodeId as e } from "../../core/scene/types.js";
 import "../../core/shapeKinds.js";
-import { cycleFill as t, solid as n, strokeOf as r } from "../../util/paint.js";
-import { useTextTool as i } from "../../tools/builtin/text/useTextTool.js";
-import { usePenTool as a } from "../../tools/builtin/pen/usePenTool.js";
-import { useRectTool as o } from "../../tools/builtin/rect/useRectTool.js";
-import { useEllipseTool as s } from "../../tools/builtin/ellipse/useEllipseTool.js";
-import { useLineTool as c } from "../../tools/builtin/line/useLineTool.js";
-import { useLassoTool as l } from "../../tools/builtin/lasso/useLassoTool.js";
-import { usePolygonTool as u } from "../../tools/builtin/polygon/usePolygonTool.js";
-import { useStarTool as d } from "../../tools/builtin/star/useStarTool.js";
-import { usePencilTool as f } from "../../tools/builtin/pencil/usePencilTool.js";
-import { boundsOfPath as p } from "@weasel-js/geom";
-import { useRef as m } from "react";
+import { useTextTool as e } from "../../tools/builtin/text/useTextTool.js";
+import { usePenTool as t } from "../../tools/builtin/pen/usePenTool.js";
+import { useRectTool as n } from "../../tools/builtin/rect/useRectTool.js";
+import { useEllipseTool as r } from "../../tools/builtin/ellipse/useEllipseTool.js";
+import { useLineTool as i } from "../../tools/builtin/line/useLineTool.js";
+import { useLassoTool as a } from "../../tools/builtin/lasso/useLassoTool.js";
+import { usePolygonTool as o } from "../../tools/builtin/polygon/usePolygonTool.js";
+import { useStarTool as s } from "../../tools/builtin/star/useStarTool.js";
+import { usePencilTool as c } from "../../tools/builtin/pencil/usePencilTool.js";
 //#region src/canvas/SceneCanvas/useBuiltinShapeTools.tsx
-function h(h) {
-	let { scene: g, adapter: _, options: v } = h, y = m(0), b = (t) => e(`${t}-${++y.current}`), x = () => t(y.current), S = () => g.layers[0]?.id ?? "default", C = (e, t, n) => ({
-		id: e,
-		kind: "leaf",
-		layer: S(),
-		pose: t,
-		data: n,
-		parent: null
-	}), w = v?.snapPoint, T = v?.insert ?? {}, E = o(T), D = s(T), O = c(T), k = u(T), A = d(T), j = f(T), M = (e) => {
-		let t = b("pn"), i = x();
-		return C(t, e.bounds, {
-			path: e.path,
-			fill: e.closed ? n(x()) : null,
-			stroke: r(i, 2)
-		});
-	};
+function l(l = {}) {
+	let { options: u } = l, d = u?.snapPoint, f = u?.insert ?? {}, p = n(f), m = r(f), h = i(f), g = o(f), _ = s(f), v = c(f);
 	return {
-		rect: E,
-		ellipse: D,
-		line: O,
-		polygon: k,
-		star: A,
-		pen: a({
-			snapPoint: w,
-			wrapPath: (e, { closed: t }) => {
-				let n = p(e);
-				return {
-					path: e,
-					closed: t,
-					bounds: {
-						x: n.x,
-						y: n.y,
-						width: n.width,
-						height: n.height
-					}
-				};
-			},
-			adapter: {
-				addNode: (e) => {
-					let t = M(e);
-					return _.insertNode(t), String(t.id);
-				},
-				makeNode: (e) => M(e),
-				setSelection: (e) => _.setSelection(e)
-			}
-		}),
-		pencil: j,
-		lasso: l(_, v?.lasso ?? {}),
-		text: i(T)
+		rect: p,
+		ellipse: m,
+		line: h,
+		polygon: g,
+		star: _,
+		pen: t({ snapPoint: d }),
+		pencil: v,
+		lasso: a(u?.lasso ?? {}),
+		text: e(f)
 	};
 }
 //#endregion
-export { h as useBuiltinShapeTools };
+export { l as useBuiltinShapeTools };
 
 //# sourceMappingURL=useBuiltinShapeTools.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useBuiltinShapeTools.js","names":["useBuiltinShapeTools","args","seqRef","useRef","freshId","asNodeId","prefix","nextFill","cycleFill","layerOf","scene","makeLeaf","snapPoint","options","insert","rect","useRectTool","ellipse","useEllipseTool","line","useLineTool","polygon","usePolygonTool","star","useStarTool","pencil","usePencilTool","makePenLeaf","id","color","carrier","solid","strokeOf","usePenTool","b","boundsOfPath","path","node","adapter","ids","useLassoTool","useTextTool"],"sources":["../../../src/canvas/SceneCanvas/useBuiltinShapeTools.tsx"],"sourcesContent":["/**\n * Shape-tool synthesis for `<SceneCanvas>` — calls the kit's per-shape tool\n * hooks with default `create` callbacks that produce leaf nodes shaped for\n * the kit's PATH_PAINTER (`data: { path, fill }`). 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 { useRef } from 'react';\nimport { asNodeId } from 'core/scene/types';\nimport { boundsOfPath } from '@weasel-js/geom';\nimport { cycleFill, solid, strokeOf } from '../../util/paint';\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, FillStyle, InsertToolOptions, LassoHitMode, NodeId, Path, PolygonPath, Scene, SceneNode, Stroke } from '@weasel-js/core';\nimport type { SceneCanvasAdapter } from '../sceneAdapter';\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<TData, TLayer extends string, TPose> {\n  scene: Scene<TData, TLayer, TPose>;\n  adapter: SceneCanvasAdapter<TData, TLayer, TPose>;\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<TData, TLayer extends string, TPose>(\n  args: UseBuiltinShapeToolsArgs<TData, TLayer, TPose>,\n): BuiltinShapeTools {\n  const { scene, adapter, options } = args;\n\n  // Per-canvas counter + fill cycler. Refs survive renders and stay\n  // private to the SceneCanvas instance.\n  const seqRef = useRef(0);\n  const freshId = (prefix: string) => asNodeId(`${prefix}-${++seqRef.current}`);\n  const nextFill = () => cycleFill(seqRef.current);\n\n  // First system-or-trivial layer is the default insertion layer. Falls back\n  // to 'default' when the scene has none yet (rare — useScene synthesizes\n  // a 'default' layer when systemLayers is omitted).\n  const layerOf = (): TLayer => (scene.layers[0]?.id ?? ('default' as TLayer));\n\n  // Helper to build the kit's leaf-node template — `data: { path, fill }`\n  // matches PATH_PAINTER's `matches`/`paint` contract. The cast through\n  // `unknown` reflects the kit's intentional looseness around TData when\n  // synthesized defaults are in play.\n  type Pose = { x: number; y: number; width: number; height: number };\n  const makeLeaf = (\n    id: NodeId,\n    pose: Pose,\n    data: { path: Path; fill: FillStyle | null; stroke?: Stroke; text?: string },\n  ): SceneNode<TData, TLayer, TPose> => ({\n    id,\n    kind: 'leaf',\n    layer: layerOf(),\n    pose: pose as unknown as TPose,\n    data: data as unknown as TData,\n    parent: null,\n  });\n\n  type LeafNode = SceneNode<TData, TLayer, TPose> & { id: NodeId };\n\n  const snapPoint = options?.snapPoint;\n  // Every drag-to-insert tool is a declarative shell: the drag is owned by\n  // the dispatcher's `insertAction` and the node is minted by the `insert`\n  // dep (`useInsertDepSource`). Tool-side `create` factories were removed\n  // when the dispatcher took over — consumers wanting custom node\n  // factories override 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  // Pen: takes an opaque \"pose\" carrier (here, the committed PolygonPath +\n  // closed flag + AABB) and an addNode/setSelection adapter. We construct\n  // the carrier in `wrapPath` and unpack it in `addNode` into a\n  // PATH_PAINTER-shaped leaf. (Pen is the one built-in still commiting\n  // through its own adapter rather than the `insert` dep — see §4b of the\n  // 2026-07-27 inspector handoff.)\n  // Editing a committed path is not the pen's job — double-click it to\n  // enter anchor-edit mode (see `usePenTool`'s PenScratch docs).\n  type PenCarrier = { path: PolygonPath; closed: boolean; bounds: { x: number; y: number; width: number; height: number } };\n  const makePenLeaf = (carrier: PenCarrier): LeafNode => {\n    const id = freshId('pn');\n    const color = nextFill();\n    return makeLeaf(id, carrier.bounds, {\n      path: carrier.path,\n      fill: carrier.closed ? solid(nextFill()) : null,\n      stroke: strokeOf(color, 2),\n    }) as LeafNode;\n  };\n  const pen = usePenTool<PenCarrier>({\n    snapPoint,\n    wrapPath: (path, { closed }): PenCarrier => {\n      const b = boundsOfPath(path);\n      return { path, closed, bounds: { x: b.x, y: b.y, width: b.width, height: b.height } };\n    },\n    adapter: {\n      addNode: (carrier) => {\n        const node = makePenLeaf(carrier);\n        adapter.insertNode(node);\n        return String(node.id);\n      },\n      makeNode: (carrier) => makePenLeaf(carrier),\n      setSelection: (ids) => adapter.setSelection(ids),\n    },\n  });\n  const lasso = useLassoTool(adapter, options?.lasso ?? {});\n  const text = useTextTool(insert);\n  return { rect, ellipse, line, polygon, star, pen, pencil, lasso, text };\n}\n"],"mappings":";;;;;;;;;;;;;;;AAkEA,SAAgBA,EACd,GACmB;CACnB,IAAM,EAAE,UAAO,YAAS,eAAYC,GAI9BC,IAASC,EAAO,CAAC,GACjBC,KAAW,MAAmBC,EAAS,GAAGC,EAAO,GAAG,EAAEJ,EAAO,SAAS,GACtEK,UAAiBC,EAAUN,EAAO,OAAO,GAKzCO,UAAyBC,EAAM,OAAO,EAAE,EAAE,MAAO,WAOjDC,KACJ,GACA,GACA,OACqC;EACrC;EACA,MAAM;EACN,OAAOF,EAAQ;EACT;EACA;EACN,QAAQ;CACV,IAIMG,IAAYC,GAAS,WAMrBC,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,GAU7Ba,KAAe,MAAkC;EACrD,IAAMC,IAAKxB,EAAQ,IAAI,GACjByB,IAAQtB,EAAS;EACvB,OAAOI,EAASiB,GAAIE,EAAQ,QAAQ;GAClC,MAAMA,EAAQ;GACd,MAAMA,EAAQ,SAASC,EAAMxB,EAAS,CAAC,IAAI;GAC3C,QAAQyB,EAASH,GAAO,CAAC;EAC3B,CAAC;CACH;CAmBA,OAAO;EAAE;EAAM;EAAS;EAAM;EAAS;EAAM,KAlBjCI,EAAuB;GACjC;GACA,WAAW,GAAM,EAAE,gBAAyB;IAC1C,IAAMC,IAAIC,EAAaC,CAAI;IAC3B,OAAO;KAAE;KAAM;KAAQ,QAAQ;MAAE,GAAGF,EAAE;MAAG,GAAGA,EAAE;MAAG,OAAOA,EAAE;MAAO,QAAQA,EAAE;KAAO;IAAE;GACtF;GACA,SAAS;IACP,UAAU,MAAY;KACpB,IAAMG,IAAOV,EAAYG,CAAO;KAEhC,OADAQ,EAAQ,WAAWD,CAAI,GAChB,OAAOA,EAAK,EAAE;IACvB;IACA,WAAW,MAAYV,EAAYG,CAAO;IAC1C,eAAe,MAAQQ,EAAQ,aAAaC,CAAG;GACjD;EACF,CAG6C;EAAK;EAAQ,OAF5CC,EAAaF,GAASzB,GAAS,SAAS,CAAC,CAEG;EAAO,MADpD4B,EAAY3B,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,38 @@
+import { useViewAnimationOn as e } from "../../core/viewport/useViewAnimation.js";
+import { useCanvasView as t } from "../useCanvasView.js";
+import { useInsertionEffect as n, useMemo as r, useRef as i } from "react";
+import { useLatest as a } from "@weasel-js/react";
+import { useAnimator as o } from "@weasel-js/animator";
+//#region src/canvas/SceneCanvas/useCanvasCamera.ts
+function s(s) {
+	let { view: c, defaultView: l, onViewChange: u, viewBounds: d, width: f, height: p, requestRedraw: m } = s, h = a({
+		width: f,
+		height: p
+	}), g = i(null), _ = t({
+		view: c,
+		defaultView: l,
+		onViewChange: (e) => {
+			g.current?.stopIfExternal(), u?.(e);
+		},
+		viewBounds: d,
+		dims: () => h.current,
+		requestRedraw: m
+	}), v = o(), { viewRef: y, setViewFromInput: b } = _, x = r(() => ({
+		get: () => y.current,
+		set: b
+	}), [y, b]), S = e(x, v);
+	return n(() => {
+		g.current = S;
+	}), {
+		viewState: _,
+		viewAnimation: S,
+		camera: r(() => ({
+			target: S.viewTarget,
+			animator: v
+		}), [S, v])
+	};
+}
+//#endregion
+export { s 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","viewState","useCanvasView","onViewChange","next","animator","useAnimator","channel","useMemo","viewRef","setViewFromInput","viewAnimation","useViewAnimationOn","useInsertionEffect"],"sources":["../../../src/canvas/SceneCanvas/useCanvasCamera.ts"],"sourcesContent":["import { useInsertionEffect, useMemo, useRef } from 'react';\nimport { useAnimator } from '@weasel-js/animator';\nimport { useLatest } from '@weasel-js/react';\nimport { useViewAnimationOn, type ViewAnimationApi } from 'core/viewport/useViewAnimation';\nimport type { SceneCanvasApi } from '../canvasExtension';\nimport { useCanvasView, type CameraProps, type CanvasViewState } from '../useCanvasView';\n\n/**\n * The canvas's camera: the view `<Canvas>` looks through, the runner behind\n * `animateView`, and the target and animator it runs on.\n */\nexport function useCanvasCamera(opts: CameraProps & {\n  /** The size the camera looks through, which `viewBounds` clamps against. */\n  width: number;\n  height: number;\n  requestRedraw: () => void;\n}): {\n  viewState: CanvasViewState;\n  viewAnimation: ViewAnimationApi;\n  camera: SceneCanvasApi['camera'];\n} {\n  const { view, defaultView, onViewChange, viewBounds, width, height, requestRedraw } = opts;\n  const size = useLatest({ width, height });\n  const animationRef = useRef<ViewAnimationApi | null>(null);\n  const viewState = useCanvasView({\n    view,\n    defaultView,\n    // Every write to the view is reported here, so it is the runner's one\n    // interrupt feed.\n    onViewChange: (next) => {\n      animationRef.current?.stopIfExternal();\n      onViewChange?.(next);\n    },\n    viewBounds,\n    dims: () => size.current,\n    requestRedraw,\n  });\n\n  // The camera runs on its own animator, never the `animator` prop's: that prop\n  // is the consumer's scene animator, and their `cancelAll()` or `pause()` must\n  // not strand a zoom half-finished or freeze the camera.\n  const animator = useAnimator();\n  const { viewRef, setViewFromInput } = viewState;\n  const channel = useMemo(\n    () => ({ get: () => viewRef.current, set: setViewFromInput }),\n    [viewRef, setViewFromInput],\n  );\n  const viewAnimation = useViewAnimationOn(channel, animator);\n  useInsertionEffect(() => { animationRef.current = viewAnimation; });\n  const camera = useMemo(() => ({ target: viewAnimation.viewTarget, animator }), [viewAnimation, animator]);\n  return { viewState, viewAnimation, camera };\n}\n"],"mappings":";;;;;;AAWA,SAAgBA,EAAgB,GAS9B;CACA,IAAM,EAAE,SAAM,gBAAa,iBAAc,eAAY,UAAO,WAAQ,qBAAkBC,GAChFC,IAAOC,EAAU;EAAE;EAAO;CAAO,CAAC,GAClCC,IAAeC,EAAgC,IAAI,GACnDC,IAAYC,EAAc;EAC9B;EACA;EAGA,eAAe,MAAS;GAEtB,AADAH,EAAa,SAAS,eAAe,GACrCI,IAAeC,CAAI;EACrB;EACA;EACA,YAAYP,EAAK;EACjB;CACF,CAAC,GAKKQ,IAAWC,EAAY,GACvB,EAAE,YAAS,wBAAqBL,GAChCM,IAAUC,SACP;EAAE,WAAWC,EAAQ;EAAS,KAAKC;CAAiB,IAC3D,CAACD,GAASC,CAAgB,CAC5B,GACMC,IAAgBC,EAAmBL,GAASF,CAAQ;CAG1D,OAFAQ,QAAyB;EAAE,EAAa,UAAUF;CAAe,CAAC,GAE3D;EAAE;EAAW;EAAe,QADpBH,SAAe;GAAE,QAAQG,EAAc;GAAY;EAAS,IAAI,CAACA,GAAeN,CAAQ,CACpE;CAAO;AAC5C"}

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 { createDispatcher as i } from "@weasel-js/routing";
+//#region src/canvas/SceneCanvas/useCanvasDispatcher.ts
+function a() {
+	let a = n(null), o = n(null);
+	o.current ||= i({ getAction: (e) => a.current?.(e) });
+	let s = o.current, [c] = r(() => t(() => o.current)), [{ previewIdsExtra: l, previewPoseExtra: u }] = r(() => e(() => o.current));
+	return {
+		dispatcher: s,
+		getActionRef: a,
+		gestureSource: c,
+		previewIdsExtra: l,
+		previewPoseExtra: u
+	};
+}
+//#endregion
+export { a as useCanvasDispatcher };
+
+//# sourceMappingURL=useCanvasDispatcher.js.map

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

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

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"}