@lupinum/board-core 0.1.0

package/dist/internal.d.ts

@@ -0,0 +1,9 @@
+export type { InternalBoardCommit, InternalHistoryRoot } from './state/types.js';
+export type { InternalBoardPlugin, InternalBoardPluginDefinition, InternalInteractionAdapter, InternalPluginContext, InternalPluginPersistence, } from './types.js';
+/** Resolve the unsupported first-party pointer/session surface used by framework adapters. */
+export declare function getBoardInteractionAdapter(engine: import('./types.js').BoardEngine): InternalInteractionAdapter;
+import type { BoardEventMap, BoardPlugin, BoardPluginApis, InternalBoardPlugin, InternalBoardPluginDefinition, InternalInteractionAdapter } from './types.js';
+export declare function defineInternalBoardPlugin<TPluginApis extends BoardPluginApis = BoardPluginApis, TEvents extends {
+    [K in keyof TEvents]: (...args: never[]) => unknown;
+} = BoardEventMap>(plugin: InternalBoardPluginDefinition<TPluginApis, TEvents>): InternalBoardPlugin<TPluginApis, TEvents>;
+export declare function assertInternalBoardPlugin(plugin: BoardPlugin): asserts plugin is InternalBoardPlugin;

package/dist/internal.js

@@ -0,0 +1,10 @@
+import {
+  assertInternalBoardPlugin,
+  defineInternalBoardPlugin,
+  getBoardInteractionAdapter
+} from "./chunk-5JZXHZWR.js";
+export {
+  assertInternalBoardPlugin,
+  defineInternalBoardPlugin,
+  getBoardInteractionAdapter
+};

package/dist/invariants.d.ts

@@ -0,0 +1,3 @@
+import type { BoardState, GridSettings, ValidationFailure, InteractionState } from './types.js';
+export declare function cloneInteraction(interaction: InteractionState): InteractionState;
+export declare function validateState(state: BoardState, grid: GridSettings, context: string): ValidationFailure[];

package/dist/math.d.ts

@@ -0,0 +1,16 @@
+import type { Bounds, Camera, Point } from './types.js';
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function lerp(a: number, b: number, t: number): number;
+export declare function lerpCamera(from: Camera, to: Camera, t: number): Camera;
+export declare function screenToWorld(point: Point, camera: Camera): Point;
+export declare function worldToScreen(point: Point, camera: Camera): Point;
+export declare function getVisibleBounds(width: number, height: number, camera: Camera): Bounds;
+export declare function pointInBounds(point: Point, bounds: Bounds): boolean;
+export declare function boundsIntersect(a: Bounds, b: Bounds): boolean;
+export declare function boundsContain(outer: Bounds, inner: Bounds): boolean;
+export declare function getBoundsFromPoints(a: Point, b: Point): Bounds;
+export declare function snapValue(value: number, step: number): number;
+export declare function snapPoint(point: Point, step: number): Point;
+export declare function snapBounds(bounds: Bounds, step: number): Bounds;
+export declare function snapSize(value: number, step: number, min: number): number;
+export declare function zoomCameraAtScreenPoint(screenPoint: Point, delta: number, camera: Camera, min: number, max: number): Camera;

package/dist/resize.d.ts

@@ -0,0 +1,26 @@
+import type { BoardNode, ResizeHandle } from './types.js';
+interface ResizeConstraints {
+    minWidth: number;
+    minHeight: number;
+}
+type NodeBounds = Pick<BoardNode, 'x' | 'y' | 'width' | 'height'>;
+export declare function applyResizeDelta(node: NodeBounds, handle: ResizeHandle, deltaX: number, deltaY: number, constraints: ResizeConstraints): NodeBounds;
+export declare function snapResizedBounds(bounds: NodeBounds, handle: ResizeHandle, gridSize: number, constraints: ResizeConstraints): NodeBounds;
+/**
+ * Aspect-ratio-locked variant of applyResizeDelta.
+ *
+ * For corner handles the dominant axis (larger normalised delta) drives the
+ * resize and the other axis is computed from `aspectRatio = width / height`.
+ * For edge handles the active axis drives and the perpendicular axis is
+ * derived, effectively upgrading the handle to its nearest corner.
+ */
+export declare function applyResizeDeltaLocked(node: NodeBounds, handle: ResizeHandle, deltaX: number, deltaY: number, constraints: ResizeConstraints, aspectRatio: number): NodeBounds;
+/**
+ * Aspect-ratio-preserving snap.  Snaps the primary dimension to the grid
+ * and derives the secondary exactly from the ratio so the shape stays true.
+ *
+ * For N / S handles height is primary; for everything else width is primary.
+ * `startBounds` is needed to keep the fixed edge anchored after snapping.
+ */
+export declare function snapResizedBoundsLocked(bounds: NodeBounds, startBounds: NodeBounds, handle: ResizeHandle, gridSize: number, constraints: ResizeConstraints, aspectRatio: number): NodeBounds;
+export {};

package/dist/selection.d.ts

@@ -0,0 +1,7 @@
+import type { Bounds, BoardEngine, BoardNode, NodeId } from './types.js';
+/** Return the currently selected nodes in snapshot order. */
+export declare function getSelectionNodes(engine: BoardEngine): BoardNode[];
+/** Compute the bounding box of the current selection, or `null` when empty. */
+export declare function getSelectionBounds(engine: BoardEngine): Bounds | null;
+/** Toggle a list of ids in an existing selection array. */
+export declare function toggleIds(current: NodeId[], ids: NodeId[]): NodeId[];

