@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/layout/community-layout-adapter.d.ts

@@ -1,107 +0,0 @@
-/**
- * Community Detection Layout Adapter
- *
- * Detects communities/clusters in graph and positions them separately.
- * Reveals modular structure and logical groupings in networks.
- *
- * Best for:
- * - Microservices architecture
- * - Organization charts
- * - Social network analysis
- * - Module detection
- *
- * Algorithm: Louvain community detection + force-directed sub-layouts
- *
- * @module layout/community-layout-adapter
- */
-import { NodeModel } from '../models/NodeModel';
-import { LinkModel } from '../models/LinkModel';
-import { LayoutAdapter, LayoutOptions, LayoutResult } from './layout-adapter.interface';
-/**
- * Community detection layout options
- */
-export interface CommunityLayoutOptions extends LayoutOptions {
-    /** Community detection algorithm (default: 'louvain') */
-    algorithm?: 'louvain' | 'label-propagation';
-    /** Resolution parameter for community detection (default: 1.0) */
-    resolution?: number;
-    /** Separate communities visually (default: true) */
-    separateCommunities?: boolean;
-    /** Spacing between communities (default: 200) */
-    communitySpacing?: number;
-    /** Layout algorithm for communities (default: 'circular') */
-    communityLayout?: 'circular' | 'grid' | 'force';
-    /** Layout algorithm within communities (default: 'force') */
-    innerLayout?: 'force' | 'circular';
-    /** Force layout options for inner layout */
-    forceOptions?: {
-        iterations?: number;
-        repulsion?: number;
-        attraction?: number;
-    };
-}
-/**
- * Community Detection Layout Adapter
- *
- * Uses Louvain algorithm to detect communities and arranges them.
- */
-export declare class CommunityLayoutAdapter implements LayoutAdapter {
-    readonly name = "community";
-    /**
-     * Card 0: the run's seeded generator. Established once per apply() so every
-     * helper below draws from the SAME reproducible stream — the seed alone is not
-     * enough if each helper mints its own generator.
-     */
-    private rng;
-    private forceAdapter;
-    /**
-     * Apply community detection layout
-     */
-    apply(nodes: NodeModel[], links: LinkModel[], options?: Partial<CommunityLayoutOptions>): Promise<LayoutResult>;
-    /**
-     * Louvain community detection algorithm
-     */
-    private louvainCommunityDetection;
-    /**
-     * Calculate modularity gain
-     */
-    private modularityGain;
-    /**
-     * Calculate total degree of nodes in community
-     */
-    private communityDegree;
-    /**
-     * Label propagation algorithm (simpler alternative)
-     */
-    private labelPropagation;
-    /**
-     * Build community objects
-     */
-    private buildCommunities;
-    /**
-     * Layout nodes within a community
-     */
-    private layoutCommunity;
-    /**
-     * Simple circular layout
-     */
-    private circularLayout;
-    /**
-     * Position communities relative to each other
-     */
-    private positionCommunities;
-    /**
-     * Calculate bounding box
-     */
-    private calculateBounds;
-    /**
-     * Apply incremental layout (Phase 1 compatibility)
-     */
-    applyIncremental(nodes: NodeModel[], links: LinkModel[], incrementalOptions: any, layoutOptions?: Partial<CommunityLayoutOptions>): Promise<LayoutResult & {
-        incremental: any;
-    }>;
-    /**
-     * Validate options
-     */
-    validateOptions(options: Partial<CommunityLayoutOptions>): boolean;
-}

package/src/libs/engine/src/layout/community-layout-adapter.js

