@grafloria/element 0.3.19 → 0.3.21

package/src/libs/engine/src/layout/LayoutManager.js

@@ -1,640 +0,0 @@
-"use strict";
-/**
- * Layout Manager
- *
- * Manages layout algorithms and provides a unified API for layout operations.
- * Responsibilities:
- * - Register and switch between layout algorithms
- * - Calculate placement for new nodes
- * - Re-layout existing diagrams
- * - Emit layout events
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LayoutManager = void 0;
-const tslib_1 = require("tslib");
-const GridLayoutAlgorithm_1 = require("./algorithms/GridLayoutAlgorithm");
-const HierarchicalLayoutAlgorithm_1 = require("./algorithms/HierarchicalLayoutAlgorithm");
-const ForceDirectedLayoutAlgorithm_1 = require("./algorithms/ForceDirectedLayoutAlgorithm");
-const HybridLayoutAlgorithm_1 = require("./algorithms/HybridLayoutAlgorithm");
-/**
- * Layout Manager
- */
-class LayoutManager {
-    constructor(diagram, initialAlgorithm = 'grid') {
-        var _a, _b;
-        this.diagram = diagram;
-        this.algorithms = new Map();
-        this.eventListeners = new Map();
-        // Register built-in algorithms
-        this.registerAlgorithm('grid', new GridLayoutAlgorithm_1.GridLayoutAlgorithm());
-        this.registerAlgorithm('hierarchical', new HierarchicalLayoutAlgorithm_1.HierarchicalLayoutAlgorithm());
-        this.registerAlgorithm('force-directed', new ForceDirectedLayoutAlgorithm_1.ForceDirectedLayoutAlgorithm());
-        this.registerAlgorithm('hybrid', new HybridLayoutAlgorithm_1.HybridLayoutAlgorithm());
-        // Set initial algorithm
-        this.currentAlgorithm = this.algorithms.get(initialAlgorithm);
-        (_b = (_a = this.currentAlgorithm).onActivate) === null || _b === void 0 ? void 0 : _b.call(_a);
-    }
-    /**
-     * Register a layout algorithm
-     */
-    registerAlgorithm(type, algorithm) {
-        this.algorithms.set(type, algorithm);
-    }
-    /**
-     * Get registered algorithm
-     */
-    getAlgorithm(type) {
-        return this.algorithms.get(type);
-    }
-    /**
-     * Get all registered algorithm types
-     */
-    getAvailableAlgorithms() {
-        return Array.from(this.algorithms.keys());
-    }
-    /**
-     * Switch to a different layout algorithm
-     */
-    setAlgorithm(type, config) {
-        var _a, _b, _c, _d;
-        const algorithm = this.algorithms.get(type);
-        if (!algorithm) {
-            throw new Error(`Layout algorithm '${type}' is not registered`);
-        }
-        // Validate if algorithm can be applied
-        const validation = algorithm.canApply(this.diagram);
-        if (!validation.valid) {
-            throw new Error(`Cannot apply ${type} layout: ${validation.reason || 'Unknown reason'}`);
-        }
-        // Deactivate current algorithm
-        (_b = (_a = this.currentAlgorithm).onDeactivate) === null || _b === void 0 ? void 0 : _b.call(_a);
-        // Switch to new algorithm
-        this.currentAlgorithm = algorithm;
-        // Configure if options provided
-        if (config) {
-            this.currentAlgorithm.configure(config);
-        }
-        // Activate new algorithm
-        (_d = (_c = this.currentAlgorithm).onActivate) === null || _d === void 0 ? void 0 : _d.call(_c);
-        // Emit event
-        this.emitEvent({
-            type: 'layout:algorithm-changed',
-            algorithmType: type,
-            data: { previousAlgorithm: this.currentAlgorithm.getType() },
-        });
-    }
-    /**
-     * Get current layout algorithm
-     */
-    getCurrentAlgorithm() {
-        return this.currentAlgorithm;
-    }
-    /**
-     * Get current algorithm type
-     */
-    getCurrentAlgorithmType() {
-        return this.currentAlgorithm.getType();
-    }
-    /**
-     * Calculate placement for a new node
-     */
-    calculatePlacement(node, viewport, options) {
-        const existingNodes = this.diagram.getNodes();
-        const placementOptions = Object.assign({ node,
-            viewport,
-            existingNodes }, options);
-        try {
-            const result = this.currentAlgorithm.calculatePlacement(placementOptions);
-            // Emit event
-            this.emitEvent({
-                type: 'layout:node-placed',
-                algorithmType: this.currentAlgorithm.getType(),
-                data: {
-                    nodeId: node.id,
-                    position: result.position,
-                    metadata: result.metadata,
-                },
-            });
-            return result;
-        }
-        catch (error) {
-            console.error('Layout placement failed:', error);
-            // Fallback to simple placement
-            return {
-                position: { x: 100, y: 100 },
-                success: false,
-            };
-        }
-    }
-    /**
-     * Re-layout all nodes using current algorithm (Phase 0.5 - Viewport-aware)
-     * Option 3: Supports animation and locked node constraints
-     */
-    reLayout(config) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            this.emitEvent({
-                type: 'layout:started',
-                algorithmType: this.currentAlgorithm.getType(),
-            });
-            try {
-                // Phase 0.5: Get viewport from diagram and pass to layout algorithm
-                const viewport = this.diagram.getViewport();
-                const enhancedConfig = Object.assign(Object.assign({}, config), { type: this.currentAlgorithm.getType(), viewport, margins: (config === null || config === void 0 ? void 0 : config.margins) || 50 });
-                // If direction shorthand is provided, merge it into hierarchical options
-                if ((config === null || config === void 0 ? void 0 : config.direction) && this.currentAlgorithm.getType() === 'hierarchical') {
-                    enhancedConfig.options = Object.assign(Object.assign({}, config.options), { direction: config.direction });
-                }
-                // Option 3: Store old positions for animation — and, always, as the
-                // baseline for invalidating stale link routes after the apply below.
-                const oldPositions = new Map();
-                this.diagram.getNodes().forEach((node) => {
-                    oldPositions.set(node.id, Object.assign({}, node.position));
-                });
-                // Calculate new positions (viewport-aware)
-                const positions = this.currentAlgorithm.reLayout(this.diagram, enhancedConfig);
-                // Option 3: Filter out locked nodes - they keep their current positions
-                const lockedNodes = new Set();
-                this.diagram.getNodes().forEach((node) => {
-                    if (node.state.locked) {
-                        lockedNodes.add(node.id);
-                        // Restore locked node's original position
-                        positions.set(node.id, Object.assign({}, node.position));
-                    }
-                });
-                if (lockedNodes.size > 0) {
-                    console.log(`📌 ${lockedNodes.size} locked node(s) preserved during layout`);
-                }
-                // Option 3: Apply animation if requested
-                if ((config === null || config === void 0 ? void 0 : config.animate) && config.animationDuration) {
-                    yield this.animateLayout(oldPositions, positions, config.animationDuration);
-                }
-                else {
-                    // Apply positions immediately (no animation)
-                    positions.forEach((position, nodeId) => {
-                        const node = this.diagram.getNode(nodeId);
-                        if (node) {
-                            node.setPosition(position.x, position.y);
-                        }
-                    });
-                }
-                // Phase 0.5.2: Optimize connections based on new node positions
-                // This must happen BEFORE recalculating paths, so links use optimal ports
-                this.optimizeConnections();
-                // THE stale-polyline fix, applied after BOTH the animated and the
-                // immediate path: a link whose endpoint nodes moved still carries the
-                // polyline it was routed on BEFORE the layout (recalculateLinkPaths
-                // regenerates it with LinkModel's simple generators during animation,
-                // but the renderer's obstacle-aware router is authoritative). Emptying
-                // the routed points is the canonical "re-route on next paint" trigger,
-                // and it marks the link dirty so no cached VNode — with its stale
-                // label position — can be reused. Links whose endpoints did NOT move
-                // keep their still-valid routes.
-                this.invalidateRoutesForMovedNodes(oldPositions);
-                this.emitEvent({
-                    type: 'layout:completed',
-                    algorithmType: this.currentAlgorithm.getType(),
-                    data: { nodeCount: positions.size, lockedNodes: lockedNodes.size, animated: !!(config === null || config === void 0 ? void 0 : config.animate) },
-                });
-            }
-            catch (error) {
-                console.error('Layout failed:', error);
-                this.emitEvent({
-                    type: 'layout:failed',
-                    algorithmType: this.currentAlgorithm.getType(),
-                    data: { error },
-                });
-                throw error;
-            }
-        });
-    }
-    /**
-     * Option 3: Animate layout transitions
-     *
-     * Smoothly transitions nodes from old positions to new positions over the specified duration.
-     * Uses requestAnimationFrame for smooth 60fps animation.
-     */
-    animateLayout(oldPositions, newPositions, duration) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve) => {
-                const startTime = performance.now();
-                const easeInOutCubic = (t) => {
-                    return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
-                };
-                const animate = (currentTime) => {
-                    const elapsed = currentTime - startTime;
-                    const progress = Math.min(elapsed / duration, 1);
-                    const easedProgress = easeInOutCubic(progress);
-                    // Interpolate positions
-                    newPositions.forEach((newPos, nodeId) => {
-                        const oldPos = oldPositions.get(nodeId);
-                        if (!oldPos)
-                            return;
-                        const node = this.diagram.getNode(nodeId);
-                        if (!node)
-                            return;
-                        // Linear interpolation
-                        const x = oldPos.x + (newPos.x - oldPos.x) * easedProgress;
-                        const y = oldPos.y + (newPos.y - oldPos.y) * easedProgress;
-                        node.setPosition(x, y);
-                    });
-                    // Update link paths during animation
-                    this.recalculateLinkPaths();
-                    // Emit progress event for renderer to update
-                    this.diagram.markDirty();
-                    if (progress < 1) {
-                        requestAnimationFrame(animate);
-                    }
-                    else {
-                        resolve();
-                    }
-                };
-                requestAnimationFrame(animate);
-            });
-        });
-    }
-    /**
-     * Invalidate the routed polyline of every link whose endpoint nodes moved.
-     *
-     * Layout moves NODES; each link keeps the polyline it was routed on before.
-     * Edge labels are placed by walking that polyline (renderer LabelRenderer via
-     * link.getPointAtPosition), so a stale route strands labels at PRE-layout
-     * midpoints — observed live with labels sitting off-canvas at the old world
-     * coordinates. `setPoints([])` is the proven trigger for a re-route on the
-     * next paint (and it marks the link dirty, busting the VNode cache).
-     *
-     * Manual waypoints are cleared with the route — they were authored against
-     * the pre-layout coordinates (same rule as setPathType / setRouter).
-     */
-    invalidateRoutesForMovedNodes(before) {
-        const moved = new Set();
-        this.diagram.getNodes().forEach((node) => {
-            const prev = before.get(node.id);
-            if (!prev || prev.x !== node.position.x || prev.y !== node.position.y) {
-                moved.add(node.id);
-            }
-        });
-        if (moved.size === 0)
-            return;
-        const nodeIdForPort = (portId) => { var _a; return (_a = this.diagram.getNodes().find((n) => n.getPorts().some((p) => p.id === portId))) === null || _a === void 0 ? void 0 : _a.id; };
-        this.diagram.getLinks().forEach((link) => {
-            var _a, _b;
-            const sourceId = (_a = link.sourceNodeId) !== null && _a !== void 0 ? _a : nodeIdForPort(link.sourcePortId);
-            const targetId = (_b = link.targetNodeId) !== null && _b !== void 0 ? _b : nodeIdForPort(link.targetPortId);
-            if (!(sourceId && moved.has(sourceId)) && !(targetId && moved.has(targetId))) {
-                return;
-            }
-            if (link.points.length > 0) {
-                link.setPoints([]);
-            }
-            if (link.getMetadata('hasManualWaypoints') === true) {
-                link.setMetadata('hasManualWaypoints', false);
-            }
-        });
-    }
-    /**
-     * Recalculate all link paths based on current node/port positions
-     *
-     * CRITICAL: This must be called after moving nodes programmatically (e.g., layout algorithms)
-     * because links don't automatically update their paths when nodes move.
-     *
-     * How it works:
-     * 1. Get all links in the diagram
-     * 2. For each link, find its source and target ports
-     * 3. Calculate port absolute positions based on current node positions
-     * 4. Call link.generatePath() to recalculate the path points
-     */
-    recalculateLinkPaths() {
-        const links = this.diagram.getLinks();
-        let recalculated = 0;
-        links.forEach((link) => {
-            var _a, _b;
-            // Find source and target nodes
-            const sourceNode = this.diagram.getNodes().find((n) => n.getPorts().some((p) => p.id === link.sourcePortId));
-            const targetNode = this.diagram.getNodes().find((n) => n.getPorts().some((p) => p.id === link.targetPortId));
-            if (!sourceNode || !targetNode) {
-                console.warn(`⚠️ Link ${link.id} missing source or target node`);
-                return;
-            }
-            // Find the actual port objects
-            const sourcePort = sourceNode.getPorts().find((p) => p.id === link.sourcePortId);
-            const targetPort = targetNode.getPorts().find((p) => p.id === link.targetPortId);
-            if (!sourcePort || !targetPort) {
-                console.warn(`⚠️ Link ${link.id} missing source or target port`);
-                return;
-            }
-            // Get node bounding boxes
-            const sourceBounds = sourceNode.getBoundingBox();
-            const targetBounds = targetNode.getBoundingBox();
-            // Calculate absolute port positions
-            const sourcePoint = sourcePort.getAbsolutePosition(sourceBounds);
-            const targetPoint = targetPort.getAbsolutePosition(targetBounds);
-            // Get port directions for orthogonal routing
-            const sourceDirection = (_a = sourcePort.alignment) === null || _a === void 0 ? void 0 : _a.side;
-            const targetDirection = (_b = targetPort.alignment) === null || _b === void 0 ? void 0 : _b.side;
-            // Regenerate the link path with new port positions and directions
-            link.generatePath(sourcePoint, targetPoint, sourceDirection, targetDirection);
-            link.markDirty(); // Force re-render
-            recalculated++;
-        });
-        console.log(`🔗 Recalculated ${recalculated} link paths after layout`);
-    }
-    /**
-     * Phase 0.5.2 Enhanced: Select optimal ports based on layout-aware algorithm
-     *
-     * Uses layout-aware analysis based on academic research:
-     * - Considers layout direction (TB/LR/RL/BT)
-     * - Classifies edges as forward/backward/cross relative to layout flow
-     * - Uses hierarchical rank information when available
-     * - Falls back to geometric analysis for non-hierarchical layouts
-     *
-     * Algorithm based on "Drawing Layered Graphs with Port Constraints" (Spönemann et al., 2013)
-     *
-     * @param sourceNode - The source node
-     * @param targetNode - The target node
-     * @param layoutContext - Optional layout context with direction and rank information
-     * @returns Object containing optimal source and target ports, or undefined if not found
-     */
-    selectOptimalPorts(sourceNode, targetNode, layoutContext) {
-        var _a, _b;
-        // Get node centers for geometric calculations
-        const sourceBounds = sourceNode.getBoundingBox();
-        const targetBounds = targetNode.getBoundingBox();
-        const sourceCenter = {
-            x: sourceBounds.left + sourceBounds.width / 2,
-            y: sourceBounds.top + sourceBounds.height / 2,
-        };
-        const targetCenter = {
-            x: targetBounds.left + targetBounds.width / 2,
-            y: targetBounds.top + targetBounds.height / 2,
-        };
-        // Calculate relative position
-        const dx = targetCenter.x - sourceCenter.x;
-        const dy = targetCenter.y - sourceCenter.y;
-        let sourceSide;
-        let targetSide;
-        // ENHANCED: Layout-aware port selection
-        if ((layoutContext === null || layoutContext === void 0 ? void 0 : layoutContext.direction) && (layoutContext === null || layoutContext === void 0 ? void 0 : layoutContext.ranks)) {
-            const direction = layoutContext.direction;
-            // Get node ranks to classify edge type
-            const sourceRank = (_a = layoutContext.ranks.get(sourceNode.id)) !== null && _a !== void 0 ? _a : 0;
-            const targetRank = (_b = layoutContext.ranks.get(targetNode.id)) !== null && _b !== void 0 ? _b : 0;
-            // Classify edge type relative to layout flow
-            const isForward = targetRank > sourceRank; // Edge flows with layout direction
-            const isBackward = targetRank < sourceRank; // Edge flows against layout direction
-            const isCross = targetRank === sourceRank; // Edge between nodes at same rank
-            // Apply layer-based port assignment algorithm
-            if (direction === 'TB' || direction === 'BT') {
-                // Vertical layout (Top-to-Bottom or Bottom-to-Top)
-                if (isForward) {
-                    // Forward edge: consider position offset for branching nodes
-                    // Calculate offset ratio to detect if target is significantly to the side
-                    const parallelOffset = Math.abs(dy);
-                    const perpendicularOffset = Math.abs(dx);
-                    const offsetRatio = parallelOffset > 0 ? perpendicularOffset / parallelOffset : 0;
-                    // Threshold: if perpendicular offset > 20% of parallel offset, use side ports
-                    // This handles decision nodes with branches going left/right
-                    if (offsetRatio > 0.2 && perpendicularOffset > 10) {
-                        // Target is significantly to the side → use left/right ports for source
-                        sourceSide = dx > 0 ? 'right' : 'left';
-                        // Target port should face the source direction
-                        // Check if source is more above/below or more left/right
-                        if (Math.abs(dy) > Math.abs(dx)) {
-                            // Source is more above/below → target uses top/bottom
-                            targetSide = 'top'; // Since dy > 0 in TB layout (source is above)
-                        }
-                        else {
-                            // Source is more to the left/right → target uses left/right
-                            targetSide = dx > 0 ? 'left' : 'right';
-                        }
-                    }
-                    else {
-                        // Target is mostly below → use bottom port (standard forward edge)
-                        sourceSide = 'bottom';
-                        targetSide = 'top';
-                    }
-                }
-                else if (isBackward) {
-                    // Backward edge (cycle): source connects from top, target from bottom
-                    sourceSide = 'top';
-                    targetSide = 'bottom';
-                }
-                else {
-                    // Cross edge (same rank): use horizontal ports based on relative position
-                    if (dx > 0) {
-                        sourceSide = 'right';
-                        targetSide = 'left';
-                    }
-                    else if (dx < 0) {
-                        sourceSide = 'left';
-                        targetSide = 'right';
-                    }
-                    else {
-                        // Nodes at exact same position - use bottom→top as default
-                        sourceSide = 'bottom';
-                        targetSide = 'top';
-                    }
-                }
-            }
-            else {
-                // Horizontal layout (Left-to-Right or Right-to-Left)
-                if (isForward) {
-                    // Forward edge: consider position offset for branching nodes
-                    // Calculate offset ratio to detect if target is significantly above/below
-                    const parallelOffset = Math.abs(dx);
-                    const perpendicularOffset = Math.abs(dy);
-                    const offsetRatio = parallelOffset > 0 ? perpendicularOffset / parallelOffset : 0;
-                    // Threshold: if perpendicular offset > 20% of parallel offset, use side ports
-                    // This handles decision nodes with branches going up/down
-                    if (offsetRatio > 0.2 && perpendicularOffset > 10) {
-                        // Target is significantly above/below → use top/bottom ports for source
-                        sourceSide = dy > 0 ? 'bottom' : 'top';
-                        // Target port should face the source direction
-                        // If source is to the left (dx > 0), target uses left port
-                        // But also check vertical alignment - if source is above/below, use top/bottom
-                        if (Math.abs(dx) > Math.abs(dy)) {
-                            // Source is more to the left/right → target uses left/right
-                            targetSide = 'left'; // Since dx > 0 in LR layout (source is to the left)
-                        }
-                        else {
-                            // Source is more above/below → target uses top/bottom
-                            targetSide = dy > 0 ? 'top' : 'bottom';
-                        }
-                    }
-                    else {
-                        // Target is mostly to the right → use right port (standard forward edge)
-                        sourceSide = 'right';
-                        targetSide = 'left';
-                    }
-                }
-                else if (isBackward) {
-                    // Backward edge (cycle): source connects from left, target from right
-                    sourceSide = 'left';
-                    targetSide = 'right';
-                }
-                else {
-                    // Cross edge (same rank): use vertical ports based on relative position
-                    if (dy > 0) {
-                        sourceSide = 'bottom';
-                        targetSide = 'top';
-                    }
-                    else if (dy < 0) {
-                        sourceSide = 'top';
-                        targetSide = 'bottom';
-                    }
-                    else {
-                        // Nodes at exact same position - use right→left as default
-                        sourceSide = 'right';
-                        targetSide = 'left';
-                    }
-                }
-            }
-        }
-        else {
-            // FALLBACK: Geometric port selection (original algorithm)
-            // Used when layout context is not available
-            const isHorizontal = Math.abs(dx) > Math.abs(dy);
-            if (isHorizontal) {
-                // Horizontal connection
-                if (dx > 0) {
-                    sourceSide = 'right';
-                    targetSide = 'left';
-                }
-                else {
-                    sourceSide = 'left';
-                    targetSide = 'right';
-                }
-            }
-            else {
-                // Vertical connection
-                if (dy > 0) {
-                    sourceSide = 'bottom';
-                    targetSide = 'top';
-                }
-                else {
-                    sourceSide = 'top';
-                    targetSide = 'bottom';
-                }
-            }
-        }
-        // Get ports by the determined sides
-        const sourcePort = sourceNode.getPortBySide(sourceSide);
-        const targetPort = targetNode.getPortBySide(targetSide);
-        if (!sourcePort || !targetPort) {
-            console.warn(`⚠️ Could not find optimal ports for nodes ${sourceNode.id} → ${targetNode.id}`);
-            return undefined;
-        }
-        return { sourcePort, targetPort };
-    }
-    /**
-     * Phase 0.5.2 Enhanced: Optimize all connections after layout
-     *
-     * Reassigns ports for all links based on current node positions and layout context.
-     * This ensures connections look natural after layout algorithms reposition nodes.
-     *
-     * Now public and layout-aware - uses hierarchical rank information when available
-     * to apply academic research-based port assignment (Spönemann et al., 2013).
-     *
-     * @param layoutContext - Optional layout context with direction and rank information
-     * @returns Number of connections optimized
-     */
-    optimizeConnections(layoutContext) {
-        const links = this.diagram.getLinks();
-        let optimized = 0;
-        links.forEach((link) => {
-            // Find source and target nodes
-            const sourceNode = this.diagram.getNodes().find((n) => n.getPorts().some((p) => p.id === link.sourcePortId));
-            const targetNode = this.diagram.getNodes().find((n) => n.getPorts().some((p) => p.id === link.targetPortId));
-            if (!sourceNode || !targetNode) {
-                return; // Skip if nodes not found
-            }
-            // Select optimal ports with layout context
-            const optimalPorts = this.selectOptimalPorts(sourceNode, targetNode, layoutContext);
-            if (optimalPorts) {
-                const { sourcePort, targetPort } = optimalPorts;
-                // Only reassign if ports changed
-                if (link.sourcePortId !== sourcePort.id || link.targetPortId !== targetPort.id) {
-                    // Remove connection from old ports
-                    const oldSourcePort = sourceNode.getPorts().find((p) => p.id === link.sourcePortId);
-                    const oldTargetPort = targetNode.getPorts().find((p) => p.id === link.targetPortId);
-                    if (oldSourcePort) {
-                        oldSourcePort.removeConnection(link.id);
-                    }
-                    if (oldTargetPort) {
-                        oldTargetPort.removeConnection(link.id);
-                    }
-                    // Update link with new ports
-                    link.setSourcePort(sourcePort.id, sourceNode.id);
-                    link.setTargetPort(targetPort.id, targetNode.id);
-                    // Add connection to new ports
-                    sourcePort.addConnection(link.id, 'source');
-                    targetPort.addConnection(link.id, 'target');
-                    optimized++;
-                }
-            }
-        });
-        if (optimized > 0) {
-            const contextInfo = (layoutContext === null || layoutContext === void 0 ? void 0 : layoutContext.direction)
-                ? ` using layout-aware algorithm (${layoutContext.direction})`
-                : ' using geometric algorithm';
-            console.log(`🎯 Optimized ${optimized} connections${contextInfo}`);
-        }
-        return optimized;
-    }
-    /**
-     * Configure current layout algorithm
-     */
-    configure(config) {
-        this.currentAlgorithm.configure(config);
-    }
-    /**
-     * Get current configuration
-     */
-    getConfiguration() {
-        return this.currentAlgorithm.getConfiguration();
-    }
-    /**
-     * Subscribe to layout events
-     */
-    on(eventType, callback) {
-        if (!this.eventListeners.has(eventType)) {
-            this.eventListeners.set(eventType, []);
-        }
-        this.eventListeners.get(eventType).push(callback);
-    }
-    /**
-     * Unsubscribe from layout events
-     */
-    off(eventType, callback) {
-        const listeners = this.eventListeners.get(eventType);
-        if (listeners) {
-            const index = listeners.indexOf(callback);
-            if (index > -1) {
-                listeners.splice(index, 1);
-            }
-        }
-    }
-    /**
-     * Emit layout event
-     */
-    emitEvent(event) {
-        const listeners = this.eventListeners.get(event.type);
-        if (listeners) {
-            listeners.forEach((callback) => callback(event));
-        }
-        // Also emit to wildcard listeners
-        const wildcardListeners = this.eventListeners.get('*');
-        if (wildcardListeners) {
-            wildcardListeners.forEach((callback) => callback(event));
-        }
-    }
-    /**
-     * Clean up resources
-     */
-    dispose() {
-        var _a, _b;
-        (_b = (_a = this.currentAlgorithm).onDeactivate) === null || _b === void 0 ? void 0 : _b.call(_a);
-        this.eventListeners.clear();
-    }
-}
-exports.LayoutManager = LayoutManager;
-//# sourceMappingURL=LayoutManager.js.map