@kortexya/nodus 0.1.0

package/types/internals/Tooltip.d.ts

@@ -0,0 +1,25 @@
+import { Module } from './Module';
+export declare class Tooltip extends Module {
+    private _x;
+    private _y;
+    private _handlers;
+    private _currentHandlerName;
+    private _tooltip;
+    private _isHover;
+    private _elt;
+    private _timeout;
+    onMounted(): void;
+    hide(): void;
+    isShown(): boolean;
+    refresh(): void;
+    show(e: any, { position: t, autoAdjust: s, className: o, x: c, y: p }?: any): void;
+    setHandler(e: string, t: any, s?: any): void;
+    _hideTooltip(e: boolean): void;
+    _createInteraction(e: string, t?: boolean): any;
+    _refreshTooltip(): void;
+    _schedule(e: () => void, t: number): void;
+    _showTooltip(e: any, t: any, s?: {
+        x: number;
+        y: number;
+    }): void;
+}

package/types/internals/TooltipPrimitives.d.ts

@@ -0,0 +1,21 @@
+export declare const VALID_POSITIONS: string[];
+export declare const NODE_POSITION_MAPPING: Record<string, {
+    x: number;
+    y: number;
+}>;
+export declare const Z_INDEX = 10000;
+export declare const DEFAULT_OPTIONS11: {
+    position: string;
+    autoAdjust: boolean;
+    delay: number;
+};
+export declare const CONDITIONS: Record<string, (info: any) => boolean>;
+export declare function makeHandlerName(type: string, info: any): string;
+export declare function isHTMLElement(el: any): el is HTMLElement;
+export declare function createElement2(tag: string): HTMLElement;
+export declare function setElementInnerHtml(el: HTMLElement, html: string): void;
+declare function sanitizeHtml(html: string): string;
+export declare const htmlSanitizer: {
+    sanitize: typeof sanitizeHtml;
+};
+export {};

package/types/internals/Topology.d.ts

@@ -0,0 +1,50 @@
+export declare const DIRECTION_IN = "in";
+export declare const DIRECTION_OUT = "out";
+export declare const DIRECTION_BOTH = "both";
+export declare class Topology {
+    private _fakeDeduper;
+    private _fakeInvertedDeduper;
+    private _graph;
+    nodeDeduper: any;
+    edgeDeduper: any;
+    private _sourceList;
+    private _targetList;
+    /** Rust-owned adjacency (`GraphTopology`). Nodus is wasm-backed: the adjacency lives entirely
+     * in Rust — the legacy TS Table-backed fallback has been deleted (Phase-5 cutover). */
+    private _topo;
+    constructor(graph: any);
+    getAdjacentDirections(nodeIndex: number): number[] | null;
+    getEdgeIndexesInDirection(dirIndex: number): number[] | null;
+    allocateNodes(indexes: number[]): void;
+    allocateEdges(edgeIndexes: number[], sources: number[], targets: number[]): void;
+    getExtremity(isSource: boolean, element: any): any;
+    setExtremities(edgeIndexes: Uint32Array | number[], sources: Uint32Array | number[] | null, targets: Uint32Array | number[] | null): void;
+    addToAdjacencyList(edgeIndex: number): void;
+    hasParallelEdges(edgeIndex: number): boolean;
+    removeFromAdjacencyList(edgeIndex: number): void;
+    getParallelEdges(element: any, opts?: any): any;
+    fastGetNodesAdjacentElements(nodeIndexes: Uint32Array | number[]): {
+        nodes: any;
+        edges: any;
+    };
+    fastGetEdgesAdjacentElements(edgeIndexes: Uint32Array | number[]): {
+        nodes: any;
+        edges: any;
+    };
+    getDeduper(isNode: boolean): any;
+    collectAdjacentEdges(nodeIndexes: Uint32Array | number[], direction: string, filter: string, dedupe?: boolean, bothExtremities?: boolean): Uint32Array;
+    collectAdjacentNodes(nodeIndexes: Uint32Array | number[], direction: string, filter: string, dedupe?: boolean, include?: Uint32Array | number[], exclude?: Uint32Array | number[]): Uint32Array;
+    getAdjacentElements(isNode: boolean, nodeIndexes: Uint32Array | number[], opts?: any): Uint32Array;
+    getDegree(nodeIndexes: Uint32Array | number[], opts?: any): number[];
+    degrees(nodeIndexes: Uint32Array | number[], direction?: string): number[];
+    private _degree;
+    private _getDegreeOptions;
+    getEdgesBetweenTwoNodes(sourceIdx: number, targetIdx: number): Uint32Array;
+    getConnectedComponents(nodeIndexes: Uint32Array | number[], opts?: any): any[];
+    getAdjacencyList(opts: {
+        directed: boolean;
+        ids: boolean;
+        weight: any;
+        nodes: Uint32Array | number[];
+    }): any;
+}

