@weasel-js/core 1.10.1 → 1.11.1

package/dist/tools/useKeybindings.js

@@ -1,56 +1,72 @@
-import { buildToolActivateBindings as e, makeToolActivateAction as t } from "../interactions/actions/defaults/toolActivate.js";
-import { makeToolResetToDefaultAction as n } from "../interactions/actions/defaults/toolResetToDefault.js";
-import { useEffect as r, useRef as i } from "react";
-import { useLatest as a } from "@weasel-js/react";
-import { useActionsRegistry as o } from "@weasel-js/routing/react";
-import { eligibleForMode as s } from "@weasel-js/modes";
+import { buildToolActivateBindings, makeToolActivateAction } from "../interactions/actions/defaults/toolActivate.js";
+import { makeToolResetToDefaultAction } from "../interactions/actions/defaults/toolResetToDefault.js";
+import { useEffect, useRef } from "react";
+import { useLatest } from "@weasel-js/react";
+import { useActionsRegistry } from "@weasel-js/routing/react";
+import { eligibleForMode } from "@weasel-js/modes";
+
 //#region src/tools/useKeybindings.ts
-function c(c, l = {}) {
-	let u = a(c), d = a(l), f = i(c.active), p = o(), { disable: m = !1 } = l;
-	r(() => {
-		if (m || !p || Object.keys(u.current.registry).length === 0) return;
-		let r = [], i = u.current.registry;
-		for (let e in i) {
-			let t = i[e].keybinding;
-			if (!t) continue;
-			let n = typeof t.key == "string" ? [t.key] : t.key;
-			for (let i of n) i && r.push({
-				toolId: e,
-				keyOpts: {
-					...t,
-					key: i
-				}
-			});
+/** Wire the single-key tool-activation shortcuts (V, P, T, …) and Escape to
+*  return to the default tool. Activation is gated on what the active mode
+*  allows, so a key cannot reach a tool the palette greys out. */
+function useKeybindings(tools, options = {}) {
+	const toolsRef = useLatest(tools);
+	const optionsRef = useLatest(options);
+	const initialActiveRef = useRef(tools.active);
+	const registry = useActionsRegistry();
+	const { disable = false } = options;
+	useEffect(() => {
+		if (disable) return;
+		if (!registry) return;
+		if (Object.keys(toolsRef.current.registry).length === 0) return;
+		const specs = [];
+		const allTools = toolsRef.current.registry;
+		for (const toolId in allTools) {
+			const binding = allTools[toolId].keybinding;
+			if (!binding) continue;
+			const keys = typeof binding.key === "string" ? [binding.key] : binding.key;
+			for (const key of keys) {
+				if (!key) continue;
+				specs.push({
+					toolId,
+					keyOpts: {
+						...binding,
+						key
+					}
+				});
+			}
 		}
-		let a = [];
-		if (r.length > 0) {
-			let n = e(r);
-			a.push(p.register(t(n, (e) => {
-				let t = d.current.modes;
-				if (!t) return !0;
-				let n = u.current.registry[e]?.eligibility.capabilities;
-				return s(t.current(), n ?? []);
+		const unregisters = [];
+		if (specs.length > 0) {
+			const bindings = buildToolActivateBindings(specs);
+			unregisters.push(registry.register(makeToolActivateAction(bindings, (toolId) => {
+				const modes = optionsRef.current.modes;
+				if (!modes) return true;
+				const tags = toolsRef.current.registry[toolId]?.eligibility.capabilities;
+				return eligibleForMode(modes.current(), tags ?? []);
 			})));
 		}
-		return a.push(p.register(n(() => {
-			let e = d.current.defaultTool;
-			if (e === null) return null;
-			let t = e ?? f.current;
-			if (!t) return null;
-			let n = u.current;
-			return !n.has(t) || n.active === t ? null : t;
-		}))), () => {
-			for (let e of a) e();
+		unregisters.push(registry.register(makeToolResetToDefaultAction(() => {
+			const opt = optionsRef.current.defaultTool;
+			if (opt === null) return null;
+			const target = opt ?? initialActiveRef.current;
+			if (!target) return null;
+			const api = toolsRef.current;
+			if (!api.has(target) || api.active === target) return null;
+			return target;
+		})));
+		return () => {
+			for (const u of unregisters) u();
 		};
 	}, [
-		p,
-		c,
-		u,
-		d,
-		m
+		registry,
+		tools,
+		toolsRef,
+		optionsRef,
+		disable
 	]);
 }
-//#endregion
-export { c as useKeybindings };
 
+//#endregion
+export { useKeybindings };
 //# sourceMappingURL=useKeybindings.js.map

package/dist/tools/useKeybindings.js.map

@@ -1 +1 @@
-{"version":3,"file":"useKeybindings.js","names":["useKeybindings","toolsRef","useLatest","tools","optionsRef","options","initialActiveRef","useRef","registry","useActionsRegistry","disable","specs","allTools","toolId","binding","keys","key","unregisters","bindings","buildToolActivateBindings","makeToolActivateAction","modes","tags","eligibleForMode","makeToolResetToDefaultAction","opt","target","api","u"],"sources":["../../src/tools/useKeybindings.ts"],"sourcesContent":["// src/tools/useKeybindings.ts\nimport { useEffect, useRef } from 'react';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport { eligibleForMode, type ModeRegistry } from '@weasel-js/modes';\nimport {\n  makeToolActivateAction,\n  buildToolActivateBindings,\n  type ToolActivateBindingSpec,\n} from 'interactions/actions/defaults/toolActivate';\nimport { makeToolResetToDefaultAction } from 'interactions/actions/defaults/toolResetToDefault';\nimport type { ToolsApi } from './overlayBinding';\n\n/** Options for `useKeybindings`. */\nexport interface UseKeybindingsOptions {\n  /** Skip all wiring. Useful for touch apps or test isolation. */\n  disable?: boolean;\n  /** Tool id Escape switches to. When omitted, defaults to whatever\n   *  `tools.active` was when the hook first ran (i.e. the initial active\n   *  tool). Pass `null` to disable Escape-returns-to-default behavior. */\n  defaultTool?: string | null;\n  /**\n   * The modes that gate keyboard tool activation: a key is refused when the\n   * active mode does not allow every tag in the tool's\n   * `eligibility.capabilities` — the predicate `ToolPalette` greys a button\n   * out by, so the grey-out is a guarantee rather than a hint. `<SceneCanvas>`\n   * passes its `modes` prop, whoever built the `ToolsApi`.\n   *\n   * Omit for consumers with no mode registry: every tool stays activatable.\n   */\n  modes?: ModeRegistry;\n}\n\n/** Wire the single-key tool-activation shortcuts (V, P, T, …) and Escape to\n *  return to the default tool. Activation is gated on what the active mode\n *  allows, so a key cannot reach a tool the palette greys out. */\nexport function useKeybindings(\n  tools: ToolsApi,\n  options: UseKeybindingsOptions = {},\n): void {\n  const toolsRef = useLatest(tools);\n  const optionsRef = useLatest(options);\n  // Snapshot the initial active tool — used as the Escape target when the\n  // consumer doesn't pass an explicit `defaultTool`. Captured in a ref\n  // (not state) so it survives re-renders without re-syncing.\n  const initialActiveRef = useRef(tools.active);\n\n  // Held-key engagement is not here: a tool declares `ToolDef.hotkey` and\n  // assembly registers `tool.offhand` from the declaration.\n  const registry = useActionsRegistry();\n\n  // --- Tool-activate: register one parametric `tool.activate` action.\n  // The single descriptor carries a `defaultBinding: BoundGesture[]` with one\n  // entry per tool — each entry pairs a key spec with `opts.params.toolId`.\n  // The invoker reads `params.toolId` and calls `setActive`. Imperative\n  // callers (palette, toolbar) reach the same effect via\n  // `registry.trigger('tool.activate', { toolId })`.\n  //\n  // Every key comes from a `ToolDef.keybinding` in the tools registry.\n  const { disable = false } = options;\n  useEffect(() => {\n    if (disable) return;\n    if (!registry) return;\n    // No tools, no tool keys: nothing to activate and nothing to return to.\n    if (Object.keys(toolsRef.current.registry).length === 0) return;\n\n    const specs: ToolActivateBindingSpec[] = [];\n\n    const allTools = toolsRef.current.registry;\n    for (const toolId in allTools) {\n      const binding = allTools[toolId].keybinding;\n      if (!binding) continue;\n      // `KeyBinding.key` may be an array of aliases: one binding per key.\n      const keys = typeof binding.key === 'string' ? [binding.key] : binding.key;\n      for (const key of keys) {\n        if (!key) continue;\n        specs.push({ toolId, keyOpts: { ...binding, key } });\n      }\n    }\n\n    const unregisters: Array<() => void> = [];\n\n    if (specs.length > 0) {\n      const bindings = buildToolActivateBindings(specs);\n      unregisters.push(registry.register(makeToolActivateAction(\n        bindings,\n        (toolId) => {\n          const modes = optionsRef.current.modes;\n          if (!modes) return true;\n          const tags = toolsRef.current.registry[toolId]?.eligibility.capabilities;\n          return eligibleForMode(modes.current(), tags ?? []);\n        },\n      )));\n    }\n\n    // Escape-returns-to-default. Registered here rather than in the deleted\n    // document listener so it competes in the dispatcher's Escape ladder\n    // instead of firing in parallel with it — see\n    // `makeToolResetToDefaultAction` for the ordering and the behavior\n    // change that implies.\n    unregisters.push(registry.register(makeToolResetToDefaultAction(() => {\n      const opt = optionsRef.current.defaultTool;\n      if (opt === null) return null;\n      const target = opt ?? initialActiveRef.current;\n      if (!target) return null;\n      const api = toolsRef.current;\n      if (!api.has(target) || api.active === target) return null;\n      return target;\n    })));\n\n    return () => { for (const u of unregisters) u(); };\n  }, [registry, tools, toolsRef, optionsRef, disable]);\n}\n\n"],"mappings":";;;;;;;AAoCA,SAAgBA,EACd,GACA,IAAiC,CAAC,GAC5B;CACN,IAAMC,IAAWC,EAAUC,CAAK,GAC1BC,IAAaF,EAAUG,CAAO,GAI9BC,IAAmBC,EAAOJ,EAAM,MAAM,GAItCK,IAAWC,EAAmB,GAU9B,EAAE,aAAU,OAAUJ;CAC5B,QAAgB;EAId,IAHIK,KACA,CAACF,KAED,OAAO,KAAKP,EAAS,QAAQ,QAAQ,CAAC,CAAC,WAAW,GAAG;EAEzD,IAAMU,IAAmC,CAAC,GAEpCC,IAAWX,EAAS,QAAQ;EAClC,KAAK,IAAMY,KAAUD,GAAU;GAC7B,IAAME,IAAUF,EAASC,EAAO,CAAC;GACjC,IAAI,CAACC,GAAS;GAEd,IAAMC,IAAO,OAAOD,EAAQ,OAAQ,WAAW,CAACA,EAAQ,GAAG,IAAIA,EAAQ;GACvE,KAAK,IAAME,KAAOD,GAChB,AAAKC,KACLL,EAAM,KAAK;IAAE;IAAQ,SAAS;KAAE,GAAGG;KAAS;IAAI;GAAE,CAAC;EAEvD;EAEA,IAAMG,IAAiC,CAAC;EAExC,IAAIN,EAAM,SAAS,GAAG;GACpB,IAAMO,IAAWC,EAA0BR,CAAK;GAChD,EAAY,KAAKH,EAAS,SAASY,EACjCF,IACC,MAAW;IACV,IAAMG,IAAQjB,EAAW,QAAQ;IACjC,IAAI,CAACiB,GAAO,OAAO;IACnB,IAAMC,IAAOrB,EAAS,QAAQ,SAASY,EAAO,EAAE,YAAY;IAC5D,OAAOU,EAAgBF,EAAM,QAAQ,GAAGC,KAAQ,CAAC,CAAC;GACpD,CACF,CAAC,CAAC;EACJ;EAiBA,OAVAL,EAAY,KAAKT,EAAS,SAASgB,QAAmC;GACpE,IAAMC,IAAMrB,EAAW,QAAQ;GAC/B,IAAIqB,MAAQ,MAAM,OAAO;GACzB,IAAMC,IAASD,KAAOnB,EAAiB;GACvC,IAAI,CAACoB,GAAQ,OAAO;GACpB,IAAMC,IAAM1B,EAAS;GAErB,OADI,CAAC0B,EAAI,IAAID,CAAM,KAAKC,EAAI,WAAWD,IAAe,OAC/CA;EACT,CAAC,CAAC,CAAC,SAEU;GAAE,KAAK,IAAME,KAAKX,GAAa,EAAE;EAAG;CACnD,GAAG;EAACT;EAAUL;EAAOF;EAAUG;EAAYM;CAAO,CAAC;AACrD"}
+{"version":3,"file":"useKeybindings.js","names":[],"sources":["../../src/tools/useKeybindings.ts"],"sourcesContent":["// src/tools/useKeybindings.ts\nimport { useEffect, useRef } from 'react';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport { eligibleForMode, type ModeRegistry } from '@weasel-js/modes';\nimport {\n  makeToolActivateAction,\n  buildToolActivateBindings,\n  type ToolActivateBindingSpec,\n} from 'interactions/actions/defaults/toolActivate';\nimport { makeToolResetToDefaultAction } from 'interactions/actions/defaults/toolResetToDefault';\nimport type { ToolsApi } from './overlayBinding';\n\n/** Options for `useKeybindings`. */\nexport interface UseKeybindingsOptions {\n  /** Skip all wiring. Useful for touch apps or test isolation. */\n  disable?: boolean;\n  /** Tool id Escape switches to. When omitted, defaults to whatever\n   *  `tools.active` was when the hook first ran (i.e. the initial active\n   *  tool). Pass `null` to disable Escape-returns-to-default behavior. */\n  defaultTool?: string | null;\n  /**\n   * The modes that gate keyboard tool activation: a key is refused when the\n   * active mode does not allow every tag in the tool's\n   * `eligibility.capabilities` — the predicate `ToolPalette` greys a button\n   * out by, so the grey-out is a guarantee rather than a hint. `<SceneCanvas>`\n   * passes its `modes` prop, whoever built the `ToolsApi`.\n   *\n   * Omit for consumers with no mode registry: every tool stays activatable.\n   */\n  modes?: ModeRegistry;\n}\n\n/** Wire the single-key tool-activation shortcuts (V, P, T, …) and Escape to\n *  return to the default tool. Activation is gated on what the active mode\n *  allows, so a key cannot reach a tool the palette greys out. */\nexport function useKeybindings(\n  tools: ToolsApi,\n  options: UseKeybindingsOptions = {},\n): void {\n  const toolsRef = useLatest(tools);\n  const optionsRef = useLatest(options);\n  // Snapshot the initial active tool — used as the Escape target when the\n  // consumer doesn't pass an explicit `defaultTool`. Captured in a ref\n  // (not state) so it survives re-renders without re-syncing.\n  const initialActiveRef = useRef(tools.active);\n\n  // Held-key engagement is not here: a tool declares `ToolDef.hotkey` and\n  // assembly registers `tool.offhand` from the declaration.\n  const registry = useActionsRegistry();\n\n  // --- Tool-activate: register one parametric `tool.activate` action.\n  // The single descriptor carries a `defaultBinding: BoundGesture[]` with one\n  // entry per tool — each entry pairs a key spec with `opts.params.toolId`.\n  // The invoker reads `params.toolId` and calls `setActive`. Imperative\n  // callers (palette, toolbar) reach the same effect via\n  // `registry.trigger('tool.activate', { toolId })`.\n  //\n  // Every key comes from a `ToolDef.keybinding` in the tools registry.\n  const { disable = false } = options;\n  useEffect(() => {\n    if (disable) return;\n    if (!registry) return;\n    // No tools, no tool keys: nothing to activate and nothing to return to.\n    if (Object.keys(toolsRef.current.registry).length === 0) return;\n\n    const specs: ToolActivateBindingSpec[] = [];\n\n    const allTools = toolsRef.current.registry;\n    for (const toolId in allTools) {\n      const binding = allTools[toolId].keybinding;\n      if (!binding) continue;\n      // `KeyBinding.key` may be an array of aliases: one binding per key.\n      const keys = typeof binding.key === 'string' ? [binding.key] : binding.key;\n      for (const key of keys) {\n        if (!key) continue;\n        specs.push({ toolId, keyOpts: { ...binding, key } });\n      }\n    }\n\n    const unregisters: Array<() => void> = [];\n\n    if (specs.length > 0) {\n      const bindings = buildToolActivateBindings(specs);\n      unregisters.push(registry.register(makeToolActivateAction(\n        bindings,\n        (toolId) => {\n          const modes = optionsRef.current.modes;\n          if (!modes) return true;\n          const tags = toolsRef.current.registry[toolId]?.eligibility.capabilities;\n          return eligibleForMode(modes.current(), tags ?? []);\n        },\n      )));\n    }\n\n    // Escape-returns-to-default. Registered here rather than in the deleted\n    // document listener so it competes in the dispatcher's Escape ladder\n    // instead of firing in parallel with it — see\n    // `makeToolResetToDefaultAction` for the ordering and the behavior\n    // change that implies.\n    unregisters.push(registry.register(makeToolResetToDefaultAction(() => {\n      const opt = optionsRef.current.defaultTool;\n      if (opt === null) return null;\n      const target = opt ?? initialActiveRef.current;\n      if (!target) return null;\n      const api = toolsRef.current;\n      if (!api.has(target) || api.active === target) return null;\n      return target;\n    })));\n\n    return () => { for (const u of unregisters) u(); };\n  }, [registry, tools, toolsRef, optionsRef, disable]);\n}\n\n"],"mappings":";;;;;;;;;;;AAoCA,SAAgB,eACd,OACA,UAAiC,CAAC,GAC5B;CACN,MAAM,WAAW,UAAU,KAAK;CAChC,MAAM,aAAa,UAAU,OAAO;CAIpC,MAAM,mBAAmB,OAAO,MAAM,MAAM;CAI5C,MAAM,WAAW,mBAAmB;CAUpC,MAAM,EAAE,UAAU,UAAU;CAC5B,gBAAgB;EACd,IAAI,SAAS;EACb,IAAI,CAAC,UAAU;EAEf,IAAI,OAAO,KAAK,SAAS,QAAQ,QAAQ,CAAC,CAAC,WAAW,GAAG;EAEzD,MAAM,QAAmC,CAAC;EAE1C,MAAM,WAAW,SAAS,QAAQ;EAClC,KAAK,MAAM,UAAU,UAAU;GAC7B,MAAM,UAAU,SAAS,OAAO,CAAC;GACjC,IAAI,CAAC,SAAS;GAEd,MAAM,OAAO,OAAO,QAAQ,QAAQ,WAAW,CAAC,QAAQ,GAAG,IAAI,QAAQ;GACvE,KAAK,MAAM,OAAO,MAAM;IACtB,IAAI,CAAC,KAAK;IACV,MAAM,KAAK;KAAE;KAAQ,SAAS;MAAE,GAAG;MAAS;KAAI;IAAE,CAAC;GACrD;EACF;EAEA,MAAM,cAAiC,CAAC;EAExC,IAAI,MAAM,SAAS,GAAG;GACpB,MAAM,WAAW,0BAA0B,KAAK;GAChD,YAAY,KAAK,SAAS,SAAS,uBACjC,WACC,WAAW;IACV,MAAM,QAAQ,WAAW,QAAQ;IACjC,IAAI,CAAC,OAAO,OAAO;IACnB,MAAM,OAAO,SAAS,QAAQ,SAAS,OAAO,EAAE,YAAY;IAC5D,OAAO,gBAAgB,MAAM,QAAQ,GAAG,QAAQ,CAAC,CAAC;GACpD,CACF,CAAC,CAAC;EACJ;EAOA,YAAY,KAAK,SAAS,SAAS,mCAAmC;GACpE,MAAM,MAAM,WAAW,QAAQ;GAC/B,IAAI,QAAQ,MAAM,OAAO;GACzB,MAAM,SAAS,OAAO,iBAAiB;GACvC,IAAI,CAAC,QAAQ,OAAO;GACpB,MAAM,MAAM,SAAS;GACrB,IAAI,CAAC,IAAI,IAAI,MAAM,KAAK,IAAI,WAAW,QAAQ,OAAO;GACtD,OAAO;EACT,CAAC,CAAC,CAAC;EAEH,aAAa;GAAE,KAAK,MAAM,KAAK,aAAa,EAAE;EAAG;CACnD,GAAG;EAAC;EAAU;EAAO;EAAU;EAAY;CAAO,CAAC;AACrD"}

package/dist/{types-DBbbCy0i.d.ts → types-7puAuVD2.d.ts}

@@ -1,8 +1,5 @@
+import { View, Rect, Path } from '@weasel-js/geom';
 import { Op } from '@weasel-js/history';
-import { Rect, Path } from '@weasel-js/geom';
-import { View } from '@weasel-js/routing';
-import { P as PoseDescriptor } from './poseDescriptor-Bqk-11Rl.js';
-import { Target } from '@weasel-js/animator';
 
 /** One value for both axes, or a separate value per axis. */
 type ScalarOrXY = number | {
@@ -155,7 +152,8 @@ type LayoutDropTargetMode = 'innermost' | 'topmost' | 'region';
  * never written.
  *
  * `useAnimatedReflow` builds one over the animator. Supply it through
- * `<SceneCanvas reflowTransition>` or `LayoutDep.reflow`.
+ * `<SceneCanvas reflowTransition>` or `LayoutDep.reflow`, and through
+ * `<SceneCanvas poseTransition>` to glide other pose writes too.
  */
 interface ReflowTransition<TPose = unknown> {
     /** Move what `id` shows toward `pose`, in the node's stored frame. A glide
@@ -210,7 +208,7 @@ interface LayoutDragged<TPose> {
  *
  * Declared on a container node (`ContainerNode.layout`). `childPoses` is the
  * resting arrangement, which the scene re-applies whenever the container's
- * children or size change, `getDropTargets` enumerates where a drag could
+ * children or size change or a child is moved, `getDropTargets` enumerates where a drag could
  * land, `reflowPoses` is the live preview once a target is picked, and
  * `commitDrop` turns the result into ops so the drop is undoable.
  */
@@ -275,261 +273,4 @@ interface LayoutStrategy<TPose> {
     releaseDrop?(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>, dragged: LayoutDragged<TPose>): Op[] | null;
 }
 
-/**
- * Opaque clipboard payload: the kit never inspects entries. The adapter both
- * produces snapshots (`snapshotSelection`) and consumes them (`commitPaste`).
- */
-interface ClipboardSnapshot {
-    items: unknown[];
-}
-/**
- * A copied node a paste did not make, and why:
- *
- * - `dependency-not-copied` — it derives from the nodes in `missing`, which
- *   were not copied with it.
- * - `derivation-not-registered` — it derives from other nodes through a
- *   function that did not survive the clipboard and is not in the scene's
- *   registry.
- * - `container-not-pasted` — its container was left out.
- */
-interface PasteOmission {
-    /** The id the node had when it was copied. */
-    id: string;
-    reason: 'dependency-not-copied' | 'derivation-not-registered' | 'container-not-pasted';
-    missing?: string[];
-}
-/** What `commitPaste` is told beyond the snapshot and the offset. */
-interface PasteCtx {
-    dropPoint?: {
-        worldX: number;
-        worldY: number;
-    };
-    /** Called once per copied node the paste leaves out. */
-    onOmit?: (omission: PasteOmission) => void;
-}
-/**
- * Where a dragged node would re-parent to if released. `slotPose` is the pose
- * (in world coordinates) the node should snap to within the target;
- * `metadata` is an opaque pass-through for app-specific snap details.
- */
-interface SnapTarget<TPose = unknown> {
-    parentId: string;
-    slotPose: TPose;
-    metadata?: unknown;
-}
-/**
- * The contracts below are slices: each names what one reader asks of an
- * adapter. The whole of it, as the kit builds it over a `Scene`, is
- * `SceneCanvasAdapter` (`sceneToAdapter`).
- *
- * **Pose semantics:** `getPose` / `setPose` work in **local** coordinates —
- * relative to the node's direct parent (or world, for root-parented nodes).
- * `getWorldPose`, where an adapter has it, is the composed reading.
- *
- * **Every adapter carries the tree:** `getNode`, `getParent`, and
- * `getChildren`. A list with no nesting is a tree whose nodes are all roots:
- * `getParent` answers `null` and `getChildren(null)` answers every id,
- * bottom first.
- */
-/** Narrow adapter for move. Apps without container-snapping leave out `findSnapTarget`. */
-interface MoveAdapter<TNode extends {
-    id: string;
-}, TPose> {
-    getNode(id: string): TNode | undefined;
-    getNodes(): TNode[];
-    getPose(id: string): TPose;
-    /** The node's container, `null` for a root. */
-    getParent(id: string): string | null;
-    /** Optional paint depth, read by `pickTopMostHit` to resolve two *siblings*
-     *  whose bodies both cover the pointer. Without it the hit list's own order
-     *  decides, which is right for a back-to-front walk and wrong for anything
-     *  else. See `PickTopMostHitAdapter` for the `compareZ` alternative. */
-    getZIndex?(id: string): number | null | undefined;
-    compareZ?(a: string, b: string): number;
-    setPose(id: string, pose: TPose): void;
-    /** Optional. Used only by reparent ops; an adapter that never reparents may omit. */
-    setParent?(id: string, parentId: string | null): void;
-    /** Optional. The commit point of a gesture. When omitted, ops are applied
-     *  against the adapter one by one; an adapter with a history of its own
-     *  takes them here as one entry. */
-    applyOps?(ops: Op[], label: string): void;
-    /** Optional. Show each node at its pose without writing the document, so
-     *  nothing is recorded; `null` withdraws a node's preview. What a behavior
-     *  that keeps moving nodes after the gesture ends writes each frame. */
-    previewPoses?(poses: ReadonlyMap<string, TPose | null>): void;
-    /** Optional. The animation target of node `id`'s pose, the same one on
-     *  every call, so everything animating the node adds; `descriptor` supplies
-     *  its axes the first time. `tweenPose`, `springPose`, and `momentum` move
-     *  it where it is there, and write `setPose` each frame where it is not or
-     *  it answers `undefined`. */
-    poseTarget?(id: string, descriptor?: PoseDescriptor<TPose>): Target<TPose> | undefined;
-    findSnapTarget?(draggedId: string, worldX: number, worldY: number): SnapTarget<TPose> | null;
-    /** Ordered children of `parentId`, `null` for the root siblings, in
-     *  z-order: index 0 is the bottom. One contract with
-     *  {@link OrderedAdapter.getChildren} — the two land on the same adapter
-     *  object. Picking walks it, and the ops read a node's sibling slot from it.
-     *  A node with no children answers `[]`. */
-    getChildren(parentId: string | null): string[];
-    /** Optional: layout strategy attached to a container, or null if the
-     *  container uses absolute positioning. When present, a move uses it to
-     *  compute drop targets, sibling reflow, and the commit op batch. */
-    getLayout?(containerId: string): LayoutStrategy<TPose> | null;
-}
-/** Narrow adapter for resize. */
-interface ResizeAdapter<TNode extends {
-    id: string;
-}, TPose> {
-    getNode(id: string): TNode | undefined;
-    getPose(id: string): TPose;
-    setPose(id: string, pose: TPose): void;
-    /** Optional: see MoveAdapter.applyOps. */
-    applyOps?(ops: Op[], label: string): void;
-}
-/** Narrow adapter for rotate, which mutates pose only and never reparents. */
-interface RotateAdapter<TNode extends {
-    id: string;
-}, TPose> {
-    getNode(id: string): TNode | undefined;
-    getPose(id: string): TPose;
-    setPose(id: string, pose: TPose): void;
-    /** Optional: see MoveAdapter.applyOps. */
-    applyOps?(ops: Op[], label: string): void;
-}
-/** The view a region pick answers for. */
-interface RegionPickView {
-    /** The camera the region was drawn under. With it, a node on a parallax
-     *  layer is tested where that camera's plane paints it. */
-    get?(): View;
-    /** Whether that view paints a layer at all. */
-    layerIsPainted?(layer: string): boolean;
-}
-/**
- * Narrow adapter for marquee selection. Transient: no checkpoint, no
- * history — `applyOps(ops)` is called with no label.
- *
- * All fields are **optional**. `useSelectTool` only wires the default marquee
- * behavior when `hitTestArea`, `getSelection`, `setSelection`, and `applyOps`
- * are all present on the adapter; otherwise empty-space drags do nothing.
- */
-interface AreaSelectAdapter {
-    /** Returns ids of nodes intersecting the world-space rect, as the view the
-     *  rect was drawn in paints them. */
-    hitTestArea?(rect: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }, view?: RegionPickView): string[];
-    /** Current selection — read by behaviors to compute additive merges. */
-    getSelection?(): string[];
-    /** Mutator wired by `setSelection` op. */
-    setSelection?(ids: string[]): void;
-    /** Apply ops without checkpointing or pushing a history entry. The optional
-     *  `label` parameter is accepted (and ignored by transient implementations)
-     *  so that this signature is compatible with `MoveAdapter.applyOps`. */
-    applyOps?(ops: Op[], label?: string): void;
-}
-/**
- * Hit mode for `LassoSelectAdapter.hitTestLasso`:
- *   - 'centers'   — the center of the node's visual bounds is inside the polygon.
- *   - 'intersect' — the node's outline meets the polygon anywhere.
- *   - 'enclosed'  — the node's whole outline is inside the polygon.
- *
- * The outline is the drawn silhouette, rotation included.
- */
-type LassoHitMode = 'centers' | 'intersect' | 'enclosed';
-/**
- * Narrow adapter for lasso selection: `AreaSelectAdapter` plus a polygon
- * hit-test. `selectFromLasso` does nothing without `hitTestLasso`.
- */
-interface LassoSelectAdapter extends AreaSelectAdapter {
-    /** Hit-test against a closed polygon. Vertex order may be CW or CCW; the
-     *  closing edge from last → first is implicit. */
-    hitTestLasso?(polygon: ReadonlyArray<{
-        x: number;
-        y: number;
-    }>, mode: LassoHitMode, view?: RegionPickView): string[];
-}
-/**
- * Narrow adapter for insert and `useClipboardOps`. The kit knows nothing
- * about what shape to construct; it asks the adapter to produce node(s) given
- * gesture or paste inputs, and wraps each in an `InsertOp`.
- */
-interface InsertAdapter<TNode extends {
-    id: string;
-}> {
-    getNode(id: string): TNode | undefined;
-    getParent(id: string): string | null;
-    /** Ordered children of `parentId`, `null` for the root siblings. An insert
-     *  resolves its sibling slot against it. */
-    getChildren(parentId: string | null): string[];
-    /** Materialize a new node from drag-rect bounds (drag-to-insert tools).
-     *  Optional: `sceneToAdapter` only fills it in when `options.commitInsert`
-     *  is supplied. */
-    commitInsert?(bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }): TNode | null;
-    /** Materialize the new nodes from a clipboard snapshot, in order.
-     *  Optional — required only for paste. */
-    commitPaste?(clipboard: ClipboardSnapshot, offset: {
-        dx: number;
-        dy: number;
-    }, ctx?: PasteCtx): TNode[];
-    /** Snapshot the current selection into the clipboard payload shape.
-     *  Optional — required only for copy, cut, and clone's ghost capture. */
-    snapshotSelection?(ids: string[]): ClipboardSnapshot;
-    getPasteOffset?(clipboard: ClipboardSnapshot): {
-        dx: number;
-        dy: number;
-    };
-    /** Mutator wired by `insertNode`-using ops (kit-side InsertOp). `index` is
-     *  the node's z-position among its siblings. `createDeleteOp` captures it
-     *  and `invert()` forwards it, so an implementation that drops it makes
-     *  undo of a delete restore the node at the top instead of where it was.
-     *  Omit only for an unordered store. */
-    insertNode(node: TNode, index?: number): void;
-    /** Mutator wired by `setSelection` ops batched alongside paste. */
-    setSelection(ids: string[]): void;
-    /** Optional: see MoveAdapter.applyOps. */
-    applyOps?(ops: Op[], label: string): void;
-    /** Returns the current selection. Used by clone behaviors. */
-    getSelection(): string[];
-}
-/**
- * The layer list of an adapter whose nodes sit on layers. The scene slot
- * paints one canvas layer per entry; a pick over a bare adapter reads it for
- * parallax planes where it is there.
- */
-interface LayerEnumerableAdapter<TLayer extends string = string> {
-    getLayers?(): readonly {
-        id: TLayer;
-        visible: boolean;
-        parallax?: ParallaxOpts;
-    }[];
-    /** Call `listener` whenever the list `getLayers` answers may have changed.
-     *  A canvas reads the list at mount and again on each call, so an adapter
-     *  whose list never changes leaves this out. */
-    subscribeLayers?(listener: () => void): () => void;
-}
-/**
- * Sibling z-order: what the reorder ops read and write.
- *
- * **Convention:** array order IS z-order. Index 0 is the bottom of the
- * stack, the last index is the top. Hit-testing should iterate the returned
- * list in REVERSE (top to bottom). Render layers iterate FORWARD (bottom to
- * top).
- */
-interface OrderedAdapter {
-    /** Ordered children of `parentId` (or root siblings if null), in z-order:
-     *  index 0 is bottom, last index is top. The same contract
-     *  {@link MoveAdapter.getChildren} declares — one method, two readers. */
-    getChildren(parentId: string | null): string[];
-    /** Rewrite the order of `parentId`'s children. Length and contents must
-     *  match the existing children — reorder only, no add/remove. */
-    setChildOrder(parentId: string | null, ids: string[]): void;
-}
-
-export { type AreaSelectAdapter as A, toPlane as B, type ContainerBounds as C, type DropRegion as D, type InsertAdapter as I, type LayoutStrategy as L, type MoveAdapter as M, type OrderedAdapter as O, type ParallaxOpts as P, type RegionPickView as R, type SnapTarget as S, type PlaneMap as a, type LayoutDropTargetMode as b, type ReflowTransition as c, type PasteOmission as d, type LayerEnumerableAdapter as e, type LassoHitMode as f, type ResizeAdapter as g, type RotateAdapter as h, type LassoSelectAdapter as i, type ClipboardSnapshot as j, type PasteCtx as k, type DropTarget as l, type LayoutArrival as m, type LayoutChild as n, type LayoutContainer as o, type LayoutDragged as p, type LayoutSnap as q, type ReflowGlideOptions as r, type ScalarOrXY as s, deriveParallaxView as t, fromPlane as u, planeMap as v, planeMatrix as w, planeToPlane as x, rectFromPlane as y, rectToPlane as z };
+export { type ContainerBounds as C, type DropRegion as D, type LayoutStrategy as L, type ParallaxOpts as P, type ReflowTransition as R, type ScalarOrXY as S, type PlaneMap as a, type LayoutDropTargetMode as b, type DropTarget as c, type LayoutArrival as d, type LayoutChild as e, type LayoutContainer as f, type LayoutDragged as g, type LayoutSnap as h, type ReflowGlideOptions as i, deriveParallaxView as j, fromPlane as k, planeMatrix as l, planeToPlane as m, rectToPlane as n, planeMap as p, rectFromPlane as r, toPlane as t };

package/dist/types-BN9hbdMI.d.ts

@@ -0,0 +1,184 @@
+import { DebugSink, HitShape, HandleKind, ViewportGestureKind, View } from '@weasel-js/routing';
+
+/** Every debug-overlay feature a `DebugConfig` flag turns on, in the order a list of them shows. */
+declare const DEBUG_FEATURES: readonly ["hitboxes", "handles", "bounds", "origins", "snap", "layers", "ids", "fps", "viewport"];
+
+/**
+ * `DebugSink`, `HitShape` and `HandleKind` are declared in
+ * `@weasel-js/routing`. Re-exported here, beside the overlay that reads one.
+ */
+
+/** One bit per debug feature; absent keys are off. */
+interface DebugConfig {
+    hitboxes?: boolean;
+    handles?: boolean;
+    bounds?: boolean;
+    origins?: boolean;
+    snap?: boolean;
+    layers?: boolean;
+    /** Render each tracked node's id as a label at the top-left of its
+     *  bounds. Pulls from the same `recordBounds` stream `bounds` uses, so
+     *  no extra sink calls are required to enable. */
+    ids?: boolean;
+    /** Frame panel in the top-left corner: repaint rate and interval, the
+     *  CPU cost and GL draw-call count of the last paint, and both again per
+     *  render layer. The rate tracks the overlay's own draw callback, so it is
+     *  the canvas's repaint rate — a canvas that is not repainting shows the
+     *  last numbers, not zero. */
+    fps?: boolean;
+    /** The last viewport change a pan or zoom made: the viewport it started
+     *  from, outlined in the current view, and the world point it held fixed. */
+    viewport?: boolean;
+    /** Ids of nodes to outline, the way the Elements panel outlines a hovered
+     *  element. Their bounds are recorded whether or not `bounds` is on. */
+    highlight?: readonly string[];
+    /** Optional per-feature color overrides; falls back to the default theme. */
+    theme?: Partial<DebugTheme>;
+    /** Optional per-feature line-width / dash overrides; falls back to
+     *  {@link DEFAULT_DEBUG_STROKES}. */
+    strokes?: Partial<DebugStrokes>;
+}
+/** The name of one debug-overlay feature — the keys of {@link DebugConfig}
+ *  that toggle a visualization. */
+type DebugFeature = (typeof DEBUG_FEATURES)[number];
+/** Colors the debug overlay draws with, one entry per feature. */
+interface DebugTheme {
+    hitboxFill: string;
+    hitboxStroke: string;
+    handle: string;
+    bounds: string;
+    origin: string;
+    snap: string;
+    layerText: string;
+    layerTextBg: string;
+    /** Color for the per-node id label rendered when `config.ids` is on. */
+    idText: string;
+    /** Foreground / background for the FPS panel. */
+    fpsText: string;
+    fpsTextBg: string;
+    /** Previous-viewport outline, anchor trail and readout. */
+    viewport: string;
+    /** Outline of each highlighted node. */
+    highlight: string;
+}
+/** Line width and dash pattern for one stroked debug feature. An empty (or
+ *  omitted) `dash` is a solid line. */
+interface DebugStroke {
+    width: number;
+    dash?: readonly number[];
+}
+/** The stroked half of the debug overlay's appearance, split from
+ *  {@link DebugTheme} because only some features draw a line at all — text
+ *  panels and filled origin dots take color and nothing else. */
+interface DebugStrokes {
+    hitbox: DebugStroke;
+    bounds: DebugStroke;
+    handle: DebugStroke;
+    /** Rejected snap candidates only; accepted ones paint as a filled dot. */
+    snap: DebugStroke;
+    /** The previous-viewport outline and the anchor's trail. */
+    viewport: DebugStroke;
+    highlight: DebugStroke;
+}
+/** A hit region tested during the current frame. */
+interface RecordedHitbox {
+    id: string;
+    kind: 'body' | 'handle' | 'rotation' | 'anchor';
+    shape: HitShape;
+}
+/** A handle drawn during the current frame, and where. */
+interface RecordedHandle {
+    id: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    kind: HandleKind;
+}
+/** A node's bounds as computed during the current frame. */
+interface RecordedBounds {
+    id: string;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/** A node's transform origin as used during the current frame. */
+interface RecordedOrigin {
+    id: string;
+    point: {
+        x: number;
+        y: number;
+    };
+}
+/** A snap candidate considered during the current gesture, and whether it
+ *  won. Unlike the other records these survive across frames, until the
+ *  gesture ends. */
+interface RecordedSnap {
+    point: {
+        x: number;
+        y: number;
+    };
+    accepted: boolean;
+}
+/** A render layer that drew during the current frame. */
+interface RecordedLayer {
+    id: string;
+    label: string;
+    space: 'world' | 'screen';
+    index: number;
+}
+/** The last viewport change a gesture made. See `DebugSink.recordViewport`. */
+interface RecordedViewport {
+    kind: ViewportGestureKind;
+    from: View;
+    to: View;
+    /** World point the gesture held fixed, when it had one. */
+    anchor?: {
+        x: number;
+        y: number;
+    };
+}
+/** What one render layer cost in a paint. */
+interface LayerFrameStats {
+    id: string;
+    /** GL draw calls issued while this layer's commands were dispatched. A
+     *  batched run is drawn when it closes, so it counts toward the layer that
+     *  closed it. */
+    drawCalls: number;
+    /** CPU milliseconds: building the layer's commands plus dispatching them. */
+    ms: number;
+}
+/** What one paint cost, for the frame panel. */
+interface FrameStats {
+    /** CPU milliseconds for the whole paint — command build and dispatch. GPU
+     *  time is not included; the GPU runs asynchronously. */
+    paintMs: number;
+    drawCalls: number;
+    layers: LayerFrameStats[];
+}
+/** Everything the sink collected, ready for the overlay to draw. */
+interface DebugSnapshot {
+    hitboxes: RecordedHitbox[];
+    handles: RecordedHandle[];
+    bounds: RecordedBounds[];
+    origins: RecordedOrigin[];
+    snap: RecordedSnap[];
+    layers: RecordedLayer[];
+    /** Latest viewport change; survives frames until replaced. */
+    viewport: RecordedViewport | null;
+    /** The previous paint's cost. The overlay draws before the paint it is part
+     *  of is dispatched, so this is always one paint behind. */
+    frame: FrameStats | null;
+}
+/** The sink `<Canvas>` creates: what tools record into, plus the canvas-side
+ *  half — the frame stats only the painter knows — and the read the overlay
+ *  draws from. */
+interface CanvasDebugSink extends DebugSink {
+    recordFrame(stats: FrameStats): void;
+    snapshot(): DebugSnapshot;
+}
+
+export { type CanvasDebugSink as C, type DebugSnapshot as D, type FrameStats as F, type LayerFrameStats as L, type RecordedBounds as R, type DebugConfig as a, type DebugStrokes as b, type DebugTheme as c, DEBUG_FEATURES as d, type DebugFeature as e, type DebugStroke as f, type RecordedHandle as g, type RecordedHitbox as h, type RecordedLayer as i, type RecordedOrigin as j, type RecordedSnap as k, type RecordedViewport as l };