@weasel-js/core 1.6.0 → 1.7.0

package/dist/grid-Dx2gQbNv.d.ts

@@ -1,158 +0,0 @@
-import { M as MoveBehavior, S as SnapStrategy } from './types-D_74YlWs.js';
-import { DebugSink } from '@weasel-js/routing';
-
-/**
- * Units — a tiny customizable unit system for canvas-kit APIs.
- *
- * The kit stores all coordinates as bare numbers in a single base unit
- * chosen by the consumer app. To make API call sites self-documenting,
- * the public surface accepts `UnitValue` — either a bare number (interpreted
- * as base units) or a `{ value, unit }` tag that's resolved against a
- * `UnitSystem` at the API boundary. Internals never see units.
- *
- * An entry is affine — `base = value * factor + offset` — so a scale that
- * puts zero somewhere else (degC against K) is expressible. No per-axis
- * units. No mixed-unit arithmetic.
- */
-/** A unit name (e.g. `'in'`, `'ft'`, `'mm'`). Looked up in a `UnitSystem`. */
-type Unit = string;
-/** What one unit is worth in base units: `base = value * factor + offset`. */
-interface UnitScale {
-    factor: number;
-    /** Where this unit puts zero, in base units. Absent is 0 — a pure scale. */
-    offset?: number;
-}
-/** One unit's conversion. A bare number is the `{ factor }` shorthand. */
-type UnitEntry = number | UnitScale;
-/** Conversion table mapping unit names to their scale against a base unit. */
-interface UnitSystem {
-    /** Name of the base unit, e.g. 'in'. All conversions resolve to this. */
-    base: Unit;
-    /** How to reach base units from each unit. The base unit's entry is 1. */
-    units: Record<Unit, UnitEntry>;
-}
-/**
- * One unit's scale, with the bare-number shorthand widened and the offset
- * defaulted — what every conversion in the kit reads. Throws if the system
- * does not carry the unit.
- */
-declare function unitScale(unitSystem: UnitSystem, unit: Unit): Required<UnitScale>;
-/** Value at a unit-aware API boundary: bare number (in base units) or `{ value, unit }` tag. */
-type UnitValue = number | {
-    value: number;
-    unit: Unit;
-};
-/**
- * Resolve a UnitValue to a number in base units.
- *  - bare number: returned as-is (assumed base)
- *  - tagged: looks up factor; throws if unit not in unit system
- */
-declare function resolveUnit(v: UnitValue, unitSystem?: UnitSystem): number;
-/**
- * Format a base-unit number as a string in the named display unit.
- *  e.g. formatUnit(36, 'ft', IMPERIAL_INCHES) => '3ft'
- *  Default precision: 2. Trailing zeros trimmed.
- */
-declare function formatUnit(baseValue: number, displayUnit: Unit, unitSystem: UnitSystem, opts?: {
-    precision?: number;
-    suffix?: boolean;
-}): string;
-/** Imperial unit system with base 'in'. */
-declare const IMPERIAL_INCHES: UnitSystem;
-/** Metric unit system with base 'mm'. */
-declare const METRIC_MM: UnitSystem;
-/** Angle unit system with base 'rad'. */
-declare const ANGLE_RADIANS: UnitSystem;
-/** Pixel unit system — sole unit is the base. */
-declare const PIXELS: UnitSystem;
-
-/** Option surface for the `move` action.
- *
- *  Lives in a sibling file (not `move.ts`) so the type contract stays stable
- *  even after the legacy `useMove` hook is gone.
- *  Consumers should import from here directly; `move.ts` re-exports the
- *  same symbol for back-compat. */
-
-/** Options for the `move` action: the behaviors (snapping, momentum) layered
- *  over the raw drag, and how a gesture expands a group into its leaves. */
-interface UseMoveOptions<TPose> {
-    behaviors?: MoveBehavior<TPose>[];
-    dragThresholdPx?: number;
-    moveLabel?: string;
-    /** Reserved for transient gestures (no history entry). Move is never transient
-     *  in practice; accepted for API consistency but ignored. */
-    transient?: boolean;
-    onGestureStart?(ids: string[]): void;
-    onGestureEnd?(committed: boolean): void;
-    /** Optional: expand the incoming id list before pose lookups. Used for
-     *  group expansion (groups have no pose; their leaves do).
-     *  Called once at `start()`. The returned list flows through ctx,
-     *  overlay (`overlay.draggedIds` is the **expanded** leaves), and op
-     *  generation. Returning `[]` aborts the gesture cleanly.
-     *  Default: identity. */
-    expandIds?: (ids: string[]) => string[];
-}
-
-/**
- * Projection used by `gridSnapStrategy` when `TPose` doesn't expose `{x,y}`
- * directly (Path, polygon, etc.). The strategy reads the snap point via
- * `getOrigin`, rounds it to the grid, then asks `translate` to move the
- * pose by the resulting delta.
- */
-interface OriginProjection<TPose> {
-    getOrigin(pose: TPose): {
-        x: number;
-        y: number;
-    };
-    translate(pose: TPose, dx: number, dy: number): TPose;
-}
-/** Identity projection for `TPose extends { x; y }`. */
-declare const RECT_ORIGIN_PROJECTION: OriginProjection<{
-    x: number;
-    y: number;
-}>;
-/** Snap-strategy that rounds the pose's origin to the nearest multiple of
- *  `spacing` (resolved through `unitSystem`). For non-rect TPose pass an
- *  `OriginProjection` so the strategy knows how to read/write the origin. */
-declare function gridSnapStrategy<TPose>(spacing: UnitValue, unitSystem?: UnitSystem): SnapStrategy<TPose>;
-/** As above, additionally reporting each candidate to a debug sink. */
-declare function gridSnapStrategy<TPose>(spacing: UnitValue, opts: {
-    unitSystem?: UnitSystem;
-    debug?: DebugSink;
-}): SnapStrategy<TPose>;
-/** As above, for a `TPose` that is not a rect: `origin` tells the strategy how
- *  to read and write the pose's origin. */
-declare function gridSnapStrategy<TPose>(spacing: UnitValue, opts: {
-    unitSystem?: UnitSystem;
-    origin: OriginProjection<TPose>;
-    debug?: DebugSink;
-}): SnapStrategy<TPose>;
-/**
- * Compute the integer cell `{col, row}` that contains `point`, given a grid
- * `spacing` and optional `origin` and `unitSystem`. Pair with
- * `createCellHighlightLayer` (its `getCell` callback) to draw a snap-target
- * preview that uses the same spacing as `gridSnapStrategy` — so the visual
- * and behavioral grids stay in lockstep:
- *
- *     const SPACING = 20;
- *     const snap = gridSnapStrategy(SPACING);
- *     // visual grid:
- *     createGridLayer({ spacing: SPACING, bounds: () => ... });
- *     // hover-preview overlay:
- *     createCellHighlightLayer({
- *       spacing: SPACING,
- *       getCell: () => hoverPoint && pointToGridCell(hoverPoint, SPACING),
- *     });
- */
-declare function pointToGridCell(point: {
-    x: number;
-    y: number;
-}, spacing: UnitValue, unitSystem?: UnitSystem, origin?: {
-    x: number;
-    y: number;
-}): {
-    col: number;
-    row: number;
-};
-
-export { ANGLE_RADIANS as A, IMPERIAL_INCHES as I, METRIC_MM as M, type OriginProjection as O, PIXELS as P, RECT_ORIGIN_PROJECTION as R, type UseMoveOptions as U, type UnitValue as a, type UnitSystem as b, type UnitEntry as c, type Unit as d, type UnitScale as e, formatUnit as f, gridSnapStrategy as g, pointToGridCell as p, resolveUnit as r, unitScale as u };