package/types/internals/Touch.d.ts

@@ -0,0 +1,16 @@
+import { Module } from './Module';
+export declare class Touch extends Module {
+    private _pressed;
+    private _domElt;
+    private _onMove;
+    private _onEnd;
+    private _addEvent;
+    private _addWinEvent;
+    private _removeWinEvent;
+    onMounted(): void;
+    get x(): number;
+    get y(): number;
+    get pressed(): boolean;
+    _listen(e: any, t: string, s: any): any;
+    _initialize(_e: any): void;
+}

package/types/internals/Transformations.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Transformations — coordinator for the transformation pipeline (groupings, filters, etc.).
+ *
+ * Registers the built-in faded/transparent classes and transformation events, then
+ * delegates element-level queries and grouping operations to the transformation API.
+ */
+import { Module } from './Module';
+export declare class Transformations extends Module {
+    api: any;
+    getSubElements: (el: any) => any;
+    getSubNodes: (el: any) => any;
+    getSubEdges: (el: any) => any;
+    getXYR: (el: any) => any;
+    onGroupsUpdated: (cb: any) => any;
+    constructor(nodus: any);
+    onMounted(): void;
+    onReady(_params: any): void;
+    destroy(): void;
+    isElementVirtual(el: any): boolean;
+    getElementTransformation(el: any): any;
+    getMetaElements(elements: any): any[];
+    getMetaElement(el: any): any;
+    getMetaEdge(el: any): any;
+    getMetaNode(el: any): any;
+    getMetaNodes(els: any): any[];
+    getMetaEdges(els: any): any[];
+    getNodeFilters(): any[];
+    getEdgeFilters(): any[];
+    group(nodes: any, opts: any): any;
+    ungroup(node: any): any;
+    addSubGraph(node: any, data: any, opts: any): any;
+    whenApplied(): Promise<any>;
+    afterNextUpdate(): Promise<any>;
+    isRefreshing(): boolean;
+    triggerGroupUpdated(nodes: any): void;
+}

package/types/internals/VirtualMouse.d.ts

@@ -0,0 +1,52 @@
+import { Module } from './Module';
+export declare class VirtualMouse extends Module {
+    onMounted(): void;
+    get x(): number;
+    get y(): number;
+    private _later;
+    move({ x: e, y: t }: {
+        x?: number;
+        y?: number;
+    }): Promise<void>;
+    down({ x: e, y: t, button: s }?: {
+        x?: number;
+        y?: number;
+        button?: string;
+    }): Promise<void>;
+    up({ x: e, y: t, button: s }?: {
+        x?: number;
+        y?: number;
+        button?: string;
+    }): Promise<void>;
+    click({ x: e, y: t, button: s }?: {
+        x?: number;
+        y?: number;
+        button?: string;
+    }): Promise<void>;
+    rightClick({ x: e, y: t, button: s }?: {
+        x?: number;
+        y?: number;
+        button?: string;
+    }): Promise<void>;
+    doubleclick({ x: e, y: t, button: s }?: {
+        x?: number;
+        y?: number;
+        button?: string;
+    }): Promise<void>;
+    drag(e: {
+        x?: number;
+        y?: number;
+    }, t: {
+        x?: number;
+        y?: number;
+    }): Promise<void>;
+    wheel({ x: e, y: t, dx: s, dy: o, delta: c, metaKey: p, ctrlKey: At }: {
+        x?: number;
+        y?: number;
+        dx?: number;
+        dy?: number;
+        delta?: number;
+        metaKey?: boolean;
+        ctrlKey?: boolean;
+    }): Promise<void>;
+}

