@weasel-js/core 1.7.0 → 1.7.2

package/dist/tools/prefs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefs.js","names":["prefUnit","self","unitScale","system","display","scale","opts","suffix","accepts","name","other","factor","offset","shown","stored","formatUnit","TOOL_PREF_KINDS","isBuiltinToolPref","leaf"],"sources":["../../src/tools/prefs.ts"],"sourcesContent":["// src/tools/prefs.ts\n//\n// Minimal pref descriptor for tools that want to expose user-facing\n// settings (commit-on-close, snap thresholds, etc.). Host apps compose\n// these into their own preferences registry; the kit ships no storage\n// or UI of its own. The shape is intentionally narrow — number,\n// boolean, string, enum, plus rendering hints — so it's a clean\n// structural subset of whatever a host app already has.\n\nimport { formatUnit, unitScale } from '@weasel-js/quantity';\nimport type { Display, Unit, UnitEntry, UnitScale, UnitSystem } from '@weasel-js/quantity';\n\n/** The value types a built-in pref leaf can hold. */\nexport type ToolPrefKind =\n  | 'number' | 'boolean' | 'string' | 'enum' | 'color' | 'paint' | 'object';\n\n/** The fields every leaf pref shares, keyed by its `kind` and typed by its stored value. */\nexport interface ToolPrefBase<K extends string, Value> {\n  kind: K;\n  /** Human-readable label. */\n  name: string;\n  /** Longer help text — shown in tooltips / a settings pane. */\n  description: string;\n  /** Fallback when nothing is persisted. */\n  default: Value;\n  /** Hide from a host app's settings UI by default. */\n  hidden?: boolean;\n  /** Render full-width with no label row in schema-driven settings UIs\n   *  (weasel-ui `PrefsForm` honors this for leaves whose control brings\n   *  its own chrome). */\n  block?: boolean;\n  /** Glyph naming this leaf in a host UI's icon set (weasel-ui resolves it\n   *  against `ICON_PATHS`). A plain string because core ships no icon set and\n   *  cannot depend on one. Read where a leaf's `name` has nowhere to go — a\n   *  `pair`ed row is labeled by the pair, so its fields have only the glyph\n   *  to tell them apart. */\n  icon?: string;\n  /** Row-pairing hint for compact property UIs (weasel-ui\n   *  `SelectionPanel`): leaves sharing a `pair` id render side-by-side\n   *  on one row labeled with the `pair` string (e.g. `'Position'` for\n   *  `pose.x` / `pose.y`). Purely presentational. */\n  pair?: string;\n  /** The label a surface with no room for `name` shows instead — a strip of\n   *  controls on one line, or a segment in a `pair`ed row. `name` stays the\n   *  accessible name, so this abbreviates without costing anything. */\n  short?: string;\n}\n\n/** How a schema-driven UI should present a number pref. */\nexport type ToolPrefNumberControl = 'input' | 'slider';\n/** How a schema-driven UI should present a boolean pref. */\nexport type ToolPrefBooleanControl = 'checkbox' | 'switch' | 'toggle';\n/** How a schema-driven UI should present a string pref. */\nexport type ToolPrefStringControl = 'input' | 'textarea';\n/** How a schema-driven UI should present an enum pref. */\nexport type ToolPrefEnumControl = 'select' | 'radio' | 'toggle';\n\n/** Display-unit conversion for number leaves whose stored value uses a\n *  canonical unit the user shouldn't see (e.g. radians stored, degrees\n *  shown). The stored value stays canonical; UIs convert at the edge. */\nexport interface ToolPrefNumberUnit {\n  toDisplay: (stored: number) => number;\n  fromDisplay: (display: number) => number;\n  /** Shown after the input, e.g. `'°'`. */\n  suffix?: string;\n  /** Suffixes a person may type, each mapped to the scale that turns a\n   *  number in that unit into a display number: `{ mm: 0.1, cm: 1 }` for a\n   *  field showing centimeters. A unit that disagrees with the display unit\n   *  about zero carries an `offset` as well. */\n  accepts?: Readonly<Record<string, UnitEntry>>;\n  /** The stored value as display text, suffix included. */\n  format?: (stored: number) => string;\n}\n\n/**\n * A display unit built from a {@link UnitSystem}: values are stored in the\n * system's base and shown in `display`, rounded to `precision` places when\n * given, and every unit in the system is accepted as typed text. `suffix`\n * defaults to the unit's name and is accepted too.\n */\nexport function prefUnit(\n  system: UnitSystem,\n  display: Unit,\n  opts?: { precision?: number; suffix?: string },\n): ToolPrefNumberUnit {\n  let self: Required<UnitScale>;\n  try {\n    self = unitScale(system, display);\n  } catch (e) {\n    throw new Error(`prefUnit: ${e instanceof Error ? e.message : String(e)}`);\n  }\n  const scale = opts?.precision === undefined ? undefined : 10 ** opts.precision;\n  const suffix = opts?.suffix ?? display;\n  const accepts: Record<string, UnitEntry> = { [suffix]: 1 };\n  for (const name of Object.keys(system.units)) {\n    const other = unitScale(system, name);\n    // A number typed in `name` reaches display units through base:\n    // `(n * factor + offset - self.offset) / self.factor`.\n    const factor = other.factor / self.factor;\n    const offset = (other.offset - self.offset) / self.factor;\n    accepts[name] = offset === 0 ? factor : { factor, offset };\n  }\n  const toDisplay = (stored: number) => {\n    const shown = (stored - self.offset) / self.factor;\n    return scale === undefined ? shown : Math.round(shown * scale) / scale;\n  };\n  return {\n    toDisplay,\n    fromDisplay: (shown) => shown * self.factor + self.offset,\n    suffix,\n    accepts,\n    format: (stored) =>\n      `${formatUnit(stored, display, system, {\n        precision: opts?.precision ?? 2,\n        suffix: false,\n      })}${suffix}`,\n  };\n}\n\n/** A numeric pref, optionally bounded and stepped, and optionally stored in a\n *  different unit from the one shown. */\nexport interface ToolPrefNumber extends ToolPrefBase<'number', number> {\n  min?: number;\n  max?: number;\n  step?: number;\n  control?: ToolPrefNumberControl;\n  /** How the value shows, speaks and reads back when typed — `compact()`\n   *  reads `2.00M`. Presentation only: the stored value stays a number. */\n  display?: Display;\n  unit?: ToolPrefNumberUnit;\n}\n/**\n * Stored-value bridge for a boolean leaf whose field is not a boolean — the\n * flag counterpart of {@link ToolPrefEnumEncoding}. `TextStyle.fontStyle` is\n * the case: it stores `'italic'`, and the control is an Italic toggle.\n */\nexport interface ToolPrefBooleanEncoding {\n  /** Whether `stored` reads as on. */\n  read: (stored: unknown, siblings: Record<string, unknown> | undefined) => boolean;\n  /** What to store for `on`. `undefined` removes the field. */\n  write: (on: boolean, siblings: Record<string, unknown> | undefined) => unknown;\n}\n\n/** An on/off pref. */\nexport interface ToolPrefBoolean extends ToolPrefBase<'boolean', boolean> {\n  control?: ToolPrefBooleanControl;\n  encoding?: ToolPrefBooleanEncoding;\n}\n/** A free-text pref. */\nexport interface ToolPrefString extends ToolPrefBase<'string', string> {\n  control?: ToolPrefStringControl;\n}\n/**\n * Stored-value bridge for an enum leaf whose value is not the option string —\n * the counterpart of {@link ToolPrefNumberUnit}, which does the same for a\n * number stored in a canonical unit.\n *\n * A dash array is the case that needs it: `Stroke.dash` stores lengths, and\n * the thing a person chooses is a style. The presets scale by the stroke's\n * width, so both directions are given the object's other fields — a style is\n * meaningless without the width it is a multiple of.\n */\nexport interface ToolPrefEnumEncoding<T extends string = string> {\n  /**\n   * The option `stored` reads as, or `undefined` for none — which a UI shows\n   * the way it shows a mixed selection, by selecting nothing.\n   *\n   * `siblings` is the object the leaf is a field of, or `undefined` when the\n   * node does not hold that object (and for a top-level leaf, which has none).\n   */\n  read: (stored: unknown, siblings: Record<string, unknown> | undefined) => T | undefined;\n  /** What to store for `option`. `undefined` removes the field. */\n  write: (option: T, siblings: Record<string, unknown> | undefined) => unknown;\n}\n\n/** A pref with a fixed set of labeled choices. `default` is `undefined` only\n *  for a {@link ToolPrefEnum.clearable} leaf, whose absence is a value. */\nexport interface ToolPrefEnum<T extends string = string>\n  extends ToolPrefBase<'enum', T | undefined> {\n  /**\n   * The field may hold none of the options, and that absence is a state of\n   * its own rather than a missing value — a script that is neither super nor\n   * sub. A toggle control then lets the chosen segment be clicked off, which\n   * removes the field.\n   */\n  clearable?: boolean;\n  /** `short` is the label a segmented control uses when a full one would not\n   *  fit — a capital or two. `icon` names a glyph in the host UI's set\n   *  (weasel-ui resolves it against `ICON_PATHS`) and outranks `short` where\n   *  it resolves. It is a plain string because core ships no icon set and\n   *  cannot depend on one. The full `label` stays the accessible name, so\n   *  neither the abbreviation nor the glyph becomes the only thing naming\n   *  the option.\n   *\n   *  `disabled` marks an option a control reports but cannot author — the\n   *  value a stored form reads as when it matches nothing offered. Dropping it\n   *  from the list instead would leave the control selecting nothing and\n   *  claiming the field is unset. */\n  options: readonly {\n    value: T;\n    label: string;\n    short?: string;\n    icon?: string;\n    disabled?: boolean;\n  }[];\n  control?: ToolPrefEnumControl;\n  encoding?: ToolPrefEnumEncoding<T>;\n}\n\n/** A single color, stored as a hex string. For a value that may also be a\n *  gradient or a pattern, use {@link ToolPrefPaint} instead. */\nexport interface ToolPrefColor extends ToolPrefBase<'color', string> {\n  /** Value is `#rrggbb`, or `#rrggbbaa` when `alpha` is set (UIs then\n   *  offer an opacity control). */\n  alpha?: boolean;\n}\n\n/**\n * Open leaf: any node with a `kind` outside the built-ins. Schema-driven\n * UIs (weasel-ui `PrefsForm` / `SelectionPanel`) dispatch it to an\n * app-supplied renderer. Deliberately NOT index-signatured so concrete\n * app interfaces stay assignable. Mirrors weasel-ui's `PrefCustom`.\n */\nexport type ToolPrefCustom = ToolPrefBase<string, unknown>;\n\n/**\n * A whole `FillStyle`, not a color inside one. Use it wherever the value is\n * the tagged paint union — a solid color, a pattern, a gradient — rather\n * than a hex string.\n *\n * Addressing `…fill.color` instead reads `undefined` off a gradient (so the\n * control shows its default and claims the text is black) and writes a\n * hybrid `{ fill: 'gradient', stops, color }` that the renderer's structural\n * `'color' in paint` checks then paint flat solid. The union has to be\n * edited as a union.\n */\nexport interface ToolPrefPaint extends ToolPrefBase<'paint', unknown> {\n  /** Offer an opacity control alongside the color. */\n  alpha?: boolean;\n}\n\n/**\n * A leaf whose value is one object, with its own fields hanging off it.\n *\n * A compound value — a stroke, a shadow, a pattern spec — could be described\n * as several sibling leaves addressing into it (`data.stroke.width`,\n * `data.stroke.cap`). It shouldn't be: each control would then write one field\n * of a value it can only half see, and writing into something that is not an\n * object yet corrupts it. Here the fields are `children` of one leaf, and\n * every edit commits the parent object whole.\n *\n * `children` paths are relative to the object. They are ordinary leaves, so a\n * field that is itself a union (a stroke's `paint`) declares the kind that\n * edits that union. A child may also be a {@link ToolPrefGroup}, which\n * organises the fields under a heading without contributing to the path —\n * the same rule group keys follow at the top level. A `TextStyle` needs it:\n * its character and paragraph fields belong to one value but read as two\n * lists.\n */\nexport interface ToolPrefObject extends ToolPrefBase<'object', unknown> {\n  children: Record<string, ToolPrefLeaf | ToolPrefGroup>;\n  /**\n   * Lift a non-object value into the object form, for a consumer field that\n   * may also be held as a scalar. Called before a child edit is applied;\n   * without it a scalar-valued leaf shows its children empty and refuses the\n   * edit.\n   */\n  fromScalar?: (value: unknown) => Record<string, unknown>;\n}\n\n/** One built-in pref leaf. `ToolPrefLeaf` widens this to include\n *  app-defined kinds. */\nexport type ToolPref =\n  | ToolPrefNumber\n  | ToolPrefBoolean\n  | ToolPrefString\n  | ToolPrefEnum\n  | ToolPrefColor\n  | ToolPrefPaint\n  | ToolPrefObject;\n\n// Compile-time tie: every built-in leaf kind must appear in ToolPrefKind\n// and vice versa (ToolPrefBase's K is open for ToolPrefCustom's sake, so\n// the union no longer enforces it).\ntype _BuiltinKindsExact = [ToolPref['kind']] extends [ToolPrefKind]\n  ? [ToolPrefKind] extends [ToolPref['kind']] ? true : never\n  : never;\nconst _builtinKindsExact: _BuiltinKindsExact = true;\nvoid _builtinKindsExact;\n\n/**\n * The built-in kinds, as a table. A kind added to {@link ToolPrefKind} is a\n * compile error here, and from here it is one in every renderer's `never`\n * guard — the only thing standing between a new kind and rendering as\n * nothing in four places at once.\n */\nexport const TOOL_PREF_KINDS: Record<ToolPrefKind, true> = {\n  number: true,\n  boolean: true,\n  string: true,\n  enum: true,\n  color: true,\n  paint: true,\n  object: true,\n};\n\n/**\n * Narrows a leaf to the built-in union, so a renderer's switch discriminates\n * on {@link ToolPrefKind} instead of the open `string` that\n * {@link ToolPrefCustom} widens `kind` to. An app-defined kind answers false\n * and belongs to the renderer's custom-renderer path.\n */\nexport function isBuiltinToolPref(leaf: ToolPrefLeaf): leaf is ToolPref {\n  return Object.hasOwn(TOOL_PREF_KINDS, leaf.kind);\n}\n\n/** Built-in or app-defined leaf. */\nexport type ToolPrefLeaf = ToolPref | ToolPrefCustom;\n\n/** Nestable group: branch nodes a tool can use to organize its prefs. */\nexport interface ToolPrefGroup {\n  /** Heading for the group's rows. **Empty means no heading** — for a group\n   *  that exists to organise, not to name: one whose children are themselves\n   *  groups carrying the labels a reader needs. Give it a name whenever the\n   *  name is the referent (a `Border` group over `Top` / `Right` / `Bottom`\n   *  reads as nothing without it). */\n  name: string;\n  description?: string;\n  children: Record<string, ToolPrefLeaf | ToolPrefGroup>;\n}\n"],"mappings":";;AAgFA,SAAgBA,EACd,GACA,GACA,GACoB;CACpB,IAAIC;CACJ,IAAI;EACF,IAAOC,EAAUC,GAAQC,CAAO;CAClC,SAAS,GAAG;EACV,MAAU,MAAM,aAAa,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC,GAAG;CAC3E;CACA,IAAMC,IAAQC,GAAM,cAAc,KAAA,IAAY,KAAA,IAAY,MAAMA,EAAK,WAC/DC,IAASD,GAAM,UAAUF,GACzBI,IAAqC,GAAGD,IAAS,EAAE;CACzD,KAAK,IAAME,KAAQ,OAAO,KAAKN,EAAO,KAAK,GAAG;EAC5C,IAAMO,IAAQR,EAAUC,GAAQM,CAAI,GAG9BE,IAASD,EAAM,SAAST,EAAK,QAC7BW,KAAUF,EAAM,SAAST,EAAK,UAAUA,EAAK;EACnD,EAAQQ,KAAQG,MAAW,IAAID,IAAS;GAAE;GAAQ;EAAO;CAC3D;CAKA,OAAO;EACL,YALiB,MAAmB;GACpC,IAAME,KAASC,IAASb,EAAK,UAAUA,EAAK;GAC5C,OAAOI,MAAU,KAAA,IAAYQ,IAAQ,KAAK,MAAMA,IAAQR,CAAK,IAAIA;EACnE;EAGE,cAAc,MAAUQ,IAAQZ,EAAK,SAASA,EAAK;EACnD;EACA;EACA,SAAS,MACP,GAAGc,EAAWD,GAAQV,GAASD,GAAQ;GACrC,WAAWG,GAAM,aAAa;GAC9B,QAAQ;EACV,CAAC,IAAIC;CACT;AACF;AAmLA,IAAaS,IAA8C;CACzD,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,MAAM;CACN,OAAO;CACP,OAAO;CACP,QAAQ;AACV;AAQA,SAAgBC,EAAkB,GAAsC;CACtE,OAAO,OAAO,OAAOD,GAAiBE,EAAK,IAAI;AACjD"}