package/dist/options-CzjxFoYZ.d.ts

@@ -1,67 +0,0 @@
-import { Op } from '@weasel-js/history';
-import { I as InsertBehavior } from './types-D_74YlWs.js';
-import { Bounds } from '@weasel-js/routing';
-
-/** Option surface for the `insert` action.
- *
- *  Lives in a sibling file (not `insert.ts`) so the type contract stays stable
- *  even after the legacy `useInsert` hook is gone.
- *  Consumers should import from here directly; `insert.ts` re-exports the
- *  same symbol for back-compat. */
-
-/** Options for the `insert` action: what the drag bounds become, what a click
- *  with no drag does, and the behaviors that shape the pose along the way. */
-interface UseInsertOptions<TPose, TNode extends {
-    id: string;
-} = {
-    id: string;
-}> {
-    behaviors?: InsertBehavior<TPose>[];
-    insertLabel?: string;
-    /** Reserved; insert is never transient in practice. Ignored. */
-    transient?: boolean;
-    /** Strictly-greater-than thresholds; bounds with width <= or height <= abort. Default { width: 0, height: 0 }. */
-    minBounds?: {
-        width: number;
-        height: number;
-    };
-    /** Construct the in-flight pose from the drag bounds. Defaults to the
-     *  identity cast (treat bounds as TPose). Override for non-rect TPose
-     *  (e.g. `(b) => rectPath(b)` or a polygon factory). */
-    posefromBounds?: (bounds: Bounds) => TPose;
-    /** Click / sub-threshold-drag fallback. When provided, a release whose
-     *  bounds fall <= minBounds calls `pointInsert(start)` instead of aborting.
-     *  Returning null aborts. The created object is dispatched as an InsertOp
-     *  under the same `insertLabel`. */
-    pointInsert?: (point: {
-        x: number;
-        y: number;
-    }) => TNode | null;
-    /** Drag-disabled mode. When true, every release routes to pointInsert(start)
-     *  regardless of bounds — commitInsert is never called. Used by tool hooks
-     *  that wire only pointer.onClick (no marquee). */
-    clickOnly?: boolean;
-    /** Override for op dispatch on commit. When set, this is called instead of
-     *  `dispatchApplyBatch(adapter, ...)`. Tool hooks that synthesize an adapter
-     *  but want commits to route through the active tool ctx's `applyOps`
-     *  (for history integration) supply a function that reads from a ref
-     *  captured on handler entry. Read fresh on every commit, so a ref-reader
-     *  works without retriggering memos. */
-    applyOps?: (ops: Op[], label: string) => void;
-    onGestureStart?: () => void;
-    onGestureEnd?: (committed: boolean) => void;
-    /** Optional: snap world-space points to the active grid (or any other
-     *  snap target). Applied to every coord the gesture ingests, so both the
-     *  live marquee overlay and the committed bounds track the snapped
-     *  values. When omitted, behavior is identical to today (identity
-     *  passthrough). */
-    snapPoint?: (p: {
-        x: number;
-        y: number;
-    }) => {
-        x: number;
-        y: number;
-    };
-}
-
-export type { UseInsertOptions as U };

