@weasel-js/core 1.6.1 → 1.7.1

package/dist/test-seams-fYf6m5pu.d.ts

@@ -0,0 +1,356 @@
+import { FillStyle, GradientUnits, GradStop, ColorSpace, MarkerKey, Stroke } from '@weasel-js/paint';
+import { ComponentType } from 'react';
+import { Reflection } from '@weasel-js/registry';
+import { c as ShaderProgram, G as GlMat3, P as ProgramSource } from './registerProgram-ateHDGjw.js';
+import { Path } from '@weasel-js/geom';
+
+/**
+ * Resolve a `units: 'bounds'` gradient into the frame its node is painted in.
+ *
+ * Node painters bake the pose into their geometry (`pathInPoseFrame`) rather
+ * than emitting a per-node transform, so by the time the renderer sees a
+ * scene node there is no node-local space left for a gradient to refer to.
+ * This is the paint-side counterpart: it maps box-relative gradient geometry
+ * onto the same box the path was just projected into, so the two arrive in
+ * the renderer in one frame.
+ */
+
+/** The box a `'bounds'` gradient's normalized geometry is mapped onto —
+ *  usually a node's bounds. */
+interface FillPoseBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Map a `'bounds'` gradient's `0..1` geometry onto `box`, returning it in the
+ * box's own frame (`units: 'local'`). Any other fill — solid, pattern, or a
+ * gradient in another space — is returned untouched.
+ *
+ * Radii scale by the box's normalized diagonal, SVG's rule for a percentage
+ * radius against `objectBoundingBox`: `sqrt(w² + h²) / sqrt(2)`, which is
+ * exactly `w` for a square box. The renderer's radial gradient is circular,
+ * so a non-square box cannot make it the ellipse SVG would — this keeps the
+ * radius proportionate instead.
+ */
+declare function fillInPoseFrame(fill: FillStyle, box: FillPoseBox): FillStyle;
+/**
+ * Inverse of {@link fillInPoseFrame}: express a gradient already positioned
+ * in `box`'s frame as `0..1` fractions of that box (`units: 'bounds'`), so
+ * it follows the node when moved or resized.
+ *
+ * The importer's counterpart — SVG `userSpaceOnUse` coordinates arrive in
+ * page space, and normalizing them here makes an imported gradient behave
+ * exactly like one drawn in the app.
+ *
+ * A zero-width or zero-height box has no frame to normalize against; the
+ * fill is returned untouched rather than divided by zero.
+ */
+declare function fillToBoundsFrame(fill: FillStyle, box: FillPoseBox): FillStyle;
+
+/**
+ * The paint-kind registry — what makes `FillStyle` open.
+ *
+ * A consumer registers a sixth kind and it renders, converts between the
+ * bounds and pose frames, and serializes, with no kit edits. The five built-in
+ * kinds are registered here at module load so an editor's kind bar can
+ * enumerate every kind through one list.
+ *
+ * Each kit layer consults this registry for a kind it does not recognize and
+ * otherwise runs its own built-in branch. That split is not laziness: a built-in
+ * kind's render slot lives in the GL renderer, its serialize slot lives in
+ * `@weasel-js/svg`, and neither can be imported from here without inverting a
+ * package dependency.
+ */
+
+/** A compiled GL program. A paint kind gets one from
+ *  {@link PaintBindContext.program} and hands it back from `bind`. */
+type PaintProgram = ShaderProgram;
+/**
+ * `FillStyle`'s discriminant, open on the string the way `ChromeId` is: the
+ * five kinds the kit ships, plus whatever a consumer registers.
+ */
+type PaintKind = 'solid' | 'linear-gradient' | 'radial-gradient' | 'conic-gradient' | 'pattern' | (string & {});
+/** What a registered kind's editor renders. `PaintInput` in `@weasel-js/ui`
+ *  is the control that mounts it. */
+interface PaintKindEditorProps {
+    value: FillStyle;
+    onInput?(next: FillStyle): void;
+    onChange(next: FillStyle): void;
+}
+/**
+ * The lifetime a paint kind's GPU state belongs to: one renderer on one live
+ * context. The object itself is the key — a kind caches textures in a
+ * `WeakMap` on it, so two renderers sharing a context never trade them — and
+ * `onRelease` is where it frees them.
+ */
+interface PaintResources {
+    /** Run `release` once, when this lifetime ends: the renderer is disposed, or
+     *  its context was lost and restored. Free every GL object made under it
+     *  there. */
+    onRelease(release: () => void): void;
+}
+/**
+ * The renderer surface a paint kind binds against, narrowed to what a paint
+ * needs. The full `DrawContext` is not consumer surface.
+ */
+interface PaintBindContext {
+    readonly gl: WebGL2RenderingContext;
+    /** The group alpha this draw inherits — multiply it into the paint's own. */
+    readonly alpha: number;
+    /**
+     * The compiled program for a `registerProgram` id, compiled against this
+     * renderer on first use. `null` when no source is registered under `id` or
+     * compilation failed.
+     */
+    program(id: string): PaintProgram | null;
+    /** Send `u_proj` and `u_model`, which every kit vertex shader takes. */
+    setProjAndModel(program: PaintProgram): void;
+    /**
+     * `u_worldInv` for a paint declaring `units` — the inverse of the transform
+     * from the paint's space to the frame the geometry arrives in. Paired with
+     * the vertex shader's `v_world` varying this is *the* paint-space
+     * convention; it is not gradient-specific.
+     *
+     * `null` when that space has no inverse — a transform or view that flattens
+     * an axis. Nothing the paint draws there means anything, so `bind` should
+     * return `null` and draw nothing.
+     */
+    spaceInverse(units: GradientUnits | undefined): GlMat3 | null;
+    /**
+     * The transform from the space `units` names to device pixels of the target
+     * this draw lands in — screen pixels times the pixel ratio on screen, output
+     * pixels in a headless render. It is what a paint baking a texture measures
+     * its resolution against. `null` where `spaceInverse` is.
+     */
+    spaceToDevice(units: GradientUnits | undefined): GlMat3 | null;
+    /** The largest texture side this context accepts, `MAX_TEXTURE_SIZE`. */
+    readonly maxTextureSize: number;
+    /** The lifetime GPU state made for this draw belongs to. Stable across the
+     *  frames of one renderer, so it is the key for a kind's texture cache. */
+    readonly resources: PaintResources;
+    /**
+     * Bake a stop ramp into the frame's ramp atlas, bind that atlas to a texture
+     * unit, and return the `v` the ramp's own row sits at — every ramp in a
+     * frame shares one texture, so a paint must sample at the returned `v` and
+     * not at a constant.
+     *
+     * `space` is the blend the stops are baked through, defaulting to `'rgb'`.
+     * It is part of the atlas key, so the same stops under two spaces take two
+     * rows rather than colliding.
+     */
+    bindRamp(stops: GradStop[], unit: number, space?: ColorSpace): number;
+}
+/**
+ * One paint kind.
+ *
+ * `seed`, `label` and `colorOf` are the editor's slots and every kind has
+ * them. The rest are optional because a kind may not need them — but
+ * `inPoseFrame` and `toBoundsFrame` come as a pair or not at all: a kind that
+ * converts one direction and not the other paints correctly once and then
+ * drifts on the next resize.
+ */
+interface PaintKindEntry {
+    id: string;
+    label: string;
+    /** Glyph naming this kind in an editor's kind bar, as an icon name the UI
+     *  layer resolves — the same indirection `ToolPrefBase.icon` uses. A kind
+     *  without one is named by its `label`. */
+    icon?: string;
+    /** A paint of this kind seeded from a color — what an editor writes when a
+     *  consumer switches a solid to this kind. */
+    seed(fromColor: string): FillStyle;
+    /** The single color this paint shows, or `undefined` when it has none. */
+    colorOf(paint: FillStyle): string | undefined;
+    /** Editor slot. */
+    Editor?: ComponentType<PaintKindEditorProps>;
+    /**
+     * The stop list this paint reads as. With `fromStops`, it is what makes a
+     * kind a gradient: `listGradientKinds` returns the kinds carrying both, and
+     * `switchGradientKind` converts between any two of them through the list.
+     */
+    stopsOf?(paint: FillStyle): GradStop[];
+    /** A paint of this kind built from a stop list, in `bounds` units. The
+     *  converse of `stopsOf`; supply both or neither. */
+    fromStops?(stops: GradStop[]): FillStyle;
+    /**
+     * Render slot: bind program, uniforms and textures for `fill` and return the
+     * bound program; `null` declines the paint.
+     *
+     * Binding is split from drawing on purpose — a caller owning its own stencil
+     * state (an inner/outer-aligned stroke, an even-odd fill) must issue its own
+     * draw call, and the kit's draw wrapper would clobber that state. Shader
+     * output must be premultiplied: `outColor = vec4(rgb * a, a)`.
+     *
+     * The geometry is not always the node's own. Text below the outline tier
+     * paints by drawing a quad over its glyphs' screen box into an offscreen
+     * buffer and masking that with glyph coverage, so a paint must come from
+     * `v_world` through `spaceInverse`, not from where `a_position` happens to
+     * lie.
+     */
+    bind?(ctx: PaintBindContext, fill: FillStyle): PaintProgram | null;
+    /** Bounds frame → the frame the node is painted in. */
+    inPoseFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;
+    /** The inverse. Required whenever `inPoseFrame` is supplied. */
+    toBoundsFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;
+    /**
+     * The `<defs>` entry backing a `url(#id)` reference.
+     *
+     * SVG has paint servers for two gradients and a pattern and nothing else, so
+     * a kind beyond those has no element to target: write a foreign-namespaced
+     * one under the `wzl:` prefix `@weasel-js/svg` declares on the root whenever
+     * a document holds such a paint. That package emits the fallback color
+     * beside the reference on its own, from `colorOf`.
+     */
+    toSvg?(id: string, fill: FillStyle): string;
+    /**
+     * Shader programs `bind` looks up through `ctx.program`, keyed by program
+     * id; registering the kind registers them. Declaring them here rather than
+     * calling `registerProgram` at import keeps a kind loaded by
+     * {@link registerPaintKindLoader} free of core's registries.
+     */
+    programs?: Readonly<Record<string, ProgramSource>>;
+}
+/** Every registered paint kind, with the overrides each displaced. */
+declare const paintKindRegistry: Reflection<PaintKindEntry>;
+/**
+ * A consumer's own paint, typed as a `FillStyle`.
+ *
+ * `FillStyle` stays a closed union: opening its discriminant would widen every
+ * built-in member and break the narrowing the kit's own branches depend on.
+ * A registered kind declares its own interface instead and passes it through
+ * here — the kit reads only `fill` and hands the whole object back to that
+ * kind's slots.
+ */
+declare function asPaint<T extends {
+    fill: string;
+}>(paint: T): FillStyle;
+/** Register a paint kind. Returns a disposer that removes it. Re-registering an
+ *  existing id is an override; disposing it uncovers whatever it displaced. */
+declare function registerPaintKind(entry: PaintKindEntry): () => void;
+/** The entry for `kind`, or `undefined`. A lookup that misses on a kind with
+ *  a loader starts that load; see {@link registerPaintKindLoader}. */
+declare function getPaintKind(kind: string | undefined): PaintKindEntry | undefined;
+/** Resolves with the entry for a kind that is loaded on first use. */
+type PaintKindLoader = () => Promise<PaintKindEntry>;
+/**
+ * Declare a paint kind that is loaded the first time something looks it up,
+ * so its code stays out of the bundle until a paint of it appears — typically
+ * `() => import('./myKind').then((m) => m.myKindEntry)`.
+ *
+ * Until it lands the kind is unregistered: the renderer draws nothing for its
+ * paints, and every other reader treats it as unknown. Registering it fires
+ * `paintKindRegistry`'s subscribers, which is what `<SceneCanvas>` repaints
+ * on. Call {@link warmPaintKinds} to load ahead of the first frame instead.
+ *
+ * A kind that is already registered never calls its loader. Returns a
+ * disposer that removes the loader.
+ */
+declare function registerPaintKindLoader(id: string, load: PaintKindLoader): () => void;
+/** Is `id` registered, or declared with a loader? */
+declare function isPaintKindKnown(id: string): boolean;
+/**
+ * Load paint kinds ahead of their first use, so the first frame that meets
+ * one draws it rather than a blank. With no list, loads every kind that has a
+ * loader — the kit's lazily loaded built-ins (`mesh-gradient`) plus any a
+ * consumer declared with {@link registerPaintKindLoader}.
+ *
+ * Resolves once every kind is registered; a kind already registered counts
+ * as loaded. Rejects when a load fails, or for a kind that is neither
+ * registered nor loadable.
+ */
+declare function warmPaintKinds(kinds?: readonly string[]): Promise<void>;
+/** Every registered kind, built-ins first, in registration order. The same
+ *  array until the registry changes. */
+declare function listPaintKinds(): readonly PaintKindEntry[];
+/** Every registered gradient kind — the ones that read as and build from a
+ *  stop list — in registration order. The same array until the registry
+ *  changes. */
+declare function listGradientKinds(): readonly PaintKindEntry[];
+/**
+ * `paint` retargeted to gradient kind `kind`, or `undefined` when either side
+ * is not a gradient kind.
+ *
+ * Between two of the stop gradients this is `withGradientKind`, which carries
+ * the geometry. Any other pair goes through the stop list — `stopsOf` on the
+ * way out, `fromStops` on the way in — keeping `interpolate` and `opacity`.
+ * Lossy wherever the kinds hold different information; an editor that wants a
+ * switch to be undoable should keep the original paint.
+ */
+declare function switchGradientKind(paint: FillStyle, kind: PaintKind): FillStyle | undefined;
+/** The registry entry for a paint, or `undefined` when its kind is unknown. */
+declare function paintKindOf(fill: FillStyle): PaintKindEntry | undefined;
+/** @internal Test helper — do not call from product code. */
+declare function _resetPaintKindsForTests(): void;
+
+/**
+ * The stroke-marker registry — arrowheads and other line terminators.
+ *
+ * Keyed by string, because a key is what sits in `stroke.markerEnd`. That is
+ * the difference from `registerNodeShape`, which resolves by first-matching
+ * predicate and whose `id` is only a label.
+ *
+ * A built-in's SVG slot lives in `@weasel-js/svg` and cannot be imported here
+ * without inverting a package dependency, so an entry carries `toSvg` for that
+ * package to consume — the same split `PaintKindEntry` uses.
+ */
+
+/** What an entry's `path` is given. Entries that ignore it may return a
+ *  constant path. */
+interface MarkerCtx {
+    /** One geometry unit, in the same world units the ribbon is tessellated in.
+     *  Defaults to the resolved stroke width. */
+    readonly size: number;
+    /** The stroke this marker belongs to, already width-resolved. */
+    readonly stroke: Stroke;
+}
+/** `'line'` means the stroke's own paint — SVG 2's `context-stroke`, as the
+ *  default rather than an opt-in. */
+type MarkerPaint = FillStyle | 'line' | 'none';
+/** A stroke-marker registry entry: a terminator's geometry, paint and inset. */
+interface MarkerEntry {
+    /** `'kit:'`-free for built-ins so the key matches the SVG attribute value;
+     *  consumers should prefix (`'app-my-head'`). A key becomes the `id` of the
+     *  emitted `<marker>` def, so it must be a valid XML name — no colons. */
+    id: MarkerKey;
+    /** Geometry with its anchor at the origin, pointing +X, in units of
+     *  `ctx.size`. An arbitrary anchor is expressed by where the geometry is
+     *  drawn, which is why there is no `refX`/`refY`. */
+    path(ctx: MarkerCtx): Path;
+    /** Default `'line'`. */
+    fill?: MarkerPaint;
+    /** Outline width is in the same units as `path`. `false` (the default)
+     *  means no outline. */
+    outline?: {
+        width: number;
+        paint?: MarkerPaint;
+    } | false;
+    /** How far back along the line the stroke stops, in units of `ctx.size`.
+     *  Default 0. A property of the shape, not a setting on the stroke: an open
+     *  V needs 0 or its arms stop meeting the line. */
+    inset?: number;
+    /** `'auto'` (default) follows the line; a number is a fixed angle in
+     *  radians, ignoring the line — SVG's `orient="<angle>"`. */
+    orient?: 'auto' | number;
+    /** The stroke fields `path` reads besides `ctx.size` — `[]` for a shape
+     *  drawn from size alone. Declared, a head is reused across stroke objects
+     *  whose listed fields are equal; omitted, only across frames that pass the
+     *  same stroke object, since `path` might read any of it. */
+    reads?: readonly (keyof Stroke)[];
+    /** Emits the `<marker>` def. Consumed by `@weasel-js/svg`. */
+    toSvg?(id: string, entry: MarkerEntry): string;
+}
+/** Every registered marker, with the overrides each displaced. */
+declare const markerRegistry: Reflection<MarkerEntry>;
+/** Register a marker. Returns a disposer. Re-registering an existing id is an
+ *  override; disposing it uncovers whatever it displaced rather than deleting the key. */
+declare function registerMarker(entry: MarkerEntry): () => void;
+/** The entry for `key`, or `undefined`. */
+declare function getMarker(key: string | undefined): MarkerEntry | undefined;
+/** Every registered marker, built-ins first, in registration order. */
+declare function listMarkers(): readonly MarkerEntry[];
+/** Test helper. Do not call from product code. */
+declare function _resetMarkersForTests(): void;
+
+export { type FillPoseBox as F, type MarkerEntry as M, type PaintKindEntry as P, _resetMarkersForTests as _, type MarkerCtx as a, type MarkerPaint as b, type PaintBindContext as c, type PaintKind as d, type PaintKindEditorProps as e, type PaintKindLoader as f, type PaintProgram as g, type PaintResources as h, asPaint as i, fillInPoseFrame as j, fillToBoundsFrame as k, getMarker as l, getPaintKind as m, isPaintKindKnown as n, listGradientKinds as o, listMarkers as p, listPaintKinds as q, markerRegistry as r, paintKindOf as s, paintKindRegistry as t, registerMarker as u, registerPaintKind as v, registerPaintKindLoader as w, switchGradientKind as x, warmPaintKinds as y, _resetPaintKindsForTests as z };

