@weasel-js/core 0.5.0

package/dist/types-Cpb4hii1.d.ts

@@ -0,0 +1,445 @@
+import * as _weasel_js_history from '@weasel-js/history';
+import { Op, SerializedHistory } from '@weasel-js/history';
+import { P as Path } from './types-B6MMiodD.js';
+
+/**
+ * Pose composition for hierarchical scene graphs.
+ *
+ * As of the nesting change, `getPose(id)` on adapters returns the
+ * **local** pose — relative to the object's direct parent. Anything in the
+ * kit that needs to draw, hit-test, snap, or otherwise reason about world
+ * coordinates routes through `composeWorldPose`, which walks the parent
+ * chain and folds local poses together via a consumer-supplied `compose`.
+ *
+ * Pose shape is generic, so the compose strategy is too. For the common
+ * `{x, y, width, height}` axis-aligned rect, use `composeRectPose` —
+ * translation only, child dimensions preserved. Custom pose shapes (paths,
+ * matrix transforms) supply their own.
+ *
+ * The inverse — `rebaseLocalPose` — converts a world-space pose into a
+ * local pose under a target parent. Used when reparenting so the visual
+ * world position of a child is preserved across the parent change.
+ */
+/**
+ * Axis-aligned rectangle pose with optional rotation. The canonical pose
+ * shape used by `composeRectPose` and the `unionBounds` helper. Rotation is
+ * in radians, pivoted on the unrotated AABB center; absent === 0. Kit-side
+ * code that consumes rotation already reads `pose.rotation ?? 0`
+ * (`SceneCanvas.defaultDrawOne`, `rotate/handle.ts`, `pathInWorld.ts`), so
+ * the slot exists on every default scene whether or not the consumer
+ * populates it. Defined here in core/transforms so the compose helpers
+ * don't depend on features.
+ */
+interface RectPose {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Rotation in radians around the unrotated AABB center. Absent === 0. */
+    rotation?: number;
+}
+/** Minimal adapter needed by `composeWorldPose` and friends — pose lookup plus parent walk. */
+interface PoseAdapter<TPose> {
+    getPose(id: string): TPose;
+    getParent(id: string): string | null;
+}
+/** Consumer's pose-composition strategy for hierarchical scenes. `compose`
+ *  folds a child's pose (in parent's frame) up to the next frame; `decompose`
+ *  is its inverse. Default is IDENTITY — an absolute-pose scene where every
+ *  node already stores world coords (parent is grouping-only, no transform). */
+interface PoseComposition<TPose> {
+    compose: (parent: TPose, child: TPose) => TPose;
+    decompose: (parent: TPose, world: TPose) => TPose;
+}
+/** Default pose-composition strategy: IDENTITY. Both `compose` and
+ *  `decompose` return the child/world pose unchanged, modeling an
+ *  absolute-pose scene where every node stores world coords and parents are
+ *  grouping-only (no transform). With this strategy `composeWorldPose`
+ *  returns a node's own raw pose and `rebaseLocalPose` is a no-op. */
+declare const IDENTITY_POSE_COMPOSITION: PoseComposition<unknown>;
+/**
+ * Walk `id`'s parent chain (root first to id last) and fold local poses into
+ * a world pose via `compose`. Returns the world pose for `id`. Cycle-safe:
+ * a visited-set guard breaks if the chain ever loops back to itself.
+ *
+ * `compose(parent, child)` interprets `child` as expressed *in `parent`'s
+ * local frame* and returns the equivalent pose in the next frame up. For a
+ * standard translation-only rect: `world = { x: p.x + c.x, y: p.y + c.y,
+ * width: c.width, height: c.height }`.
+ */
+declare function composeWorldPose<TPose>(adapter: PoseAdapter<TPose>, id: string, compose: (parent: TPose, child: TPose) => TPose): TPose;
+/**
+ * Default `compose` for axis-aligned rectangles. Adds translation; preserves
+ * child width/height. Treat as the canonical compose for any
+ * `{x, y, width, height}` pose under a translation-only hierarchy.
+ *
+ * Generic over the concrete pose type so callers with a wider pose
+ * (e.g. `RectPose & { rotation }`) can pass it through; the extra fields
+ * are taken from the child unchanged.
+ */
+declare function composeRectPose<TPose extends RectPose>(parent: TPose, child: TPose): TPose;
+/**
+ * Translate a `RectPose`-shaped pose by `(dx, dy)`. Suitable as the default
+ * `translatePose` for `useMove` when poses carry top-level `x`/`y`. Other
+ * fields (width/height, plus any extra props on `TPose`) are preserved.
+ */
+declare function translateRectPose<TPose extends RectPose>(pose: TPose, dx: number, dy: number): TPose;
+/**
+ * Convert `worldPose` into a local pose expressed under `newParentId`'s
+ * frame. Used when reparenting so the child's visual world position is
+ * preserved despite the change of frame. Inverse of one `compose` step.
+ *
+ * `decompose(parent, world)` returns the local pose `child` such that
+ * `compose(parent, child) === world`. For axis-aligned rects:
+ * `child = { ...world, x: world.x - parent.x, y: world.y - parent.y }`.
+ *
+ * Pass `newParentId === null` for the root frame; the function returns
+ * `worldPose` unchanged.
+ */
+declare function rebaseLocalPose<TPose>(adapter: PoseAdapter<TPose>, worldPose: TPose, newParentId: string | null, compose: (parent: TPose, child: TPose) => TPose, decompose: (parent: TPose, world: TPose) => TPose): TPose;
+/** Inverse of `composeRectPose` — subtracts parent translation. */
+declare function decomposeRectPose<TPose extends RectPose>(parent: TPose, world: TPose): TPose;
+/**
+ * Build a `(id) => world pose | null` callback over a `PoseAdapter`.
+ * Convenience for RenderLayers that take a `getPose` callback (selection
+ * overlays, debug layers, etc.) so consumers don't hand-write a
+ * `composeWorldPose` call per layer.
+ *
+ * Returns `null` when `adapter.getPose` or `adapter.getParent` throws — the
+ * common case is an id removed mid-render between selection state and the
+ * next paint. Layers should treat `null` as "skip this id."
+ */
+declare function worldPoseLookup<TPose>(adapter: PoseAdapter<TPose>, compose: (parent: TPose, child: TPose) => TPose): (id: string) => TPose | null;
+
+/**
+ * # SceneNode — the thing in the scene
+ *
+ * A `SceneNode` is the single canonical unit of a weasel scene. Everything
+ * the user sees on the canvas — a shape, a group, an annotation, a tile —
+ * is one of these. Containers and leaves are both nodes; the kit has no
+ * other concept of "scene element."
+ *
+ * ## Three orthogonal slots
+ *
+ * Every node carries three independent slots, plus its tree position:
+ *
+ *   - **`data: TData`** — app-defined payload. The kit never inspects it.
+ *     Color, label, kind, glyph, sample-rate, whatever the app's domain
+ *     calls for. Mutated via `Scene.update(id, { data })`.
+ *
+ *   - **`pose: TPose`** — local transform, relative to the node's direct
+ *     parent (or world, for root nodes). Default `RectPose` is
+ *     `{ x, y, width, height }`, but `TPose` is fully generic so apps can
+ *     use rotated rects, paths, ellipses, etc. The kit composes world
+ *     poses via `composeWorldPose` when rendering / hit-testing / snapping.
+ *
+ *   - **`layer: TLayer`** — a string tag associating the node with a
+ *     visual `RenderLayer` at draw time. Separate from `LayerRecord` (the
+ *     per-layer visible/locked metadata held by the `Scene`).
+ *
+ * Tree position lives on the node itself: every node has a `parent` (or
+ * `null` for roots), and `ContainerNode` adds an ordered `children: NodeId[]`.
+ *
+ * ## Identity is by `NodeId`, not by reference
+ *
+ * Nodes are addressed by `NodeId` everywhere outside the scene tree:
+ * selection is `NodeId[]`, ops reference `NodeId`s, adapter methods accept
+ * `string` ids and look up the node on demand. The `Node` object itself is
+ * a snapshot of current state — don't hold references to it across scene
+ * updates; look up by id when you need the latest.
+ *
+ * Picking helpers (`pickBest`, `pickEvery`) likewise return ids, not nodes —
+ * they're hit-testing primitives that stay ignorant of node payload shape.
+ *
+ * ## Vocabulary
+ *
+ * The kit-internal name is `Node`; the public re-export is `SceneNode`
+ * (avoids collision with DOM `Node` at call sites). Adapter methods speak
+ * the same vocabulary: `getNode`, `getNodes`, `insertNode`, `removeNode`,
+ * `cloneNode`, `addNode`. Older code, demos, and comments may still say
+ * "object" or "item" — those are historical aliases for the same concept.
+ */
+/** Opaque branded id. Treat as opaque outside the kit. */
+type NodeId = string & {
+    readonly __brand: 'NodeId';
+};
+/** Brand a string as a NodeId. */
+declare const asNodeId: (s: string) => NodeId;
+interface NodeBase<TData, TLayer extends string, TPose> {
+    id: NodeId;
+    layer: TLayer;
+    pose: TPose;
+    data: TData;
+    parent: NodeId | null;
+}
+interface LeafNode<TData, TLayer extends string, TPose = RectPose> extends NodeBase<TData, TLayer, TPose> {
+    kind: 'leaf';
+}
+interface ContainerNode<TData, TLayer extends string, TPose = RectPose> extends NodeBase<TData, TLayer, TPose> {
+    kind: 'container';
+    children: NodeId[];
+    /** Optional clip-path source. Re-evaluated each render. Returning `null`
+     *  means "no clip for this container right now"; an empty / zero-area path
+     *  means "clip everything out" (children render nowhere). When set, the
+     *  renderer rasterizes the returned path into the stencil buffer and
+     *  paints descendants only where it covers. */
+    clipFromPose?: (pose: TPose) => Path | null;
+}
+type Node<TData, TLayer extends string, TPose = RectPose> = LeafNode<TData, TLayer, TPose> | ContainerNode<TData, TLayer, TPose>;
+interface LayerRecordBase<TLayer extends string> {
+    id: TLayer;
+    visible: boolean;
+    locked: boolean;
+}
+interface SystemLayerRecord<TLayer extends string> extends LayerRecordBase<TLayer> {
+    kind: 'system';
+}
+interface UserLayerRecord<TLayer extends string> extends LayerRecordBase<TLayer> {
+    kind: 'user';
+    name: string;
+}
+type LayerRecord<TLayer extends string> = SystemLayerRecord<TLayer> | UserLayerRecord<TLayer>;
+interface AddNodeSpec<TData, TLayer extends string, TPose = RectPose> {
+    kind: 'leaf' | 'container';
+    layer: TLayer;
+    pose: TPose;
+    data: TData;
+    parent?: NodeId | null;
+    index?: number;
+    /** Explicit id wins over the Scene's `generateId` and the kit default. */
+    id?: NodeId;
+    /** Only meaningful when `kind === 'container'`. Attach a clip-path function
+     *  to the node; ignored for leaves. Mirrors `ContainerNode.clipFromPose`. */
+    clipFromPose?: (pose: TPose) => Path | null;
+}
+interface RegisteredOp<P> {
+    apply: (payload: P) => void;
+    revert: (payload: P) => void;
+}
+interface SystemLayerSpec<TLayer extends string> {
+    id: TLayer;
+    visible?: boolean;
+    locked?: boolean;
+}
+/** Argument to `Scene.addLayer`. Always produces a `UserLayerRecord`
+ *  (`kind: 'user'`). */
+interface AddLayerSpec<TLayer extends string> {
+    id: TLayer;
+    name: string;
+    /** Default `true`. */
+    visible?: boolean;
+    /** Default `false`. */
+    locked?: boolean;
+    /** Render-stack position. Default: top of stack (highest render index). */
+    index?: number;
+}
+/** JSON-serializable shape of a Scene's current state. Produced by
+ *  `scene.toJSON()`; consumed by `sceneFromJSON()`. Function fields
+ *  (e.g., `clipFromPose`) appear as string keys (`clipFromPoseKey`) and
+ *  are resolved through `SceneRegistry` at load time. */
+interface SerializedScene<TData, TLayer extends string, TPose> {
+    version: 1;
+    systemLayers: readonly SystemLayerSpec<TLayer>[];
+    nodes: readonly SerializedNode<TData, TLayer, TPose>[];
+}
+/** JSON-serializable shape of a single node. Mirrors `AddNodeSpec` but
+ *  with function fields replaced by registry keys. */
+interface SerializedNode<TData, TLayer extends string, TPose> {
+    id: string;
+    kind: 'leaf' | 'container';
+    layer: TLayer;
+    pose: TPose;
+    data: TData;
+    /** Parent id; omitted for roots. */
+    parent?: string;
+    /** Registry key for the container's clip-path factory.
+     *  Containers only; omitted when the container has no clip. */
+    clipFromPoseKey?: string;
+}
+/** Per-scene registry mapping string keys to live function references.
+ *  Passed to `createScene({ ..., registry })` and `sceneFromJSON(json, { registry })`.
+ *  Each function-field type has its own keyed map. */
+interface SceneRegistry<TPose> {
+    /** Maps registry keys to `clipFromPose` factory functions for container nodes. */
+    clipFromPose?: Readonly<Record<string, (pose: TPose) => Path | null>>;
+}
+interface UseSceneOptions<TData, TLayer extends string, TPose = RectPose> {
+    systemLayers: readonly SystemLayerSpec<TLayer>[];
+    initial?: readonly AddNodeSpec<TData, TLayer, TPose>[];
+    ops?: Readonly<Record<string, RegisteredOp<unknown>>>;
+    historyLimit?: number;
+    /** Window (ms) within which consecutive same-shaped mutations merge into
+     *  the previous undo entry (matching per-op coalesce keys — e.g. repeated
+     *  `setPose` on the same node, or repeated `applyBatch` calls whose ops
+     *  carry matching `coalesceKey` multisets). `0` (default) disables
+     *  coalescing: every mutation is a discrete undo entry. Undo of a
+     *  coalesced entry returns to the state before the first merged mutation;
+     *  redo restores the latest. `scene.batch` entries never coalesce. */
+    coalesceWindowMs?: number;
+    generateId?: () => NodeId;
+    /** Per-scene registry for non-serializable function fields (clipFromPose, etc.).
+     *  Required only when serializing/deserializing scenes that use function fields. */
+    registry?: SceneRegistry<TPose>;
+    /** When supplied, `scene.applyOps(ops, label)` consults this on every call.
+     *  If it returns a non-null `Journal`, ops are routed to the journal's
+     *  `applyBatch` instead of recording a new parent-history entry. The journal
+     *  drives adapter mutation internally (via `op.apply(adapter)`), so the
+     *  scene state changes as normal; only the history tracking differs.
+     *
+     *  The accessor is called on every `applyOps` invocation so the caller can
+     *  swap the active journal in and out by updating the closure's reference
+     *  (e.g., an app's mode machine holds `let activeJournal: Journal | null`
+     *  and the accessor reads that variable).
+     *
+     *  When the accessor isn't known at scene-construction time (typical for
+     *  mode machines that depend on `scene.history`), pass nothing here and
+     *  wire it after construction via `scene.setActiveJournalAccessor(fn)`. */
+    getActiveJournal?: () => _weasel_js_history.Journal | null;
+}
+interface Scene<TData, TLayer extends string, TPose = RectPose> {
+    readonly nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>;
+    readonly roots: readonly NodeId[];
+    readonly layers: readonly LayerRecord<TLayer>[];
+    get(id: NodeId): Node<TData, TLayer, TPose> | undefined;
+    childrenOf(id: NodeId): readonly NodeId[];
+    ancestorsOf(id: NodeId): readonly NodeId[];
+    renderOrder(): Iterable<NodeId>;
+    add(spec: AddNodeSpec<TData, TLayer, TPose>): NodeId;
+    /** Delete `id` **and its entire subtree** — every descendant is removed in
+     *  the same operation. Recorded as one undoable step; `undo()` restores the
+     *  whole subtree (root + descendants, child order intact). */
+    remove(id: NodeId): void;
+    update(id: NodeId, patch: {
+        data: TData;
+    }): void;
+    setPose(id: NodeId, pose: TPose): void;
+    /** Retag `id` to `layer`. On a **container this cascades**: every descendant
+     *  is moved to the same layer, recorded as a **single** undo step.
+     *
+     *  Invariants:
+     *  - **Layer floor** — a child may not render below its parent, so retagging
+     *    to a layer *below* the node's parent throws. Retagging to the parent's
+     *    layer or any higher one is allowed; a node with no parent is
+     *    unconstrained.
+     *  - **No-op elision** — setting the layer a node already has does nothing
+     *    and pushes **no** history entry. */
+    setLayer(id: NodeId, layer: TLayer): void;
+    /** Reparent `id` under `parent` (or to a root when `parent` is `null`) at
+     *  `index` within the new sibling list, appending when `index` is omitted.
+     *  Siblings are reindexed. Recorded as one undoable step.
+     *
+     *  Rejected (throws) when:
+     *  - `parent` exists but is a **leaf**, not a container;
+     *  - the move would form a **cycle** — `parent` is `id` itself or one of
+     *    `id`'s own descendants;
+     *  - it would drop `id` **below its new parent's layer** (child may not
+     *    render below its parent).
+     *
+     *  `move(id, null)` — detaching to a root — is always allowed regardless of
+     *  layer, since a root has no parent to render beneath. */
+    move(id: NodeId, parent: NodeId | null, index?: number): void;
+    /** Shift `id` to `index` within its **current** parent's child list. Unlike
+     *  {@link move}, the parent never changes — only sibling order. */
+    reorder(id: NodeId, index: number): void;
+    setLayerVisible(layer: TLayer, visible: boolean): void;
+    setLayerLocked(layer: TLayer, locked: boolean): void;
+    addLayer(spec: AddLayerSpec<TLayer>): void;
+    removeLayer(layer: TLayer): void;
+    renameLayer(layer: TLayer, name: string): void;
+    moveLayer(layer: TLayer, index: number): void;
+    registerOp<P>(kind: string, handler: RegisteredOp<P>): void;
+    recordOp<P>(op: {
+        kind: string;
+        payload: P;
+    }): void;
+    /** Install (or clear) the active-journal accessor after scene construction.
+     *  Useful when the journal source (typically a mode machine) is built
+     *  with `scene.history` as a dependency — a chicken-and-egg situation
+     *  where the accessor can't be passed in via `UseSceneOptions`.
+     *
+     *  Pass `null` to detach. Overrides any `getActiveJournal` set in
+     *  `UseSceneOptions`. */
+    setActiveJournalAccessor(fn: (() => _weasel_js_history.Journal | null) | null): void;
+    /** Apply a batch of ops with journal-aware routing.
+     *
+     *  - **Without active journal** (or no `getActiveJournal` in options):
+     *    the ops themselves are recorded as one undo entry on the scene's own
+     *    history, rebound to `adapter` — undo replays each op's `invert()`
+     *    against that same adapter. Consecutive `applyBatch` entries can
+     *    coalesce via matching op `coalesceKey`s when the scene opts into
+     *    `coalesceWindowMs`.
+     *  - **With active journal**: routes ops to `journal.applyBatch(ops, label)`.
+     *    The scene's history recording is suppressed for the duration so the
+     *    journal's inner history — not the scene's undo stack — tracks the batch.
+     *    Mutations still happen on `adapter` / scene state.
+     *
+     *  `adapter` must be the same adapter the ops expect (typically a
+     *  `SceneCanvasAdapter`). Pass `this` from `sceneToAdapter` or a compatible
+     *  adapter. */
+    applyBatch(ops: Op[], label: string, adapter: unknown): void;
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    batch<T>(label: string, fn: () => T): T;
+    /** Read-only snapshot of every history entry currently reachable from
+     *  the present state. Oldest applied first, then redoable entries in
+     *  the order they'd be re-applied. Each entry id is stable. */
+    historyEntries(): readonly {
+        id: string;
+        label: string;
+    }[];
+    /** Index of the "current state". Equals the count of applied entries;
+     *  `0` means "nothing applied" (initial). */
+    historyIndex(): number;
+    /** Jump to the given history index by calling undo/redo repeatedly.
+     *  Clamps to [0, total]. Returns true if any movement occurred. */
+    jumpToHistoryIndex(index: number): boolean;
+    /** Snapshot the undo/redo history in a JSON-serializable form (the
+     *  engine's `SerializedHistory`). Entries containing any nameless op are
+     *  dropped (hand-rolled anonymous ops passed to `applyBatch`); kit and
+     *  consumer-registered ops always carry names. Payload JSON-safety
+     *  (e.g. typed arrays inside poses) is the caller's concern. Do not call
+     *  mid-`batch` — the open batch's ops are not yet recorded. */
+    serializeHistory(): SerializedHistory;
+    /** Replace the undo/redo history from a `serializeHistory()` snapshot.
+     *  Call on a scene whose node/layer state already matches the snapshot's
+     *  head state (i.e. right after `loadState` from the paired scene
+     *  snapshot); node state is NOT mutated. Ops re-registered via
+     *  `registerOp` before this call round-trip; unknown kinds become no-op
+     *  placeholders; external ops rebuild via the global op-factory registry
+     *  and replay against the `setHistoryAdapter` accessor. Restored entries
+     *  never coalesce with new ones. Notifies once. Do not call mid-`batch`:
+     *  the stacks are replaced underneath the open batch, whose eventual
+     *  flush would graft onto (and evict against) the restored stacks. */
+    restoreHistory(snapshot: SerializedHistory): void;
+    /** Install (or clear with `null`) the accessor for the adapter that
+     *  RESTORED external ops (recorded via `applyBatch`, rebuilt from a
+     *  `restoreHistory` snapshot) apply against on undo/redo. Resolved lazily
+     *  at each apply, so wiring order relative to `restoreHistory` doesn't
+     *  matter. Live `applyBatch` entries are unaffected (they bind their
+     *  call-site adapter). If unset when a restored op applies, the op is a
+     *  debug-warned no-op. */
+    setHistoryAdapter(fn: (() => unknown) | null): void;
+    /** Snapshot the current scene state to a JSON-serializable shape.
+     *  History (undo/redo stacks) is NOT captured. Function fields like
+     *  `ContainerNode.clipFromPose` are translated to string keys via the
+     *  scene's registry; throws if any function field has no matching key. */
+    toJSON(): SerializedScene<TData, TLayer, TPose>;
+    /** Replace this scene's entire node + layer state in place from a snapshot
+     *  produced by `toJSON()`. Unlike `sceneFromJSON`, the existing Scene
+     *  instance is preserved — holders such as `<SceneCanvas>` keep their
+     *  reference. History (undo/redo) is cleared, matching `sceneFromJSON`.
+     *  Bumps `getVersion()` and notifies subscribers exactly once.
+     *
+     *  Throws on an unsupported version or unknown registry/layer ids; on a
+     *  malformed snapshot the scene is left empty or partially populated (callers should treat a
+     *  `loadState` throw as fatal and reload). Snapshots from `toJSON()` are
+     *  always well-formed. */
+    loadState(json: SerializedScene<TData, TLayer, TPose>): void;
+    subscribe(listener: () => void): () => void;
+    /** Monotonically increasing version. Snapshot for `useSyncExternalStore`. */
+    getVersion(): number;
+}
+
+export { type AddLayerSpec as A, type ContainerNode as C, IDENTITY_POSE_COMPOSITION as I, type LayerRecord as L, type NodeId as N, type PoseComposition as P, type RectPose as R, type Scene as S, type UseSceneOptions as U, type Node as a, type SerializedScene as b, type SceneRegistry as c, type RegisteredOp as d, type AddNodeSpec as e, type LeafNode as f, type PoseAdapter as g, type SerializedNode as h, type SystemLayerRecord as i, type SystemLayerSpec as j, type UserLayerRecord as k, asNodeId as l, composeRectPose as m, composeWorldPose as n, decomposeRectPose as o, rebaseLocalPose as r, translateRectPose as t, worldPoseLookup as w };

