@kortexya/nodus 0.1.4 → 0.1.6

package/types/algorithms/hierarchical/sugiyama.d.ts

@@ -1,144 +0,0 @@
-export declare const SENTINEL: -1;
-export declare const SENTINEL_DATA: {
-    id: string;
-    layer: number;
-    sink: boolean;
-    fixed: boolean;
-    siblingIndex: number;
-    parentIds: any[];
-    children: any[];
-    radius: number;
-    ref: any;
-};
-export interface SugNode {
-    id: any;
-    layer: number;
-    data: any;
-    children: SugNode[];
-    ref?: any;
-    x: number;
-    y: number;
-}
-export declare function makeVirtualNode(id: any, layer: number): SugNode;
-export declare function isVirtual(n: SugNode): boolean;
-export declare function isReal(n: SugNode): boolean;
-declare class LNode {
-    data: any;
-    prev: LNode | null;
-    next: LNode | null;
-    constructor(data: any, prev?: LNode | null, next?: LNode | null);
-    toString(): any;
-}
-declare class NodeLinkedList {
-    head: LNode | null;
-    tail: LNode | null;
-    byId: {
-        [id: string]: LNode;
-    };
-    byIndex: {
-        [idx: number]: LNode;
-    };
-    length: number;
-    append(data: any, id: string | number): LNode;
-    forEach(cb: (node: LNode, idx: number) => void): void;
-}
-export declare function insertVirtualNodes(graph: {
-    nodes: SugNode[];
-}): SugNode[][];
-export declare function decrossLayers(layers: SugNode[][], shouldDecross: boolean, sortSiblings: boolean): void;
-export declare class SugiyamaLayout {
-    edges: {
-        source: any;
-        target: any;
-        virtual: boolean;
-        id: number;
-    }[];
-    nodeMap: {
-        [id: string]: SugNode;
-    };
-    nodeIndexTopDown: {
-        [id: string]: number;
-    };
-    nodeToLayer: {
-        [id: string]: number;
-    };
-    longEdges: {
-        [id: string]: string[];
-    };
-    virt: {
-        [id: string]: boolean;
-    };
-    height: {
-        [layer: number]: number;
-    };
-    breadth: {
-        [id: string]: number;
-    };
-    first: SugNode[];
-    totalW: {
-        [id: string]: number;
-    };
-    mDist: {
-        [id: string]: number;
-    };
-    X: {
-        [id: string]: number;
-    };
-    block: {
-        [id: string]: any;
-    };
-    nodeList: NodeLinkedList;
-    nodeDistance: number;
-    layerDistance: number;
-    layers: SugNode[][];
-    N: number;
-    Y: Float32Array;
-    adjacencyList: {
-        [src: string]: any[];
-    };
-    neighbours: {
-        prev: {
-            [id: string]: any[];
-        };
-        next: {
-            [id: string]: any[];
-        };
-    };
-    constructor(layers: SugNode[][], nodeDistance: number, layerDistance: number);
-    computeMinNodeDistances(): void;
-    decrossVirtualEdges(): void;
-    placeLongEdges(): void;
-    sortLongEdges(e: string, t: number, s: {
-        [id: string]: number;
-    }, o: {
-        done: boolean;
-        dist: number;
-    }, c: {
-        [id: string]: number;
-    }, p: {
-        [id: string]: number;
-    }): boolean;
-    placeNonVirtualNodes(): void;
-    placeSequence(e: any, t: any, s: any, o: any, c: number, p?: number): void;
-    calculateBends(e: number, t: number, s: any, o: any, c: any, p: any, At: any, Tt: any): {
-        res: number;
-        bends: {
-            value: number;
-            key: number;
-        }[];
-    };
-    combineSequences(e: any, t: any, s: any, o: any, c: any, p: any, At: any, Tt: number): void;
-    placeNode(e: any, t: any, s: any, o: number, c: number): number;
-    moveLongEdge(e: SugNode, t: number, s: {
-        [id: string]: boolean;
-    }): void;
-    moveLongEdges(): void;
-    computeY(): void;
-    straightenLongEdge(e: SugNode, t: {
-        [id: string]: boolean;
-    }): void;
-    straightenEdges(): void;
-    run(): void;
-}
-export declare function sugiyamaCoordinates(layers: SugNode[][], nodeDistance?: number, layerDistance?: number): SugNode[][];
-export {};

package/types/hypergraph/layout/Adam.d.ts

