@weasel-js/core 1.6.1 → 1.7.0

package/dist/grid-BXdz8GF2.d.ts

@@ -1,158 +0,0 @@
-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.
- *
- * 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;
-
-/**
- * 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 };