package/dist/types-D2tTKEU0.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Guide — a horizontal or vertical world-space line used as a snap target
+ * and an optional rendered overlay.
+ *
+ * `axis === 'x'` means a vertical line at world `x = offset` (snaps the X
+ * coordinate); `axis === 'y'` means a horizontal line at world `y = offset`
+ * (snaps the Y coordinate). This matches "the X axis snaps along X."
+ */
+interface Guide {
+    /** Stable, caller-supplied id. Used by removeGuide and as a render key. */
+    id: string;
+    /** Which world axis this guide constrains. */
+    axis: 'x' | 'y';
+    /** World-space offset along the constrained axis. */
+    offset: number;
+}
+
+export type { Guide as G };

package/dist/view-DSQgxBJB.d.ts

@@ -0,0 +1,63 @@
+/** Pan offset (in pixels) plus per-axis zoom (pixels per content unit). */
+interface ViewTransform {
+    panX: number;
+    panY: number;
+    zoom: {
+        x: number;
+        y: number;
+    };
+}
+/** Project a world-space point to screen-space pixels through a `ViewTransform`. */
+declare function worldToScreen(worldX: number, worldY: number, view: ViewTransform): [number, number];
+/** Inverse of `worldToScreen` — recover the world-space point under a screen-space pixel. */
+declare function screenToWorld(screenX: number, screenY: number, view: ViewTransform): [number, number];
+
+/**
+ * Viewport state. `(view.x, view.y)` is the **world point currently
+ * rendered at the canvas top-left**; `view.scale.x` / `view.scale.y` is
+ * pixels per world unit on each axis (default `{ x: 1, y: 1 }`). So:
+ *
+ *   screenX = (worldX - view.x) * view.scale.x
+ *   screenY = (worldY - view.y) * view.scale.y
+ *   worldX  = screenX / view.scale.x + view.x
+ *   worldY  = screenY / view.scale.y + view.y
+ *
+ * `scale` is always a 2-vector. Input convenience types
+ * {@link ZoomFactor} and {@link ZoomBound} let callers pass a scalar
+ * when they want both axes treated the same.
+ */
+interface View {
+    x: number;
+    y: number;
+    scale: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Input convenience for zoom primitives. A `number` is treated as a
+ * uniform factor applied to both axes; a `{x, y}` vector applies
+ * per-axis factors.
+ */
+type ZoomFactor = number | {
+    x: number;
+    y: number;
+};
+/**
+ * Input convenience for zoom-clamp ranges. A `number` is applied as the
+ * same bound on both axes; a `{x, y}` vector applies per-axis bounds.
+ */
+type ZoomBound = number | {
+    x: number;
+    y: number;
+};
+/**
+ * Bridge `View` into the legacy `ViewTransform` shape so chrome can keep
+ * calling `worldToScreen` / `screenToWorld`. `View` and `ViewTransform`
+ * use opposite sign conventions for the translation half (`view.x` is
+ * camera position; `panX` is canvas translation), so the adapter flips
+ * the sign and multiplies by per-axis scale.
+ */
+declare function viewToTransform(view: View): ViewTransform;
+
+export { type View as V, type ZoomBound as Z, type ViewTransform as a, type ZoomFactor as b, screenToWorld as s, viewToTransform as v, worldToScreen as w };

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@weasel-js/core",
+  "version": "0.5.0",
+  "description": "Domain-agnostic 2D scene graph primitives for React: viewport math, drag/resize/insert/clone interactions, layered canvas rendering.",
+  "license": "MIT",
+  "author": "orochi235",
+  "homepage": "https://orochi235.github.io/weasel/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orochi235/weasel.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/orochi235/weasel/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./move": {
+      "import": "./dist/move.js",
+      "types": "./dist/move.d.ts"
+    },
+    "./resize": {
+      "import": "./dist/resize.js",
+      "types": "./dist/resize.d.ts"
+    },
+    "./insert": {
+      "import": "./dist/insert.js",
+      "types": "./dist/insert.d.ts"
+    },
+    "./clipboard": {
+      "import": "./dist/clipboard.js",
+      "types": "./dist/clipboard.d.ts"
+    },
+    "./clone": {
+      "import": "./dist/clone.js",
+      "types": "./dist/clone.d.ts"
+    },
+    "./patterns-builtin": {
+      "import": "./dist/patterns-builtin.js",
+      "types": "./dist/patterns-builtin.d.ts"
+    },
+    "./renderer": {
+      "import": "./dist/renderer.js",
+      "types": "./dist/renderer.d.ts"
+    },
+    "./routing": {
+      "import": "./dist/routing.js",
+      "types": "./dist/routing.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "dependencies": {
+    "@weasel-js/geom": "0.5.0",
+    "@weasel-js/gestures": "0.5.0",
+    "@weasel-js/history": "0.5.0",
+    "@weasel-js/modes": "0.5.0",
+    "earcut": "2.2.4",
+    "polygon-clipping": "^0.15.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "react",
+    "canvas",
+    "scene-graph",
+    "drag",
+    "resize",
+    "viewport",
+    "2d"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
+}