package/dist/test-seams.d.ts

@@ -0,0 +1,6 @@
+export { _ as _resetMarkersForTests, z as _resetPaintKindsForTests } from './test-seams-fYf6m5pu.js';
+import '@weasel-js/paint';
+import 'react';
+import '@weasel-js/registry';
+import './registerProgram-ateHDGjw.js';
+import '@weasel-js/geom';

package/dist/test-seams.js

@@ -0,0 +1,3 @@
+import { _resetPaintKindsForTests as e } from "./core/paintKinds.js";
+import { _resetMarkersForTests as t } from "./core/strokeMarkers.js";
+export { t as _resetMarkersForTests, e as _resetPaintKindsForTests };

package/dist/tools/builtin/ellipse/useEllipseTool.js

@@ -0,0 +1,33 @@
+import { defineTool as e } from "../../overlayBinding.js";
+import t from "../../../icons/EllipseIcon.js";
+import { insertBindingBehaviors as n } from "../shared/insertToolOptions.js";
+import { useMemo as r } from "react";
+import { jsx as i } from "react/jsx-runtime";
+import { cursorFor as a } from "@weasel-js/cursor";
+//#region src/tools/builtin/ellipse/useEllipseTool.tsx
+function o(o = {}) {
+	let { behaviors: s } = o;
+	return r(() => e({
+		id: "ellipse",
+		capabilities: ["creates-shapes"],
+		hookName: "useEllipseTool",
+		cursor: a("crosshairEllipse", { fallback: "crosshair" }),
+		presentation: {
+			label: "Ellipse",
+			group: "shape",
+			icon: /* @__PURE__ */ i(t, {})
+		},
+		bindings: [{
+			spec: { kind: "drag" },
+			actionId: "insert",
+			opts: {
+				params: { kind: "ellipse" },
+				...n(s)
+			}
+		}]
+	}), [s]);
+}
+//#endregion
+export { o as useEllipseTool };
+
+//# sourceMappingURL=useEllipseTool.js.map