@@ -1,486 +0,0 @@
-"use strict";
-/**
- * Community Detection Layout Adapter
- *
- * Detects communities/clusters in graph and positions them separately.
- * Reveals modular structure and logical groupings in networks.
- *
- * Best for:
- * - Microservices architecture
- * - Organization charts
- * - Social network analysis
- * - Module detection
- *
- * Algorithm: Louvain community detection + force-directed sub-layouts
- *
- * @module layout/community-layout-adapter
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommunityLayoutAdapter = void 0;
-const tslib_1 = require("tslib");
-const rng_1 = require("./rng");
-const layout_quality_metrics_1 = require("./layout-quality-metrics");
-const force_layout_adapter_1 = require("./force-layout-adapter");
-/**
- * Community Detection Layout Adapter
- *
- * Uses Louvain algorithm to detect communities and arranges them.
- */
-class CommunityLayoutAdapter {
-    constructor() {
-        this.name = 'community';
-        /**
-         * Card 0: the run's seeded generator. Established once per apply() so every
-         * helper below draws from the SAME reproducible stream — the seed alone is not
-         * enough if each helper mints its own generator.
-         */
-        this.rng = (0, rng_1.createLayoutRng)();
-        this.forceAdapter = new force_layout_adapter_1.ForceLayoutAdapter();
-    }
-    /**
-     * Apply community detection layout
-     */
-    apply(nodes_1, links_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* (nodes, links, options = {}) {
-            var _a, _b, _c, _d, _e, _f, _g;
-            this.rng = (0, rng_1.createLayoutRng)(options === null || options === void 0 ? void 0 : options.seed);
-            const startTime = performance.now();
-            // Merge with defaults
-            const opts = Object.assign({ algorithm: (_a = options.algorithm) !== null && _a !== void 0 ? _a : 'louvain', resolution: (_b = options.resolution) !== null && _b !== void 0 ? _b : 1.0, separateCommunities: (_c = options.separateCommunities) !== null && _c !== void 0 ? _c : true, communitySpacing: (_d = options.communitySpacing) !== null && _d !== void 0 ? _d : 200, communityLayout: (_e = options.communityLayout) !== null && _e !== void 0 ? _e : 'circular', innerLayout: (_f = options.innerLayout) !== null && _f !== void 0 ? _f : 'force', forceOptions: (_g = options.forceOptions) !== null && _g !== void 0 ? _g : {
-                    iterations: 100,
-                    repulsion: 50,
-                    attraction: 0.1,
-                } }, options);
-            if (nodes.length === 0) {
-                return {
-                    nodePositions: new Map(),
-                    bounds: { x: 0, y: 0, width: 0, height: 0 },
-                    metadata: {
-                        algorithm: 'community',
-                        executionTime: performance.now() - startTime,
-                        nodeCount: 0,
-                        linkCount: 0,
-                    },
-                };
-            }
-            // Build node index map
-            const nodeIndexMap = new Map(nodes.map((node, i) => [node.id, i]));
-            // Detect communities
-            const communityAssignments = opts.algorithm === 'louvain'
-                ? this.louvainCommunityDetection(nodes, links, opts.resolution)
-                : this.labelPropagation(nodes, links);
-            // Group nodes by community
-            const communities = this.buildCommunities(nodes, communityAssignments);
-            console.log(`Detected ${communities.length} communities`);
-            // Layout each community internally
-            const communityLayouts = yield Promise.all(communities.map(community => this.layoutCommunity(community, nodes, links, opts)));
-            // Position communities relative to each other
-            if (opts.separateCommunities) {
-                this.positionCommunities(communityLayouts, opts);
-            }
-            // Build final positions
-            const nodePositions = new Map();
-            for (const community of communityLayouts) {
-                community.nodeIds.forEach(nodeId => {
-                    const node = nodes.find(n => n.id === nodeId);
-                    if (node) {
-                        nodePositions.set(nodeId, {
-                            x: node.position.x + community.x,
-                            y: node.position.y + community.y,
-                        });
-                    }
-                });
-            }
-            // Apply positions to nodes
-            nodes.forEach(node => {
-                const position = nodePositions.get(node.id);
-                if (position) {
-                    node.setPosition(position.x, position.y);
-                }
-            });
-            // Calculate bounds
-            const bounds = this.calculateBounds(nodePositions);
-            const endTime = performance.now();
-            // Calculate quality metrics if requested
-            let quality = undefined;
-            if (options.calculateQuality) {
-                quality = layout_quality_metrics_1.LayoutQualityMetrics.assess(nodes, links, {
-                    includeSuggestions: true,
-                    canvasDimensions: options.canvasDimensions,
-                });
-            }
-            return {
-                nodePositions,
-                bounds,
-                metadata: {
-                    algorithm: 'community',
-                    communityCount: communities.length,
-                    detectionAlgorithm: opts.algorithm,
-                    executionTime: endTime - startTime,
-                    nodeCount: nodes.length,
-                    linkCount: links.length,
-                },
-                quality,
-            };
-        });
-    }
-    /**
-     * Louvain community detection algorithm
-     */
-    louvainCommunityDetection(nodes, links, resolution) {
-        const n = nodes.length;
-        const nodeIndexMap = new Map(nodes.map((node, i) => [node.id, i]));
-        // Initialize each node in its own community
-        const communities = new Map(nodes.map((node, i) => [node.id, i]));
-        // Build adjacency list
-        const adjacency = new Map();
-        nodes.forEach(node => adjacency.set(node.id, new Set()));
-        links.forEach(link => {
-            var _a, _b;
-            if (link.sourceNodeId && link.targetNodeId) {
-                (_a = adjacency.get(link.sourceNodeId)) === null || _a === void 0 ? void 0 : _a.add(link.targetNodeId);
-                (_b = adjacency.get(link.targetNodeId)) === null || _b === void 0 ? void 0 : _b.add(link.sourceNodeId);
-            }
-        });
-        // Calculate degrees
-        const degrees = new Map(nodes.map(node => [node.id, adjacency.get(node.id).size]));
-        const totalEdges = links.length;
-        let improved = true;
-        let iteration = 0;
-        // Phase 1: Move nodes to maximize modularity
-        while (improved && iteration < 100) {
-            improved = false;
-            for (const node of nodes) {
-                const nodeId = node.id;
-                const currentCommunity = communities.get(nodeId);
-                // Calculate modularity gains for moving to neighbor communities
-                const neighborCommunities = new Set();
-                adjacency.get(nodeId).forEach(neighborId => {
-                    neighborCommunities.add(communities.get(neighborId));
-                });
-                let bestCommunity = currentCommunity;
-                let bestGain = 0;
-                for (const targetCommunity of neighborCommunities) {
-                    if (targetCommunity === currentCommunity)
-                        continue;
-                    const gain = this.modularityGain(nodeId, currentCommunity, targetCommunity, communities, adjacency, degrees, totalEdges, resolution);
-                    if (gain > bestGain) {
-                        bestGain = gain;
-                        bestCommunity = targetCommunity;
-                    }
-                }
-                if (bestCommunity !== currentCommunity) {
-                    communities.set(nodeId, bestCommunity);
-                    improved = true;
-                }
-            }
-            iteration++;
-        }
-        // Renumber communities sequentially
-        const communityIds = new Set(communities.values());
-        const communityMap = new Map(Array.from(communityIds).map((id, i) => [id, i]));
-        const result = new Map();
-        communities.forEach((community, nodeId) => {
-            result.set(nodeId, communityMap.get(community));
-        });
-        return result;
-    }
-    /**
-     * Calculate modularity gain
-     */
-    modularityGain(nodeId, fromCommunity, toCommunity, communities, adjacency, degrees, totalEdges, resolution) {
-        let deltaQ = 0;
-        const nodeDegree = degrees.get(nodeId) || 0;
-        // Edges to nodes in target community
-        let edgesToCommunity = 0;
-        adjacency.get(nodeId).forEach(neighborId => {
-            if (communities.get(neighborId) === toCommunity) {
-                edgesToCommunity++;
-            }
-        });
-        // Edges from nodes in target community
-        let edgesFromCommunity = 0;
-        adjacency.get(nodeId).forEach(neighborId => {
-            if (communities.get(neighborId) === fromCommunity) {
-                edgesFromCommunity++;
-            }
-        });
-        deltaQ =
-            (edgesToCommunity - edgesFromCommunity) / totalEdges -
-                resolution *
-                    nodeDegree *
-                    (this.communityDegree(toCommunity, communities, degrees) -
-                        this.communityDegree(fromCommunity, communities, degrees)) /
-                    (2 * totalEdges * totalEdges);
-        return deltaQ;
-    }
-    /**
-     * Calculate total degree of nodes in community
-     */
-    communityDegree(community, communities, degrees) {
-        let total = 0;
-        communities.forEach((comm, nodeId) => {
-            if (comm === community) {
-                total += degrees.get(nodeId) || 0;
-            }
-        });
-        return total;
-    }
-    /**
-     * Label propagation algorithm (simpler alternative)
-     */
-    labelPropagation(nodes, links) {
-        // Initialize labels
-        const labels = new Map(nodes.map((node, i) => [node.id, i]));
-        // Build adjacency list
-        const adjacency = new Map();
-        nodes.forEach(node => adjacency.set(node.id, new Set()));
-        links.forEach(link => {
-            var _a, _b;
-            if (link.sourceNodeId && link.targetNodeId) {
-                (_a = adjacency.get(link.sourceNodeId)) === null || _a === void 0 ? void 0 : _a.add(link.targetNodeId);
-                (_b = adjacency.get(link.targetNodeId)) === null || _b === void 0 ? void 0 : _b.add(link.sourceNodeId);
-            }
-        });
-        // Propagate labels
-        let changed = true;
-        let iteration = 0;
-        while (changed && iteration < 100) {
-            changed = false;
-            // Randomize order
-            // Card 0: a SEEDED shuffle. `sort(() => Math.random() - 0.5)` was doubly
-            // wrong — non-deterministic AND not even a uniform shuffle (a comparator
-            // that answers inconsistently violates the sort contract, so the result is
-            // engine-dependent). Fisher-Yates against the seeded generator instead.
-            const nodeOrder = shuffle([...nodes], this.rng);
-            for (const node of nodeOrder) {
-                // Count neighbor labels
-                const labelCounts = new Map();
-                adjacency.get(node.id).forEach(neighborId => {
-                    const label = labels.get(neighborId);
-                    labelCounts.set(label, (labelCounts.get(label) || 0) + 1);
-                });
-                if (labelCounts.size > 0) {
-                    // Find most common label
-                    let maxCount = 0;
-                    let maxLabel = labels.get(node.id);
-                    labelCounts.forEach((count, label) => {
-                        if (count > maxCount) {
-                            maxCount = count;
-                            maxLabel = label;
-                        }
-                    });
-                    if (maxLabel !== labels.get(node.id)) {
-                        labels.set(node.id, maxLabel);
-                        changed = true;
-                    }
-                }
-            }
-            iteration++;
-        }
-        // Renumber communities
-        const communityIds = new Set(labels.values());
-        const communityMap = new Map(Array.from(communityIds).map((id, i) => [id, i]));
-        const result = new Map();
-        labels.forEach((label, nodeId) => {
-            result.set(nodeId, communityMap.get(label));
-        });
-        return result;
-    }
-    /**
-     * Build community objects
-     */
-    buildCommunities(nodes, assignments) {
-        const communityMap = new Map();
-        assignments.forEach((community, nodeId) => {
-            if (!communityMap.has(community)) {
-                communityMap.set(community, []);
-            }
-            communityMap.get(community).push(nodeId);
-        });
-        const communities = [];
-        communityMap.forEach((nodeIds, id) => {
-            communities.push({
-                id,
-                nodeIds,
-                x: 0,
-                y: 0,
-                width: 0,
-                height: 0,
-            });
-        });
-        return communities;
-    }
-    /**
-     * Layout nodes within a community
-     */
-    layoutCommunity(community, allNodes, allLinks, options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            // Get nodes and links for this community
-            const communityNodes = allNodes.filter(n => community.nodeIds.includes(n.id));
-            const communityLinks = allLinks.filter(link => link.sourceNodeId &&
-                link.targetNodeId &&
-                community.nodeIds.includes(link.sourceNodeId) &&
-                community.nodeIds.includes(link.targetNodeId));
-            if (communityNodes.length === 0) {
-                return community;
-            }
-            // Apply inner layout
-            if (options.innerLayout === 'force') {
-                yield this.forceAdapter.apply(communityNodes, communityLinks, Object.assign(Object.assign({}, options.forceOptions), { iterations: ((_a = options.forceOptions) === null || _a === void 0 ? void 0 : _a.iterations) || 100, repulsion: ((_b = options.forceOptions) === null || _b === void 0 ? void 0 : _b.repulsion) || 50, randomize: false }));
-            }
-            else {
-                // Circular layout
-                this.circularLayout(communityNodes);
-            }
-            // Calculate bounds
-            let minX = Infinity, minY = Infinity;
-            let maxX = -Infinity, maxY = -Infinity;
-            communityNodes.forEach(node => {
-                minX = Math.min(minX, node.position.x);
-                minY = Math.min(minY, node.position.y);
-                maxX = Math.max(maxX, node.position.x);
-                maxY = Math.max(maxY, node.position.y);
-            });
-            community.width = maxX - minX + 100;
-            community.height = maxY - minY + 100;
-            // Center nodes at origin
-            const cx = (minX + maxX) / 2;
-            const cy = (minY + maxY) / 2;
-            communityNodes.forEach(node => {
-                node.setPosition(node.position.x - cx, node.position.y - cy);
-            });
-            return community;
-        });
-    }
-    /**
-     * Simple circular layout
-     */
-    circularLayout(nodes) {
-        const n = nodes.length;
-        const radius = Math.max(100, n * 20);
-        nodes.forEach((node, i) => {
-            const angle = (i / n) * 2 * Math.PI;
-            node.setPosition(Math.cos(angle) * radius, Math.sin(angle) * radius);
-        });
-    }
-    /**
-     * Position communities relative to each other
-     */
-    positionCommunities(communities, options) {
-        if (communities.length === 0)
-            return;
-        const spacing = options.communitySpacing;
-        if (options.communityLayout === 'circular') {
-            // Arrange communities in a circle
-            const radius = Math.max(300, communities.length * 150);
-            communities.forEach((community, i) => {
-                const angle = (i / communities.length) * 2 * Math.PI;
-                community.x = Math.cos(angle) * radius;
-                community.y = Math.sin(angle) * radius;
-            });
-        }
-        else if (options.communityLayout === 'grid') {
-            // Arrange in grid
-            const cols = Math.ceil(Math.sqrt(communities.length));
-            let x = 0, y = 0;
-            let maxHeight = 0;
-            communities.forEach((community, i) => {
-                community.x = x;
-                community.y = y;
-                maxHeight = Math.max(maxHeight, community.height);
-                x += community.width + spacing;
-                if ((i + 1) % cols === 0) {
-                    x = 0;
-                    y += maxHeight + spacing;
-                    maxHeight = 0;
-                }
-            });
-        }
-        else {
-            // Force-directed layout of communities
-            // Simplified: just space them out
-            let x = 0;
-            communities.forEach(community => {
-                community.x = x;
-                community.y = 0;
-                x += community.width + spacing;
-            });
-        }
-    }
-    /**
-     * Calculate bounding box
-     */
-    calculateBounds(positions) {
-        if (positions.size === 0) {
-            return { x: 0, y: 0, width: 0, height: 0 };
-        }
-        let minX = Infinity, minY = Infinity;
-        let maxX = -Infinity, maxY = -Infinity;
-        positions.forEach(pos => {
-            minX = Math.min(minX, pos.x);
-            minY = Math.min(minY, pos.y);
-            maxX = Math.max(maxX, pos.x);
-            maxY = Math.max(maxY, pos.y);
-        });
-        const padding = 50;
-        minX -= padding;
-        minY -= padding;
-        maxX += padding;
-        maxY += padding;
-        return {
-            x: minX,
-            y: minY,
-            width: maxX - minX,
-            height: maxY - minY,
-        };
-    }
-    /**
-     * Apply incremental layout (Phase 1 compatibility)
-     */
-    applyIncremental(nodes, links, incrementalOptions, layoutOptions) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            // Community detection layout doesn't support true incremental layout
-            // Just apply full layout
-            const result = yield this.apply(nodes, links, layoutOptions);
-            return Object.assign(Object.assign({}, result), { incremental: {
-                    newNodeIds: incrementalOptions.newNodeIds || [],
-                    pinnedNodeIds: [],
-                    movedNodeIds: nodes.map(n => n.id),
-                    strategy: 'full-relayout',
-                    constraintsApplied: 0,
-                } });
-        });
-    }
-    /**
-     * Validate options
-     */
-    validateOptions(options) {
-        if (options.resolution !== undefined && options.resolution <= 0) {
-            return false;
-        }
-        if (options.communitySpacing !== undefined && options.communitySpacing < 0) {
-            return false;
-        }
-        return true;
-    }
-}
-exports.CommunityLayoutAdapter = CommunityLayoutAdapter;
-/**
- * Fisher-Yates against a seeded generator.
- *
- * The code this replaces used `array.sort(() => Math.random() - 0.5)`, which is a
- * classic: it is not merely non-deterministic, it is not a uniform shuffle at all
- * (an inconsistent comparator breaks the sort contract, so the distribution is
- * whatever the engine's sort happens to do). Label propagation's convergence
- * depends on visit order, so the community layout was biased AND irreproducible.
- */
-function shuffle(items, rng) {
-    for (let i = items.length - 1; i > 0; i--) {
-        const j = Math.floor(rng.next() * (i + 1));
-        [items[i], items[j]] = [items[j], items[i]];
-    }
-    return items;
-}
-//# sourceMappingURL=community-layout-adapter.js.map