package/types/internals/WasmHGrid.d.ts

@@ -0,0 +1,25 @@
+export interface CameraState {
+    cos: number;
+    sin: number;
+    bentEnable: boolean;
+    bentVertical: boolean;
+}
+export declare class WasmHGrid {
+    private _graph;
+    private _stateFn;
+    private _minCell;
+    private _halfWorld;
+    private _rust;
+    private _items;
+    private _dirty;
+    constructor(_graph: any, _stateFn: () => CameraState, _minCell: number, _halfWorld: number);
+    clear(): void;
+    insert(item: number): void;
+    remove(item: number): void;
+    has(item: number): boolean;
+    get size(): number;
+    /** Force a rebuild on the next query (e.g. after a camera rotation changes bent-edge bounds). */
+    markDirty(): void;
+    private _rebuild;
+    query(x1: number, y1: number, x2: number, y2: number): number[];
+}

package/types/internals/WatcherModule.d.ts

@@ -0,0 +1,25 @@
+/**
+ * WatcherModule — schema watcher for node/edge property changes.
+ * Faithfully translated from /tmp/nodus_extracted/WatcherModule.js
+ */
+import { Module } from './Module';
+export declare class WatcherModule extends Module {
+    private _propertyWatchers;
+    private _objectPropertyWatchers;
+    private _onExcludedStateChange;
+    private _onDataChange;
+    private _onElementsAdded;
+    private _onElementsRemoved;
+    private _onGraphClear;
+    onMounted(): void;
+    watchNodeObjectProperty(opts: any): any;
+    watchEdgeObjectProperty(opts: any): any;
+    watchNodeNonObjectProperty(opts: any): any;
+    watchEdgeNonObjectProperty(opts: any): any;
+    watchPropertyInformation(isNode: boolean, property: any, onChange: any, filter: any, unwindArrays: any): any;
+    unwatchPropertyInformation(isNode: boolean, property: any, onChange: any, filter: any, unwindArrays: any): void;
+    private _watchObjectProperty;
+    private _watchNonObjectProperty;
+    private _findWatcher;
+    private _createWatcher;
+}

package/types/internals/Workers.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Workers — web worker pool for layout algorithms.
+ *
+ * Two implementations live here:
+ *   - SyncWorker: runs the layout's update loop on the main thread, yielding
+ *     between iterations via setTimeout(0). Compatible with environments
+ *     where Web Workers aren't available (SSR, tests).
+ *   - AsyncWorker: runs the same descriptor in a real Web Worker so heavy
+ *     iterations (radial/hierarchical/forceLink at 10K+) don't freeze the
+ *     main thread. The worker entry is `./layoutWorker.ts`, bundled by
+ *     Vite via the `?worker` import suffix.
+ *
+ * The Nodus layout descriptor API is preserved exactly: configure() always
+ * runs on the main thread (it needs graph access), and its serialisable
+ * result is shipped to the worker as the initial msg. update() is pure on
+ * its inputs (NodeMatrix/EdgeMatrix typed arrays + settings) so it ports
+ * cleanly into the worker.
+ */
+import { Module } from './Module';
+/** Abstract base for sync/async worker implementations */
+declare class BaseWorker extends EventTarget {
+    _complete: boolean;
+    _busy: boolean;
+    _destroyed: boolean;
+    _data: any;
+    _modules: any;
+    _configure: (opts: any, modules: any) => any;
+    _update: (msg: any, ctx: any) => any;
+    _createContext: () => any;
+    _isRunning: (ctx: any, msg: any) => boolean;
+    _stop: (ctx: any) => void;
+    _onStart: () => void;
+    _onStop: () => void;
+    _onPause: () => void;
+    _setIdle: (v: any) => void;
+    timer: {
+        start: number;
+        steps: number;
+    };
+    id: number;
+    promise: Promise<any>;
+    resolve: (v: any) => void;
+    reject: (e: any) => void;
+    constructor(cfg: any, modules: any);
+    _name: string;
+    configure(cfg: {
+        name?: string;
+        configure?: Function;
+        update?: Function;
+        context?: Function;
+        stop?: Function;
+        isRunning?: Function;
+        onStart?: Function;
+        onStop?: Function;
+        onPause?: Function;
+        setIdle?: Function;
+    }): void;
+    setData(d: any): void;
+    getData(): any;
+    start(opts: any): this;
+    stop(sendStop?: boolean): Promise<any>;
+    pause(): void;
+    setIdle(v: any): void;
+    isBusy(): boolean;
+    setBusy(v: boolean): void;
+    getPromise(): Promise<any>;
+    send(_msg: any): this;
+    on(event: string, callback: (e: any) => void): this;
+    fire(event: string, data?: any): this;
+    destroy(): void;
+}
+export declare class Workers extends Module {
+    private _pool;
+    create(cfg: any, useAsync?: boolean): BaseWorker;
+    start(worker: BaseWorker, opts: any): BaseWorker;
+    run(cfg: any, opts: any, useAsync?: boolean): BaseWorker;
+    destroy(): void;
+}
+export {};

