@grafloria/element 0.3.19 → 0.3.21

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

@@ -1,697 +0,0 @@
-"use strict";
-/**
- * Dagre Layout Adapter
- *
- * Integrates the Dagre library for hierarchical graph layouts.
- * Supports multiple directions, ranking algorithms, and fine-tuned spacing controls.
- *
- * @see https://github.com/dagrejs/dagre
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DagreLayoutAdapter = void 0;
-const tslib_1 = require("tslib");
-const dagre = require("@dagrejs/dagre");
-const port_label_bridge_1 = require("./port-label-bridge");
-const layout_constraints_interface_1 = require("./layout-constraints.interface");
-const incremental_layout_interface_1 = require("./incremental-layout.interface");
-const layout_quality_metrics_1 = require("./layout-quality-metrics");
-const port_aware_layout_interface_1 = require("./port-aware-layout.interface");
-const subgraph_layout_interface_1 = require("./subgraph-layout.interface");
-const edge_bundling_interface_1 = require("./edge-bundling.interface");
-/**
- * Default Dagre layout options
- */
-const DEFAULT_DAGRE_OPTIONS = {
-    rankdir: 'TB',
-    nodesep: 50,
-    edgesep: 10,
-    ranksep: 50,
-    marginx: 0,
-    marginy: 0,
-    ranker: 'network-simplex',
-    deepRankThreshold: 300,
-};
-const DEFAULT_DEEP_RANK_THRESHOLD = 300;
-/**
- * Estimate graph depth: longest-path ranks, O(V+E), fully ITERATIVE (dagre's
- * own recursive dfs is what stack-overflows on a 2000-chain — we must not
- * repeat that here). Cycle-safe: an explicit-stack DFS classifies back edges
- * (target currently on the DFS stack) and drops them, then Kahn's algorithm
- * assigns rank(v) = max(rank(pred) + 1) over the remaining DAG.
- */
-function computeAcyclicLongestPathRanks(nodes, links) {
-    const n = nodes.length;
-    const index = new Map();
-    nodes.forEach((node, i) => index.set(node.id, i));
-    const out = Array.from({ length: n }, () => []);
-    links.forEach((link) => {
-        if (!link.sourceNodeId || !link.targetNodeId)
-            return;
-        const s = index.get(link.sourceNodeId);
-        const t = index.get(link.targetNodeId);
-        if (s === undefined || t === undefined || s === t)
-            return;
-        out[s].push(t);
-    });
-    // Iterative DFS: keep tree/forward/cross edges, drop back edges.
-    const WHITE = 0, GRAY = 1, BLACK = 2;
-    const color = new Uint8Array(n);
-    const kept = Array.from({ length: n }, () => []);
-    const indeg = new Int32Array(n);
-    const stackV = [];
-    const stackI = [];
-    for (let root = 0; root < n; root++) {
-        if (color[root] !== WHITE)
-            continue;
-        color[root] = GRAY;
-        stackV.push(root);
-        stackI.push(0);
-        while (stackV.length > 0) {
-            const v = stackV[stackV.length - 1];
-            const i = stackI[stackV.length - 1];
-            if (i < out[v].length) {
-                stackI[stackV.length - 1] = i + 1;
-                const w = out[v][i];
-                if (color[w] === GRAY)
-                    continue; // back edge — breaks the cycle
-                kept[v].push(w);
-                indeg[w]++;
-                if (color[w] === WHITE) {
-                    color[w] = GRAY;
-                    stackV.push(w);
-                    stackI.push(0);
-                }
-            }
-            else {
-                color[v] = BLACK;
-                stackV.pop();
-                stackI.pop();
-            }
-        }
-    }
-    // Kahn's topological pass with longest-path relaxation.
-    const rankArr = new Int32Array(n);
-    const queue = [];
-    for (let v = 0; v < n; v++)
-        if (indeg[v] === 0)
-            queue.push(v);
-    let head = 0;
-    let maxRank = 0;
-    while (head < queue.length) {
-        const v = queue[head++];
-        for (const w of kept[v]) {
-            if (rankArr[v] + 1 > rankArr[w]) {
-                rankArr[w] = rankArr[v] + 1;
-                if (rankArr[w] > maxRank)
-                    maxRank = rankArr[w];
-            }
-            if (--indeg[w] === 0)
-                queue.push(w);
-        }
-    }
-    const rank = new Map();
-    nodes.forEach((node, i) => rank.set(node.id, rankArr[i]));
-    return { rank, rankCount: n === 0 ? 0 : maxRank + 1 };
-}
-/**
- * Dagre Layout Adapter
- *
- * Provides hierarchical layout using the Dagre library.
- * Converts between Grafloria's node/link model and Dagre's graph structure.
- */
-class DagreLayoutAdapter {
-    constructor() {
-        this.name = 'dagre';
-    }
-    /**
-     * Apply Dagre layout to nodes and links
-     *
-     * @param nodes - Nodes to layout
-     * @param links - Links connecting the nodes
-     * @param options - Dagre layout options
-     * @returns Layout result with positions and metadata
-     */
-    apply(nodes_1, links_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* (nodes, links, options = {}) {
-            var _a;
-            const startTime = performance.now();
-            // Merge default options with provided options
-            const dagreOptions = Object.assign(Object.assign({}, DEFAULT_DAGRE_OPTIONS), options);
-            const labelAware = options.labelAware !== false;
-            // DEEP-GRAPH FAST PATH decision — see DagreLayoutOptions.deepRankThreshold.
-            // The estimate is O(V+E) and only runs when the threshold is finite.
-            const threshold = (_a = dagreOptions.deepRankThreshold) !== null && _a !== void 0 ? _a : DEFAULT_DEEP_RANK_THRESHOLD;
-            const depth = Number.isFinite(threshold)
-                ? computeAcyclicLongestPathRanks(nodes, links)
-                : null;
-            const useDeepFastPath = depth !== null && depth.rankCount > threshold;
-            const core = useDeepFastPath
-                ? this.runDeepFastPath(nodes, links, dagreOptions, labelAware, depth)
-                : this.runDagre(nodes, links, dagreOptions, labelAware);
-            const { nodePositions, nodeRanks, routing } = core;
-            // The ranker that actually produced the ranks: the fast path IS a
-            // longest-path ranking, whatever the configured dagre ranker was.
-            const effectiveRanker = useDeepFastPath ? 'longest-path' : dagreOptions.ranker;
-            // Apply layout constraints if provided
-            if (options.constraints) {
-                const constraintManager = new layout_constraints_interface_1.ConstraintManager(options.constraints);
-                const conflictResolution = options.constraints.conflictResolution || 'priority';
-                // Apply constraints to each node position
-                nodePositions.forEach((position, nodeId) => {
-                    const constrainedPosition = constraintManager.applyConstraints(nodeId, position, conflictResolution);
-                    nodePositions.set(nodeId, constrainedPosition);
-                });
-            }
-            // Calculate bounding box
-            const bounds = this.calculateBounds(nodePositions, nodes);
-            const endTime = performance.now();
-            // Calculate quality metrics if requested
-            let quality = undefined;
-            if (options.calculateQuality) {
-                // Apply positions to nodes temporarily for quality assessment
-                nodes.forEach(node => {
-                    const newPos = nodePositions.get(node.id);
-                    if (newPos) {
-                        node.setPosition(newPos.x, newPos.y);
-                    }
-                });
-                quality = layout_quality_metrics_1.LayoutQualityMetrics.assess(nodes, links, {
-                    includeSuggestions: true,
-                    canvasDimensions: options.canvasDimensions,
-                });
-            }
-            // Process port-aware layout if enabled (Phase 3)
-            let portAware = undefined;
-            if (options.portAware && options.portAware.enabled) {
-                const nodeSizes = new Map();
-                nodes.forEach(node => {
-                    nodeSizes.set(node.id, {
-                        width: node.size.width || 150,
-                        height: node.size.height || 50,
-                    });
-                });
-                portAware = port_aware_layout_interface_1.PortAwareLayoutManager.computePortLayout(options.portAware.ports || [], nodePositions, nodeSizes, links.map(link => ({
-                    sourcePortId: link.sourcePortId,
-                    targetPortId: link.targetPortId,
-                })), options.portAware);
-            }
-            // Process subgraph layout if enabled (Phase 3)
-            let subgraph = undefined;
-            if (options.subgraph && options.subgraph.enabled && options.subgraph.groups) {
-                const nodeSizes = new Map();
-                nodes.forEach(node => {
-                    nodeSizes.set(node.id, {
-                        width: node.size.width || 150,
-                        height: node.size.height || 50,
-                    });
-                });
-                // Convert NodeModel[] to generic node array
-                const genericNodes = nodes.map(node => (Object.assign({}, node)));
-                const genericLinks = links.map(link => (Object.assign({ sourceNodeId: link.sourceNodeId || '', targetNodeId: link.targetNodeId || '' }, link)));
-                subgraph = yield subgraph_layout_interface_1.SubgraphLayoutManager.computeSubgraphLayout(options.subgraph.groups, genericNodes, genericLinks, nodeSizes, this, options.subgraph);
-                // If subgraph layout was performed, use those positions
-                if (subgraph.nodePositions.size > 0) {
-                    // Replace node positions with subgraph positions
-                    subgraph.nodePositions.forEach((pos, nodeId) => {
-                        nodePositions.set(nodeId, { x: pos.x, y: pos.y });
-                    });
-                    // Update bounds
-                    bounds.x = subgraph.bounds.x;
-                    bounds.y = subgraph.bounds.y;
-                    bounds.width = subgraph.bounds.width;
-                    bounds.height = subgraph.bounds.height;
-                }
-            }
-            // Process edge bundling if enabled (Phase 4)
-            let edgeBundling = undefined;
-            if (options.edgeBundling && options.edgeBundling.enabled) {
-                // Convert links to EdgeInfo
-                const edgeInfos = links.map(link => ({
-                    id: link.id,
-                    sourceNodeId: link.sourceNodeId || '',
-                    targetNodeId: link.targetNodeId || '',
-                    sourcePortId: link.sourcePortId,
-                    targetPortId: link.targetPortId,
-                    weight: 1,
-                }));
-                // Prepare node positions for bundling
-                const bundlingNodePositions = new Map();
-                nodePositions.forEach((pos, nodeId) => {
-                    bundlingNodePositions.set(nodeId, { x: pos.x, y: pos.y });
-                });
-                // Prepare port positions if available
-                const bundlingPortPositions = new Map();
-                if (portAware) {
-                    portAware.portPositions.forEach((pos, portId) => {
-                        var _a, _b;
-                        // Port positions are relative, need to convert to absolute
-                        // For now, use node positions as approximation
-                        const portInfo = (_b = (_a = options.portAware) === null || _a === void 0 ? void 0 : _a.ports) === null || _b === void 0 ? void 0 : _b.find(p => p.id === portId);
-                        if (portInfo) {
-                            const nodePos = bundlingNodePositions.get(portInfo.nodeId);
-                            if (nodePos) {
-                                bundlingPortPositions.set(portId, {
-                                    x: nodePos.x + pos.x,
-                                    y: nodePos.y + pos.y,
-                                });
-                            }
-                        }
-                    });
-                }
-                // Compute edge bundling
-                edgeBundling = edge_bundling_interface_1.EdgeBundlingManager.computeBundling(edgeInfos, bundlingNodePositions, bundlingPortPositions, options.edgeBundling);
-            }
-            return {
-                nodePositions,
-                bounds,
-                metadata: {
-                    algorithm: 'dagre',
-                    direction: dagreOptions.rankdir,
-                    ranker: effectiveRanker,
-                    deepFastPath: useDeepFastPath,
-                    executionTime: endTime - startTime,
-                    nodeCount: nodes.length,
-                    linkCount: links.length,
-                    nodeRanks, // NEW: Include hierarchical ranks for port assignment
-                    labelledEdges: routing.labelSpace.size,
-                },
-                quality,
-                portAware,
-                subgraph,
-                edgeBundling,
-                routing,
-            };
-        });
-    }
-    /**
-     * The classic path: hand the graph to `dagre.layout` and read positions,
-     * ranks and edge polylines back. Behavior-identical to the pre-fast-path
-     * adapter — shallow graphs must lay out byte-for-byte the same.
-     */
-    runDagre(nodes, links, dagreOptions, labelAware) {
-        // Create dagre graph.
-        //
-        // MULTIGRAPH — Wave 7, Card 7. A plain `new dagre.graphlib.Graph()` is NOT a
-        // multigraph: `setEdge(a, b)` keyed only by its endpoints, so two parallel
-        // links A→B silently COLLAPSED into one. Dagre then ranked the graph as if
-        // the second edge did not exist, and — now that edges carry label boxes —
-        // would have reserved room for one label where two were needed. Keying each
-        // edge by its link id keeps them distinct and lets the route be read back
-        // per link.
-        const g = new dagre.graphlib.Graph({ multigraph: true });
-        // Set graph-level options
-        g.setGraph({
-            rankdir: dagreOptions.rankdir,
-            align: dagreOptions.align,
-            nodesep: dagreOptions.nodesep,
-            edgesep: dagreOptions.edgesep,
-            ranksep: dagreOptions.ranksep,
-            marginx: dagreOptions.marginx,
-            marginy: dagreOptions.marginy,
-            acyclicer: dagreOptions.acyclicer,
-            ranker: dagreOptions.ranker,
-        });
-        g.setDefaultEdgeLabel(() => ({}));
-        // Add nodes to dagre graph
-        nodes.forEach((node) => {
-            g.setNode(node.id, {
-                width: node.size.width || 150,
-                height: node.size.height || 50,
-                // Store original node for reference
-                nodeModel: node,
-            });
-        });
-        // Add edges to dagre graph.
-        //
-        // LABEL-AWARE — Wave 7, Card 7. Dagre reserves space for an edge label when
-        // the edge carries a `width`/`height`: it ranks the label as a dummy node, so
-        // the channel between ranks genuinely widens to fit it. Before this, every
-        // layout packed the ranks as though edges were bare lines, and the renderer's
-        // edge optimizer was then asked to place a label into a gap that layout had
-        // never left. Placement is still the optimizer's job — this is the reservation.
-        links.forEach((link) => {
-            if (!link.sourceNodeId || !link.targetNodeId)
-                return;
-            const box = labelAware ? (0, port_label_bridge_1.linkLabelBox)(link) : undefined;
-            const edgeLabel = box
-                ? { width: box.width, height: box.height, labelpos: 'c' }
-                : {};
-            g.setEdge(link.sourceNodeId, link.targetNodeId, edgeLabel, link.id);
-        });
-        // Run dagre layout algorithm
-        dagre.layout(g);
-        // Extract positions from dagre graph
-        const nodePositions = new Map();
-        // Extract ranks for port assignment (hierarchical layer information)
-        const nodeRanks = new Map();
-        g.nodes().forEach((nodeId) => {
-            const node = g.node(nodeId);
-            if (node) {
-                // Dagre returns center position, convert to top-left corner
-                nodePositions.set(nodeId, {
-                    x: node.x - (node.width || 0) / 2,
-                    y: node.y - (node.height || 0) / 2,
-                });
-                // Extract rank (hierarchical layer) - used for port side selection
-                // Rank represents the layer in the hierarchy (0 = first layer, 1 = second, etc.)
-                // Note: rank property exists at runtime but not in TypeScript types
-                const nodeWithRank = node;
-                if (nodeWithRank.rank !== undefined) {
-                    nodeRanks.set(nodeId, nodeWithRank.rank);
-                }
-            }
-        });
-        // Read back the polyline dagre computed for each edge — Wave 7, Card 7.
-        // Dagre has always produced `edge.points`, and the adapter has always thrown
-        // them away (the same bug shape as ELK's discarded sections). They are hints:
-        // the wave-5 routing engine still owns the final path.
-        const routing = {
-            portPositions: new Map(),
-            edgeRoutes: new Map(),
-            labelSpace: new Map(),
-            orthogonal: false, // dagre emits a polyline, not an orthogonal route
-        };
-        links.forEach((link) => {
-            var _a;
-            if (!link.sourceNodeId || !link.targetNodeId)
-                return;
-            const edge = g.edge({ v: link.sourceNodeId, w: link.targetNodeId, name: link.id });
-            const points = (_a = edge === null || edge === void 0 ? void 0 : edge.points) !== null && _a !== void 0 ? _a : [];
-            if (points.length >= 2) {
-                routing.edgeRoutes.set(link.id, {
-                    start: { x: points[0].x, y: points[0].y },
-                    end: { x: points[points.length - 1].x, y: points[points.length - 1].y },
-                    bends: points.slice(1, -1).map((p) => ({ x: p.x, y: p.y })),
-                });
-            }
-            const box = labelAware ? (0, port_label_bridge_1.linkLabelBox)(link) : undefined;
-            if (box)
-                routing.labelSpace.set(link.id, { width: box.width, height: box.height });
-        });
-        return { nodePositions, nodeRanks, routing };
-    }
-    /**
-     * DEEP-GRAPH FAST PATH — O(V + E) hierarchical placement for graphs whose
-     * rank count exceeds `deepRankThreshold`, where `dagre.layout` goes quadratic
-     * (or stack-overflows — see the option's doc comment for the measurements).
-     *
-     * Longest-path ranks (already computed for the depth estimate), a few
-     * deterministic barycenter ordering sweeps, then centered coordinates:
-     * each rank is centered on the cross axis, ranks advance by
-     * max-node-extent + ranksep (+ reserved label space when labelAware).
-     * A deep chain comes out as dagre would draw it: one straight centered
-     * column, `ranksep` apart.
-     */
-    runDeepFastPath(nodes, links, opts, labelAware, depth) {
-        const horizontal = opts.rankdir === 'LR' || opts.rankdir === 'RL';
-        const widthOf = (node) => node.size.width || 150;
-        const heightOf = (node) => node.size.height || 50;
-        // Extent along the rank axis / cross axis, per rankdir.
-        const rankExtentOf = horizontal ? widthOf : heightOf;
-        const crossExtentOf = horizontal ? heightOf : widthOf;
-        const routing = {
-            portPositions: new Map(),
-            edgeRoutes: new Map(),
-            labelSpace: new Map(),
-            orthogonal: false,
-        };
-        // ---- Layers (input order within a rank = deterministic initial order) ----
-        const layers = [];
-        for (let r = 0; r < depth.rankCount; r++)
-            layers.push([]);
-        if (layers.length === 0 && nodes.length > 0)
-            layers.push([]);
-        nodes.forEach((node) => {
-            var _a;
-            layers[(_a = depth.rank.get(node.id)) !== null && _a !== void 0 ? _a : 0].push(node);
-        });
-        // ---- Undirected adjacency for barycenter sweeps ----
-        const neighbors = new Map();
-        nodes.forEach((node) => neighbors.set(node.id, []));
-        links.forEach((link) => {
-            if (!link.sourceNodeId || !link.targetNodeId)
-                return;
-            if (link.sourceNodeId === link.targetNodeId)
-                return;
-            const s = neighbors.get(link.sourceNodeId);
-            const t = neighbors.get(link.targetNodeId);
-            if (!s || !t)
-                return;
-            s.push(link.targetNodeId);
-            t.push(link.sourceNodeId);
-        });
-        // ---- Barycenter ordering: 4 alternating sweeps over normalized positions.
-        // Everything is deterministic: input order seeds the layers, Array.sort is
-        // stable, ties keep their order. No RNG => same input, same result.
-        const pos = new Map(); // normalized [0..1] position in layer
-        const refresh = (layer) => {
-            layer.forEach((node, i) => {
-                pos.set(node.id, layer.length > 1 ? i / (layer.length - 1) : 0.5);
-            });
-        };
-        layers.forEach(refresh);
-        const SWEEPS = 4;
-        for (let s = 0; s < SWEEPS; s++) {
-            const ordered = s % 2 === 0 ? layers : [...layers].reverse();
-            for (const layer of ordered) {
-                if (layer.length < 2)
-                    continue;
-                const bary = new Map();
-                layer.forEach((node) => {
-                    var _a, _b;
-                    const ns = (_a = neighbors.get(node.id)) !== null && _a !== void 0 ? _a : [];
-                    if (ns.length === 0) {
-                        bary.set(node.id, (_b = pos.get(node.id)) !== null && _b !== void 0 ? _b : 0.5);
-                        return;
-                    }
-                    let sum = 0;
-                    ns.forEach((id) => { var _a; return (sum += (_a = pos.get(id)) !== null && _a !== void 0 ? _a : 0.5); });
-                    bary.set(node.id, sum / ns.length);
-                });
-                layer.sort((a, b) => { var _a, _b; return ((_a = bary.get(a.id)) !== null && _a !== void 0 ? _a : 0.5) - ((_b = bary.get(b.id)) !== null && _b !== void 0 ? _b : 0.5); });
-                refresh(layer);
-            }
-        }
-        // ---- Label space reservation (the dagre path reserves via dummy ranks;
-        // here we widen the gap after the label's source rank) ----
-        const gapExtra = new Array(Math.max(layers.length - 1, 0)).fill(0);
-        links.forEach((link) => {
-            if (!link.sourceNodeId || !link.targetNodeId)
-                return;
-            const box = labelAware ? (0, port_label_bridge_1.linkLabelBox)(link) : undefined;
-            if (!box)
-                return;
-            routing.labelSpace.set(link.id, { width: box.width, height: box.height });
-            const rs = depth.rank.get(link.sourceNodeId);
-            const rt = depth.rank.get(link.targetNodeId);
-            if (rs === undefined || rt === undefined || rs === rt)
-                return;
-            const gap = Math.min(rs, rt);
-            const extent = horizontal ? box.width : box.height;
-            if (gap >= 0 && gap < gapExtra.length) {
-                gapExtra[gap] = Math.max(gapExtra[gap], extent);
-            }
-        });
-        // ---- Rank-axis positions ----
-        const rankCenter = [];
-        let cursor = 0;
-        layers.forEach((layer, r) => {
-            var _a;
-            const thickness = layer.reduce((m, node) => Math.max(m, rankExtentOf(node)), 0);
-            rankCenter[r] = cursor + thickness / 2;
-            cursor += thickness + opts.ranksep + ((_a = gapExtra[r]) !== null && _a !== void 0 ? _a : 0);
-        });
-        const totalRankExtent = layers.length > 0 ? cursor - opts.ranksep : 0;
-        // ---- Cross-axis positions: each layer packed with nodesep, centered on 0 ----
-        const centers = new Map();
-        layers.forEach((layer, r) => {
-            const sizes = layer.map(crossExtentOf);
-            const total = sizes.reduce((a, b) => a + b, 0) + opts.nodesep * Math.max(layer.length - 1, 0);
-            let c = -total / 2;
-            layer.forEach((node, i) => {
-                centers.set(node.id, { rank: rankCenter[r], cross: c + sizes[i] / 2 });
-                c += sizes[i] + opts.nodesep;
-            });
-        });
-        // ---- Map (rank, cross) -> (x, y) per rankdir; emit top-left corners ----
-        const nodePositions = new Map();
-        nodes.forEach((node) => {
-            const c = centers.get(node.id);
-            let cx;
-            let cy;
-            switch (opts.rankdir) {
-                case 'BT':
-                    cx = c.cross;
-                    cy = totalRankExtent - c.rank;
-                    break;
-                case 'LR':
-                    cx = c.rank;
-                    cy = c.cross;
-                    break;
-                case 'RL':
-                    cx = totalRankExtent - c.rank;
-                    cy = c.cross;
-                    break;
-                default: // TB
-                    cx = c.cross;
-                    cy = c.rank;
-            }
-            nodePositions.set(node.id, {
-                x: cx - widthOf(node) / 2,
-                y: cy - heightOf(node) / 2,
-            });
-        });
-        // Translate so the top-left of the drawing sits at (marginx, marginy),
-        // mirroring dagre's translateGraph.
-        if (nodePositions.size > 0) {
-            let minX = Infinity;
-            let minY = Infinity;
-            nodePositions.forEach((p) => {
-                if (p.x < minX)
-                    minX = p.x;
-                if (p.y < minY)
-                    minY = p.y;
-            });
-            const dx = (opts.marginx || 0) - minX;
-            const dy = (opts.marginy || 0) - minY;
-            nodePositions.forEach((p) => {
-                p.x += dx;
-                p.y += dy;
-            });
-        }
-        // ---- Straight-line edge route hints (routing engine owns the final path) ----
-        const nodeById = new Map();
-        nodes.forEach((node) => nodeById.set(node.id, node));
-        links.forEach((link) => {
-            if (!link.sourceNodeId || !link.targetNodeId)
-                return;
-            const sp = nodePositions.get(link.sourceNodeId);
-            const tp = nodePositions.get(link.targetNodeId);
-            const sn = nodeById.get(link.sourceNodeId);
-            const tn = nodeById.get(link.targetNodeId);
-            if (!sp || !tp || !sn || !tn)
-                return;
-            routing.edgeRoutes.set(link.id, {
-                start: { x: sp.x + widthOf(sn) / 2, y: sp.y + heightOf(sn) / 2 },
-                end: { x: tp.x + widthOf(tn) / 2, y: tp.y + heightOf(tn) / 2 },
-                bends: [],
-            });
-        });
-        return { nodePositions, nodeRanks: new Map(depth.rank), routing };
-    }
-    /**
-     * Validate Dagre layout options
-     *
-     * @param options - Options to validate
-     * @returns true if valid, false otherwise
-     */
-    validateOptions(options) {
-        // Validate rankdir
-        if (options.rankdir && !['TB', 'BT', 'LR', 'RL'].includes(options.rankdir)) {
-            return false;
-        }
-        // Validate align
-        if (options.align && !['UL', 'UR', 'DL', 'DR'].includes(options.align)) {
-            return false;
-        }
-        // Validate ranker
-        if (options.ranker &&
-            !['network-simplex', 'tight-tree', 'longest-path'].includes(options.ranker)) {
-            return false;
-        }
-        // Validate acyclicer
-        if (options.acyclicer !== undefined && options.acyclicer !== 'greedy') {
-            return false;
-        }
-        // Validate numeric options are positive
-        if (options.nodesep !== undefined && options.nodesep < 0) {
-            return false;
-        }
-        if (options.edgesep !== undefined && options.edgesep < 0) {
-            return false;
-        }
-        if (options.ranksep !== undefined && options.ranksep < 0) {
-            return false;
-        }
-        // Validate deep-graph threshold (Infinity allowed = "never fast-path")
-        if (options.deepRankThreshold !== undefined &&
-            (typeof options.deepRankThreshold !== 'number' ||
-                Number.isNaN(options.deepRankThreshold) ||
-                options.deepRankThreshold < 0)) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Calculate bounding box for all laid-out nodes
-     *
-     * @param positions - Map of node positions
-     * @param nodes - Array of nodes
-     * @returns Bounding box
-     */
-    calculateBounds(positions, nodes) {
-        if (positions.size === 0) {
-            return { x: 0, y: 0, width: 0, height: 0 };
-        }
-        // Map lookup, not nodes.find: the old per-position `nodes.find` scan made
-        // bounds O(V²) — measurable dead weight on the very graphs (1-2k nodes)
-        // this adapter now handles.
-        const nodeById = new Map();
-        nodes.forEach((node) => nodeById.set(node.id, node));
-        let minX = Infinity;
-        let minY = Infinity;
-        let maxX = -Infinity;
-        let maxY = -Infinity;
-        positions.forEach((pos, nodeId) => {
-            const node = nodeById.get(nodeId);
-            if (node) {
-                const width = node.size.width || 150;
-                const height = node.size.height || 50;
-                minX = Math.min(minX, pos.x);
-                minY = Math.min(minY, pos.y);
-                maxX = Math.max(maxX, pos.x + width);
-                maxY = Math.max(maxY, pos.y + height);
-            }
-        });
-        return {
-            x: minX,
-            y: minY,
-            width: maxX - minX,
-            height: maxY - minY,
-        };
-    }
-    /**
-     * Apply incremental layout - layout new nodes while preserving existing positions
-     *
-     * @param nodes - Array of all nodes (existing + new)
-     * @param links - Array of all links
-     * @param incrementalOptions - Options for incremental layout
-     * @param layoutOptions - Base layout options
-     * @returns Layout result with positions and incremental statistics
-     */
-    applyIncremental(nodes, links, incrementalOptions, layoutOptions) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            // Store original positions for movement calculation
-            const oldPositions = new Map();
-            nodes.forEach(node => {
-                const pos = node.position;
-                oldPositions.set(node.id, { x: pos.x, y: pos.y });
-            });
-            // Identify new nodes
-            const newNodeIds = incremental_layout_interface_1.IncrementalLayoutManager.identifyNewNodes(nodes, incrementalOptions);
-            const strategy = incrementalOptions.strategy || 'pin-existing';
-            // Generate constraints based on strategy
-            const generatedConstraints = incremental_layout_interface_1.IncrementalLayoutManager.generateConstraints(nodes, incrementalOptions);
-            // Merge layout options with generated constraints
-            const mergedOptions = Object.assign(Object.assign({}, layoutOptions), { constraints: generatedConstraints });
-            // Apply normal layout with constraints
-            const layoutResult = yield this.apply(nodes, links, mergedOptions);
-            // Calculate incremental statistics
-            const incrementalResult = incremental_layout_interface_1.IncrementalLayoutManager.calculateResult(nodes, oldPositions, newNodeIds, generatedConstraints, strategy);
-            // Return combined result
-            return Object.assign(Object.assign({}, layoutResult), { incremental: incrementalResult });
-        });
-    }
-}
-exports.DagreLayoutAdapter = DagreLayoutAdapter;
-//# sourceMappingURL=dagre-layout-adapter.js.map