package/dist/tools/builtin/ellipse/useEllipseTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEllipseTool.js","names":["EllipseIcon","useEllipseTool","options","useMemo","defineTool","cursorFor","insertBindingBehaviors","behaviors"],"sources":["../../../../src/tools/builtin/ellipse/useEllipseTool.tsx"],"sourcesContent":["import { useMemo } from 'react';\nimport { defineTool } from '../../overlayBinding';\nimport { EllipseIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport { insertBindingBehaviors, type InsertToolOptions } from '../shared/insertToolOptions';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/**\n * Drag-to-draw ellipse tool. Mirrors `useRectTool`: the `drag` binding\n * routes to `insertAction`, which owns the live preview and commits\n * through the `insert` dep. Alt toggles from-corner ⇄ from-center\n * mid-drag via the action's live modifier read.\n */\nexport function useEllipseTool(options: InsertToolOptions = {}): Tool<null> {\n  const { behaviors } = options;\n  return useMemo(\n    () =>\n      defineTool<null>({\n        id: 'ellipse',\n        capabilities: ['creates-shapes'],\n        hookName: 'useEllipseTool',\n        cursor: cursorFor('crosshairEllipse', { fallback: 'crosshair' }),\n        presentation: {\n          label: 'Ellipse',\n          group: 'shape',\n          icon: <EllipseIcon />,\n        },\n        bindings: [\n          {\n            spec: { kind: 'drag' },\n            actionId: 'insert',\n            opts: { params: { kind: 'ellipse' } , ...insertBindingBehaviors(behaviors) },\n          },\n        ],\n      }),\n    [behaviors],\n  );\n}\n"],"mappings":";;;;;;;AAaA,SAAgBC,EAAe,IAA6B,CAAC,GAAe;CAC1E,IAAM,EAAE,iBAAcC;CACtB,OAAOC,QAEHC,EAAiB;EACf,IAAI;EACJ,cAAc,CAAC,gBAAgB;EAC/B,UAAU;EACV,QAAQC,EAAU,oBAAoB,EAAE,UAAU,YAAY,CAAC;EAC/D,cAAc;GACZ,OAAO;GACP,OAAO;GACP,MAAM,kBAACL,GAAD,CAAc,CAAA;EACtB;EACA,UAAU,CACR;GACE,MAAM,EAAE,MAAM,OAAO;GACrB,UAAU;GACV,MAAM;IAAE,QAAQ,EAAE,MAAM,UAAU;IAAI,GAAGM,EAAuBC,CAAS;GAAE;EAC7E,CACF;CACF,CAAC,GACH,CAACA,CAAS,CACZ;AACF"}

package/dist/tools/builtin/eyedropper/useEyedropperTool.js

@@ -0,0 +1,55 @@
+import { defineTool as e } from "../../overlayBinding.js";
+import t from "../../../icons/EyedropperIcon.js";
+import { createElement as n, useMemo as r } from "react";
+import { useLatest as i } from "@weasel-js/react";
+import { cursorFor as a } from "@weasel-js/cursor";
+//#region src/tools/builtin/eyedropper/useEyedropperTool.ts
+function o(o) {
+	let s = i(o.onPick), c = i(o.colorOf), l = r(() => ({
+		id: "eyedropper.pick",
+		label: "Eyedropper — sample color",
+		eligible: { capability: "samples-color" },
+		requires: ["nodeAtPoint"],
+		invoker: {
+			timing: "immediate",
+			run: (e, t) => {
+				let n = t;
+				if (n?.pressX === void 0 || n.pressY === void 0) return;
+				let r = e.nodeAtPoint, i = r?.({
+					x: n.pressX,
+					y: n.pressY
+				}) ?? null;
+				i !== null && s.current(c.current(i));
+			}
+		}
+	}), [s, c]);
+	return r(() => {
+		let r = o.keybinding === null ? void 0 : o.keybinding ?? { key: "I" }, i = o.hotkey === null ? void 0 : o.hotkey ?? "alt";
+		return e({
+			id: "eyedropper",
+			capabilities: ["samples-color"],
+			hookName: "useEyedropperTool",
+			keybinding: r,
+			hotkey: i,
+			cursor: a("eyedropper", { fallback: "crosshair" }),
+			presentation: {
+				label: "Eyedropper",
+				icon: n(t),
+				group: "view"
+			},
+			actions: [l],
+			bindings: [{
+				spec: { kind: "click" },
+				actionId: "eyedropper.pick"
+			}]
+		});
+	}, [
+		o.keybinding,
+		o.hotkey,
+		l
+	]);
+}
+//#endregion
+export { o as useEyedropperTool };
+
+//# sourceMappingURL=useEyedropperTool.js.map

package/dist/tools/builtin/eyedropper/useEyedropperTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEyedropperTool.js","names":["EyedropperIcon","useEyedropperTool","onPickRef","useLatest","opts","colorOfRef","pickAction","useMemo","p","params","nodeAtPoint","deps","id","keybinding","hotkey","defineTool","cursorFor","createElement"],"sources":["../../../../src/tools/builtin/eyedropper/useEyedropperTool.ts"],"sourcesContent":["import { useMemo, createElement } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { defineTool } from '../../overlayBinding';\nimport type { Tool } from '../../overlayBinding';\nimport type { HotkeyTrigger } from '@weasel-js/routing';\nimport type { ToolKeybinding } from '@weasel-js/routing';\nimport type { Action } from '@weasel-js/routing';\nimport type { NodeAtPointDep } from 'interactions/actions/depSchema';\nimport { EyedropperIcon } from '../../../icons';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/** Options for `useEyedropperTool`. */\nexport interface UseEyedropperToolOptions {\n  /** Called when the user picks a color. `null` means \"no node was hit\n   *  with a color\" — currently only reachable when `colorOf` returns null\n   *  on a real hit; empty-click is a no-op in v1. */\n  onPick: (color: string | null) => void;\n\n  /** Map a node id to a color string, or `null` if the node has no color\n   *  to sample. Called on click with the id of the topmost node under the\n   *  click point. */\n  colorOf: (id: string) => string | null;\n\n  /** Override the default `{ key: 'I' }` keybinding. Pass `null` to omit\n   *  the keybinding entirely (palette-only or hotkey-only wiring). */\n  keybinding?: ToolKeybinding | null;\n\n  /** Override the default `'alt'` hotkey trigger. Pass `null` to omit. */\n  hotkey?: HotkeyTrigger | null;\n}\n\n/**\n * Eyedropper. Click a node to sample its color; the consumer's `onPick`\n * callback decides where the color goes. Engages as a sticky active-slot\n * tool (`I` keybinding) and as a momentary hotkey-slot tool while Alt\n * is held — consumers can override either trigger to `null`.\n *\n * Pure-read tool — does NOT mutate the scene. v1 is click-only; drag is\n * unbound (a future drag-to-sample option is additive).\n *\n * The node under the click comes from the `nodeAtPoint` dep, so an\n * eyedropper in a consumer that never registered that dep samples nothing.\n * `<SceneCanvas>` sources it from the same picker the rest of the kit hits.\n */\nexport function useEyedropperTool(opts: UseEyedropperToolOptions): Tool<null> {\n  const onPickRef = useLatest(opts.onPick);\n  const colorOfRef = useLatest(opts.colorOf);\n\n  // Registered by `useToolActions` from inside the ActionsProvider — see\n  // `ToolDef.actions`. Closing over the option refs here is what lets the\n  // consumer's `onPick` stay a plain callback instead of a dep.\n  const pickAction = useMemo<Action>(\n    () => ({\n      id: 'eyedropper.pick',\n      label: 'Eyedropper — sample color',\n      // Same tag the tool declares, so a mode that disallows color sampling\n      // can't be reached through the gesture either. The tool's own\n      // eligibility already gates activation; this closes the gesture side.\n      eligible: { capability: 'samples-color' },\n      requires: ['nodeAtPoint'],\n      invoker: {\n        timing: 'immediate' as const,\n        run: (deps, params) => {\n          const p = params as { pressX?: number; pressY?: number } | undefined;\n          if (p?.pressX === undefined || p.pressY === undefined) return;\n          const nodeAtPoint = deps.nodeAtPoint as NodeAtPointDep | undefined;\n          const id = nodeAtPoint?.({ x: p.pressX, y: p.pressY }) ?? null;\n          // Empty click is a no-op in v1 — `onPick(null)` is reserved for\n          // \"hit a node that has no color to sample.\"\n          if (id === null) return;\n          onPickRef.current(colorOfRef.current(id));\n        },\n      },\n    }),\n    [onPickRef, colorOfRef],\n  );\n\n  return useMemo(() => {\n    // Resolve overrides. The spec says `null` => omit; defineTool reads\n    // these directly into the returned Tool, and the registry treats\n    // `undefined` as \"no trigger.\" Convert null → undefined here.\n    const keybinding =\n      opts.keybinding === null ? undefined : (opts.keybinding ?? { key: 'I' });\n    const hotkey =\n      opts.hotkey === null ? undefined : (opts.hotkey ?? 'alt');\n\n    return defineTool<null>({\n      id: 'eyedropper',\n      capabilities: ['samples-color'],\n      hookName: 'useEyedropperTool',\n      keybinding,\n      hotkey,\n      cursor: cursorFor('eyedropper', { fallback: 'crosshair' }),\n      presentation: {\n        label: 'Eyedropper',\n        icon: createElement(EyedropperIcon),\n        group: 'view',\n      },\n      actions: [pickAction],\n      // One binding, no target filter: the action resolves the node itself\n      // and no-ops on empty. Sampling deliberately reads the PRESS point\n      // rather than the release — a 4px drift between the two can land on a\n      // different node, and the color you meant is the one you pressed.\n      //\n      // The eyedropper used to carry a `pointerDown` route that existed only\n      // to claim the press before `useSelectTool`'s own always-claiming\n      // pointerdown route could. That was an artifact of two dispatchers\n      // racing; hotkey scope now outranks active scope in the one dispatcher\n      // that remains, so holding Alt wins without a gate.\n      bindings: [{ spec: { kind: 'click' as const }, actionId: 'eyedropper.pick' }],\n    });\n  }, [opts.keybinding, opts.hotkey, pickAction]);\n}\n"],"mappings":";;;;;;AA4CA,SAAgBC,EAAkB,GAA4C;CAC5E,IAAMC,IAAYC,EAAUC,EAAK,MAAM,GACjCC,IAAaF,EAAUC,EAAK,OAAO,GAKnCE,IAAaC,SACV;EACL,IAAI;EACJ,OAAO;EAIP,UAAU,EAAE,YAAY,gBAAgB;EACxC,UAAU,CAAC,aAAa;EACxB,SAAS;GACP,QAAQ;GACR,MAAM,GAAM,MAAW;IACrB,IAAMC,IAAIC;IACV,IAAID,GAAG,WAAW,KAAA,KAAaA,EAAE,WAAW,KAAA,GAAW;IACvD,IAAME,IAAcC,EAAK,aACnBC,IAAKF,IAAc;KAAE,GAAGF,EAAE;KAAQ,GAAGA,EAAE;IAAO,CAAC,KAAK;IAG1D,AAAII,MAAO,QACXV,EAAU,QAAQG,EAAW,QAAQO,CAAE,CAAC;GAC1C;EACF;CACF,IACA,CAACV,GAAWG,CAAU,CACxB;CAEA,OAAOE,QAAc;EAInB,IAAMM,IACJT,EAAK,eAAe,OAAO,KAAA,IAAaA,EAAK,cAAc,EAAE,KAAK,IAAI,GAClEU,IACJV,EAAK,WAAW,OAAO,KAAA,IAAaA,EAAK,UAAU;EAErD,OAAOW,EAAiB;GACtB,IAAI;GACJ,cAAc,CAAC,eAAe;GAC9B,UAAU;GACV;GACA;GACA,QAAQC,EAAU,cAAc,EAAE,UAAU,YAAY,CAAC;GACzD,cAAc;IACZ,OAAO;IACP,MAAMC,EAAcjB,CAAc;IAClC,OAAO;GACT;GACA,SAAS,CAACM,CAAU;GAWpB,UAAU,CAAC;IAAE,MAAM,EAAE,MAAM,QAAiB;IAAG,UAAU;GAAkB,CAAC;EAC9E,CAAC;CACH,GAAG;EAACF,EAAK;EAAYA,EAAK;EAAQE;CAAU,CAAC;AAC/C"}

package/dist/tools/builtin/hand/dragPanContribution.js

@@ -0,0 +1,17 @@
+//#region src/tools/builtin/hand/dragPanContribution.ts
+var e = "viewport.dragPanBinding";
+function t(t = {}) {
+	return {
+		id: e,
+		eligibility: { always: !0 },
+		bindings: [{
+			spec: { kind: "drag" },
+			actionId: "viewport.dragPan",
+			...Object.keys(t).length > 0 ? { opts: { params: { ...t } } } : {}
+		}]
+	};
+}
+//#endregion
+export { e as DRAG_PAN_ID, t as dragPanContribution };
+
+//# sourceMappingURL=dragPanContribution.js.map

package/dist/tools/builtin/hand/dragPanContribution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dragPanContribution.js","names":["DRAG_PAN_ID","dragPanContribution","params"],"sources":["../../../../src/tools/builtin/hand/dragPanContribution.ts"],"sourcesContent":["import type { Contribution } from '../../overlayBinding';\nimport type { DragPanParams } from '../../../interactions/actions/defaults/viewportDragPan';\n\n/** Id of the entry {@link dragPanContribution} builds. */\nexport const DRAG_PAN_ID = 'viewport.dragPanBinding';\n\n/** An always-live entry that pans the view on a drag no tool claims. No preset\n *  installs it: the hand tool pans, space-held or chosen, and a canvas that\n *  should pan on a plain drag — a viewer, a map — adds this to its ambient\n *  list. `params` are `viewport.dragPan`'s, as the hand tool passes them. */\nexport function dragPanContribution(params: DragPanParams = {}): Contribution {\n  return {\n    id: DRAG_PAN_ID,\n    eligibility: { always: true },\n    bindings: [{\n      spec: { kind: 'drag' },\n      actionId: 'viewport.dragPan',\n      ...(Object.keys(params).length > 0 ? { opts: { params: { ...params } } } : {}),\n    }],\n  };\n}\n"],"mappings":";AAIA,IAAaA,IAAc;AAM3B,SAAgBC,EAAoB,IAAwB,CAAC,GAAiB;CAC5E,OAAO;EACL,IAAID;EACJ,aAAa,EAAE,QAAQ,GAAK;EAC5B,UAAU,CAAC;GACT,MAAM,EAAE,MAAM,OAAO;GACrB,UAAU;GACV,GAAI,OAAO,KAAKE,CAAM,CAAC,CAAC,SAAS,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAGA,EAAO,EAAE,EAAE,IAAI,CAAC;EAC9E,CAAC;CACH;AACF"}

package/dist/tools/builtin/hand/useHandTool.js

@@ -0,0 +1,31 @@
+import { defineTool as e } from "../../overlayBinding.js";
+import t from "../../../icons/HandIcon.js";
+import { createElement as n, useMemo as r } from "react";
+import { useLatest as i } from "@weasel-js/react";
+//#region src/tools/builtin/hand/useHandTool.ts
+function a(a = {}) {
+	let o = i(a);
+	return r(() => Object.assign(e({
+		id: "hand",
+		capabilities: ["navigation"],
+		hotkey: "space",
+		hookName: "useHandTool",
+		presentation: {
+			label: "Hand",
+			icon: n(t),
+			group: "view"
+		},
+		cursor: "grab"
+	}), { bindings: [{
+		spec: { kind: "drag" },
+		actionId: "viewport.dragPan",
+		opts: { params: () => ({
+			axis: o.current.axis ?? "both",
+			inertia: o.current.inertia
+		}) }
+	}] }), [o]);
+}
+//#endregion
+export { a as useHandTool };
+
+//# sourceMappingURL=useHandTool.js.map

package/dist/tools/builtin/hand/useHandTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHandTool.js","names":["HandIcon","useHandTool","optsRef","useLatest","opts","useMemo","defineTool","createElement"],"sources":["../../../../src/tools/builtin/hand/useHandTool.ts"],"sourcesContent":["import { useMemo, createElement } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { defineTool } from '../../overlayBinding';\nimport type { Tool } from '../../overlayBinding';\nimport { HandIcon } from '../../../icons';\nimport type { View } from 'core/viewport/view';\nimport type { InertiaConfig } from 'core/viewport/useDecayLoop';\n\nexport type { InertiaConfig };\n\n/** Options for `useHandTool`. Both are forwarded to `viewport.dragPan` as\n *  binding params; momentum additionally needs a `view` dep publishing\n *  `decay`, which `<SceneCanvas>` wires. */\nexport interface UseHandToolOptions {\n  /** Momentum after release. Omit or pass `false` for none. */\n  inertia?: false | InertiaConfig;\n  /**\n   * Which axes the drag responds to. Default `'both'`.\n   *\n   * - `'both'` — pan both axes (default).\n   * - `'x'` — drag only changes `view.x`. Inertia (if enabled) also stays on x.\n   * - `'y'` — drag only changes `view.y`. Inertia stays on y.\n   *\n   * Locks drag panning to a single axis. The former `useWheelPanTool` /\n   * `useWheelZoomTool` / `useKeyboardZoomTool` axis option is dissolved.\n   */\n  axis?: 'both' | 'x' | 'y';\n}\n\n/** @internal */\ninterface HandScratch {\n  startView: View;\n  startScreenPoint: { x: number; y: number };\n}\n\n/**\n * Pan-on-drag tool. Registered in both the active slot (sticky, `H` key)\n * and the hotkey slot (momentary, hold `space`).\n *\n * Drag handlers compute pan deltas inline. View is read from ctx.view at\n * gesture start and written via ctx.setView on every move — so the tool\n * works with both controlled and uncontrolled Canvas viewport modes\n * without any extra wiring.\n *\n * Sign convention: dragging the mouse right moves the canvas content right\n * relative to the viewport — i.e. the camera moves *left*. So the new view\n * is `{ x: startView.x - dx, y: startView.y - dy }`.\n */\nexport function useHandTool(opts: UseHandToolOptions = {}): Tool<HandScratch | null> {\n  // Read through a ref from a params thunk rather than closing over the\n  // values: a consumer passing `inertia={{ friction: 0.9 }}` inline would\n  // otherwise mint a new tool identity on every render.\n  const optsRef = useLatest(opts);\n  return useMemo(\n    () =>\n      Object.assign(defineTool<HandScratch>({\n        id: 'hand',\n        capabilities: ['navigation'],\n        hotkey: 'space',\n        hookName: 'useHandTool',\n        presentation: {\n          label: 'Hand',\n          icon: createElement(HandIcon),\n          group: 'view',\n        },\n        cursor: 'grab',\n      }), {\n        // Declarative binding routes drag through the dispatcher +\n        // viewportDragPanAction, which also owns the grabbing cursor\n        // (`Action.activeCursor`) the tool used to declare as an `engaged`\n        // phase entry.\n        bindings: [{\n          spec: { kind: 'drag' as const },\n          actionId: 'viewport.dragPan',\n          opts: {\n            params: () => ({\n              axis: optsRef.current.axis ?? 'both',\n              inertia: optsRef.current.inertia,\n            }),\n          },\n        }],\n      }) as Tool<HandScratch | null>,\n    [optsRef],\n  );\n}\n"],"mappings":";;;;;AAgDA,SAAgBC,EAAY,IAA2B,CAAC,GAA6B;CAInF,IAAMC,IAAUC,EAAUC,CAAI;CAC9B,OAAOC,QAEH,OAAO,OAAOC,EAAwB;EACpC,IAAI;EACJ,cAAc,CAAC,YAAY;EAC3B,QAAQ;EACR,UAAU;EACV,cAAc;GACZ,OAAO;GACP,MAAMC,EAAcP,CAAQ;GAC5B,OAAO;EACT;EACA,QAAQ;CACV,CAAC,GAAG,EAKF,UAAU,CAAC;EACT,MAAM,EAAE,MAAM,OAAgB;EAC9B,UAAU;EACV,MAAM,EACJ,eAAe;GACb,MAAME,EAAQ,QAAQ,QAAQ;GAC9B,SAASA,EAAQ,QAAQ;EAC3B,GACF;CACF,CAAC,EACH,CAAC,GACH,CAACA,CAAO,CACV;AACF"}

package/dist/tools/builtin/image/useImageTool.js

@@ -0,0 +1,41 @@
+import { defineTool as e } from "../../overlayBinding.js";
+import t from "../../../icons/ImageIcon.js";
+import { insertBindingBehaviors as n } from "../shared/insertToolOptions.js";
+import { useMemo as r } from "react";
+import { jsx as i } from "react/jsx-runtime";
+//#region src/tools/builtin/image/useImageTool.tsx
+function a(a) {
+	let { src: o, label: s = "Image", preview: c = "bitmap", behaviors: l } = a;
+	return r(() => e({
+		id: "image",
+		capabilities: ["creates-shapes"],
+		hookName: "useImageTool",
+		cursor: "crosshair",
+		presentation: {
+			label: s,
+			group: "shape",
+			icon: /* @__PURE__ */ i(t, {})
+		},
+		bindings: [{
+			spec: { kind: "drag" },
+			actionId: "insert",
+			opts: {
+				params: {
+					kind: "image",
+					src: o,
+					preview: c
+				},
+				...n(l)
+			}
+		}]
+	}), [
+		o,
+		s,
+		c,
+		l
+	]);
+}
+//#endregion
+export { a as useImageTool };
+
+//# sourceMappingURL=useImageTool.js.map

package/dist/tools/builtin/image/useImageTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useImageTool.js","names":["ImageIcon","useImageTool","options","useMemo","defineTool","insertBindingBehaviors","behaviors","src","label","preview"],"sources":["../../../../src/tools/builtin/image/useImageTool.tsx"],"sourcesContent":["import { useMemo } from 'react';\nimport { defineTool } from '../../overlayBinding';\nimport { ImageIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport { insertBindingBehaviors, type InsertToolOptions } from '../shared/insertToolOptions';\n\n/** Options for `useImageTool`. */\nexport interface UseImageToolOptions extends InsertToolOptions {\n  /** Image source for inserted nodes — a URL, a `blob:` URL, or a\n   *  `data:image/…;base64,…` URI. Stored verbatim on each new node's\n   *  `data.image.src`. */\n  src: string;\n  label?: string;\n  /** What the live drag paints. `'bitmap'` (default) previews the decoded\n   *  image inside the drag bounds, falling back to the outline until it\n   *  decodes; `'outline'` never draws the image. */\n  preview?: 'bitmap' | 'outline';\n}\n\n/**\n * Drag-to-insert image tool. A drag-rect commits a leaf node with\n * `data: { image: { src } }` through the dispatcher's `insertAction` + the\n * kit's `insert` dep (the same path the shape tools use); the `kit:image`\n * painter renders it once the bitmap decodes.\n *\n * Thin declarative veneer — the node is minted by `useInsertDepSource`'s\n * `'image'` case, not the tool. `src` is baked into the binding's `params`\n * so the insert dep can stamp it onto the new node.\n */\nexport function useImageTool(options: UseImageToolOptions): Tool<null> {\n  const { src, label = 'Image', preview = 'bitmap', behaviors } = options;\n  return useMemo(\n    () =>\n      defineTool<null>({\n        id: 'image',\n        capabilities: ['creates-shapes'],\n        hookName: 'useImageTool',\n        cursor: 'crosshair',\n        presentation: {\n          label,\n          group: 'shape',\n          icon: <ImageIcon />,\n        },\n        // Declarative binding routes empty-space drags through the\n        // dispatcher + insertAction; `kind: 'image'` selects the insert\n        // dep's image factory and `src` rides along on the new node.\n        bindings: [\n          {\n            spec: { kind: 'drag' },\n            actionId: 'insert',\n            opts: { params: { kind: 'image', src, preview }, ...insertBindingBehaviors(behaviors) },\n          },\n        ],\n      }),\n    [src, label, preview, behaviors],\n  );\n}\n"],"mappings":";;;;;;AA6BA,SAAgBC,EAAa,GAA0C;CACrE,IAAM,EAAE,QAAK,WAAQ,SAAS,aAAU,UAAU,iBAAcC;CAChE,OAAOC,QAEHC,EAAiB;EACf,IAAI;EACJ,cAAc,CAAC,gBAAgB;EAC/B,UAAU;EACV,QAAQ;EACR,cAAc;GACZ;GACA,OAAO;GACP,MAAM,kBAACJ,GAAD,CAAY,CAAA;EACpB;EAIA,UAAU,CACR;GACE,MAAM,EAAE,MAAM,OAAO;GACrB,UAAU;GACV,MAAM;IAAE,QAAQ;KAAE,MAAM;KAAS;KAAK;IAAQ;IAAG,GAAGK,EAAuBC,CAAS;GAAE;EACxF,CACF;CACF,CAAC,GACH;EAACC;EAAKC;EAAOC;EAASH;CAAS,CACjC;AACF"}

package/dist/tools/builtin/lasso/useLassoTool.js

@@ -0,0 +1,42 @@
+import { defineTool as e } from "../../overlayBinding.js";
+import t from "../../../icons/LassoIcon.js";
+import { createElement as n, useMemo as r } from "react";
+import { useLatest as i } from "@weasel-js/react";
+//#region src/tools/builtin/lasso/useLassoTool.ts
+function a(a, o = {}) {
+	let s = i({
+		mode: o.mode ?? "intersect",
+		...o.minVertexSpacing === void 0 ? {} : { minVertexSpacing: o.minVertexSpacing }
+	}), { behaviors: c } = o;
+	return r(() => e({
+		id: "lasso",
+		capabilities: ["creates-selection"],
+		hookName: "useLassoTool",
+		...o.keybinding === null ? {} : { keybinding: o.keybinding ?? { key: "L" } },
+		cursor: "crosshair",
+		presentation: {
+			label: "Lasso",
+			icon: n(t),
+			group: "select"
+		},
+		bindings: [{
+			spec: {
+				kind: "drag",
+				mods: { shift: "optional" }
+			},
+			actionId: "lassoSelect",
+			opts: {
+				params: () => s.current,
+				...c ? { behaviors: c } : {}
+			}
+		}]
+	}), [
+		o.keybinding,
+		c,
+		s
+	]);
+}
+//#endregion
+export { a as useLassoTool };
+
+//# sourceMappingURL=useLassoTool.js.map

package/dist/tools/builtin/lasso/useLassoTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLassoTool.js","names":["LassoIcon","useLassoTool","paramsRef","useLatest","options","useMemo","defineTool","createElement","behaviors"],"sources":["../../../../src/tools/builtin/lasso/useLassoTool.ts"],"sourcesContent":["import { useMemo, createElement } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { defineTool } from '../../overlayBinding';\nimport { LassoIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport type { UseLassoSelectOptions } from 'interactions/actions/lasso-select/options';\nimport type { LassoHitMode, LassoSelectAdapter } from 'core/adapters/types';\nimport type { ToolKeybinding } from '@weasel-js/routing';\n\n/** Options for `useLassoTool` — the lasso-select action's options plus the\n *  tool's own hit mode and activation key. */\nexport interface UseLassoToolOptions extends UseLassoSelectOptions {\n  /** Hit mode for the action's own selection commit, which runs when no\n   *  behavior claims the gesture. A behavior carries its own, as\n   *  `selectFromLasso({ mode })` does. Default 'intersect'. */\n  mode?: LassoHitMode;\n  /** Override the default keybinding (`{ key: 'L' }`). Pass `null` to omit. */\n  keybinding?: ToolKeybinding | null;\n}\n\n/** Free-form polygon select Tool. Drag is handled entirely by the gesture\n *  dispatcher via the `lassoSelect` action binding below; the dispatcher\n *  overlay layer (`useDispatcherOverlayLayer`) paints the live polyline +\n *  dashed close-line while the gesture is in flight. Esc cancels through\n *  the dispatcher's standard cancel pipeline.\n *\n *  The legacy `useLassoSelect` hook is removed — all gesture\n *  state, overlay rendering, and selection commit live in\n *  `lassoSelectAction` (see `src/interactions/actions/defaults/lassoSelect.ts`). */\nexport function useLassoTool(\n  _adapter: LassoSelectAdapter,\n  options: UseLassoToolOptions = {},\n): Tool<undefined> {\n  const paramsRef = useLatest<{ mode: LassoHitMode; minVertexSpacing?: number }>({\n    mode: options.mode ?? 'intersect',\n    ...(options.minVertexSpacing !== undefined ? { minVertexSpacing: options.minVertexSpacing } : {}),\n  });\n  const { behaviors } = options;\n\n  return useMemo(() => {\n    return defineTool<undefined>({\n      id: 'lasso',\n      capabilities: ['creates-selection'],\n      hookName: 'useLassoTool',\n      ...(options.keybinding === null ? {} : { keybinding: options.keybinding ?? { key: 'L' } }),\n      cursor: 'crosshair',\n      presentation: {\n        label: 'Lasso',\n        icon: createElement(LassoIcon),\n        group: 'select',\n      },\n      // Declarative drag binding for the new gesture dispatcher. The\n      // dispatcher invokes `lassoSelectAction`, which owns vertex buffering,\n      // overlay state, and the commit-on-end selection write.\n      bindings: [\n        {\n          spec: { kind: 'drag', mods: { shift: 'optional' } },\n          actionId: 'lassoSelect',\n          // Thunked so a mode or spacing change reaches the next gesture\n          // without rebuilding the tool.\n          opts: {\n            params: () => paramsRef.current,\n            ...(behaviors ? { behaviors } : {}),\n          },\n        },\n      ],\n    });\n  }, [options.keybinding, behaviors, paramsRef]);\n}\n"],"mappings":";;;;;AA6BA,SAAgBC,EACd,GACA,IAA+B,CAAC,GACf;CACjB,IAAMC,IAAYC,EAA6D;EAC7E,MAAMC,EAAQ,QAAQ;EACtB,GAAIA,EAAQ,qBAAqB,KAAA,IAA6D,CAAC,IAAlD,EAAE,kBAAkBA,EAAQ,iBAAiB;CAC5F,CAAC,GACK,EAAE,iBAAcA;CAEtB,OAAOC,QACEC,EAAsB;EAC3B,IAAI;EACJ,cAAc,CAAC,mBAAmB;EAClC,UAAU;EACV,GAAIF,EAAQ,eAAe,OAAO,CAAC,IAAI,EAAE,YAAYA,EAAQ,cAAc,EAAE,KAAK,IAAI,EAAE;EACxF,QAAQ;EACR,cAAc;GACZ,OAAO;GACP,MAAMG,EAAcP,CAAS;GAC7B,OAAO;EACT;EAIA,UAAU,CACR;GACE,MAAM;IAAE,MAAM;IAAQ,MAAM,EAAE,OAAO,WAAW;GAAE;GAClD,UAAU;GAGV,MAAM;IACJ,cAAcE,EAAU;IACxB,GAAIM,IAAY,EAAE,aAAU,IAAI,CAAC;GACnC;EACF,CACF;CACF,CAAC,GACA;EAACJ,EAAQ;EAAYI;EAAWN;CAAS,CAAC;AAC/C"}