@nodius/layouting 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,176 @@
+/** Position on a node where a handle can be placed */
+type HandleSide = 'top' | 'right' | 'bottom' | 'left';
+/** Handle type - input receives connections, output sends connections */
+type HandleType = 'input' | 'output';
+/** Layout direction */
+type LayoutDirection = 'TB' | 'LR' | 'BT' | 'RL';
+/** A 2D point */
+interface Point {
+    x: number;
+    y: number;
+}
+/** Handle definition on a node */
+interface HandleInput {
+    id: string;
+    type: HandleType;
+    position: HandleSide;
+    /** Position along the side (0 = start, 1 = end). Default: 0.5 */
+    offset?: number;
+}
+/** Node input definition */
+interface NodeInput {
+    id: string;
+    width: number;
+    height: number;
+    handles: HandleInput[];
+}
+/** Edge input definition */
+interface EdgeInput {
+    id: string;
+    from: string;
+    to: string;
+    fromHandle: string;
+    toHandle: string;
+}
+/** Complete layout input */
+interface LayoutInput {
+    nodes: NodeInput[];
+    edges: EdgeInput[];
+}
+/** Layout configuration options */
+interface LayoutOptions {
+    /** Layout direction. Default: 'TB' */
+    direction?: LayoutDirection;
+    /** Minimum spacing between nodes in the same layer. Default: 40 */
+    nodeSpacing?: number;
+    /** Minimum spacing between layers. Default: 60 */
+    layerSpacing?: number;
+    /** Number of iterations for crossing minimization. Default: 24 */
+    crossingMinimizationIterations?: number;
+    /** Number of iterations for coordinate optimization. Default: 8 */
+    coordinateOptimizationIterations?: number;
+    /** Margin for edge routing (distance from node before turning). Default: 20 */
+    edgeMargin?: number;
+}
+/** Positioned handle in the output */
+interface HandleOutput {
+    id: string;
+    type: HandleType;
+    position: HandleSide;
+    x: number;
+    y: number;
+}
+/** Positioned node in the output */
+interface NodeOutput {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    handles: HandleOutput[];
+}
+/** Routed edge in the output */
+interface EdgeOutput {
+    id: string;
+    from: string;
+    to: string;
+    fromHandle: string;
+    toHandle: string;
+    points: Point[];
+}
+/** Complete layout result */
+interface LayoutResult {
+    nodes: NodeOutput[];
+    edges: EdgeOutput[];
+}
+
+interface InternalNode {
+    id: string;
+    width: number;
+    height: number;
+    handles: HandleInput[];
+    isDummy: boolean;
+    layer: number;
+    order: number;
+    x: number;
+    y: number;
+}
+interface InternalEdge {
+    id: string;
+    from: string;
+    to: string;
+    fromHandle: string;
+    toHandle: string;
+    reversed: boolean;
+    originalId: string;
+}
+declare class Graph {
+    nodes: Map<string, InternalNode>;
+    edges: Map<string, InternalEdge>;
+    outEdges: Map<string, Set<string>>;
+    inEdges: Map<string, Set<string>>;
+    addNode(node: InternalNode): void;
+    addEdge(edge: InternalEdge): void;
+    removeEdge(edgeId: string): void;
+    removeNode(nodeId: string): void;
+    predecessors(nodeId: string): string[];
+    successors(nodeId: string): string[];
+}
+
+/**
+ * Compute a complete layout for the given graph.
+ * This is the main entry point for one-shot layout computation.
+ */
+declare function layout(input: LayoutInput, options?: LayoutOptions): LayoutResult;
+
+/**
+ * Incremental layout engine.
+ * Maintains layout state and supports adding/removing nodes
+ * without full recomputation.
+ */
+declare class IncrementalLayout {
+    private options;
+    private inputNodes;
+    private inputEdges;
+    private lastResult;
+    private nodePositions;
+    constructor(options?: LayoutOptions);
+    /**
+     * Set the full graph and compute a complete layout.
+     */
+    setGraph(input: LayoutInput): LayoutResult;
+    /**
+     * Add nodes and edges incrementally.
+     * Attempts to minimize layout changes for existing nodes.
+     */
+    addNodes(nodes: NodeInput[], edges?: EdgeInput[]): LayoutResult;
+    /**
+     * Remove nodes (and their connected edges) from the layout.
+     */
+    removeNodes(nodeIds: string[]): LayoutResult;
+    /**
+     * Add edges between existing nodes.
+     */
+    addEdges(edges: EdgeInput[]): LayoutResult;
+    /**
+     * Remove edges from the layout.
+     */
+    removeEdges(edgeIds: string[]): LayoutResult;
+    /**
+     * Get the current layout result.
+     */
+    getResult(): LayoutResult | null;
+    private recompute;
+    private recomputeIncremental;
+    /**
+     * Apply stability: blend new positions with old positions for existing nodes.
+     * This reduces visual disruption when adding new nodes.
+     */
+    private applyStability;
+    private cachePositions;
+    private buildResult;
+}
+
+declare function countAllCrossings(graph: Graph, layers: string[][]): number;
+
+export { type EdgeInput, type EdgeOutput, type HandleInput, type HandleOutput, type HandleSide, type HandleType, IncrementalLayout, type LayoutDirection, type LayoutInput, type LayoutOptions, type LayoutResult, type NodeInput, type NodeOutput, type Point, countAllCrossings, layout };