package/src/libs/engine/src/layout/component-packing.d.ts

@@ -1,98 +0,0 @@
-import type { NodeModel } from '../models/NodeModel';
-import type { LinkModel } from '../models/LinkModel';
-import type { LayoutResult } from './layout-adapter.interface';
-import type { UnifiedLayoutOptions } from './layout-registry';
-/** Dagre's fallbacks, reused so every layout agrees on what an unsized node is. */
-export declare const DEFAULT_NODE_WIDTH = 150;
-export declare const DEFAULT_NODE_HEIGHT = 50;
-/** A node's box, with the same defaults every layout in the portfolio uses. */
-export declare function nodeSize(node: NodeModel): {
-    width: number;
-    height: number;
-};
-/** One connected component: its nodes, and the links that live entirely inside it. */
-export interface GraphComponent {
-    nodes: NodeModel[];
-    links: LinkModel[];
-}
-/**
- * The contract a layout must satisfy to be packable: nodes + links in, positions
- * out. Deliberately array-based (not DiagramModel-based) — a component is a
- * SUBSET of a diagram, and there is no such thing as a sub-DiagramModel.
- */
-export type GraphLayoutFn = (nodes: NodeModel[], links: LinkModel[], options: UnifiedLayoutOptions) => Promise<LayoutResult> | LayoutResult;
-/** A box to pack, plus the id used to break ties deterministically. */
-export interface PackBox {
-    id: string;
-    width: number;
-    height: number;
-}
-export interface PackingOptions {
-    /** Gap between packed components. Defaults to the layout's `nodeSpacing`. */
-    spacing?: number;
-    /** Target width/height of the packed result. 1.6 ≈ a landscape screen. */
-    aspectRatio?: number;
-}
-/**
- * THE OVERLAP PASS — one rule, one place, for every path that produces positions.
- *
- * It lives outside the five algorithms for the same reason packing does: force and
- * community lay out DIMENSIONLESS POINTS and happily return boxes that intersect
- * (see overlap-removal.ts). For every layout that does not overlap — dagre, ELK,
- * tree, grid, circular, radial — it is a no-op, so it costs them one comparison
- * pass and nothing else.
- *
- * wave10/gallery — WHY IT IS EXPORTED, which is the bug.
- *
- * It used to be a closure inside `layoutWithComponentPacking`, reachable only from
- * `adapter.apply()`. But the layout HOST — the path `engine.layout()` actually
- * takes — does not call `apply()` for a steppable algorithm: it drives
- * `createRun()`/`step()`/`snapshot()` so the run can report progress and be
- * cancelled. `snapshot()` was returned RAW.
- *
- * Force is the only steppable built-in. So the one algorithm that genuinely needs
- * overlap removal was the one algorithm that never got it, and
- * `engine.layout('force')` handed back overlapping node boxes — while every unit
- * test stayed green, because they all go through `apply()`.
- *
- * A demo caught it in the first thirty seconds of being pointed at a real browser.
- */
-export declare function separateOverlappingNodes(nodes: readonly NodeModel[], positions: Map<string, {
-    x: number;
-    y: number;
-}>, options?: UnifiedLayoutOptions): Map<string, {
-    x: number;
-    y: number;
-}>;
-/**
- * Split a graph into connected components.
- *
- * Connectivity is UNDIRECTED — an edge joins its endpoints regardless of which
- * way it points. (A tree whose edges all point away from the root is still one
- * component; treating edges as directed would shatter it into leaves.)
- *
- * Deterministic: nodes are visited in id order and each node's neighbours are
- * visited in id order, so the components — and the order they come back in —
- * depend only on the graph, never on insertion order.
- */
-export declare function findConnectedComponents(nodes: readonly NodeModel[], links: readonly LinkModel[]): GraphComponent[];
-/**
- * Shelf packing, first-fit-decreasing-height.
- *
- * Returns the top-left OFFSET for every box. Boxes are laid left-to-right into
- * a shelf; when the next box would overflow the target width a new shelf opens
- * below the tallest box on the current one.
- */
-export declare function packBoxes(boxes: readonly PackBox[], options?: PackingOptions): Map<string, {
-    x: number;
-    y: number;
-}>;
-/**
- * Run a layout with component packing.
- *
- * The wrapper every registered layout goes through. See the header: for a
- * CONNECTED graph this is a straight delegation (packing a single component is
- * the identity), so it cannot regress anything; for a disconnected one it is the
- * difference between a tidy row of trees and a pile.
- */
-export declare function layoutWithComponentPacking(name: string, fn: GraphLayoutFn, nodes: readonly NodeModel[], links: readonly LinkModel[], options?: UnifiedLayoutOptions): Promise<LayoutResult>;