@nodius/layouting 0.1.0 → 0.1.1

package/dist/algorithms/value-placement.d.ts

@@ -0,0 +1,25 @@
+import { Graph } from '../graph';
+import { LayoutDirection, ResolvedOptions } from '../types';
+/**
+ * Sidecar placement for value nodes.
+ *
+ * Values (nodes whose every incident edge is a data edge) are NOT laid out
+ * alongside the control rail — they are attached as sidecars to the flanks of
+ * their dominant consumer once the rail is finalized. This way:
+ *
+ *   - the rail stays perfectly aligned (its layout is computed without values)
+ *   - values cluster around the node that actually uses them
+ *   - extra values don't widen/displace the rail
+ *
+ * In TB direction, sidecars sit at the consumer's vertical center, alternating
+ * left/right. In LR direction, they sit at the consumer's horizontal center,
+ * alternating top/bottom.
+ */
+export declare function placeValueSidecars(graph: Graph, layers: string[][], options: ResolvedOptions): void;
+export declare function isValueLayer(layer: string[], graph: Graph): boolean;
+/** Filter layers to keep only non-value, non-dummy nodes per layer. */
+export declare function railLayers(layers: string[][], graph: Graph): string[][];
+export declare function getDirection(direction: LayoutDirection): {
+    isHorizontal: boolean;
+};
+//# sourceMappingURL=value-placement.d.ts.map

package/dist/algorithms/value-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-placement.d.ts","sourceRoot":"","sources":["../../src/algorithms/value-placement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE5D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,OAAO,EAAE,eAAe,GACvB,IAAI,CAyFN;AA0HD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAMnE;AAED,uEAAuE;AACvE,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,EAAE,EAAE,CAOvE;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,eAAe,GAAG;IAAE,YAAY,EAAE,OAAO,CAAA;CAAE,CAElF"}

package/dist/debug.d.ts

@@ -0,0 +1,20 @@
+import { LayoutResult } from './types';
+/**
+ * Render a `LayoutResult` to a human-readable text block.
+ *
+ * Useful when iterating on the algorithm without opening a browser:
+ *   - a per-layer summary (Y bands in TB, X bands in LR-ish)
+ *   - per-node hierarchy + bbox
+ *   - per-edge endpoints and kind
+ *   - an ASCII grid (optional) sketching the final layout
+ */
+export interface PrintLayoutOptions {
+    /** Include an ASCII grid sketch (default: true). */
+    grid?: boolean;
+    /** Grid resolution: characters per coordinate unit (default: auto). */
+    gridScale?: number;
+    /** Max grid width in characters (default: 80). */
+    gridWidth?: number;
+}
+export declare function printLayout(result: LayoutResult, options?: PrintLayoutOptions): string;
+//# sourceMappingURL=debug.d.ts.map

package/dist/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../src/debug.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAA0B,MAAM,SAAS,CAAC;AAE/D;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,oDAAoD;IACpD,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,GAAE,kBAAuB,GAAG,MAAM,CA0F1F"}

package/dist/graph.d.ts

@@ -0,0 +1,50 @@
+import { HandleInput, HandleSide, NodeInput, EdgeInput, Point, EdgeKind } from './types';
+export interface InternalNode {
+    id: string;
+    width: number;
+    height: number;
+    handles: HandleInput[];
+    isDummy: boolean;
+    layer: number;
+    order: number;
+    x: number;
+    y: number;
+    parentId?: string;
+    /** True if this node represents a compound (its size was computed from children). */
+    isCompound: boolean;
+    /** True when the node has no control edges and only participates in data edges. */
+    isValue: boolean;
+}
+export interface InternalEdge {
+    id: string;
+    from: string;
+    to: string;
+    fromHandle: string;
+    toHandle: string;
+    reversed: boolean;
+    originalId: string;
+    kind: EdgeKind;
+    weight: number;
+}
+export 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[];
+}
+export interface BuildGraphContext {
+    controlWeight: number;
+    dataWeight: number;
+}
+export declare function buildGraph(nodes: NodeInput[], edges: EdgeInput[], ctx?: BuildGraphContext): Graph;
+/** Compute the absolute position of a handle on a positioned node */
+export declare function getHandlePosition(node: InternalNode, handleId: string): Point;
+/** Get the direction vector for exiting/entering a handle */
+export declare function getHandleDirection(side: HandleSide): Point;
+//# sourceMappingURL=graph.d.ts.map