package/dist/tools/useKeybindings.js

@@ -0,0 +1,66 @@
+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";
+//#region src/tools/useKeybindings.ts
+var s = {
+	select: { key: "V" },
+	rect: { key: "R" },
+	ellipse: { key: "E" },
+	line: { key: "\\" },
+	polygon: { key: "G" },
+	pencil: { key: "N" },
+	text: { key: "T" },
+	hand: { key: "H" },
+	pen: { key: "P" }
+};
+function c(c, l = {}) {
+	let u = a(c), d = a(l), f = i(c.active), p = o();
+	r(() => {
+		if (d.current.disable || !p || Object.keys(u.current.registry).length === 0) return;
+		let r = [];
+		for (let [e, t] of Object.entries(s)) u.current.has(e) && r.push({
+			toolId: e,
+			keyOpts: t
+		});
+		let i = u.current.registry;
+		for (let e in i) {
+			if (e in s) continue;
+			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
+				}
+			});
+		}
+		let a = [];
+		if (r.length > 0) {
+			let n = e(r);
+			a.push(p.register(t(n, (e) => d.current.isToolEligible?.(e) ?? !0)));
+		}
+		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();
+		};
+	}, [
+		p,
+		c,
+		u,
+		d
+	]);
+}
+//#endregion
+export { c as useKeybindings };
+
+//# sourceMappingURL=useKeybindings.js.map