package/dist/snap.d.ts

@@ -0,0 +1,29 @@
+import type { BoardNode, NodeId, ResizeHandle, SnapAxis, SnapGuide } from './types.js';
+interface EdgeCandidate {
+    axis: SnapAxis;
+    value: number;
+    extentMin: number;
+    extentMax: number;
+    nodeId?: NodeId;
+}
+export interface SnapEdgeIndex {
+    readonly x: readonly EdgeCandidate[];
+    readonly y: readonly EdgeCandidate[];
+}
+export interface SnapResult {
+    bounds: Pick<BoardNode, 'x' | 'y' | 'width' | 'height'>;
+    guides: SnapGuide[];
+}
+export interface DragSnapResult {
+    dx: number;
+    dy: number;
+    guides: SnapGuide[];
+}
+export declare function collectNodeEdges(node: Pick<BoardNode, 'x' | 'y' | 'width' | 'height'>): EdgeCandidate[];
+export declare function collectOtherNodeEdges(nodes: Iterable<BoardNode>, excludeId: NodeId): EdgeCandidate[];
+export declare function collectOtherNodeEdgesExcluding(nodes: Iterable<BoardNode>, excludeIds: Set<NodeId>): EdgeCandidate[];
+/** Rebuildable index derived only from the current canonical node root. */
+export declare function buildSnapEdgeIndex(nodes: Iterable<BoardNode>): SnapEdgeIndex;
+export declare function snapBoundsToEdges(bounds: Pick<BoardNode, 'x' | 'y' | 'width' | 'height'>, handle: ResizeHandle, otherEdges: EdgeCandidate[] | SnapEdgeIndex, threshold: number, excludeIds?: ReadonlySet<NodeId>): SnapResult;
+export declare function snapPositionToEdges(bounds: Pick<BoardNode, 'x' | 'y' | 'width' | 'height'>, otherEdges: EdgeCandidate[] | SnapEdgeIndex, threshold: number, excludeIds?: ReadonlySet<NodeId>): DragSnapResult;
+export {};

package/dist/state/initial.d.ts

@@ -0,0 +1,2 @@
+import type { BoardNode } from '../types.js';
+export declare function normalizeExistingNode(node: BoardNode): BoardNode;

package/dist/state/selectors.d.ts

@@ -0,0 +1,5 @@
+import type { InternalBoardSnapshot, BoardState, BoardNode, GridSettings, NodeId } from '../types.js';
+import type { MutableBoardState } from './types.js';
+export declare function buildPublicNodeMap(state: Pick<MutableBoardState, 'nodes'>): ReadonlyMap<NodeId, BoardNode>;
+export declare function buildSnapshot(state: MutableBoardState, grid: GridSettings, publicNodes: ReadonlyMap<NodeId, BoardNode>): InternalBoardSnapshot;
+export declare function buildPublicState(state: MutableBoardState, grid: GridSettings, publicNodes: ReadonlyMap<NodeId, BoardNode>): BoardState;

package/dist/state/types.d.ts

@@ -0,0 +1,31 @@
+import type { BoardEventMap, BoardNode, Camera, CommandMetadata, GridSettings, InteractionState, NodeConstraints, NodeId, Point, SnapGuide, ZoomSettings } from '../types.js';
+export declare const DEFAULT_CAMERA: Camera;
+export declare const DEFAULT_ZOOM: ZoomSettings;
+export declare const DEFAULT_GRID: GridSettings;
+export declare const DEFAULT_NODE_CONSTRAINTS: NodeConstraints;
+export declare const DEFAULT_VIEWPORT_SIZE: Point;
+export interface MutableBoardState {
+    camera: Camera;
+    nodes: Map<NodeId, BoardNode>;
+    selection: Set<NodeId>;
+    interaction: InteractionState;
+    snapGuides: SnapGuide[];
+    nextZIndex: number;
+}
+export type ListenerMap = Map<keyof BoardEventMap, Set<(...args: unknown[]) => void>>;
+/** Structurally shared persistent state captured by first-party history. */
+export interface InternalHistoryRoot {
+    readonly nodes: ReadonlyMap<NodeId, BoardNode>;
+    readonly grid: GridSettings;
+    readonly selection: ReadonlySet<NodeId>;
+    readonly nextZIndex: number;
+    readonly pluginSlices: ReadonlyMap<string, unknown>;
+}
+/** A successfully published outer command. */
+export interface InternalBoardCommit {
+    readonly label: string;
+    readonly timestamp: number;
+    readonly metadata: CommandMetadata;
+    readonly before: InternalHistoryRoot;
+    readonly after: InternalHistoryRoot;
+}

package/dist/subscribable.d.ts

@@ -0,0 +1,20 @@
+import type { Subscribable } from './types.js';
+/** Batch coordination shared across the subscribables owned by one engine instance. */
+export interface BatchController {
+    depth: number;
+    pending: Set<() => void>;
+    rollbacks: Set<() => void>;
+}
+/** Create a batch controller that defers subscriber notifications until the batch completes. */
+export declare function createBatchController(): BatchController;
+/**
+ * Create a mutable subscribable value.
+ *
+ * The returned object implements the public `Subscribable<T>` contract plus
+ * `set()` and `notify()` helpers used by the engine internals.
+ */
+export declare function createSubscribable<T>(initial: T, batch: BatchController, reportError: (error: unknown) => void): Subscribable<T> & {
+    set(value: T): void;
+    notify(): void;
+    destroy(): void;
+};