@weasel-js/core 1.6.0 → 1.6.1

package/dist/{grid-Dx2gQbNv.d.ts → grid-BXdz8GF2.d.ts}

@@ -1,6 +1,33 @@
 import { M as MoveBehavior, S as SnapStrategy } from './types-D_74YlWs.js';
 import { DebugSink } from '@weasel-js/routing';
 
+/** 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[];
+}
+
 /**
  * Units — a tiny customizable unit system for canvas-kit APIs.
  *
@@ -66,33 +93,6 @@ 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

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;