@@ -1,12 +0,0 @@
-/**
- * Adam optimizer fallback. Selectable when L-BFGS line search fails on
- * a pathological dataset.
- */
-import type { LBFGSOptions, ObjectiveFn, LBFGSResult } from './LBFGS';
-export interface AdamOptions extends Pick<LBFGSOptions, 'maxIter' | 'tol' | 'mask' | 'onIter'> {
-    lr?: number;
-    beta1?: number;
-    beta2?: number;
-    eps?: number;
-}
-export declare function minimizeAdam(f: ObjectiveFn, x0: Float64Array, opts?: AdamOptions): LBFGSResult;

package/types/hypergraph/layout/Energy.d.ts

@@ -1,55 +0,0 @@
-/**
- * Energy terms for the polygon-layout objective (paper §5.3, building
- * on Qu et al. [41]). Five terms:
- *
- *  1. Polygon regularity   E_reg
- *  2. Polygon area         E_area
- *  3. Polygon separation   E_sep
- *  4. Regularity intersection (convexity recovery)  E_int
- *  5. Primal-dual coordination  E_pd
- *
- * State vectors:
- *   x : Float64Array of length 2|V|  (primal vertex positions)
- *   y : Float64Array of length 2|E|  (dual vertex positions = primal hyperedge centroids)
- */
-import type { LayoutWeights } from '../types';
-export interface LayoutModel {
-    /** vertex id → flat index 0..|V|-1 */
-    vIndex: Map<string | number, number>;
-    /** hyperedge id → flat index 0..|E|-1 */
-    eIndex: Map<string | number, number>;
-    vCount: number;
-    eCount: number;
-    /** Per-hyperedge: list of vertex flat-indices (sorted CCW around centroid). */
-    hyperedgeVerts: number[][];
-    /** Per-hyperedge: cardinality (equal to hyperedgeVerts[i].length, cached). */
-    cardinality: number[];
-    /** Per-hyperedge: cardinality used for E_area / E_sep in the regularity
-     *  phase. Paper §5.3: "we use the corresponding cardinalities saved
-     *  from the original scale H_0" — for hyperedges that have absorbed
-     *  others via merger, this is the sum of merged H_0 cardinalities;
-     *  for hyperedges intact since H_0, this equals the H_0 cardinality. */
-    originalCardinality: number[];
-    /** Per-hyperedge: target polygon area A*(k). Computed from
-     *  originalCardinality, not the current k. */
-    targetArea: number[];
-    /** Per-vertex: list of hyperedge flat-indices that contain it. */
-    vertexInHyperedges: number[][];
-    /** Buffer distance d_b for separation energy. */
-    bufferDistance: number;
-    /** Which phase the energy evaluator should use for the separation
-     *  d_0 formula. 'separation' uses Eq. 3 (½ sum of current diameters
-     *  + d_b); 'regularity' uses the circumradius of the regular polygon
-     *  with originalCardinality and targetArea. */
-    phase: 'separation' | 'regularity';
-}
-/**
- * Compute total energy and its gradient w.r.t. (x, y).
- *
- * Returns { energy, grad } where grad is a flat Float64Array of length
- * 2*(|V| + |E|): first 2|V| entries are ∂E/∂x, next 2|E| are ∂E/∂y.
- */
-export declare function evaluateEnergy(model: LayoutModel, state: Float64Array, weights: LayoutWeights): {
-    energy: number;
-    grad: Float64Array;
-};

package/types/hypergraph/layout/LBFGS.d.ts

@@ -1,32 +0,0 @@
-/**
- * Limited-memory BFGS solver. m=8 by default. Backtracking Armijo line
- * search (sufficient for our convex-ish energy basin once separation is
- * resolved). No external dependencies.
- *
- * Used by the hypergraph layout optimizer; the paper specifically cites
- * primal-dual quasi-Newton methods because the energy Hessian is ill-
- * conditioned (regularity term curvature ≫ coordination term curvature).
- */
-export interface LBFGSOptions {
-    m?: number;
-    maxIter?: number;
-    tol?: number;
-    c1?: number;
-    alphaInit?: number;
-    alphaShrink?: number;
-    maxLineSearch?: number;
-    /** Optional mask: if mask[i] is false, gradient and step are zeroed for index i. */
-    mask?: Uint8Array;
-    onIter?: (iter: number, f: number, gnorm: number) => void;
-}
-export type ObjectiveFn = (x: Float64Array) => {
-    energy: number;
-    grad: Float64Array;
-};
-export interface LBFGSResult {
-    x: Float64Array;
-    energy: number;
-    iterations: number;
-    converged: boolean;
-}
-export declare function minimizeLBFGS(f: ObjectiveFn, x0: Float64Array, opts?: LBFGSOptions): LBFGSResult;