package/types/internals/algorithmExports.d.ts

@@ -0,0 +1,333 @@
+/**
+ * Algorithm exports barrel file.
+ * Re-exports the algorithm primitives defined across the internals modules and
+ * provides the standalone graph and layout algorithm implementations used by Nodus.
+ */
+/** Directed cycle detection (Rust detect_cycle, byte-exact with the deleted TS). */
+export declare function detectCyclesDirected(nodeIndexes: ArrayLike<number>, sourceIndexes: ArrayLike<number>, targetIndexes: ArrayLike<number>): Uint32Array | null;
+/** All simple cycles (Rust, byte-exact discovery order with the deleted CyclesFinder). */
+export declare class CyclesFinder {
+    private readonly _n;
+    private readonly _s;
+    private readonly _t;
+    constructor(n: ArrayLike<number>, s: ArrayLike<number>, t: ArrayLike<number>);
+    getCycles(): Uint32Array[];
+}
+/** Kruskal MST (Rust union-find core; the reference comparator sort stays JS). */
+export declare function kruskal_default(nodes: number[], edges: number[], getSource: (edge: any) => number, getTarget: (edge: any) => number, weight?: (edge: any) => number): number[];
+export { kruskal_default as kruskal };
+/** Brandes betweenness (Rust core, byte-exact with the deleted TS betweennes). */
+export declare function betweennes(opts: {
+    adjacency: Array<{
+        id: number;
+        adj: number[];
+    }>;
+    directed: boolean;
+    normalized: boolean;
+}): number[];
+export { betweennes as betweenness };
+/** Fisheye distortion (Rust kernel; per-node position extraction stays JS). */
+export declare function fisheye(nodes: any, _edges: any, k: number, opts: any): any;
+export { Quadtree, default as quadtree_default } from './Quadtree';
+export { minDisk } from '../geometry';
+export { distance, circleCircleIntersection, circleSortCompare, indexArrayToArray, cubicIn, magnitude, minmax, } from './algorithmHelpers';
+export interface MinHeapInstance<T> {
+    readonly keys: Record<string, number>;
+    readonly size: number;
+    heapify(index: number): number;
+    pop(): T | undefined;
+    decreaseKey(index: number, value?: T): number;
+    min(): T;
+    remove(index: number): T | undefined;
+    push(value: T): number;
+    empty(): boolean;
+    toArray(): T[];
+}
+/**
+ * Creates a binary min-heap with decrease-key support.
+ *
+ * @param compare - Comparison function (returns negative if a < b)
+ * @param items - Initial array of items (will be used as backing store)
+ * @param keyMap - Map from item keys to heap indexes
+ * @param getKey - Extracts a string key from an item
+ * @returns A min-heap instance
+ */
+export declare function minHeap<T = number>(compare?: (a: T, b: T) => number, items?: T[], keyMap?: Record<string, number>, getKey?: (item: T) => string | number): MinHeapInstance<T>;
+export interface BellmanFordOptions {
+    sources: ArrayLike<number>;
+    targets: ArrayLike<number>;
+    weights?: number[];
+    source: number;
+    target?: number;
+    undirected?: boolean;
+    indexes?: Uint32Array;
+    N?: number;
+}
+export interface ShortestPathResult {
+    distances: Float32Array;
+    path: number[] | null;
+    pathLength: number | null;
+}
+/**
+ * Bellman-Ford single-source shortest path algorithm.
+ * Handles negative edge weights and detects negative cycles.
+ *
+ * @returns Shortest path result, or null if a negative cycle is detected.
+ */
+export declare function bellmanFord({ sources, targets, weights, source, target, undirected, indexes, N, }: BellmanFordOptions): ShortestPathResult | null;
+export interface AdjacencyEntry {
+    nodes: number[];
+    weights?: number[];
+}
+/**
+ * Dijkstra's single-source shortest path algorithm using a min-heap.
+ *
+ * @param adjacency - Adjacency list for each node index
+ * @param sourceId - Source node ID
+ * @param targetId - Optional target node ID for path reconstruction
+ * @param nodeIds - Array of node IDs (default: 1-indexed)
+ * @param indexMap - Map from node ID to internal index
+ * @param ignoreWeights - If true, all edges have weight 1
+ * @param weightFn - Optional custom weight function (sourceId, targetId) => weight
+ * @returns Distances, path to target, and path length
+ */
+export declare function dijkstra(adjacency: AdjacencyEntry[], sourceId: number, targetId?: number, nodeIds?: ArrayLike<number>, indexMap?: Record<number, number>, ignoreWeights?: boolean, weightFn?: (source: number, target: number) => number): ShortestPathResult;
+export interface JohnsonOptions {
+    sources: ArrayLike<number>;
+    targets: ArrayLike<number>;
+    weights: number[];
+    indexes?: Uint32Array;
+    adjacency: AdjacencyEntry[];
+    undirected?: boolean;
+    ignoreWeights?: boolean;
+}
+/**
+ * Johnson's all-pairs shortest path algorithm.
+ * Uses Bellman-Ford for re-weighting, then Dijkstra from each node.
+ *
+ * @returns An NxN matrix of shortest distances.
+ * @throws If the graph contains negative weight cycles.
+ */
+export declare function johnson({ sources, targets, weights, indexes, adjacency, undirected, ignoreWeights, }: JohnsonOptions): Float32Array[];
+/**
+ * Computes weighted stress of a graph layout.
+ * Stress = sum of w_ij * (d_ij - ||p_i - p_j||)^2
+ *
+ * @param graphDist - All-pairs shortest path distance matrix
+ * @param x - X coordinates of nodes
+ * @param y - Y coordinates of nodes
+ * @param count - Number of nodes in the layout subset
+ * @param scale - Distance scaling factor
+ * @param indexes - Node index mapping array
+ */
+export declare function weightedStress(graphDist: Float32Array[], x: Float32Array, y: Float32Array, count: number, scale: number, indexes: Uint32Array): number;
+/**
+ * Computes distance-based stress contribution from a single focus node.
+ *
+ * @param graphDist - All-pairs shortest path distance matrix
+ * @param x - X coordinates
+ * @param y - Y coordinates
+ * @param count - Number of nodes
+ * @param focusNode - The focus node index (-1 means no focus → returns 0)
+ * @param scale - Distance scaling factor
+ * @param indexes - Node index mapping
+ */
+export declare function distanceStress(graphDist: Float32Array[], x: Float32Array, y: Float32Array, count: number, focusNode: number, scale: number, indexes: Uint32Array): number;
+/**
+ * Computes constrained stress: a blend of global stress and focus-node stress.
+ *
+ * @param graphDist - All-pairs shortest path distance matrix
+ * @param x - X coordinates
+ * @param y - Y coordinates
+ * @param count - Number of nodes
+ * @param focusNode - The focus node index
+ * @param scale - Distance scaling factor
+ * @param alpha - Blend factor (0 = pure global, 1 = pure focus)
+ * @param indexes - Node index mapping
+ */
+export declare function constrainedStress(graphDist: Float32Array[], x: Float32Array, y: Float32Array, count: number, focusNode: number, scale: number, alpha: number, indexes: Uint32Array): number;
+/**
+ * Performs one iteration of stress minimization with optional focus-node constraint.
+ *
+ * @param graphDist - All-pairs shortest path distance matrix
+ * @param x - X coordinates (modified in-place)
+ * @param y - Y coordinates (modified in-place)
+ * @param count - Number of nodes
+ * @param focusNode - Focus node index (-1 for none)
+ * @param scale - Distance scaling factor
+ * @param alpha - Constraint blending factor
+ * @param indexes - Node index mapping
+ * @param distTransform - Function to transform graph distances
+ * @returns Updated x and y coordinate arrays
+ */
+export declare function stressMinimizationStep(graphDist: Float32Array[], x: Float32Array, y: Float32Array, count: number, focusNode: number | undefined, scale: number, alpha: number, indexes: Uint32Array, distTransform: (d: number) => number): {
+    x: Float32Array;
+    y: Float32Array;
+};
+/**
+ * General stress minimization step (simplified version without distTransform).
+ *
+ * @param graphDist - All-pairs shortest path distance matrix
+ * @param x - X coordinates (modified in-place)
+ * @param y - Y coordinates (modified in-place)
+ * @param count - Number of nodes
+ * @param focusNode - Focus node index (-1 for none)
+ * @param scale - Distance scaling factor
+ * @param alpha - Constraint blending factor
+ * @param indexes - Node index mapping
+ * @returns Updated x and y coordinate arrays
+ */
+export declare function stressMinimizationStepGeneral(graphDist: Float32Array[], x: Float32Array, y: Float32Array, count: number, focusNode: number | undefined, scale: number, alpha: number, indexes: Uint32Array): {
+    x: Float32Array;
+    y: Float32Array;
+};
+/**
+ * Computes the convex hull of a set of 2D points.
+ * Uses Andrew's monotone chain algorithm.
+ *
+ * @param points - Array of [x, y] coordinate pairs
+ * @returns Array of points forming the convex hull, or null if fewer than 3 points
+ */
+export declare function convexHull<T extends [number, number]>(points: T[]): T[] | null;
+export interface CircleSpreadOptions {
+    X: Float32Array;
+    Y: Float32Array;
+    R: Float32Array;
+    center?: [number, number];
+    maxSteps?: number;
+    padding?: number;
+    epsilon?: number;
+    damping?: number;
+    pinned?: number;
+    indexes?: Uint32Array;
+    onUpdate?: (x: Float32Array, y: Float32Array) => void;
+    pushSmallerOut?: boolean;
+}
+/**
+ * Spreads nodes on a circle to reduce overlaps by iteratively pushing apart overlapping nodes.
+ *
+ * @returns Updated X and Y coordinate arrays
+ */
+export declare function circleSpread({ X, Y, R, center, maxSteps, padding, epsilon, damping, pinned, indexes, onUpdate, pushSmallerOut, }: CircleSpreadOptions): {
+    X: Float32Array;
+    Y: Float32Array;
+};
+interface CirclePackNode {
+    x: number;
+    y: number;
+    radius: number;
+}
+/**
+ * Circle packing algorithm.
+ * Places circles without overlap in a compact arrangement.
+ *
+ * @param circles - Array of objects with `radius`, modified in-place with `x` and `y`
+ * @param cx - Center X coordinate
+ * @param cy - Center Y coordinate
+ * @returns The same circles array with positions assigned
+ */
+export declare function circlePack(circles: CirclePackNode[], cx?: number, cy?: number): CirclePackNode[];
+export interface RemoveRadialOverlapOptions {
+    X: Float32Array;
+    Y: Float32Array;
+    sizes: Float32Array;
+    indexes: Uint32Array;
+    R: number;
+    center: [number, number];
+    gap?: number;
+    epsilon?: number;
+    maxLoops?: number;
+    inPlace?: boolean;
+}
+/**
+ * Resolves radial overlaps among nodes arranged around a center point on a circle.
+ * Pushes overlapping nodes apart while keeping them on the circle of radius R.
+ *
+ * @returns Updated X and Y coordinate arrays
+ */
+export declare function removeRadialOverlap({ X, Y, sizes, indexes, R, center, gap, epsilon, maxLoops, inPlace, }: RemoveRadialOverlapOptions): {
+    X: Float32Array;
+    Y: Float32Array;
+};
+/**
+ * Finds the largest empty circles within the convex hull of a set of points,
+ * using Delaunay triangulation.
+ *
+ * @param points - Array of { x, y } point objects
+ * @param maxCount - Maximum number of circles to return
+ * @param minRadius - Minimum radius threshold (squared internally)
+ * @param triangleVertices - Pre-computed triangle vertices (optional)
+ * @param hullVertices - Pre-computed convex hull vertices (optional)
+ * @returns Array of [centerX, centerY, radius] tuples
+ */
+export declare function getLargestEmptyCircle(points: {
+    x: number;
+    y: number;
+}[], maxCount?: number, minRadius?: number, triangleVertices?: number[][], hullVertices?: number[][]): [number, number, number][];
+/**
+ * Detects whether an undirected graph contains a cycle using Union-Find.
+ *
+ * @param nodeIds - Array of node IDs
+ * @param sourceIds - Array of edge source IDs
+ * @param targetIds - Array of edge target IDs
+ * @param allowSelfLoops - If true, self-loops are considered cycles
+ * @returns True if a cycle is detected
+ */
+export declare function detectCyclesUndirected(nodeIds: ArrayLike<number>, sourceIds: ArrayLike<number>, targetIds: ArrayLike<number>, allowSelfLoops?: boolean): boolean;
+/**
+ * Detects whether an undirected graph contains a cycle using depth-first search.
+ *
+ * @param nodeIds - Array of node IDs
+ * @param sourceIds - Array of edge source IDs
+ * @param targetIds - Array of edge target IDs
+ * @returns True if a cycle is detected
+ */
+export declare function detectCyclesUndirectedDFS(nodeIds: ArrayLike<number>, sourceIds: ArrayLike<number>, targetIds: ArrayLike<number>): boolean;
+import { Quadtree as QuadtreeClass } from './Quadtree';
+import { minDisk } from '../geometry';
+/**
+ * The unified algorithms object that aggregates every exported algorithm
+ * under a single namespace for convenient consumption.
+ */
+export declare const algorithms: {
+    CyclesFinder: typeof CyclesFinder;
+    Quadtree: typeof QuadtreeClass;
+    bellmanFord: typeof bellmanFord;
+    betweenness: typeof betweennes;
+    circlePack: typeof circlePack;
+    circleSpread: typeof circleSpread;
+    constrainedStress: typeof constrainedStress;
+    convexhull: typeof convexHull;
+    detectCyclesDirected: typeof detectCyclesDirected;
+    detectCyclesUndirected: typeof detectCyclesUndirected;
+    detectCyclesUndirectedDFS: typeof detectCyclesUndirectedDFS;
+    dijkstra: typeof dijkstra;
+    distanceStress: typeof distanceStress;
+    fisheye: typeof fisheye;
+    johnson: typeof johnson;
+    kruskal: typeof kruskal_default;
+    largestEmptyCircle: typeof getLargestEmptyCircle;
+    minDisk: typeof minDisk;
+    minHeap: typeof minHeap;
+    removeRadialOverlap: typeof removeRadialOverlap;
+    stressMinimizationStep: typeof stressMinimizationStep;
+    stressMinimizationStepGeneral: typeof stressMinimizationStepGeneral;
+    weightedStress: typeof weightedStress;
+    calculateRadii: typeof calculateRadii;
+    linear: typeof linear;
+};
+export { convexHull as convexhull };
+export { getLargestEmptyCircle as largestEmptyCircle };
+export declare function linear(t: number): number;
+/**
+ * Compute the radius for each ring distance in the radial layout.
+ *
+ * @param centerIndex  Index of the center node in the sizes array
+ * @param rings        Map from ring distance → array of node indices
+ * @param sizes        Per-node sizes (diameters)
+ * @param nodeGap      Gap between nodes on the same ring
+ * @param radiusRatio  Multiplier for cumulative ring spacing
+ * @param radiusDelta  Additive increment for cumulative ring spacing (0 = use ratio)
+ */
+export declare function calculateRadii(centerIndex: number, rings: Record<number | string, number[]>, sizes: ArrayLike<number>, nodeGap: number, radiusRatio: number, radiusDelta: number): Record<number | string, number>;
+export default algorithms;