package/dist/{math-DRa6HBBs.d.ts → math-MCQcf_gc.d.ts}

@@ -4,6 +4,117 @@ import { b as RotatedPose } from './poseDescriptor-rZa9W5hJ.js';
 import '@weasel-js/geom';
 import './autoPoseDescriptor-_XOyF7t4.js';
 
+/**
+ * Fluent builder for `PolygonPath`. Hides the `Uint8Array` / `Float32Array`
+ * encoding behind move/line/curve/close calls and a final `build()`. Use
+ * this to construct paths in tests and demos; production callers that need
+ * to mutate large paths in place should reach for the raw arrays directly.
+ *
+ * Numeric capacity grows by doubling — typical for amortized O(1) push.
+ *
+ * Also exposes `rectPath` / `polygonFromPoints` shortcuts for the common
+ * cases. `rectPath` returns the lighter `RectPath` subtype, not a polygon.
+ */
+
+/** Fluent builder for `PolygonPath`; hides the `Uint8Array`/`Float32Array` encoding behind move/line/curve/close calls. */
+declare class PathBuilder {
+    private cmds;
+    private xs;
+    private fillRule;
+    /** Seed a builder with an existing `PolygonPath`. Useful for extending
+     *  an in-flight path with another segment (e.g. appending a cubic to
+     *  the end of a curve in response to a user action) without hand-
+     *  reaching into the `commands` / `coords` typed arrays.
+     *
+     *  ```ts
+     *  const next = PathBuilder.fromPath(current).curveTo(...).build();
+     *  ```
+     */
+    static fromPath(path: PolygonPath): PathBuilder;
+    setFillRule(rule: PathFillRule): this;
+    moveTo(x: number, y: number): this;
+    lineTo(x: number, y: number): this;
+    /** Cubic bezier to (x, y) with control points (x1, y1) and (x2, y2). */
+    curveTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): this;
+    /** Quadratic bezier to (x, y) with control point (x1, y1). */
+    quadTo(x1: number, y1: number, x: number, y: number): this;
+    close(): this;
+    build(): PolygonPath;
+}
+/** Construct a `RectPath` (the fast-path subtype). */
+declare function rectPath(x: number, y: number, width: number, height: number): RectPath;
+/** Build an open polyline from a flat list of points — the same geometry as
+ *  {@link polygonFromPoints} without the closing edge. A freehand stroke and a
+ *  measurement line want this; a region wants the closed one. */
+declare function polylineFromPoints(points: readonly {
+    x: number;
+    y: number;
+}[]): PolygonPath | RectPath;
+/** Build a closed polygon from a flat list of points. */
+declare function polygonFromPoints(points: readonly {
+    x: number;
+    y: number;
+}[], opts?: {
+    fillRule?: PathFillRule;
+}): PolygonPath;
+/** Closed ellipse inscribed in `bounds`, as a 4-cubic-Bezier `PolygonPath`.
+ *  Matches the geometry `useEllipseTool`'s overlay paints. */
+declare function ellipsePath(bounds: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): PolygonPath;
+/** Closed regular n-gon centered at `center`, circumscribed by `radius`.
+ *  `rotation` is in radians; default 0 puts the first vertex on the +x axis. */
+declare function regularPolygonPath(center: {
+    x: number;
+    y: number;
+}, radius: number, sides: number, rotation?: number): PolygonPath;
+/** Closed n-pointed star centered at `center`, alternating `outerRadius` and
+ *  `innerRadius` (default `outerRadius / 2`). `rotation` is in radians. */
+declare function starPath(center: {
+    x: number;
+    y: number;
+}, outerRadius: number, points?: number, innerRadius?: number, rotation?: number): PolygonPath;
+/** Open 2-vertex polyline from `a` to `b` — strokeable, not fillable. */
+declare function linePath(a: {
+    x: number;
+    y: number;
+}, b: {
+    x: number;
+    y: number;
+}): PolygonPath;
+
+/**
+ * A station along a path: where it is at a fraction of its length, and which
+ * way it is heading there.
+ *
+ * For anything positioned *along* geometry rather than beside it — a label on a
+ * routed edge, a tick on a curve, a badge near an arrowhead. Curves are
+ * flattened first, so the fraction is arc length along the drawn shape rather
+ * than a curve parameter, which is what makes 0.5 look like the middle.
+ */
+
+interface PathStation {
+    point: Point2;
+    /** Unit vector along the path at `point`, pointing toward the end. */
+    tangent: Point2;
+}
+interface PointAlongPathOptions {
+    /** Curve flattening tolerance, in world units. Default 0.5. */
+    flattenTolerance?: number;
+}
+/**
+ * Where `path` is at `t` of its total length, and its heading there.
+ *
+ * `t` is clamped to 0..1. Subpaths are measured in order and treated as one
+ * run, the way a browser measures a whole `<path>`. Returns `null` for a path
+ * with no points at all; a path of zero length answers at its single point,
+ * heading along +X.
+ */
+declare function pointAlongPath(path: Path, t: number, opts?: PointAlongPathOptions): PathStation | null;
+
 /**
  * Minimal node interface for the simulation primitive. Matches d3-force's
  * node shape exactly so d3-force's bundled forces work without translation.
@@ -128,117 +239,6 @@ declare const DEFAULT_VELOCITY_DECAY = 0.4;
 
 declare function createSimulation<TNode extends SimulationNode>(opts: SimulationOptions<TNode>): SimulationCore<TNode>;
 
-/**
- * Fluent builder for `PolygonPath`. Hides the `Uint8Array` / `Float32Array`
- * encoding behind move/line/curve/close calls and a final `build()`. Use
- * this to construct paths in tests and demos; production callers that need
- * to mutate large paths in place should reach for the raw arrays directly.
- *
- * Numeric capacity grows by doubling — typical for amortized O(1) push.
- *
- * Also exposes `rectPath` / `polygonFromPoints` shortcuts for the common
- * cases. `rectPath` returns the lighter `RectPath` subtype, not a polygon.
- */
-
-/** Fluent builder for `PolygonPath`; hides the `Uint8Array`/`Float32Array` encoding behind move/line/curve/close calls. */
-declare class PathBuilder {
-    private cmds;
-    private xs;
-    private fillRule;
-    /** Seed a builder with an existing `PolygonPath`. Useful for extending
-     *  an in-flight path with another segment (e.g. appending a cubic to
-     *  the end of a curve in response to a user action) without hand-
-     *  reaching into the `commands` / `coords` typed arrays.
-     *
-     *  ```ts
-     *  const next = PathBuilder.fromPath(current).curveTo(...).build();
-     *  ```
-     */
-    static fromPath(path: PolygonPath): PathBuilder;
-    setFillRule(rule: PathFillRule): this;
-    moveTo(x: number, y: number): this;
-    lineTo(x: number, y: number): this;
-    /** Cubic bezier to (x, y) with control points (x1, y1) and (x2, y2). */
-    curveTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): this;
-    /** Quadratic bezier to (x, y) with control point (x1, y1). */
-    quadTo(x1: number, y1: number, x: number, y: number): this;
-    close(): this;
-    build(): PolygonPath;
-}
-/** Construct a `RectPath` (the fast-path subtype). */
-declare function rectPath(x: number, y: number, width: number, height: number): RectPath;
-/** Build an open polyline from a flat list of points — the same geometry as
- *  {@link polygonFromPoints} without the closing edge. A freehand stroke and a
- *  measurement line want this; a region wants the closed one. */
-declare function polylineFromPoints(points: readonly {
-    x: number;
-    y: number;
-}[]): PolygonPath | RectPath;
-/** Build a closed polygon from a flat list of points. */
-declare function polygonFromPoints(points: readonly {
-    x: number;
-    y: number;
-}[], opts?: {
-    fillRule?: PathFillRule;
-}): PolygonPath;
-/** Closed ellipse inscribed in `bounds`, as a 4-cubic-Bezier `PolygonPath`.
- *  Matches the geometry `useEllipseTool`'s overlay paints. */
-declare function ellipsePath(bounds: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}): PolygonPath;
-/** Closed regular n-gon centered at `center`, circumscribed by `radius`.
- *  `rotation` is in radians; default 0 puts the first vertex on the +x axis. */
-declare function regularPolygonPath(center: {
-    x: number;
-    y: number;
-}, radius: number, sides: number, rotation?: number): PolygonPath;
-/** Closed n-pointed star centered at `center`, alternating `outerRadius` and
- *  `innerRadius` (default `outerRadius / 2`). `rotation` is in radians. */
-declare function starPath(center: {
-    x: number;
-    y: number;
-}, outerRadius: number, points?: number, innerRadius?: number, rotation?: number): PolygonPath;
-/** Open 2-vertex polyline from `a` to `b` — strokeable, not fillable. */
-declare function linePath(a: {
-    x: number;
-    y: number;
-}, b: {
-    x: number;
-    y: number;
-}): PolygonPath;
-
-/**
- * A station along a path: where it is at a fraction of its length, and which
- * way it is heading there.
- *
- * For anything positioned *along* geometry rather than beside it — a label on a
- * routed edge, a tick on a curve, a badge near an arrowhead. Curves are
- * flattened first, so the fraction is arc length along the drawn shape rather
- * than a curve parameter, which is what makes 0.5 look like the middle.
- */
-
-interface PathStation {
-    point: Point2;
-    /** Unit vector along the path at `point`, pointing toward the end. */
-    tangent: Point2;
-}
-interface PointAlongPathOptions {
-    /** Curve flattening tolerance, in world units. Default 0.5. */
-    flattenTolerance?: number;
-}
-/**
- * Where `path` is at `t` of its total length, and its heading there.
- *
- * `t` is clamped to 0..1. Subpaths are measured in order and treated as one
- * run, the way a browser measures a whole `<path>`. Returns `null` for a path
- * with no points at all; a path of zero length answers at its single point,
- * heading along +X.
- */
-declare function pointAlongPath(path: Path, t: number, opts?: PointAlongPathOptions): PathStation | null;
-
 /** AABB center of an unrotated rect — the canonical rotation pivot. */
 declare function aabbCenter(bounds: Bounds): {
     x: number;