package/dist/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../src/graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEzF,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qFAAqF;IACrF,UAAU,EAAE,OAAO,CAAC;IACpB,mFAAmF;IACnF,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,KAAK;IAChB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAa;IAC7C,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAa;IAC7C,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAa;IAC/C,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAa;IAE9C,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAMjC,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAQjC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQhC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAUhC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAYtC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;CAWrC;AAED,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,SAAS,EAAE,EAClB,KAAK,EAAE,SAAS,EAAE,EAClB,GAAG,GAAE,iBAA0D,GAC9D,KAAK,CA2DP;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,CAkB7E;AAED,6DAA6D;AAC7D,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,KAAK,CAO1D"}

package/dist/incremental.d.ts

@@ -0,0 +1,33 @@
+import { LayoutInput, LayoutOptions, LayoutResult, NodeInput, EdgeInput } from './types';
+/**
+ * Incremental layout engine.
+ * Maintains layout state and supports adding/removing nodes
+ * without full recomputation.
+ *
+ * Compound layouts and value-pulled nodes are handled through the unified
+ * `layout()` entry point, so any input change re-uses the same logic.
+ */
+export declare class IncrementalLayout {
+    private resolvedOptions;
+    private options;
+    private inputNodes;
+    private inputEdges;
+    private lastResult;
+    private nodePositions;
+    constructor(options?: LayoutOptions);
+    setGraph(input: LayoutInput): LayoutResult;
+    addNodes(nodes: NodeInput[], edges?: EdgeInput[]): LayoutResult;
+    removeNodes(nodeIds: string[]): LayoutResult;
+    addEdges(edges: EdgeInput[]): LayoutResult;
+    removeEdges(edgeIds: string[]): LayoutResult;
+    getResult(): LayoutResult | null;
+    private recompute;
+    private recomputeWithStability;
+    /**
+     * Blend the freshly computed positions with the previous ones, so existing
+     * nodes don't jump too far when a small change happens.
+     */
+    private applyStability;
+    private cachePositions;
+}
+//# sourceMappingURL=incremental.d.ts.map

package/dist/incremental.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"incremental.d.ts","sourceRoot":"","sources":["../src/incremental.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,aAAa,EACb,YAAY,EACZ,SAAS,EACT,SAAS,EAGV,MAAM,SAAS,CAAC;AAGjB;;;;;;;GAOG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,UAAU,CAAqC;IACvD,OAAO,CAAC,UAAU,CAAqC;IACvD,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,aAAa,CAAoD;gBAE7D,OAAO,CAAC,EAAE,aAAa;IAKnC,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY;IAQ1C,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,KAAK,CAAC,EAAE,SAAS,EAAE,GAAG,YAAY;IAM/D,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,YAAY;IAY5C,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,YAAY;IAK1C,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,YAAY;IAK5C,SAAS,IAAI,YAAY,GAAG,IAAI;IAIhC,OAAO,CAAC,SAAS;IAUjB,OAAO,CAAC,sBAAsB;IAY9B;;;OAGG;IACH,OAAO,CAAC,cAAc;IA2BtB,OAAO,CAAC,cAAc;CAOvB"}

package/dist/index.d.ts

@@ -1,176 +1,7 @@
-/** 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 };
+export { layout } from './layout';
+export { IncrementalLayout } from './incremental';
+export { countAllCrossings } from './algorithms/crossing-minimization';
+export { printLayout } from './debug';
+export type { HandleSide, HandleType, LayoutDirection, EdgeKind, EdgeWeights, Point, HandleInput, NodeInput, EdgeInput, LayoutInput, LayoutOptions, HandleOutput, NodeOutput, EdgeOutput, LayoutResult, LayoutProposal, RotateProposal, ProposalCallback, } from './types';
+export { rotateHandles } from './proposals';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,YAAY,EACV,UAAU,EACV,UAAU,EACV,eAAe,EACf,QAAQ,EACR,WAAW,EACX,KAAK,EACL,WAAW,EACX,SAAS,EACT,SAAS,EACT,WAAW,EACX,aAAa,EACb,YAAY,EACZ,UAAU,EACV,UAAU,EACV,YAAY,EACZ,cAAc,EACd,cAAc,EACd,gBAAgB,GACjB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}