@grafloria/element 0.3.20 → 0.3.22

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

@@ -1,586 +0,0 @@
-"use strict";
-/**
- * ELK Layout Adapter
- *
- * Integrates the Eclipse Layout Kernel (ELK) for advanced multi-algorithm layouts.
- * Supports 6 different layout algorithms: layered, force, stress, mrtree, radial, and disco.
- *
- * @see https://www.eclipse.org/elk/
- * @see https://github.com/kieler/elkjs
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ELKLayoutAdapter = void 0;
-const tslib_1 = require("tslib");
-const elk_loader_1 = require("./elk-loader");
-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");
-const port_label_bridge_1 = require("./port-label-bridge");
-/**
- * Default ELK layout options
- */
-const DEFAULT_ELK_OPTIONS = {
-    algorithm: 'layered',
-    'elk.direction': 'RIGHT',
-    'elk.spacing.nodeNode': 80,
-};
-/**
- * The footprint a port occupies in ELK's model. Grafloria's ports are drawn as small
- * handles on the node border; ELK only needs a non-zero box to reason about
- * spacing and ordering along a side.
- */
-const ELK_PORT_SIZE = 8;
-/** Default gap between an edge and its label. */
-const DEFAULT_EDGE_LABEL_SPACING = 6;
-/**
- * ELK Layout Adapter
- *
- * Provides advanced layout algorithms using the Eclipse Layout Kernel.
- * Supports multiple algorithms with extensive configuration options.
- */
-class ELKLayoutAdapter {
-    constructor() {
-        this.name = 'elk';
-    }
-    elkInstance() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a;
-            return ((_a = this._elk) !== null && _a !== void 0 ? _a : (this._elk = new (yield (0, elk_loader_1.loadElk)()).default()));
-        });
-    }
-    /**
-     * Apply ELK layout to nodes and links
-     *
-     * @param nodes - Nodes to layout
-     * @param links - Links connecting the nodes
-     * @param options - ELK 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, _b, _c, _d, _e;
-            const startTime = performance.now();
-            // Merge default options with provided options
-            const elkOptions = Object.assign(Object.assign({}, DEFAULT_ELK_OPTIONS), options);
-            // -----------------------------------------------------------------------
-            // Wave 7 — Card 7: build a PORT- and LABEL-AWARE ELK graph.
-            //
-            // THE BUG THIS CLOSES. The old builder sent ELK a graph of bare boxes:
-            // children carried nothing but {id, width, height}, and edges were
-            // node-to-node (`sources: [link.sourceNodeId]`). ELK is one of the very few
-            // engines that does REAL port-aware layered layout with orthogonal edge
-            // routing — and we were neither giving it the ports nor reading back the
-            // routes. It was being asked a question about boxes and answering one, and
-            // then we threw away the half of the answer we never asked for.
-            //
-            // Now: declared ports go in WITH their sides, edges attach to those PORTS,
-            // and labelled edges carry the box their label needs so ELK's layered
-            // algorithm makes room for it (it inserts label dummy nodes in the ranking —
-            // which is precisely "reserve space at layout time").
-            // -----------------------------------------------------------------------
-            const portMode = (_a = elkOptions.portConstraints) !== null && _a !== void 0 ? _a : 'auto';
-            const labelAware = elkOptions.labelAware !== false;
-            // Ports the caller hand-authored still win (back-compat with the old
-            // `options.portAware.ports`); otherwise they come from the real model.
-            const portInfos = (_c = (_b = elkOptions.portAware) === null || _b === void 0 ? void 0 : _b.ports) !== null && _c !== void 0 ? _c : (portMode === 'free' ? [] : (0, port_label_bridge_1.derivePortInfos)(nodes));
-            const portInfoById = new Map(portInfos.map((p) => [p.id, p]));
-            // Group ports by owning node ONCE. The old per-node `portInfos.filter(...)`
-            // was O(nodes × ports) — a quadratic translation cost on port-heavy graphs
-            // (900 nodes × 1800 ports = 1.6M predicate calls before ELK even ran).
-            // `portInfos` is canonically sorted (nodeId, side, priority, id), so pushing
-            // in order preserves the exact per-node port order the filter produced.
-            const portsByNode = new Map();
-            for (const p of portInfos) {
-                const list = portsByNode.get(p.nodeId);
-                if (list)
-                    list.push(p);
-                else
-                    portsByNode.set(p.nodeId, [p]);
-            }
-            const elkChildren = nodes.map((node) => {
-                var _a;
-                const nodePorts = (_a = portsByNode.get(node.id)) !== null && _a !== void 0 ? _a : [];
-                const constraint = (0, port_label_bridge_1.resolvePortConstraint)(node, portMode);
-                const child = {
-                    id: node.id,
-                    width: node.size.width || 150,
-                    height: node.size.height || 50,
-                };
-                // Only constrain a node that actually declares ports. A node with none is
-                // left FREE, so ELK keeps every degree of freedom it had before.
-                if (nodePorts.length > 0 && constraint !== 'FREE') {
-                    child.layoutOptions = { 'elk.portConstraints': constraint };
-                    child.ports = nodePorts.map((port, i) => {
-                        var _a, _b;
-                        return ({
-                            id: port.id,
-                            width: ELK_PORT_SIZE,
-                            height: ELK_PORT_SIZE,
-                            layoutOptions: {
-                                'elk.port.side': (0, port_label_bridge_1.toElkPortSide)((_a = port.preferredSide) !== null && _a !== void 0 ? _a : 'right'),
-                                'elk.port.index': String((_b = port.priority) !== null && _b !== void 0 ? _b : i),
-                            },
-                        });
-                    });
-                }
-                return child;
-            });
-            // An edge may only reference a port ELK actually knows about — i.e. one we
-            // emitted above. A link hanging off an auto-created DEFAULT port falls back
-            // to the node id, which is what the old code always did.
-            const emittedPortIds = new Set(elkChildren.flatMap((c) => { var _a; return ((_a = c.ports) !== null && _a !== void 0 ? _a : []).map((p) => p.id); }));
-            const endpoint = (portId, nodeId) => portId && emittedPortIds.has(portId) ? portId : nodeId;
-            // Size every link's label box ONCE — it is needed twice (as the ELK edge
-            // label below, and again as `labelSpace` in the routing hints), and the old
-            // code ran the estimate/word-wrap pass both times. Computed for ALL links,
-            // exactly as extractRoutingHints always did, so the hint output is unchanged.
-            const labelBoxByLink = new Map();
-            if (labelAware) {
-                for (const link of links)
-                    labelBoxByLink.set(link.id, (0, port_label_bridge_1.linkLabelBox)(link));
-            }
-            const elkEdges = links
-                .filter((link) => link.sourceNodeId && link.targetNodeId)
-                .map((link) => {
-                const edge = {
-                    id: link.id,
-                    sources: [endpoint(link.sourcePortId, link.sourceNodeId)],
-                    targets: [endpoint(link.targetPortId, link.targetNodeId)],
-                };
-                // Label-aware: hand ELK the box the label needs. This is a RESERVATION,
-                // not a placement — the renderer's edge optimizer still decides where the
-                // label finally sits; it just now has somewhere to put it.
-                const box = labelBoxByLink.get(link.id);
-                if (box) {
-                    edge.labels = [{ id: box.id, text: box.text, width: box.width, height: box.height }];
-                }
-                return edge;
-            });
-            const elkGraph = {
-                id: 'root',
-                layoutOptions: this.buildLayoutOptions(elkOptions, labelAware),
-                children: elkChildren,
-                edges: elkEdges,
-            };
-            // Run ELK layout algorithm
-            const layoutedGraph = yield (yield this.elkInstance()).layout(elkGraph);
-            // Extract positions from layouted graph
-            const nodePositions = new Map();
-            (_d = layoutedGraph.children) === null || _d === void 0 ? void 0 : _d.forEach((child) => {
-                if (child.x !== undefined && child.y !== undefined) {
-                    nodePositions.set(child.id, {
-                        x: child.x,
-                        y: child.y,
-                    });
-                }
-            });
-            // -----------------------------------------------------------------------
-            // Read back the half of ELK's answer that used to go in the bin: where it
-            // put each port, and the orthogonal route it found for each edge.
-            // -----------------------------------------------------------------------
-            const routing = this.extractRoutingHints(layoutedGraph, labelBoxByLink, portInfoById, (_e = elkOptions.edgeRouting) !== null && _e !== void 0 ? _e : (elkOptions.orthogonalRouting === false ? 'POLYLINE' : 'ORTHOGONAL'));
-            // 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(layoutedGraph);
-            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: 'elk',
-                    elkAlgorithm: elkOptions.algorithm || 'layered',
-                    direction: elkOptions['elk.direction'] || 'RIGHT',
-                    executionTime: endTime - startTime,
-                    nodeCount: nodes.length,
-                    linkCount: links.length,
-                    portConstrainedNodes: elkChildren.filter((c) => { var _a; return (_a = c.ports) === null || _a === void 0 ? void 0 : _a.length; }).length,
-                    labelledEdges: elkEdges.filter((e) => { var _a; return (_a = e.labels) === null || _a === void 0 ? void 0 : _a.length; }).length,
-                },
-                quality,
-                portAware,
-                subgraph,
-                edgeBundling,
-                routing,
-            };
-        });
-    }
-    /**
-     * Wave 7 — Card 7: harvest ELK's port positions and edge routes.
-     *
-     * ELK returns each port's coordinates RELATIVE to its owning node, and each
-     * edge as a list of `sections` (start point, end point, optional bend points).
-     * The old adapter read neither. These are advisory hints — the wave-5 routing
-     * engine still owns the final path — but they are no longer thrown away, and a
-     * router can seed from them.
-     */
-    extractRoutingHints(graph, labelBoxByLink, portInfoById, edgeRouting) {
-        var _a, _b, _c, _d;
-        const portPositions = new Map();
-        const edgeRoutes = new Map();
-        const labelSpace = new Map();
-        // Ports come back relative to the node — lift them into diagram space.
-        (_a = graph.children) === null || _a === void 0 ? void 0 : _a.forEach((child) => {
-            var _a, _b, _c;
-            const nodeX = (_a = child.x) !== null && _a !== void 0 ? _a : 0;
-            const nodeY = (_b = child.y) !== null && _b !== void 0 ? _b : 0;
-            (_c = child.ports) === null || _c === void 0 ? void 0 : _c.forEach((port) => {
-                var _a, _b;
-                if (port.x === undefined || port.y === undefined)
-                    return;
-                portPositions.set(port.id, {
-                    x: nodeX + port.x,
-                    y: nodeY + port.y,
-                    side: (_b = (_a = portInfoById.get(port.id)) === null || _a === void 0 ? void 0 : _a.preferredSide) !== null && _b !== void 0 ? _b : 'right',
-                });
-            });
-        });
-        // Edge sections: the orthogonal route ELK computed.
-        const edges = ((_b = graph.edges) !== null && _b !== void 0 ? _b : []);
-        for (const edge of edges) {
-            const sections = (_c = edge.sections) !== null && _c !== void 0 ? _c : [];
-            if (sections.length === 0)
-                continue;
-            const first = sections[0];
-            const last = sections[sections.length - 1];
-            const bends = [];
-            for (const section of sections) {
-                for (const bend of (_d = section.bendPoints) !== null && _d !== void 0 ? _d : [])
-                    bends.push({ x: bend.x, y: bend.y });
-            }
-            edgeRoutes.set(edge.id, {
-                start: { x: first.startPoint.x, y: first.startPoint.y },
-                end: { x: last.endPoint.x, y: last.endPoint.y },
-                bends,
-            });
-        }
-        // Boxes were sized once in apply() (empty map when label-awareness is off).
-        for (const [linkId, box] of labelBoxByLink) {
-            if (box)
-                labelSpace.set(linkId, { width: box.width, height: box.height });
-        }
-        return {
-            portPositions,
-            edgeRoutes,
-            labelSpace,
-            orthogonal: edgeRouting === 'ORTHOGONAL',
-        };
-    }
-    /**
-     * Build ELK layout options from our options interface
-     *
-     * Converts our strongly-typed options to ELK's string-based option format.
-     *
-     * @param options - Our layout options
-     * @returns ELK layout options object
-     */
-    buildLayoutOptions(options, labelAware = true) {
-        const elkOptions = {
-            'elk.algorithm': options.algorithm || 'layered',
-        };
-        // Wave 7 — Card 7. Orthogonal by default: it is what Grafloria's ManhattanRouter
-        // draws, so asking ELK for anything else would have layout optimise for a
-        // picture the renderer never draws. `orthogonalRouting: false` opts out.
-        if (!options.edgeRouting && options.orthogonalRouting !== false) {
-            elkOptions['elk.edgeRouting'] = 'ORTHOGONAL';
-        }
-        // Label-aware: tell ELK to keep edge labels off the nodes and off each other.
-        // ELK's layered algorithm turns a label box into a dummy node in the ranking,
-        // so this genuinely reserves space rather than just nudging the label after
-        // the fact.
-        if (labelAware) {
-            elkOptions['elk.edgeLabels.placement'] = 'CENTER';
-            elkOptions['elk.edgeLabels.inline'] = 'false';
-            if (options['elk.spacing.edgeLabel'] === undefined) {
-                elkOptions['elk.spacing.edgeLabel'] = String(DEFAULT_EDGE_LABEL_SPACING);
-            }
-        }
-        // Map direction option
-        if (options['elk.direction']) {
-            elkOptions['elk.direction'] = options['elk.direction'];
-        }
-        // Map spacing options
-        if (options['elk.spacing.nodeNode'] !== undefined) {
-            elkOptions['elk.spacing.nodeNode'] = String(options['elk.spacing.nodeNode']);
-        }
-        if (options['elk.spacing.edgeNode'] !== undefined) {
-            elkOptions['elk.spacing.edgeNode'] = String(options['elk.spacing.edgeNode']);
-        }
-        if (options['elk.spacing.edgeEdge'] !== undefined) {
-            elkOptions['elk.spacing.edgeEdge'] = String(options['elk.spacing.edgeEdge']);
-        }
-        // Layered algorithm options
-        if (options['elk.layered.spacing.nodeNodeBetweenLayers'] !== undefined) {
-            elkOptions['elk.layered.spacing.nodeNodeBetweenLayers'] = String(options['elk.layered.spacing.nodeNodeBetweenLayers']);
-        }
-        if (options['elk.layered.spacing.edgeNodeBetweenLayers'] !== undefined) {
-            elkOptions['elk.layered.spacing.edgeNodeBetweenLayers'] = String(options['elk.layered.spacing.edgeNodeBetweenLayers']);
-        }
-        if (options['elk.layered.nodePlacement.strategy']) {
-            elkOptions['elk.layered.nodePlacement.strategy'] =
-                options['elk.layered.nodePlacement.strategy'];
-        }
-        if (options['elk.layered.crossingMinimization.strategy']) {
-            elkOptions['elk.layered.crossingMinimization.strategy'] =
-                options['elk.layered.crossingMinimization.strategy'];
-        }
-        // Force algorithm options
-        if (options['elk.force.repulsion'] !== undefined) {
-            elkOptions['elk.force.repulsion'] = String(options['elk.force.repulsion']);
-        }
-        if (options['elk.force.temperature'] !== undefined) {
-            elkOptions['elk.force.temperature'] = String(options['elk.force.temperature']);
-        }
-        if (options['elk.force.iterations'] !== undefined) {
-            elkOptions['elk.force.iterations'] = String(options['elk.force.iterations']);
-        }
-        // Radial algorithm options
-        if (options['elk.radial.radius'] !== undefined) {
-            elkOptions['elk.radial.radius'] = String(options['elk.radial.radius']);
-        }
-        if (options['elk.radial.compaction'] !== undefined) {
-            elkOptions['elk.radial.compaction'] = String(options['elk.radial.compaction']);
-        }
-        // Advanced options
-        if (options.hierarchyHandling) {
-            elkOptions['elk.hierarchyHandling'] = options.hierarchyHandling;
-        }
-        if (options.edgeRouting) {
-            elkOptions['elk.edgeRouting'] = options.edgeRouting;
-        }
-        return elkOptions;
-    }
-    /**
-     * Validate ELK layout options
-     *
-     * @param options - Options to validate
-     * @returns true if valid, false otherwise
-     */
-    validateOptions(options) {
-        // Validate algorithm
-        const validAlgorithms = [
-            'layered',
-            'force',
-            'stress',
-            'mrtree',
-            'radial',
-            'disco',
-        ];
-        if (options.algorithm && !validAlgorithms.includes(options.algorithm)) {
-            return false;
-        }
-        // Validate direction
-        const validDirections = ['RIGHT', 'LEFT', 'DOWN', 'UP'];
-        if (options['elk.direction'] && !validDirections.includes(options['elk.direction'])) {
-            return false;
-        }
-        // Validate node placement strategy
-        const validNodePlacementStrategies = [
-            'SIMPLE',
-            'INTERACTIVE',
-            'LINEAR_SEGMENTS',
-            'BRANDES_KOEPF',
-            'NETWORK_SIMPLEX',
-        ];
-        if (options['elk.layered.nodePlacement.strategy'] &&
-            !validNodePlacementStrategies.includes(options['elk.layered.nodePlacement.strategy'])) {
-            return false;
-        }
-        // Validate crossing minimization strategy
-        const validCrossingMinStrategies = ['LAYER_SWEEP', 'INTERACTIVE'];
-        if (options['elk.layered.crossingMinimization.strategy'] &&
-            !validCrossingMinStrategies.includes(options['elk.layered.crossingMinimization.strategy'])) {
-            return false;
-        }
-        // Validate numeric options are positive
-        const numericOptions = [
-            'elk.spacing.nodeNode',
-            'elk.spacing.edgeNode',
-            'elk.spacing.edgeEdge',
-            'elk.layered.spacing.nodeNodeBetweenLayers',
-            'elk.layered.spacing.edgeNodeBetweenLayers',
-            'elk.force.repulsion',
-            'elk.force.temperature',
-            'elk.force.iterations',
-            'elk.radial.radius',
-        ];
-        for (const option of numericOptions) {
-            if (options[option] !== undefined && options[option] < 0) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Calculate bounding box from ELK graph
-     *
-     * @param graph - ELK graph after layout
-     * @returns Bounding box
-     */
-    calculateBounds(graph) {
-        if (!graph.children || graph.children.length === 0) {
-            return { x: 0, y: 0, width: 0, height: 0 };
-        }
-        let minX = Infinity;
-        let minY = Infinity;
-        let maxX = -Infinity;
-        let maxY = -Infinity;
-        graph.children.forEach((child) => {
-            if (child.x !== undefined && child.y !== undefined) {
-                const width = child.width || 0;
-                const height = child.height || 0;
-                minX = Math.min(minX, child.x);
-                minY = Math.min(minY, child.y);
-                maxX = Math.max(maxX, child.x + width);
-                maxY = Math.max(maxY, child.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.ELKLayoutAdapter = ELKLayoutAdapter;
-//# sourceMappingURL=elk-layout-adapter.js.map

package/src/libs/engine/src/layout/elk-loader.d.ts

@@ -1 +0,0 @@
-export declare function loadElk(): Promise<typeof import('elkjs/lib/elk.bundled')>;

package/src/libs/engine/src/layout/elk-loader.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadElk = loadElk;
-/**
- * Lazy, memoized loader for elkjs — the single heaviest dependency in the
- * engine (~1.4 MB bundled GWT output).
- *
- * ELK is only needed when a diagram actually RUNS the `elk` layout algorithm
- * (or the ElkRouter routing strategy). Importing it at module top-level made
- * every consumer bundle carry it whether they used it or not. Loading through
- * `import()` keeps the module graph free of elkjs until first use: bundlers
- * (esbuild, vite, webpack, the Angular CLI) split it into its own chunk that
- * is fetched on the first ELK layout call, and the CommonJS build defers the
- * `require` the same way.
- *
- * The wave11 lesson still applies one level down: constructing `new ELK()`
- * spawns elkjs's nested Worker, so instances must ALSO be created lazily —
- * this loader only fetches the module; callers instantiate on first layout.
- */
-let pending;
-function loadElk() {
-    return (pending !== null && pending !== void 0 ? pending : (pending = Promise.resolve().then(() => require('elkjs/lib/elk.bundled'))));
-}
-//# sourceMappingURL=elk-loader.js.map