package/dist/tools/useKeybindings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeybindings.js","names":["BUILTIN_SELECT_KEYS","useKeybindings","toolsRef","useLatest","tools","optionsRef","options","initialActiveRef","useRef","registry","useActionsRegistry","specs","toolId","keyOpts","allTools","binding","keys","key","unregisters","bindings","buildToolActivateBindings","makeToolActivateAction","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 {\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   * Gate for keyboard tool activation: return false to refuse a tool the\n   * active mode doesn't allow. `<SceneCanvas>` wires this from\n   * its `modes` registry + each tool's `eligibility.capabilities`, using the same predicate\n   * `ToolPalette` uses to grey a button out — so the grey-out becomes a\n   * guarantee rather than a hint.\n   *\n   * Omit for consumers with no mode registry: every tool stays activatable.\n   */\n  isToolEligible?: (toolId: string) => boolean;\n}\n\n/** Key opts for every built-in tool whose activation key lives here rather\n *  than on the ToolDef. Consumed by the tool-select action-registration effect. */\nconst BUILTIN_SELECT_KEYS: Record<string, { key: string }> = {\n  select: { key: 'V' },\n  rect: { key: 'R' },\n  ellipse: { key: 'E' },\n  line: { key: '\\\\' },\n  polygon: { key: 'G' },\n  pencil: { key: 'N' },\n  text: { key: 'T' },\n  hand: { key: 'H' },\n  pen: { key: 'P' },\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  // Built-in tools with static keys come from BUILTIN_SELECT_KEYS; tools\n  // whose activation key is configurable via their ToolDef (e.g. useLassoTool)\n  // are picked up dynamically from the tools registry.\n  useEffect(() => {\n    if (optionsRef.current.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    for (const [toolId, keyOpts] of Object.entries(BUILTIN_SELECT_KEYS)) {\n      if (toolsRef.current.has(toolId)) {\n        specs.push({ toolId, keyOpts });\n      }\n    }\n\n    const allTools = toolsRef.current.registry;\n    for (const toolId in allTools) {\n      if (toolId in BUILTIN_SELECT_KEYS) continue;\n      const binding = allTools[toolId].keybinding;\n      if (!binding) continue;\n      // KeyBinding.key may be an array; the consolidated action's per-entry\n      // key spec expects a string. Take the first key in the array case —\n      // multi-key aliases are rare in practice and the action system doesn't\n      // support them yet.\n      // `KeyBinding.key` may be an array of aliases. Emit one binding per\n      // key: the old document listener matched every alias while this path\n      // only took `key[0]`, so a multi-key tool activated on all its keys\n      // through one route and only the first through the other.\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) => optionsRef.current.isToolEligible?.(toolId) ?? true,\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]);\n}\n\n"],"mappings":";;;;;;AAkCA,IAAMA,IAAuD;CAC3D,QAAQ,EAAE,KAAK,IAAI;CACnB,MAAM,EAAE,KAAK,IAAI;CACjB,SAAS,EAAE,KAAK,IAAI;CACpB,MAAM,EAAE,KAAK,KAAK;CAClB,SAAS,EAAE,KAAK,IAAI;CACpB,QAAQ,EAAE,KAAK,IAAI;CACnB,MAAM,EAAE,KAAK,IAAI;CACjB,MAAM,EAAE,KAAK,IAAI;CACjB,KAAK,EAAE,KAAK,IAAI;AAClB;AAKA,SAAgBC,EACd,GACA,IAAiC,CAAC,GAC5B;CACN,IAAMC,IAAWC,EAAUC,CAAK,GAC1BC,IAAaF,EAAUG,CAAO,GAI9BC,IAAmBC,EAAOJ,EAAM,MAAM,GAItCK,IAAWC,EAAmB;CAYpC,QAAgB;EAId,IAHIL,EAAW,QAAQ,WACnB,CAACI,KAED,OAAO,KAAKP,EAAS,QAAQ,QAAQ,CAAC,CAAC,WAAW,GAAG;EAEzD,IAAMS,IAAmC,CAAC;EAE1C,KAAK,IAAM,CAACC,GAAQC,MAAY,OAAO,QAAQb,CAAmB,GAChE,AAAIE,EAAS,QAAQ,IAAIU,CAAM,KAC7BD,EAAM,KAAK;GAAE;GAAQ;EAAQ,CAAC;EAIlC,IAAMG,IAAWZ,EAAS,QAAQ;EAClC,KAAK,IAAMU,KAAUE,GAAU;GAC7B,IAAIF,KAAUZ,GAAqB;GACnC,IAAMe,IAAUD,EAASF,EAAO,CAAC;GACjC,IAAI,CAACG,GAAS;GASd,IAAMC,IAAO,OAAOD,EAAQ,OAAQ,WAAW,CAACA,EAAQ,GAAG,IAAIA,EAAQ;GACvE,KAAK,IAAME,KAAOD,GAChB,AAAKC,KACLN,EAAM,KAAK;IAAE;IAAQ,SAAS;KAAE,GAAGI;KAAS;IAAI;GAAE,CAAC;EAEvD;EAEA,IAAMG,IAAiC,CAAC;EAExC,IAAIP,EAAM,SAAS,GAAG;GACpB,IAAMQ,IAAWC,EAA0BT,CAAK;GAChD,EAAY,KAAKF,EAAS,SAASY,EACjCF,IACC,MAAWd,EAAW,QAAQ,iBAAiBO,CAAM,KAAK,EAC7D,CAAC,CAAC;EACJ;EAiBA,OAVAM,EAAY,KAAKT,EAAS,SAASa,QAAmC;GACpE,IAAMC,IAAMlB,EAAW,QAAQ;GAC/B,IAAIkB,MAAQ,MAAM,OAAO;GACzB,IAAMC,IAASD,KAAOhB,EAAiB;GACvC,IAAI,CAACiB,GAAQ,OAAO;GACpB,IAAMC,IAAMvB,EAAS;GAErB,OADI,CAACuB,EAAI,IAAID,CAAM,KAAKC,EAAI,WAAWD,IAAe,OAC/CA;EACT,CAAC,CAAC,CAAC,SAEU;GAAE,KAAK,IAAME,KAAKR,GAAa,EAAE;EAAG;CACnD,GAAG;EAACT;EAAUL;EAAOF;EAAUG;CAAU,CAAC;AAC5C"}

package/dist/{types-D-9QWBy5.d.ts → types-A37hYkeR.d.ts}

@@ -1,5 +1,89 @@
 import { Op } from '@weasel-js/history';
-import { P as Path } from './path-JEV2c5If.js';
+import { Path } from '@weasel-js/geom';
+import { View } from '@weasel-js/routing';
+
+/** One value for both axes, or a separate value per axis. */
+type ScalarOrXY = number | {
+    x: number;
+    y: number;
+};
+/** How a parallax plane tracks the camera: `pan` is the fraction of the
+ *  camera's translation it follows (1 = locked to the scene, 0 = fixed to the
+ *  screen), `zoom` the same for scale, and `anchor` the camera position
+ *  (`view.x` / `view.y`) the translation is measured from — every plane lines
+ *  up when the camera sits there. */
+interface ParallaxOpts {
+    pan: ScalarOrXY;
+    zoom?: ScalarOrXY;
+    anchor?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Pure derivation of a parallax plane's inner `View` from the camera view
+ * plus per-plane factors.
+ *
+ * `pan` controls how much the plane translates with the camera (1 = normal,
+ * 0 = locked to `anchor`, >1 = leads). `zoom` controls how much it scales
+ * with camera zoom (1 = normal, 0 = fixed at identity scale). `anchor`
+ * (default origin) is the camera position at which all planes agree.
+ *
+ * Identity holds: `pan=1, zoom=1` returns a view equal to `outer`.
+ */
+declare function deriveParallaxView(outer: View, opts: ParallaxOpts): View;
+/** How a point of the camera's world lands in a plane's world, per axis:
+ *  `plane = world * scale + offset`. A plane draws its content through its
+ *  own view; this is what lets a pointer, a marquee or a selection box cross
+ *  between that view and the camera's. */
+interface PlaneMap {
+    scale: {
+        x: number;
+        y: number;
+    };
+    offset: {
+        x: number;
+        y: number;
+    };
+}
+/** The map from `outer`'s world into the world of a plane drawn through
+ *  `deriveParallaxView(outer, opts)` — the one that puts both points under the
+ *  same pixel. */
+declare function planeMap(outer: View, opts: ParallaxOpts): PlaneMap;
+/** Map a point from the outer view's world into the plane's world. */
+declare function toPlane(m: PlaneMap, p: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+};
+/** Map a point from the plane's world back into the outer view's world. */
+declare function fromPlane(m: PlaneMap, p: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+};
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** A camera-world rect in the plane's world. The map is axis-aligned, so a
+ *  rect stays a rect; a flipped axis is normalized back to a positive size. */
+declare function rectToPlane<R extends Rect>(m: PlaneMap, r: R): R;
+/** A plane-world rect in the camera's world — see {@link rectToPlane}. */
+declare function rectFromPlane<R extends Rect>(m: PlaneMap, r: R): R;
+/** The map from one world into another, where `null` is the camera's own:
+ *  `fromPlane(from)`, then `toPlane(to)`. Null when the two are the same
+ *  world, so a caller can skip the work. */
+declare function planeToPlane(from: PlaneMap | null, to: PlaneMap | null): PlaneMap | null;
+/** The map as an affine matrix in `@weasel-js/geom`'s `[a, b, c, d, e, f]`
+ *  order, for `transformPath` and friends. */
+declare function planeMatrix(m: PlaneMap): [number, number, number, number, number, number];
 
 /** A layout container's extent in world units. */
 type ContainerBounds = {
@@ -67,11 +151,59 @@ type DropRegion = Path | ((point: {
  *   only when the point is inside it; ties are broken as for `'innermost'`.
  */
 type LayoutDropTargetMode = 'innermost' | 'topmost' | 'region';
+/**
+ * Carries a layout's sibling reflow to its targets over time rather than in
+ * one frame. `moveAction` hands every sibling a drag displaces to `glide`
+ * instead of snapping it, and `settle`s each one when it stops reflowing or
+ * the gesture ends; the dragged nodes themselves settle from where they were
+ * let go, and a node grabbed mid-glide is held where it is shown and dragged
+ * from there. What the node shows meanwhile is published through the
+ * scene's pose overrides; the document is never written.
+ *
+ * The scene's own reflows — the arrangement it re-applies after an insert,
+ * delete, reorder or resize inside a laid-out container — are `settle`d from
+ * the pose each child had before.
+ *
+ * `useAnimatedReflow` builds one over the animator. Supply it through
+ * `<SceneCanvas reflowTransition>` or `LayoutDep.reflow`.
+ */
+interface ReflowTransition<TPose = unknown> {
+    /** Move what `id` shows toward `pose`, in the node's stored frame. A glide
+     *  already running is retargeted from where it is now; naming the pose it
+     *  is already heading for changes nothing. With `from`, the glide starts
+     *  over from that pose instead. */
+    glide(id: string, pose: TPose, opts?: ReflowGlideOptions<TPose>): void;
+    /** Glide `id` onto its document pose, then stop overriding it. Without
+     *  `from` this only touches a node it is already moving; with `from` it
+     *  takes the node over from that pose, whatever is showing it. */
+    settle(id: string, opts?: ReflowGlideOptions<TPose>): void;
+    /** Stop overriding `id` now, wherever it is. */
+    stop(id: string): void;
+    /** What `id` is being shown at, or `undefined` when this is not moving it. */
+    poseOf(id: string): TPose | undefined;
+}
+/** Where a {@link ReflowTransition} glide starts. */
+interface ReflowGlideOptions<TPose = unknown> {
+    /** The pose to start from, in the node's stored frame — where something
+     *  else was last showing it, such as a drag at its release. Default:
+     *  wherever the node is shown now. */
+    from?: TPose;
+}
 /** The container a layout strategy is arranging children within. */
 interface LayoutContainer {
     id: string;
     bounds: ContainerBounds;
 }
+/** What a container does about an edit to its children: see
+ *  {@link LayoutStrategy.arrive} and {@link LayoutStrategy.depart}. */
+interface LayoutArrival<TPose> {
+    /** World poses to write — the arrivals', and any sibling the strategy moves
+     *  to make room. A child left out keeps its pose. */
+    poses: Map<string, TPose>;
+    /** The container's new world bounds, when the arrangement needs a
+     *  different extent. Absent keeps the container as it is. */
+    bounds?: ContainerBounds;
+}
 /** The child currently being dragged: where it started, where the pointer
  *  currently proposes it goes, and which container it came from. */
 interface LayoutDragged<TPose> {
@@ -86,8 +218,10 @@ interface LayoutDragged<TPose> {
  * How a container arranges its children, and what happens when one is dragged
  * into or around it.
  *
- * The four required methods cover the whole cycle: `childPoses` is the resting
- * arrangement, `getDropTargets` enumerates where a drag could land,
+ * Declared on a container node (`ContainerNode.layout`). The four required
+ * methods cover the whole cycle: `childPoses` is the resting arrangement,
+ * which the scene re-applies whenever the container's children or size
+ * change, `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.
  */
@@ -118,14 +252,44 @@ interface LayoutStrategy<TPose> {
      *  absent, every drag is considered — rejection is still possible later, by
      *  `snap.pickTarget` returning null. */
     acceptsDrop?(container: LayoutContainer, dragged: LayoutDragged<TPose>): boolean;
+    /** Optional: place children that joined this container by an edit — an
+     *  insert, a reparent, a duplicate or group landing inside it — rather than
+     *  by a drag onto one of its targets. `children` is the container as the
+     *  edit left it, `arrivals` included, all in world poses. Return `null` to
+     *  refuse: the whole edit is reverted and nothing lands, as with a drop
+     *  that finds no target. A drag onto the container arrives here too, after
+     *  `commitDrop` has placed it, so a strategy leaves a child that already
+     *  sits where it belongs alone. Absent, `childPoses` arranges them like
+     *  any other change to the container's children. Applied by the scene's
+     *  layout pass — for a layout the container declares, or one
+     *  `<SceneCanvas layouts>` / `useLayoutArrivals` installs. */
+    arrive?(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>, arrivals: ReadonlySet<string>): LayoutArrival<TPose> | null;
+    /** Optional: rearrange a container that children left by an edit — a
+     *  delete, or a reparent or drag out of it. `children` is what stays, in
+     *  world poses, still where they were; `departed` is who went, so
+     *  `children.length + departed.size` is how many it held before. A
+     *  container that sizes itself to its children shrinks here, from the pitch
+     *  it had at that count. The edit's arrivals are placed afterward, by
+     *  `arrive`, or with `childPoses` when there is none. Absent, `childPoses`
+     *  arranges what stays like any other change. Applied by the scene's layout
+     *  pass, in the same undo step as the departure. */
+    depart?(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>, departed: ReadonlySet<string>): LayoutArrival<TPose>;
+    /** Optional: the world region the arrangement of `children` covers. Larger
+     *  than `container.bounds` when children sit past it — a grid whose
+     *  overflow runs on below its last visible row — and that difference is
+     *  what a host scrolling the container's content scrolls over. Absent means
+     *  the container's own bounds. */
+    contentExtent?(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>): ContainerBounds;
     /** Optional: what this container does about a child of its own that was
      *  released outside every layout container. Returning ops replaces the
      *  free-space commit — put the child back in its slot, reflow the gap
      *  closed — and an empty array leaves the container unchanged, which snaps
      *  the child home because the drag only ever wrote previews. `null` lets
      *  the drop stand where the pointer left it, which is also what a strategy
-     *  without this method gets. The drag preview follows the pointer either
-     *  way; this decides the release. */
+     *  without this method gets; dropped outside the container's body, the
+     *  child then leaves it for the plain container under the drop, or the top
+     *  level. The drag preview follows the pointer either way; this decides the
+     *  release. */
     releaseDrop?(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>, dragged: LayoutDragged<TPose>): Op[] | null;
 }
 
@@ -260,10 +424,14 @@ interface RotateAdapter<TNode extends {
     /** Optional: see SceneAdapter.applyOps. */
     applyOps?(ops: Op[], label: string): void;
 }
-/**
- * Narrow adapter for `useAreaSelect`. Transient: no checkpoint, no
- * history. The hook calls `applyOps(ops)` instead of `applyOps(ops, label)`.
- */
+/** 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 `useAreaSelect`. Transient: no checkpoint, no
  * history. The hook calls `applyOps(ops)` instead of `applyOps(ops, label)`.
@@ -276,13 +444,14 @@ interface RotateAdapter<TNode extends {
  * Demos that don't need marquee selection can omit these methods entirely.
  */
 interface AreaSelectAdapter {
-    /** Returns ids of nodes intersecting the world-space rect. */
+    /** 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;
-    }): string[];
+    }, view?: RegionPickView): string[];
     /** Current selection — read by behaviors to compute additive merges. */
     getSelection?(): string[];
     /** Mutator wired by `setSelection` op. */
@@ -298,8 +467,8 @@ interface AreaSelectAdapter {
  *   - '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. `arrayAdapter`,
- * which has no painters to ask, tests its descriptor's bounds instead.
+ * The outline is the drawn silhouette, rotation included. `arrayAdapter` asks
+ * its `silhouette` option for it, since the painters sit above `core/`.
  */
 type LassoHitMode = 'centers' | 'intersect' | 'enclosed';
 /**
@@ -314,7 +483,7 @@ interface LassoSelectAdapter extends AreaSelectAdapter {
     hitTestLasso?(polygon: ReadonlyArray<{
         x: number;
         y: number;
-    }>, mode: LassoHitMode): string[];
+    }>, mode: LassoHitMode, view?: RegionPickView): string[];
 }
 /**
  * Narrow adapter for `useInsert` and `useClipboardOps`. The kit knows
@@ -384,6 +553,7 @@ interface LayerEnumerableAdapter<TLayer extends string = string> {
     getLayers?(): readonly {
         id: TLayer;
         visible: boolean;
+        parallax?: ParallaxOpts;
     }[];
 }
 /**
@@ -411,4 +581,4 @@ interface OrderedAdapter {
     setChildOrder?(parentId: string | null, ids: string[]): void;
 }
 
-export type { AreaSelectAdapter as A, ClipboardSnapshot as C, DropRegion as D, InsertAdapter as I, LayoutStrategy as L, MoveAdapter as M, OrderedAdapter as O, ResizeAdapter as R, SnapTarget as S, SceneAdapter as a, LayoutDropTargetMode as b, LassoHitMode as c, LassoSelectAdapter as d, RotateAdapter as e, LayerEnumerableAdapter as f, LayoutSnap as g, ContainerBounds as h, DropTarget as i, LayoutChild as j, LayoutContainer as k, LayoutDragged as l };
+export { type AreaSelectAdapter as A, 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 PlaneMap as P, type RegionPickView as R, type SnapTarget as S, type ParallaxOpts as a, type SceneAdapter as b, type LayoutDropTargetMode as c, type ReflowTransition as d, type LayerEnumerableAdapter as e, type LassoHitMode as f, type LassoSelectAdapter as g, type ResizeAdapter as h, type RotateAdapter as i, type ClipboardSnapshot as j, type DropTarget as k, type LayoutArrival as l, type LayoutChild as m, type LayoutContainer as n, type LayoutDragged as o, type LayoutSnap as p, type ReflowGlideOptions as q, type ScalarOrXY as r, deriveParallaxView as s, fromPlane as t, planeMap as u, planeMatrix as v, planeToPlane as w, rectFromPlane as x, rectToPlane as y, toPlane as z };

package/dist/{types-qYpyTAiZ.d.ts → types-B_9g6hMM.d.ts}

@@ -1,6 +1,6 @@
+import { S as SnapTarget, P as PlaneMap, M as MoveAdapter, I as InsertAdapter } from './types-A37hYkeR.js';
 import { Op } from '@weasel-js/history';
-import { S as SnapTarget, M as MoveAdapter, I as InsertAdapter } from './types-D-9QWBy5.js';
-import { Bounds, ModifierState, ResizeAnchor } from '@weasel-js/routing';
+import { Bounds, ModifierState, View, ResizeAnchor } from '@weasel-js/routing';
 
 /** Pointer position in both world and client coords. */
 interface PointerState {
@@ -26,6 +26,19 @@ interface GestureContext<TPose, TNode extends {
     snap: SnapTarget<TPose> | null;
     modifiers: ModifierState;
     pointer: PointerState;
+    /**
+     * Camera of the view the input landed in (a `<CanvasView>`'s own, not the
+     * surface's), current as of this frame. `null` where no view answered; a
+     * screen-pixel length then reads as one world unit.
+     */
+    view: View | null;
+    /**
+     * How the camera's world maps into the world this gesture's poses are in,
+     * when that is a parallax plane; absent or null otherwise. The camera draws
+     * its guides and grid in its own world, so a snap strategy carries them
+     * through this before comparing them with a pose.
+     */
+    plane?: PlaneMap | null;
     adapter: MoveAdapter<TNode, TPose>;
     /**
      * Per-gesture mutable store. Keys should be namespaced by behavior name to avoid
@@ -43,8 +56,14 @@ interface SnapStrategy<TPose> {
 /**
  * Generalized base behavior. Each hook defines an alias that pins the
  * proposed-pose shape (TProposed) and the onMove return shape (TMoveResult).
- * onEnd is uniform: first non-undefined return wins (Op[] = commit those,
- * null = abort, undefined = defer).
+ * onEnd runs on commit for every behavior, in order, and the first
+ * non-undefined return wins (Op[] = commit those, null = abort, undefined =
+ * defer); later answers are ignored. So a behavior holding state outside the
+ * gesture (published guides, a timer) releases it in onEnd even when an
+ * earlier behavior decides. `end.answered` says one did: a behavior that acts
+ * on the scene itself from onEnd (starts an animation, applies ops) only
+ * cleans up then. A canceled gesture (Esc, pointercancel) runs every
+ * behavior's `onCancel` instead, which releases the same state.
  *
  * `defaultTransient`: when one behavior of a move, resize or rotate sets it
  * and the binding leaves `transient` unset, the gesture commits through
@@ -54,7 +73,14 @@ interface ActionBehavior<TPose, TProposed, TMoveResult> {
     defaultTransient?: boolean;
     onStart?(ctx: GestureContext<TPose>): void;
     onMove?(ctx: GestureContext<TPose>, proposed: TProposed): TMoveResult | void;
-    onEnd?(ctx: GestureContext<TPose>): Op[] | null | void;
+    onEnd?(ctx: GestureContext<TPose>, end: BehaviorEnd): Op[] | null | void;
+    onCancel?(ctx: GestureContext<TPose>): void;
+}
+/** What a behavior's `onEnd` is told about the commit, beside the gesture. */
+interface BehaviorEnd {
+    /** An earlier behavior's `onEnd` already decided the commit, so this one's
+     *  answer is ignored. */
+    answered: boolean;
 }
 /**
  * Uniform group transform proposed by a gesture and shaped by behaviors.
@@ -304,4 +330,4 @@ interface CloneBehavior {
     }) => Op[];
 }
 
-export type { ActionBehavior as A, BoundsConstraint as B, CloneBehavior as C, GestureContext as G, InsertBehavior as I, LassoSelectBehavior as L, MoveBehavior as M, PointSnapBehavior as P, RotateBehavior as R, SnapStrategy as S, PointSnapFrame as a, AreaSelectOverlay as b, BehaviorMoveResult as c, BehaviorResult as d, CloneLayer as e, ClonePose as f, GroupTransform as g, InsertMoveResult as h, InsertOverlay as i, InsertPoint as j, InsertProposed as k, LassoSelectMoveResult as l, LassoSelectOverlay as m, LassoSelectPose as n, LassoSelectProposed as o, PointSnapContext as p, PointSnapResult as q, PointerState as r, ResizeMoveResult as s, ResizeOverlay as t, ResizeProposed as u, RotateMoveResult as v, RotateOverlay as w, RotateProposed as x };
+export type { ActionBehavior as A, BoundsConstraint as B, CloneBehavior as C, GestureContext as G, InsertBehavior as I, LassoSelectBehavior as L, MoveBehavior as M, PointSnapBehavior as P, RotateBehavior as R, SnapStrategy as S, AreaSelectOverlay as a, BehaviorEnd as b, BehaviorMoveResult as c, BehaviorResult as d, CloneLayer as e, ClonePose as f, GroupTransform as g, InsertMoveResult as h, InsertOverlay as i, InsertPoint as j, InsertProposed as k, LassoSelectMoveResult as l, LassoSelectOverlay as m, LassoSelectPose as n, LassoSelectProposed as o, PointSnapContext as p, PointSnapFrame as q, PointSnapResult as r, PointerState as s, ResizeMoveResult as t, ResizeOverlay as u, ResizeProposed as v, RotateMoveResult as w, RotateOverlay as x, RotateProposed as y };

package/dist/util/color.js

@@ -0,0 +1,26 @@
+//#region src/util/color.ts
+function e(e) {
+	if (!e.startsWith("#")) return e;
+	let t = e.slice(1);
+	if (t.length === 3) {
+		let e = t[0], n = t[1], r = t[2];
+		return `#${e}${e}${n}${n}${r}${r}ff`;
+	}
+	return t.length === 6 ? `#${t}ff` : t.length === 8 ? e.toLowerCase() : e;
+}
+function t(e) {
+	if (!e.startsWith("#") || e.length !== 9) return 1;
+	let t = parseInt(e.slice(7, 9), 16);
+	return Number.isFinite(t) ? t / 255 : 1;
+}
+function n(t, n) {
+	let r = Math.round(Math.max(0, Math.min(1, n)) * 255).toString(16).padStart(2, "0"), i = e(t);
+	return !i.startsWith("#") || i.length !== 9 ? t : `${i.slice(0, 7)}${r}`;
+}
+function r(e, r) {
+	return e.length === 9 && e.startsWith("#") ? e.toLowerCase() : n(e, t(r));
+}
+//#endregion
+export { t as getAlpha01, r as mergeAlphaFromPrev, e as toHex8, n as withAlpha01 };
+
+//# sourceMappingURL=color.js.map

package/dist/util/color.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.js","names":["toHex8","color","hex","r","g","b","getAlpha01","a","withAlpha01","aa","alpha01","eight","mergeAlphaFromPrev","picked","prev"],"sources":["../../src/util/color.ts"],"sourcesContent":["/** Color hex8 helpers. All stored colors are `#rrggbbaa`. `<input type=\"color\">`\n *  only round-trips the 6-char form, so call-sites pad the saved alpha back on\n *  when the user picks via the native widget. */\n\n/** Expand `#rgb` / `#rrggbb` to `#rrggbbaa`. Pads `ff` when no alpha\n *  channel is present. Non-hex inputs (named colors, `rgba(...)`) are\n *  returned unchanged — the kit's renderer accepts arbitrary CSS, and\n *  we only normalize the hex shapes we actually persist. */\nexport function toHex8(color: string): string {\n  if (!color.startsWith('#')) return color;\n  const hex = color.slice(1);\n  if (hex.length === 3) {\n    const r = hex[0], g = hex[1], b = hex[2];\n    return `#${r}${r}${g}${g}${b}${b}ff`;\n  }\n  if (hex.length === 6) return `#${hex}ff`;\n  if (hex.length === 8) return color.toLowerCase();\n  return color;\n}\n\n/** Return the alpha channel of `color` as 0..1. Defaults to 1 when the\n *  color is not in 8-char hex form. */\nexport function getAlpha01(color: string): number {\n  if (!color.startsWith('#') || color.length !== 9) return 1;\n  const a = parseInt(color.slice(7, 9), 16);\n  return Number.isFinite(a) ? a / 255 : 1;\n}\n\n/** Replace the alpha channel of `color` with `alpha01` (clamped to 0..1).\n *  Expands shorter hex forms first. Pass-through for non-hex inputs. */\nexport function withAlpha01(color: string, alpha01: number): string {\n  const a = Math.max(0, Math.min(1, alpha01));\n  const aa = Math.round(a * 255).toString(16).padStart(2, '0');\n  const eight = toHex8(color);\n  if (!eight.startsWith('#') || eight.length !== 9) return color;\n  return `${eight.slice(0, 7)}${aa}`;\n}\n\n/** Merge a freshly-picked color with the previous color's alpha channel.\n *  If `picked` is already in 8-char hex form (`#rrggbbaa`, length 9), it is\n *  used as-is — its explicit alpha is preserved. Otherwise the alpha from\n *  `prev` is adopted, which handles the common case where `<input type=\"color\">`\n *  strips the alpha channel and returns a bare 6-char hex. */\nexport function mergeAlphaFromPrev(picked: string, prev: string): string {\n  if (picked.length === 9 && picked.startsWith('#')) return picked.toLowerCase();\n  return withAlpha01(picked, getAlpha01(prev));\n}\n"],"mappings":";AAQA,SAAgBA,EAAO,GAAuB;CAC5C,IAAI,CAACC,EAAM,WAAW,GAAG,GAAG,OAAOA;CACnC,IAAMC,IAAMD,EAAM,MAAM,CAAC;CACzB,IAAIC,EAAI,WAAW,GAAG;EACpB,IAAMC,IAAID,EAAI,IAAIE,IAAIF,EAAI,IAAIG,IAAIH,EAAI;EACtC,OAAO,IAAIC,IAAIA,IAAIC,IAAIA,IAAIC,IAAIA,EAAE;CACnC;CAGA,OAFIH,EAAI,WAAW,IAAU,IAAIA,EAAI,MACjCA,EAAI,WAAW,IAAUD,EAAM,YAAY,IACxCA;AACT;AAIA,SAAgBK,EAAW,GAAuB;CAChD,IAAI,CAACL,EAAM,WAAW,GAAG,KAAKA,EAAM,WAAW,GAAG,OAAO;CACzD,IAAMM,IAAI,SAASN,EAAM,MAAM,GAAG,CAAC,GAAG,EAAE;CACxC,OAAO,OAAO,SAASM,CAAC,IAAIA,IAAI,MAAM;AACxC;AAIA,SAAgBC,EAAY,GAAe,GAAyB;CAElE,IAAMC,IAAK,KAAK,MADN,KAAK,IAAI,GAAG,KAAK,IAAI,GAAGC,CAAO,CACnB,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,GACrDC,IAAQX,EAAOC,CAAK;CAE1B,OADI,CAACU,EAAM,WAAW,GAAG,KAAKA,EAAM,WAAW,IAAUV,IAClD,GAAGU,EAAM,MAAM,GAAG,CAAC,IAAIF;AAChC;AAOA,SAAgBG,EAAmB,GAAgB,GAAsB;CAEvE,OADIC,EAAO,WAAW,KAAKA,EAAO,WAAW,GAAG,IAAUA,EAAO,YAAY,IACtEL,EAAYK,GAAQP,EAAWQ,CAAI,CAAC;AAC7C"}

package/dist/util/constrainTo45.js

@@ -0,0 +1,17 @@
+//#region src/util/constrainTo45.ts
+function e(e, t) {
+	let n = Math.hypot(e, t);
+	if (n === 0) return {
+		dx: 0,
+		dy: 0
+	};
+	let r = Math.atan2(t, e), i = Math.PI / 4, a = Math.round(r / i) * i;
+	return {
+		dx: Math.cos(a) * n,
+		dy: Math.sin(a) * n
+	};
+}
+//#endregion
+export { e as constrainTo45 };
+
+//# sourceMappingURL=constrainTo45.js.map

package/dist/util/constrainTo45.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constrainTo45.js","names":["constrainTo45","mag","dx","dy","angle","step","snapped"],"sources":["../../src/util/constrainTo45.ts"],"sourcesContent":["/**\n * Snap a (dx, dy) direction vector to the nearest 0/45/90/135° axis,\n * preserving the input magnitude. Used by the pen tool's Shift-constrain\n * affordance; reusable for any tool that wants axis/diagonal locking.\n *\n * Returns (0, 0) for a zero-length input (no direction to snap).\n */\nexport function constrainTo45(dx: number, dy: number): { dx: number; dy: number } {\n  const mag = Math.hypot(dx, dy);\n  if (mag === 0) return { dx: 0, dy: 0 };\n  const angle = Math.atan2(dy, dx);\n  // Snap to nearest multiple of π/4.\n  const step = Math.PI / 4;\n  const snapped = Math.round(angle / step) * step;\n  return { dx: Math.cos(snapped) * mag, dy: Math.sin(snapped) * mag };\n}\n"],"mappings":";AAOA,SAAgBA,EAAc,GAAY,GAAwC;CAChF,IAAMC,IAAM,KAAK,MAAMC,GAAIC,CAAE;CAC7B,IAAIF,MAAQ,GAAG,OAAO;EAAE,IAAI;EAAG,IAAI;CAAE;CACrC,IAAMG,IAAQ,KAAK,MAAMD,GAAID,CAAE,GAEzBG,IAAO,KAAK,KAAK,GACjBC,IAAU,KAAK,MAAMF,IAAQC,CAAI,IAAIA;CAC3C,OAAO;EAAE,IAAI,KAAK,IAAIC,CAAO,IAAIL;EAAK,IAAI,KAAK,IAAIK,CAAO,IAAIL;CAAI;AACpE"}

package/dist/util/paint.js

@@ -0,0 +1,72 @@
+import { getAlpha01 as e } from "./color.js";
+import { colorLiteralToHex as t, hexToColorLiteral as n, resolvePaletteColor as r } from "@weasel-js/paint";
+//#region src/util/paint.ts
+var i = "#ffffffff", a = "#000000ff", o = (e) => n(e), s = { entries: [
+	{
+		name: "sage",
+		color: o("#7fb069")
+	},
+	{
+		name: "tan",
+		color: o("#d4a574")
+	},
+	{
+		name: "lavender",
+		color: o("#a48bd4")
+	},
+	{
+		name: "sky",
+		color: o("#7ab8d4")
+	},
+	{
+		name: "rose",
+		color: o("#d47a7a")
+	}
+] };
+function c(e, n = s, a = i) {
+	let { entries: o } = n, c = o[(e % o.length + o.length) % o.length], l = c && r(n, { ref: c.name });
+	return (l && t(l)) ?? a;
+}
+var l = c(0);
+function u(t) {
+	let n = e(t), r = t.length === 9 && t.startsWith("#") ? t.slice(0, 7) : t;
+	return n === 1 ? { color: r } : {
+		color: r,
+		opacity: n
+	};
+}
+function d(e, t = 1) {
+	return {
+		paint: u(e),
+		width: t
+	};
+}
+function f(e, t = 1) {
+	return {
+		paint: e,
+		width: t
+	};
+}
+var p = { color: "#888" };
+function m(e) {
+	return e?.opacity ?? 1;
+}
+function h(e, t) {
+	return {
+		...e,
+		opacity: Math.max(0, Math.min(1, t))
+	};
+}
+function g(e, t) {
+	let n = u(t);
+	if (t.length === 9 && t.startsWith("#") || e === void 0) return n;
+	let r = m(e);
+	return r === 1 ? n : {
+		...n,
+		opacity: r
+	};
+}
+//#endregion
+export { i as DEFAULT_FILL_COLOR, s as DEFAULT_PALETTE, p as DEFAULT_SHAPE_FILL, a as DEFAULT_STROKE_COLOR, l as GHOST_STROKE, c as cycleFill, m as paintAlpha, h as paintWithAlpha, g as paintWithColor, u as solid, d as strokeOf, f as strokeWith };
+
+//# sourceMappingURL=paint.js.map

package/dist/util/paint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paint.js","names":["DEFAULT_FILL_COLOR","DEFAULT_STROKE_COLOR","srgb","hexToColorLiteral","hex","DEFAULT_PALETTE","cycleFill","palette","entry","entries","seq","color","resolvePaletteColor","colorLiteralToHex","fallback","GHOST_STROKE","solid","a","getAlpha01","rgb","strokeOf","strokeWith","DEFAULT_SHAPE_FILL","paintAlpha","paint","paintWithAlpha","alpha01","paintWithColor","next","alpha"],"sources":["../../src/util/paint.ts"],"sourcesContent":["/** Kit-shipped default paint constants.\n *\n *  Single source of truth for the colors the built-in tools and the default\n *  fill/stroke actions reach for. Consumers that want to match the kit's\n *  out-of-the-box look (e.g. seed their own active-paint state) should import\n *  these rather than re-declaring the literals.\n *\n *  All values are `#rrggbbaa` so they round-trip through the kit's hex8 alpha\n *  helpers (`util/color`) without ambiguity.\n */\nimport {\n  colorLiteralToHex,\n  hexToColorLiteral,\n  resolvePaletteColor,\n  type ColorLiteral,\n  type FillStyle,\n  type Palette,\n  type Stroke,\n} from '@weasel-js/paint';\nimport { getAlpha01 } from './color';\n\n/** Default fill paint for shapes and the fill action — opaque white. */\nexport const DEFAULT_FILL_COLOR = '#ffffffff';\n\n/** Default stroke paint for shapes and the stroke action — opaque black. */\nexport const DEFAULT_STROKE_COLOR = '#000000ff';\n\nconst srgb = (hex: string): ColorLiteral => hexToColorLiteral(hex) as ColorLiteral;\n\n/** Default fill palette cycled through for auto-generated shape nodes\n *  (the kit's built-in shape tools and the `insert` action). */\nexport const DEFAULT_PALETTE: Palette = {\n  entries: [\n    { name: 'sage', color: srgb('#7fb069') },\n    { name: 'tan', color: srgb('#d4a574') },\n    { name: 'lavender', color: srgb('#a48bd4') },\n    { name: 'sky', color: srgb('#7ab8d4') },\n    { name: 'rose', color: srgb('#d47a7a') },\n  ],\n};\n\n/** The `seq`th color of `palette`'s entries as hex, wrapping past the end.\n *  An entry that resolves to nothing, or to a space with no hex form, gives\n *  `fallback`. */\nexport function cycleFill(seq: number, palette: Palette = DEFAULT_PALETTE, fallback = DEFAULT_FILL_COLOR): string {\n  const { entries } = palette;\n  const entry = entries[((seq % entries.length) + entries.length) % entries.length];\n  const color = entry && resolvePaletteColor(palette, { ref: entry.name });\n  return (color && colorLiteralToHex(color)) ?? fallback;\n}\n\n/** Preview / \"ghost\" stroke color used by drag-to-draw tool overlays and the\n *  selected-anchor highlight. Derived from the first palette entry so the\n *  preview chrome matches the default insert color. */\nexport const GHOST_STROKE: string = cycleFill(0);\n\n/**\n * A solid paint from a color string — the authoring shorthand for the one\n * shape a node's `data.fill` (and a `Stroke.paint`) may take.\n *\n * An alpha channel in `color` moves to `opacity`, because that is where every\n * paint kind carries its alpha; leaving it in the hex too would multiply the\n * two in the renderer.\n */\nexport function solid(color: string): FillStyle {\n  const a = getAlpha01(color);\n  const rgb = color.length === 9 && color.startsWith('#') ? color.slice(0, 7) : color;\n  return a === 1 ? { color: rgb } : { color: rgb, opacity: a };\n}\n\n/** A solid stroke of `color` at `width` world units. Authoring shorthand for\n *  `{ paint: solid(color), width }`. */\nexport function strokeOf(color: string, width = 1): Stroke {\n  return { paint: solid(color), width };\n}\n\n/** A stroke painted with `paint` at `width` world units — `strokeOf`'s sibling\n *  for a gradient or pattern, which has no color to pass. */\nexport function strokeWith(paint: FillStyle, width = 1): Stroke {\n  return { paint, width };\n}\n\n/** The kit's default node paint — what a shape with no declared fill paints. */\nexport const DEFAULT_SHAPE_FILL: FillStyle = { color: '#888' };\n\n/**\n * The 0..1 alpha a paint paints at.\n *\n * Every paint kind carries its alpha in `opacity` — that is the one slot a\n * gradient or a pattern has, so it is the slot all of them use.\n */\nexport function paintAlpha(paint: FillStyle | undefined): number {\n  return paint?.opacity ?? 1;\n}\n\n/** `paint` painting at `alpha01` (clamped to 0..1). */\nexport function paintWithAlpha(paint: FillStyle, alpha01: number): FillStyle {\n  return { ...paint, opacity: Math.max(0, Math.min(1, alpha01)) };\n}\n\n/**\n * `paint` recolored to `color`, keeping everything else about it.\n *\n * A solid paint takes the new color; a gradient or a pattern has no single\n * color to replace, so it is superseded by a solid one — picking a color off\n * a swatch means \"paint this color\". An alpha channel in `color` wins;\n * without one, the paint's existing opacity carries over.\n */\nexport function paintWithColor(paint: FillStyle | undefined, color: string): FillStyle {\n  const next = solid(color);\n  const explicitAlpha = color.length === 9 && color.startsWith('#');\n  if (explicitAlpha || paint === undefined) return next;\n  const alpha = paintAlpha(paint);\n  return alpha === 1 ? next : { ...next, opacity: alpha };\n}\n"],"mappings":";;;AAsBA,IAAaA,IAAqB,aAGrBC,IAAuB,aAE9BC,KAAQ,MAA8BC,EAAkBC,CAAG,GAIpDC,IAA2B,EACtC,SAAS;CACP;EAAE,MAAM;EAAQ,OAAOH,EAAK,SAAS;CAAE;CACvC;EAAE,MAAM;EAAO,OAAOA,EAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAY,OAAOA,EAAK,SAAS;CAAE;CAC3C;EAAE,MAAM;EAAO,OAAOA,EAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAQ,OAAOA,EAAK,SAAS;CAAE;AACzC,EACF;AAKA,SAAgBI,EAAU,GAAa,IAAmBD,GAAiB,IAAWL,GAA4B;CAChH,IAAM,EAAE,eAAYO,GACdC,IAAQC,GAAUC,IAAMD,EAAQ,SAAUA,EAAQ,UAAUA,EAAQ,SACpEE,IAAQH,KAASI,EAAoBL,GAAS,EAAE,KAAKC,EAAM,KAAK,CAAC;CACvE,QAAQG,KAASE,EAAkBF,CAAK,MAAMG;AAChD;AAKA,IAAaC,IAAuBT,EAAU,CAAC;AAU/C,SAAgBU,EAAM,GAA0B;CAC9C,IAAMC,IAAIC,EAAWP,CAAK,GACpBQ,IAAMR,EAAM,WAAW,KAAKA,EAAM,WAAW,GAAG,IAAIA,EAAM,MAAM,GAAG,CAAC,IAAIA;CAC9E,OAAOM,MAAM,IAAI,EAAE,OAAOE,EAAI,IAAI;EAAE,OAAOA;EAAK,SAASF;CAAE;AAC7D;AAIA,SAAgBG,EAAS,GAAe,IAAQ,GAAW;CACzD,OAAO;EAAE,OAAOJ,EAAML,CAAK;EAAG;CAAM;AACtC;AAIA,SAAgBU,EAAW,GAAkB,IAAQ,GAAW;CAC9D,OAAO;EAAE;EAAO;CAAM;AACxB;AAGA,IAAaC,IAAgC,EAAE,OAAO,OAAO;AAQ7D,SAAgBC,EAAW,GAAsC;CAC/D,OAAOC,GAAO,WAAW;AAC3B;AAGA,SAAgBC,EAAe,GAAkB,GAA4B;CAC3E,OAAO;EAAE,GAAGD;EAAO,SAAS,KAAK,IAAI,GAAG,KAAK,IAAI,GAAGE,CAAO,CAAC;CAAE;AAChE;AAUA,SAAgBC,EAAe,GAA8B,GAA0B;CACrF,IAAMC,IAAOZ,EAAML,CAAK;CAExB,IADsBA,EAAM,WAAW,KAAKA,EAAM,WAAW,GAAG,KAC3Ca,MAAU,KAAA,GAAW,OAAOI;CACjD,IAAMC,IAAQN,EAAWC,CAAK;CAC9B,OAAOK,MAAU,IAAID,IAAO;EAAE,GAAGA;EAAM,SAASC;CAAM;AACxD"}

package/dist/version.js

@@ -0,0 +1,6 @@
+//#region src/version.ts
+var e = "1.7.2";
+//#endregion
+export { e as VERSION };
+
+//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","names":["VERSION"],"sources":["../src/version.ts"],"sourcesContent":["/**\n * The kit version a build was compiled from, so an app can report what it is\n * running. Substituted at build time — by `vite.config.ts` for the published\n * package, and by `scripts/vite-build-info.ts` for anything in this repo that\n * bundles core's source through the workspace aliases.\n *\n * Apps pair this with their own compile timestamp; the kit deliberately does\n * not carry one, since a published package's build date says nothing about\n * when the app embedding it was built.\n */\n\ndeclare const __WEASEL_CORE_VERSION__: string | undefined;\n\n/**\n * Semver of `@weasel-js/core` as of the build.\n *\n * Falls back to `'0.0.0-unknown'` when core's source is imported by a bundler\n * that hasn't been given the define — honest about not knowing rather than\n * throwing, since nothing about version reporting should be able to break a\n * consumer's build.\n */\nexport const VERSION: string =\n  typeof __WEASEL_CORE_VERSION__ === 'string' ? __WEASEL_CORE_VERSION__ : '0.0.0-unknown';\n"],"mappings":";AAqBA,IAAaA,IAAA"}