@weasel-js/core 1.10.0 → 1.11.0

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-CIKDwlsP.d.ts → types-CHVXGfYm.d.ts}

@@ -1,7 +1,6 @@
 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 { View, Rect, Path } from '@weasel-js/geom';
+import { P as PoseDescriptor } from './poseDescriptor-DN2yfnq_.js';
 import { Target } from '@weasel-js/animator';
 
 /** One value for both axes, or a separate value per axis. */
@@ -155,7 +154,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
@@ -325,6 +325,11 @@ interface SnapTarget<TPose = unknown> {
  * **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 {
@@ -333,10 +338,8 @@ interface MoveAdapter<TNode extends {
     getNode(id: string): TNode | undefined;
     getNodes(): TNode[];
     getPose(id: string): TPose;
-    /** Optional. Required only by hierarchy-aware paths: layout-pass drop
-     *  targeting (`getLayout` present), nested-hit collapse
-     *  (`pickTopMostHit`), and group-pose composition. Flat scenes may omit. */
-    getParent?(id: string): string | null;
+    /** 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
@@ -344,7 +347,7 @@ interface MoveAdapter<TNode extends {
     getZIndex?(id: string): number | null | undefined;
     compareZ?(a: string, b: string): number;
     setPose(id: string, pose: TPose): void;
-    /** Optional. Used only by reparent ops; flat scenes that never reparent may omit. */
+    /** 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
@@ -361,12 +364,12 @@ interface MoveAdapter<TNode extends {
      *  it answers `undefined`. */
     poseTarget?(id: string, descriptor?: PoseDescriptor<TPose>): Target<TPose> | undefined;
     findSnapTarget?(draggedId: string, worldX: number, worldY: number): SnapTarget<TPose> | null;
-    /** Optional: ordered children of `parentId`, `null` for the root siblings.
-     *  One contract with {@link OrderedAdapter.getChildren} — the two land on
-     *  the same adapter object, and an implementation that answers only node
-     *  ids returns `[]` for the root, which the ops read as "no siblings".
-     */
-    getChildren?(parentId: string | null): string[];
+    /** 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. */
@@ -455,6 +458,11 @@ interface LassoSelectAdapter extends AreaSelectAdapter {
 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. */
@@ -507,8 +515,7 @@ interface LayerEnumerableAdapter<TLayer extends string = string> {
     subscribeLayers?(listener: () => void): () => void;
 }
 /**
- * Optional adapter mixin for sibling z-order. Reorder ops no-op when either
- * method is absent.
+ * 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
@@ -519,10 +526,10 @@ 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[];
+    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;
+    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 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 PlaneMap as P, type RegionPickView as R, type SnapTarget as S, type ParallaxOpts as a, type PasteOmission as b, type LayoutDropTargetMode as c, type ReflowTransition 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 };

package/dist/util/color.js

@@ -1,26 +1,47 @@
 //#region src/util/color.ts
-function e(e) {
-	if (!e.startsWith("#")) return e;
-	let t = e.slice(1);
-	if (t.length === 3 || t.length === 4) {
-		let [e, n, r, i = "f"] = t.toLowerCase();
-		return `#${e}${e}${n}${n}${r}${r}${i}${i}`;
+/** Color hex8 helpers. All stored colors are `#rrggbbaa`. `<input type="color">`
+*  only round-trips the 6-char form, so call-sites pad the saved alpha back on
+*  when the user picks via the native widget. */
+/** Expand `#rgb` / `#rgba` / `#rrggbb` to `#rrggbbaa`. Pads `ff` when no alpha
+*  channel is present. Non-hex inputs (named colors, `rgba(...)`) are
+*  returned unchanged — the kit's renderer accepts arbitrary CSS, and
+*  we only normalize the hex shapes we actually persist. */
+function toHex8(color) {
+	if (!color.startsWith("#")) return color;
+	const hex = color.slice(1);
+	if (hex.length === 3 || hex.length === 4) {
+		const [r, g, b, a = "f"] = hex.toLowerCase();
+		return `#${r}${r}${g}${g}${b}${b}${a}${a}`;
 	}
-	return t.length === 6 ? `#${t}ff` : t.length === 8 ? e.toLowerCase() : e;
+	if (hex.length === 6) return `#${hex}ff`;
+	if (hex.length === 8) return color.toLowerCase();
+	return color;
 }
-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;
+/** Return the alpha channel of `color` as 0..1. Defaults to 1 when the
+*  color is not in 8-char hex form. */
+function getAlpha01(color) {
+	if (!color.startsWith("#") || color.length !== 9) return 1;
+	const a = parseInt(color.slice(7, 9), 16);
+	return Number.isFinite(a) ? a / 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}`;
+/** Replace the alpha channel of `color` with `alpha01` (clamped to 0..1).
+*  Expands shorter hex forms first. Pass-through for non-hex inputs. */
+function withAlpha01(color, alpha01) {
+	const aa = Math.round(Math.max(0, Math.min(1, alpha01)) * 255).toString(16).padStart(2, "0");
+	const eight = toHex8(color);
+	if (!eight.startsWith("#") || eight.length !== 9) return color;
+	return `${eight.slice(0, 7)}${aa}`;
 }
-function r(e, r) {
-	return e.length === 9 && e.startsWith("#") ? e.toLowerCase() : n(e, t(r));
+/** Merge a freshly-picked color with the previous color's alpha channel.
+*  If `picked` is already in 8-char hex form (`#rrggbbaa`, length 9), it is
+*  used as-is — its explicit alpha is preserved. Otherwise the alpha from
+*  `prev` is adopted, which handles the common case where `<input type="color">`
+*  strips the alpha channel and returns a bare 6-char hex. */
+function mergeAlphaFromPrev(picked, prev) {
+	if (picked.length === 9 && picked.startsWith("#")) return picked.toLowerCase();
+	return withAlpha01(picked, getAlpha01(prev));
 }
-//#endregion
-export { t as getAlpha01, r as mergeAlphaFromPrev, e as toHex8, n as withAlpha01 };
 
+//#endregion
+export { getAlpha01, mergeAlphaFromPrev, toHex8, withAlpha01 };
 //# sourceMappingURL=color.js.map

package/dist/util/color.js.map

@@ -1 +1 @@
-{"version":3,"file":"color.js","names":["toHex8","color","hex","r","g","b","a","getAlpha01","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` / `#rgba` / `#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 || hex.length === 4) {\n    const [r, g, b, a = 'f'] = hex.toLowerCase();\n    return `#${r}${r}${g}${g}${b}${b}${a}${a}`;\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,KAAKA,EAAI,WAAW,GAAG;EACxC,IAAM,CAACC,GAAGC,GAAGC,GAAGC,IAAI,OAAOJ,EAAI,YAAY;EAC3C,OAAO,IAAIC,IAAIA,IAAIC,IAAIA,IAAIC,IAAIA,IAAIC,IAAIA;CACzC;CAGA,OAFIJ,EAAI,WAAW,IAAU,IAAIA,EAAI,MACjCA,EAAI,WAAW,IAAUD,EAAM,YAAY,IACxCA;AACT;AAIA,SAAgBM,EAAW,GAAuB;CAChD,IAAI,CAACN,EAAM,WAAW,GAAG,KAAKA,EAAM,WAAW,GAAG,OAAO;CACzD,IAAMK,IAAI,SAASL,EAAM,MAAM,GAAG,CAAC,GAAG,EAAE;CACxC,OAAO,OAAO,SAASK,CAAC,IAAIA,IAAI,MAAM;AACxC;AAIA,SAAgBE,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,GAAQN,EAAWO,CAAI,CAAC;AAC7C"}
+{"version":3,"file":"color.js","names":[],"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` / `#rgba` / `#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 || hex.length === 4) {\n    const [r, g, b, a = 'f'] = hex.toLowerCase();\n    return `#${r}${r}${g}${g}${b}${b}${a}${a}`;\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,SAAgB,OAAO,OAAuB;CAC5C,IAAI,CAAC,MAAM,WAAW,GAAG,GAAG,OAAO;CACnC,MAAM,MAAM,MAAM,MAAM,CAAC;CACzB,IAAI,IAAI,WAAW,KAAK,IAAI,WAAW,GAAG;EACxC,MAAM,CAAC,GAAG,GAAG,GAAG,IAAI,OAAO,IAAI,YAAY;EAC3C,OAAO,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;CACzC;CACA,IAAI,IAAI,WAAW,GAAG,OAAO,IAAI,IAAI;CACrC,IAAI,IAAI,WAAW,GAAG,OAAO,MAAM,YAAY;CAC/C,OAAO;AACT;;;AAIA,SAAgB,WAAW,OAAuB;CAChD,IAAI,CAAC,MAAM,WAAW,GAAG,KAAK,MAAM,WAAW,GAAG,OAAO;CACzD,MAAM,IAAI,SAAS,MAAM,MAAM,GAAG,CAAC,GAAG,EAAE;CACxC,OAAO,OAAO,SAAS,CAAC,IAAI,IAAI,MAAM;AACxC;;;AAIA,SAAgB,YAAY,OAAe,SAAyB;CAElE,MAAM,KAAK,KAAK,MADN,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,OAAO,CACnB,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;CAC3D,MAAM,QAAQ,OAAO,KAAK;CAC1B,IAAI,CAAC,MAAM,WAAW,GAAG,KAAK,MAAM,WAAW,GAAG,OAAO;CACzD,OAAO,GAAG,MAAM,MAAM,GAAG,CAAC,IAAI;AAChC;;;;;;AAOA,SAAgB,mBAAmB,QAAgB,MAAsB;CACvE,IAAI,OAAO,WAAW,KAAK,OAAO,WAAW,GAAG,GAAG,OAAO,OAAO,YAAY;CAC7E,OAAO,YAAY,QAAQ,WAAW,IAAI,CAAC;AAC7C"}

package/dist/util/paint.js

@@ -1,72 +1,127 @@
-import { getAlpha01 as e } from "./color.js";
-import { colorLiteralToHex as t, hexToColorLiteral as n, resolvePaletteColor as r } from "@weasel-js/paint";
+import { getAlpha01 } from "./color.js";
+import { colorLiteralToHex, hexToColorLiteral, resolvePaletteColor } from "@weasel-js/paint";
+
 //#region src/util/paint.ts
-var i = "#ffffffff", a = "#000000ff", o = (e) => n(e), s = { entries: [
+/** Kit-shipped default paint constants.
+*
+*  Single source of truth for the colors the built-in tools and the default
+*  fill/stroke actions reach for. Consumers that want to match the kit's
+*  out-of-the-box look (e.g. seed their own active-paint state) should import
+*  these rather than re-declaring the literals.
+*
+*  All values are `#rrggbbaa` so they round-trip through the kit's hex8 alpha
+*  helpers (`util/color`) without ambiguity.
+*/
+/** Default fill paint for shapes and the fill action — opaque white. */
+var DEFAULT_FILL_COLOR = "#ffffffff";
+/** Default stroke paint for shapes and the stroke action — opaque black. */
+var DEFAULT_STROKE_COLOR = "#000000ff";
+var srgb = (hex) => hexToColorLiteral(hex);
+/** Default fill palette cycled through for auto-generated shape nodes
+*  (the kit's built-in shape tools and the `insert` action). */
+var DEFAULT_PALETTE = { entries: [
 	{
 		name: "sage",
-		color: o("#7fb069")
+		color: srgb("#7fb069")
 	},
 	{
 		name: "tan",
-		color: o("#d4a574")
+		color: srgb("#d4a574")
 	},
 	{
 		name: "lavender",
-		color: o("#a48bd4")
+		color: srgb("#a48bd4")
 	},
 	{
 		name: "sky",
-		color: o("#7ab8d4")
+		color: srgb("#7ab8d4")
 	},
 	{
 		name: "rose",
-		color: o("#d47a7a")
+		color: srgb("#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;
+/** The `seq`th color of `palette`'s entries as hex, wrapping past the end.
+*  An entry that resolves to nothing, or to a space with no hex form, gives
+*  `fallback`. */
+function cycleFill(seq, palette = DEFAULT_PALETTE, fallback = DEFAULT_FILL_COLOR) {
+	const { entries } = palette;
+	const entry = entries[(seq % entries.length + entries.length) % entries.length];
+	const color = entry && resolvePaletteColor(palette, { ref: entry.name });
+	return (color && colorLiteralToHex(color)) ?? fallback;
 }
-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
+/** Preview / "ghost" stroke color used by drag-to-draw tool overlays and the
+*  selected-anchor highlight. Derived from the first palette entry so the
+*  preview chrome matches the default insert color. */
+var GHOST_STROKE = cycleFill(0);
+/**
+* A solid paint from a color string — the authoring shorthand for the one
+* shape a `Fill.paint` or a `Stroke.paint` may take.
+*
+* An alpha channel in `color` moves to `opacity`, because that is where every
+* paint kind carries its alpha; leaving it in the hex too would multiply the
+* two in the renderer.
+*/
+function solid(color) {
+	const a = getAlpha01(color);
+	const rgb = color.length === 9 && color.startsWith("#") ? color.slice(0, 7) : color;
+	return a === 1 ? { color: rgb } : {
+		color: rgb,
+		opacity: a
 	};
 }
-function d(e, t = 1) {
+/** A solid stroke of `color` at `width` world units. Authoring shorthand for
+*  `{ paint: solid(color), width }`. */
+function strokeOf(color, width = 1) {
 	return {
-		paint: u(e),
-		width: t
+		paint: solid(color),
+		width
 	};
 }
-function f(e, t = 1) {
+/** A stroke painted with `paint` at `width` world units — `strokeOf`'s sibling
+*  for a gradient or pattern, which has no color to pass. */
+function strokeWith(paint, width = 1) {
 	return {
-		paint: e,
-		width: t
+		paint,
+		width
 	};
 }
-var p = { paint: { color: "#888" } };
-function m(e) {
-	return e?.opacity ?? 1;
+/** The kit's default node fill — what a shape with no declared fill paints. */
+var DEFAULT_SHAPE_FILL = { paint: { color: "#888" } };
+/**
+* The 0..1 alpha a paint paints at.
+*
+* Every paint kind carries its alpha in `opacity` — that is the one slot a
+* gradient or a pattern has, so it is the slot all of them use.
+*/
+function paintAlpha(paint) {
+	return paint?.opacity ?? 1;
 }
-function h(e, t) {
+/** `paint` painting at `alpha01` (clamped to 0..1). */
+function paintWithAlpha(paint, alpha01) {
 	return {
-		...e,
-		opacity: Math.max(0, Math.min(1, t))
+		...paint,
+		opacity: Math.max(0, Math.min(1, alpha01))
 	};
 }
-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
+/**
+* `paint` recolored to `color`, keeping everything else about it.
+*
+* A solid paint takes the new color; a gradient or a pattern has no single
+* color to replace, so it is superseded by a solid one — picking a color off
+* a swatch means "paint this color". An alpha channel in `color` wins;
+* without one, the paint's existing opacity carries over.
+*/
+function paintWithColor(paint, color) {
+	const next = solid(color);
+	if (color.length === 9 && color.startsWith("#") || paint === void 0) return next;
+	const alpha = paintAlpha(paint);
+	return alpha === 1 ? next : {
+		...next,
+		opacity: alpha
 	};
 }
-//#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 };
 
+//#endregion
+export { DEFAULT_FILL_COLOR, DEFAULT_PALETTE, DEFAULT_SHAPE_FILL, DEFAULT_STROKE_COLOR, GHOST_STROKE, cycleFill, paintAlpha, paintWithAlpha, paintWithColor, solid, strokeOf, strokeWith };
 //# sourceMappingURL=paint.js.map

package/dist/util/paint.js.map

@@ -1 +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 CommandStroke,\n  type Fill,\n  type Paint,\n  type Palette,\n  type SolidPaint,\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 `Fill.paint` or 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): SolidPaint {\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): CommandStroke & { paint: SolidPaint } {\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: Paint, width = 1): Stroke {\n  return { paint, width };\n}\n\n/** The kit's default node fill — what a shape with no declared fill paints. */\nexport const DEFAULT_SHAPE_FILL: Fill & { paint: Paint } = { paint: { 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: Paint | undefined): number {\n  return paint?.opacity ?? 1;\n}\n\n/** `paint` painting at `alpha01` (clamped to 0..1). */\nexport function paintWithAlpha(paint: Paint, alpha01: number): Paint {\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: Paint | undefined, color: string): Paint {\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":";;;AAyBA,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,GAA2B;CAC/C,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,GAA0C;CACxF,OAAO;EAAE,OAAOJ,EAAML,CAAK;EAAG;CAAM;AACtC;AAIA,SAAgBU,EAAW,GAAc,IAAQ,GAAW;CAC1D,OAAO;EAAE;EAAO;CAAM;AACxB;AAGA,IAAaC,IAA8C,EAAE,OAAO,EAAE,OAAO,OAAO,EAAE;AAQtF,SAAgBC,EAAW,GAAkC;CAC3D,OAAOC,GAAO,WAAW;AAC3B;AAGA,SAAgBC,EAAe,GAAc,GAAwB;CACnE,OAAO;EAAE,GAAGD;EAAO,SAAS,KAAK,IAAI,GAAG,KAAK,IAAI,GAAGE,CAAO,CAAC;CAAE;AAChE;AAUA,SAAgBC,EAAe,GAA0B,GAAsB;CAC7E,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"}
+{"version":3,"file":"paint.js","names":[],"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 CommandStroke,\n  type Fill,\n  type Paint,\n  type Palette,\n  type SolidPaint,\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 `Fill.paint` or 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): SolidPaint {\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): CommandStroke & { paint: SolidPaint } {\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: Paint, width = 1): Stroke {\n  return { paint, width };\n}\n\n/** The kit's default node fill — what a shape with no declared fill paints. */\nexport const DEFAULT_SHAPE_FILL: Fill & { paint: Paint } = { paint: { 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: Paint | undefined): number {\n  return paint?.opacity ?? 1;\n}\n\n/** `paint` painting at `alpha01` (clamped to 0..1). */\nexport function paintWithAlpha(paint: Paint, alpha01: number): Paint {\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: Paint | undefined, color: string): Paint {\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":";;;;;;;;;;;;;;;AAyBA,IAAa,qBAAqB;;AAGlC,IAAa,uBAAuB;AAEpC,IAAM,QAAQ,QAA8B,kBAAkB,GAAG;;;AAIjE,IAAa,kBAA2B,EACtC,SAAS;CACP;EAAE,MAAM;EAAQ,OAAO,KAAK,SAAS;CAAE;CACvC;EAAE,MAAM;EAAO,OAAO,KAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAY,OAAO,KAAK,SAAS;CAAE;CAC3C;EAAE,MAAM;EAAO,OAAO,KAAK,SAAS;CAAE;CACtC;EAAE,MAAM;EAAQ,OAAO,KAAK,SAAS;CAAE;AACzC,EACF;;;;AAKA,SAAgB,UAAU,KAAa,UAAmB,iBAAiB,WAAW,oBAA4B;CAChH,MAAM,EAAE,YAAY;CACpB,MAAM,QAAQ,SAAU,MAAM,QAAQ,SAAU,QAAQ,UAAU,QAAQ;CAC1E,MAAM,QAAQ,SAAS,oBAAoB,SAAS,EAAE,KAAK,MAAM,KAAK,CAAC;CACvE,QAAQ,SAAS,kBAAkB,KAAK,MAAM;AAChD;;;;AAKA,IAAa,eAAuB,UAAU,CAAC;;;;;;;;;AAU/C,SAAgB,MAAM,OAA2B;CAC/C,MAAM,IAAI,WAAW,KAAK;CAC1B,MAAM,MAAM,MAAM,WAAW,KAAK,MAAM,WAAW,GAAG,IAAI,MAAM,MAAM,GAAG,CAAC,IAAI;CAC9E,OAAO,MAAM,IAAI,EAAE,OAAO,IAAI,IAAI;EAAE,OAAO;EAAK,SAAS;CAAE;AAC7D;;;AAIA,SAAgB,SAAS,OAAe,QAAQ,GAA0C;CACxF,OAAO;EAAE,OAAO,MAAM,KAAK;EAAG;CAAM;AACtC;;;AAIA,SAAgB,WAAW,OAAc,QAAQ,GAAW;CAC1D,OAAO;EAAE;EAAO;CAAM;AACxB;;AAGA,IAAa,qBAA8C,EAAE,OAAO,EAAE,OAAO,OAAO,EAAE;;;;;;;AAQtF,SAAgB,WAAW,OAAkC;CAC3D,OAAO,OAAO,WAAW;AAC3B;;AAGA,SAAgB,eAAe,OAAc,SAAwB;CACnE,OAAO;EAAE,GAAG;EAAO,SAAS,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC;CAAE;AAChE;;;;;;;;;AAUA,SAAgB,eAAe,OAA0B,OAAsB;CAC7E,MAAM,OAAO,MAAM,KAAK;CAExB,IADsB,MAAM,WAAW,KAAK,MAAM,WAAW,GAAG,KAC3C,UAAU,QAAW,OAAO;CACjD,MAAM,QAAQ,WAAW,KAAK;CAC9B,OAAO,UAAU,IAAI,OAAO;EAAE,GAAG;EAAM,SAAS;CAAM;AACxD"}

package/dist/version.js

@@ -1,6 +1,14 @@
 //#region src/version.ts
-var e = "1.10.0";
-//#endregion
-export { e as VERSION };
+/**
+* Semver of `@weasel-js/core` as of the build.
+*
+* Falls back to `'0.0.0-unknown'` when core's source is imported by a bundler
+* that hasn't been given the define — honest about not knowing rather than
+* throwing, since nothing about version reporting should be able to break a
+* consumer's build.
+*/
+var VERSION = "1.11.0";
 
+//#endregion
+export { VERSION };
 //# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -1 +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"}
+{"version":3,"file":"version.js","names":[],"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,IAAa"}

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@weasel-js/core",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "A 2D scene-graph engine for React, rendered on WebGL2: the scene tree, viewport math, pointer and keyboard input, layered rendering, and op-based undo.",
+  "weasel": {
+    "needs": ["webgl2"]
+  },
   "license": "MIT",
   "author": "orochi235",
   "homepage": "https://orochi235.github.io/weasel/",
@@ -30,6 +33,9 @@
     "LICENSE",
     "CHANGELOG.md"
   ],
+  "weaselIcons": {
+    "table": "./dist/icons.table.json"
+  },
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -39,6 +45,10 @@
       "types": "./dist/index.d.ts"
     },
     "./style.css": "./dist/style.css",
+    "./icons": {
+      "import": "./dist/icons.js",
+      "types": "./dist/icons.d.ts"
+    },
     "./math": {
       "import": "./dist/math.js",
       "types": "./dist/math.d.ts"
@@ -82,33 +92,34 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "vite build && tsup && node ../labkit/scripts/build-css.mjs --if-built",
+    "build": "vite build && tsup && cp src/icons.table.json dist/ && node ../labkit/scripts/build-css.mjs --if-built",
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "peerDependencies": {
-    "@weasel-js/font": "1.10.0",
+    "@weasel-js/font": "1.11.0",
     "react": ">=18"
   },
   "dependencies": {
     "@msb235/blits": "0.10.0",
-    "@weasel-js/animator": "1.10.0",
-    "@weasel-js/cursor": "1.10.0",
-    "@weasel-js/geom": "1.10.0",
-    "@weasel-js/gestures": "1.10.0",
-    "@weasel-js/history": "1.10.0",
-    "@weasel-js/modes": "1.10.0",
-    "@weasel-js/paint": "1.10.0",
-    "@weasel-js/prefs": "1.10.0",
-    "@weasel-js/quantity": "1.10.0",
-    "@weasel-js/react": "1.10.0",
-    "@weasel-js/registry": "1.10.0",
-    "@weasel-js/renderer": "1.10.0",
-    "@weasel-js/routing": "1.10.0",
-    "@weasel-js/select": "1.10.0",
-    "@weasel-js/simulation": "1.10.0",
-    "@weasel-js/stroke": "1.10.0",
-    "@weasel-js/text": "1.10.0",
-    "@weasel-js/text-dom": "1.10.0",
+    "@weasel-js/animator": "1.11.0",
+    "@weasel-js/cursor": "1.11.0",
+    "@weasel-js/geom": "1.11.0",
+    "@weasel-js/gestures": "1.11.0",
+    "@weasel-js/history": "1.11.0",
+    "@weasel-js/icons": "1.11.0",
+    "@weasel-js/modes": "1.11.0",
+    "@weasel-js/paint": "1.11.0",
+    "@weasel-js/prefs": "1.11.0",
+    "@weasel-js/quantity": "1.11.0",
+    "@weasel-js/react": "1.11.0",
+    "@weasel-js/registry": "1.11.0",
+    "@weasel-js/renderer": "1.11.0",
+    "@weasel-js/routing": "1.11.0",
+    "@weasel-js/select": "1.11.0",
+    "@weasel-js/simulation": "1.11.0",
+    "@weasel-js/stroke": "1.11.0",
+    "@weasel-js/text": "1.11.0",
+    "@weasel-js/text-dom": "1.11.0",
     "earcut": "3.2.3",
     "polygon-clipping": "^0.15.7"
   },
@@ -126,7 +137,8 @@
     "2d"
   ],
   "devDependencies": {
-    "@weasel-js/modes": "1.10.0",
-    "@weasel-js/theme": "1.10.0"
+    "@weasel-js/icons-plugin": "1.11.0",
+    "@weasel-js/modes": "1.11.0",
+    "@weasel-js/theme": "1.11.0"
   }
 }