@grafloria/element 0.3.20 → 0.3.22

package/src/libs/engine/src/layout/algorithms/HierarchicalLayoutAlgorithm.js

@@ -1,307 +0,0 @@
-"use strict";
-/**
- * Hierarchical Layout Algorithm
- *
- * Uses Dagre library to create hierarchical/layered layouts for directed graphs.
- * Perfect for:
- * - Flowcharts
- * - Process diagrams
- * - Decision trees
- * - Organizational charts
- * - Any directed acyclic graph (DAG)
- *
- * Features:
- * - Respects edge direction (parent → child flow)
- * - Minimizes edge crossings
- * - Clear visual hierarchy
- * - Configurable direction (TB, BT, LR, RL)
- * - Professional appearance
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HierarchicalLayoutAlgorithm = void 0;
-const dagre = require("@dagrejs/dagre");
-const ILayoutAlgorithm_1 = require("../ILayoutAlgorithm");
-const ViewportTransform_1 = require("../ViewportTransform");
-const SmartSpacingCalculator_1 = require("../SmartSpacingCalculator");
-class HierarchicalLayoutAlgorithm extends ILayoutAlgorithm_1.BaseLayoutAlgorithm {
-    constructor(config) {
-        super(config);
-        this.hierarchicalOptions = (config === null || config === void 0 ? void 0 : config.options) || {};
-    }
-    getName() {
-        return 'Hierarchical Layout';
-    }
-    getType() {
-        return 'hierarchical';
-    }
-    /**
-     * Calculate placement for a single new node
-     * For hierarchical layout, we'll place it near connected nodes
-     */
-    calculatePlacement(options) {
-        var _a, _b;
-        const { node, viewport, existingNodes, spacing = this.hierarchicalOptions.nodeSpacing || 50, padding = 100, } = options;
-        // Get node dimensions
-        const nodeWidth = ((_a = node.size) === null || _a === void 0 ? void 0 : _a.width) || 200;
-        const nodeHeight = ((_b = node.size) === null || _b === void 0 ? void 0 : _b.height) || 100;
-        // If no existing nodes, place at start position
-        if (existingNodes.length === 0) {
-            return {
-                position: { x: padding, y: padding },
-                success: true,
-                metadata: {
-                    reason: 'First node in diagram',
-                },
-            };
-        }
-        // Find connected nodes (nodes this node links to or from)
-        const connectedNodes = this.findConnectedNodes(node, existingNodes);
-        if (connectedNodes.length > 0) {
-            // Place near connected nodes
-            const avgPosition = this.calculateAveragePosition(connectedNodes);
-            // Offset below the average position (assuming top-to-bottom flow)
-            const direction = this.hierarchicalOptions.direction || 'TB';
-            let candidate;
-            switch (direction) {
-                case 'TB': // Top to bottom
-                    candidate = {
-                        x: avgPosition.x,
-                        y: avgPosition.y + nodeHeight + spacing,
-                    };
-                    break;
-                case 'BT': // Bottom to top
-                    candidate = {
-                        x: avgPosition.x,
-                        y: avgPosition.y - nodeHeight - spacing,
-                    };
-                    break;
-                case 'LR': // Left to right
-                    candidate = {
-                        x: avgPosition.x + nodeWidth + spacing,
-                        y: avgPosition.y,
-                    };
-                    break;
-                case 'RL': // Right to left
-                    candidate = {
-                        x: avgPosition.x - nodeWidth - spacing,
-                        y: avgPosition.y,
-                    };
-                    break;
-                default:
-                    candidate = avgPosition;
-            }
-            // Check for collisions and adjust if needed
-            if (!this.hasCollision(candidate, { width: nodeWidth, height: nodeHeight }, existingNodes, spacing)) {
-                return {
-                    position: candidate,
-                    success: true,
-                    metadata: {
-                        reason: `Placed near ${connectedNodes.length} connected node(s)`,
-                    },
-                };
-            }
-        }
-        // Fallback: Place at next available position
-        const bounds = this.calculateBounds(existingNodes);
-        if (bounds) {
-            const direction = this.hierarchicalOptions.direction || 'TB';
-            let fallbackPosition;
-            switch (direction) {
-                case 'TB':
-                    fallbackPosition = {
-                        x: bounds.minX,
-                        y: bounds.maxY + spacing,
-                    };
-                    break;
-                case 'BT':
-                    fallbackPosition = {
-                        x: bounds.minX,
-                        y: bounds.minY - nodeHeight - spacing,
-                    };
-                    break;
-                case 'LR':
-                    fallbackPosition = {
-                        x: bounds.maxX + spacing,
-                        y: bounds.minY,
-                    };
-                    break;
-                case 'RL':
-                    fallbackPosition = {
-                        x: bounds.minX - nodeWidth - spacing,
-                        y: bounds.minY,
-                    };
-                    break;
-                default:
-                    fallbackPosition = { x: bounds.maxX + spacing, y: bounds.minY };
-            }
-            return {
-                position: fallbackPosition,
-                success: true,
-                metadata: {
-                    reason: 'Placed at next available position',
-                },
-            };
-        }
-        // Ultimate fallback
-        return {
-            position: { x: padding, y: padding },
-            success: true,
-        };
-    }
-    /**
-     * Re-layout all nodes using Dagre
-     */
-    reLayout(diagram, config) {
-        if (config) {
-            this.configure(config);
-        }
-        const nodes = diagram.getNodes();
-        const links = diagram.getLinks();
-        const positions = new Map();
-        if (nodes.length === 0) {
-            return positions;
-        }
-        // Use viewport from config if provided, otherwise fallback to default
-        const viewport = (config === null || config === void 0 ? void 0 : config.viewport) || { x: 0, y: 0, width: 1200, height: 800 };
-        // Calculate smart spacing for hierarchical layout
-        const smartSpacing = (0, SmartSpacingCalculator_1.calculateHierarchicalSmartSpacing)({
-            viewport,
-            nodeCount: nodes.length,
-            zoom: viewport.zoom || 1.0, // Zoom might be on viewport from config
-        });
-        // Use smart spacing (fallback to manual config if provided)
-        const nodeSpacing = this.hierarchicalOptions.nodeSpacing || smartSpacing.horizontal;
-        const rankSpacing = this.hierarchicalOptions.rankSpacing || smartSpacing.vertical;
-        // Create Dagre graph
-        const g = new dagre.graphlib.Graph();
-        // Set graph options with smart spacing
-        g.setGraph({
-            rankdir: this.hierarchicalOptions.direction || 'TB',
-            nodesep: nodeSpacing,
-            ranksep: rankSpacing,
-            marginx: 20,
-            marginy: 20,
-        });
-        // Default to assigning a new object as a label for each new edge
-        g.setDefaultEdgeLabel(() => ({}));
-        // Add nodes to Dagre graph
-        nodes.forEach((node) => {
-            var _a, _b;
-            g.setNode(node.id, {
-                label: node.getMetadata('label') || node.id,
-                width: ((_a = node.size) === null || _a === void 0 ? void 0 : _a.width) || 200,
-                height: ((_b = node.size) === null || _b === void 0 ? void 0 : _b.height) || 100,
-            });
-        });
-        // Add edges to Dagre graph
-        links.forEach((link) => {
-            if (link.sourceNodeId && link.targetNodeId) {
-                g.setEdge(link.sourceNodeId, link.targetNodeId);
-            }
-        });
-        // Run Dagre layout
-        dagre.layout(g);
-        // Extract positions from Dagre (in relative space)
-        const relativePositions = [];
-        nodes.forEach((node) => {
-            const dagreNode = g.node(node.id);
-            if (dagreNode) {
-                // Dagre returns center position, convert to top-left
-                const relativePos = {
-                    x: dagreNode.x - dagreNode.width / 2,
-                    y: dagreNode.y - dagreNode.height / 2,
-                };
-                relativePositions.push({ node, position: relativePos });
-            }
-        });
-        // Phase 0.5: Apply viewport transform if viewport is provided
-        if (config === null || config === void 0 ? void 0 : config.viewport) {
-            // Calculate bounding box of layout
-            const layoutBounds = (0, ViewportTransform_1.calculateNodeBounds)(relativePositions.map(({ node, position }) => ({
-                position,
-                size: node.size || { width: 200, height: 100 }
-            })));
-            // Calculate transform to fit in viewport
-            const transform = (0, ViewportTransform_1.calculateViewportTransform)(layoutBounds, config.viewport, config.margins || 50);
-            // Apply transform to all positions
-            relativePositions.forEach(({ node, position }) => {
-                const transformedPos = (0, ViewportTransform_1.applyTransform)(position, transform);
-                positions.set(node.id, transformedPos);
-            });
-            console.log(`📐 Hierarchical layout: ${nodes.length} nodes fit in viewport (scale: ${transform.scale.toFixed(2)}, node-spacing: ${nodeSpacing}px, rank-spacing: ${rankSpacing}px)`);
-        }
-        else {
-            // No viewport - use relative positions as-is (backward compatibility)
-            relativePositions.forEach(({ node, position }) => {
-                positions.set(node.id, position);
-            });
-        }
-        return positions;
-    }
-    /**
-     * Configure hierarchical-specific options
-     */
-    configure(config) {
-        super.configure(config);
-        if (config.options) {
-            this.hierarchicalOptions = Object.assign(Object.assign({}, this.hierarchicalOptions), config.options);
-        }
-    }
-    /**
-     * Hierarchical layout works best on DAGs but can handle any graph
-     */
-    canApply(diagram) {
-        const links = diagram.getLinks();
-        if (links.length === 0) {
-            return {
-                valid: true,
-                reason: 'No edges - will arrange nodes in layers',
-            };
-        }
-        // Check for cycles (optional warning, not blocking)
-        const hasCycles = this.detectCycles(diagram);
-        if (hasCycles) {
-            return {
-                valid: true,
-                reason: 'Graph has cycles - Dagre will break them automatically',
-            };
-        }
-        return { valid: true };
-    }
-    /**
-     * Find nodes that are connected to the given node
-     */
-    findConnectedNodes(node, allNodes) {
-        // This is a simplified version - in real implementation,
-        // we'd check the diagram's links to find actual connections
-        return [];
-    }
-    /**
-     * Calculate average position of nodes
-     */
-    calculateAveragePosition(nodes) {
-        if (nodes.length === 0) {
-            return { x: 100, y: 100 };
-        }
-        let sumX = 0;
-        let sumY = 0;
-        nodes.forEach((node) => {
-            sumX += node.position.x;
-            sumY += node.position.y;
-        });
-        return {
-            x: sumX / nodes.length,
-            y: sumY / nodes.length,
-        };
-    }
-    /**
-     * Detect cycles in the graph (simplified DFS approach)
-     */
-    detectCycles(diagram) {
-        // Simplified - just return false for now
-        // In a complete implementation, we'd do a DFS to detect cycles
-        return false;
-    }
-}
-exports.HierarchicalLayoutAlgorithm = HierarchicalLayoutAlgorithm;
-//# sourceMappingURL=HierarchicalLayoutAlgorithm.js.map

package/src/libs/engine/src/layout/algorithms/HybridLayoutAlgorithm.d.ts

@@ -1,62 +0,0 @@
-import { BaseLayoutAlgorithm, type ILayoutAlgorithm } from '../ILayoutAlgorithm';
-import type { PlacementOptions, PlacementResult, LayoutConfiguration, HybridOptions } from '../types';
-import type { DiagramModel } from '../../models/DiagramModel';
-import type { Point } from '../../types';
-type DetectedPattern = 'grid' | 'tree' | 'network' | 'sparse';
-/**
- * HybridLayoutAlgorithm
- *
- * Intelligent layout algorithm that:
- * - Analyzes the diagram structure
- * - Detects patterns (grid, tree, network, sparse)
- * - Automatically selects the best algorithm
- * - Delegates to the chosen algorithm
- *
- * Pattern Detection:
- * - Grid: Few or no edges, uniform structure
- * - Tree/Hierarchy: Acyclic, directional flow
- * - Network: Dense connections, cycles
- * - Sparse: Few nodes, simple connections
- *
- * Best for:
- * - Dynamic diagrams where structure changes
- * - Mixed diagram types
- * - When user doesn't want to choose algorithm
- */
-export declare class HybridLayoutAlgorithm extends BaseLayoutAlgorithm implements ILayoutAlgorithm {
-    private hybridOptions;
-    private gridAlgorithm;
-    private hierarchicalAlgorithm;
-    private forceDirectedAlgorithm;
-    private lastDetectedPattern?;
-    constructor(options?: HybridOptions);
-    getName(): string;
-    getType(): 'hybrid';
-    configure(config: LayoutConfiguration): void;
-    getConfiguration(): LayoutConfiguration;
-    canApply(diagram: DiagramModel): {
-        valid: boolean;
-        reason?: string;
-    };
-    /**
-     * Analyze diagram structure and detect pattern
-     */
-    private analyzePattern;
-    /**
-     * Detect cycles in graph using DFS
-     */
-    private detectCycles;
-    /**
-     * Count connected components using BFS
-     */
-    private countConnectedComponents;
-    calculatePlacement(options: PlacementOptions): PlacementResult;
-    reLayout(diagram: DiagramModel, config?: LayoutConfiguration): Map<string, Point>;
-    onActivate(): void;
-    onDeactivate(): void;
-    /**
-     * Get the last detected pattern (useful for debugging/UI)
-     */
-    getLastDetectedPattern(): DetectedPattern | undefined;
-}
-export {};

package/src/libs/engine/src/layout/algorithms/HybridLayoutAlgorithm.js

@@ -1,324 +0,0 @@
-"use strict";
-// HybridLayoutAlgorithm - Intelligent pattern detection and algorithm selection
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HybridLayoutAlgorithm = void 0;
-const ILayoutAlgorithm_1 = require("../ILayoutAlgorithm");
-const GridLayoutAlgorithm_1 = require("./GridLayoutAlgorithm");
-const HierarchicalLayoutAlgorithm_1 = require("./HierarchicalLayoutAlgorithm");
-const ForceDirectedLayoutAlgorithm_1 = require("./ForceDirectedLayoutAlgorithm");
-/**
- * HybridLayoutAlgorithm
- *
- * Intelligent layout algorithm that:
- * - Analyzes the diagram structure
- * - Detects patterns (grid, tree, network, sparse)
- * - Automatically selects the best algorithm
- * - Delegates to the chosen algorithm
- *
- * Pattern Detection:
- * - Grid: Few or no edges, uniform structure
- * - Tree/Hierarchy: Acyclic, directional flow
- * - Network: Dense connections, cycles
- * - Sparse: Few nodes, simple connections
- *
- * Best for:
- * - Dynamic diagrams where structure changes
- * - Mixed diagram types
- * - When user doesn't want to choose algorithm
- */
-class HybridLayoutAlgorithm extends ILayoutAlgorithm_1.BaseLayoutAlgorithm {
-    constructor(options) {
-        super();
-        this.hybridOptions = Object.assign({ fallbackAlgorithm: 'grid', enableAutoSwitch: true, analysisThreshold: 0.7 }, options);
-        // Initialize sub-algorithms
-        this.gridAlgorithm = new GridLayoutAlgorithm_1.GridLayoutAlgorithm();
-        this.hierarchicalAlgorithm = new HierarchicalLayoutAlgorithm_1.HierarchicalLayoutAlgorithm();
-        this.forceDirectedAlgorithm = new ForceDirectedLayoutAlgorithm_1.ForceDirectedLayoutAlgorithm();
-    }
-    getName() {
-        return 'Hybrid Layout (Auto)';
-    }
-    getType() {
-        return 'hybrid';
-    }
-    configure(config) {
-        if (config.options) {
-            this.hybridOptions = Object.assign(Object.assign({}, this.hybridOptions), config.options);
-        }
-        // Pass configuration to sub-algorithms
-        const hybridOpts = config.options;
-        if (hybridOpts === null || hybridOpts === void 0 ? void 0 : hybridOpts.gridOptions) {
-            this.gridAlgorithm.configure({ type: 'grid', options: hybridOpts.gridOptions });
-        }
-        if (hybridOpts === null || hybridOpts === void 0 ? void 0 : hybridOpts.hierarchicalOptions) {
-            this.hierarchicalAlgorithm.configure({
-                type: 'hierarchical',
-                options: hybridOpts.hierarchicalOptions,
-            });
-        }
-        if (hybridOpts === null || hybridOpts === void 0 ? void 0 : hybridOpts.forceDirectedOptions) {
-            this.forceDirectedAlgorithm.configure({
-                type: 'force-directed',
-                options: hybridOpts.forceDirectedOptions,
-            });
-        }
-    }
-    getConfiguration() {
-        return {
-            type: 'hybrid',
-            options: this.hybridOptions,
-        };
-    }
-    canApply(diagram) {
-        const nodes = diagram.getNodes();
-        if (nodes.length === 0) {
-            return { valid: false, reason: 'No nodes to layout' };
-        }
-        return { valid: true };
-    }
-    /**
-     * Analyze diagram structure and detect pattern
-     */
-    analyzePattern(diagram) {
-        const nodes = diagram.getNodes();
-        const links = diagram.getLinks();
-        const nodeCount = nodes.length;
-        const edgeCount = links.length;
-        // Calculate graph metrics
-        const density = nodeCount > 1 ? (2 * edgeCount) / (nodeCount * (nodeCount - 1)) : 0;
-        const avgDegree = nodeCount > 0 ? (2 * edgeCount) / nodeCount : 0;
-        // Build adjacency list
-        const adjacency = new Map();
-        const inDegree = new Map();
-        const outDegree = new Map();
-        nodes.forEach((node) => {
-            adjacency.set(node.id, new Set());
-            inDegree.set(node.id, 0);
-            outDegree.set(node.id, 0);
-        });
-        links.forEach((link) => {
-            var _a, _b;
-            if (link.sourceNodeId && link.targetNodeId) {
-                (_a = adjacency.get(link.sourceNodeId)) === null || _a === void 0 ? void 0 : _a.add(link.targetNodeId);
-                (_b = adjacency.get(link.targetNodeId)) === null || _b === void 0 ? void 0 : _b.add(link.sourceNodeId);
-                outDegree.set(link.sourceNodeId, (outDegree.get(link.sourceNodeId) || 0) + 1);
-                inDegree.set(link.targetNodeId, (inDegree.get(link.targetNodeId) || 0) + 1);
-            }
-        });
-        // Detect cycles using DFS
-        const hasCycles = this.detectCycles(adjacency, nodes.map((n) => n.id));
-        // Check if graph is directed (unequal in/out degrees)
-        let isDirected = false;
-        for (const nodeId of nodes.map((n) => n.id)) {
-            if (inDegree.get(nodeId) !== outDegree.get(nodeId)) {
-                isDirected = true;
-                break;
-            }
-        }
-        // Count connected components
-        const connectedComponents = this.countConnectedComponents(adjacency, nodes.map((n) => n.id));
-        // Pattern detection logic
-        let pattern;
-        let confidence;
-        let reason;
-        let recommendedAlgorithm;
-        // Rule 1: Very few or no edges -> Grid
-        if (edgeCount === 0 || density < 0.1) {
-            pattern = 'sparse';
-            confidence = 0.95;
-            reason = 'Few or no connections detected';
-            recommendedAlgorithm = 'grid';
-        }
-        // Rule 2: Acyclic + directed flow -> Tree/Hierarchy
-        else if (!hasCycles && isDirected && density < 0.4) {
-            pattern = 'tree';
-            confidence = 0.9;
-            reason = 'Acyclic directed graph detected (tree structure)';
-            recommendedAlgorithm = 'hierarchical';
-        }
-        // Rule 3: High connectivity or cycles -> Network
-        else if (hasCycles || density > 0.3 || avgDegree > 3) {
-            pattern = 'network';
-            confidence = 0.85;
-            reason = 'Dense network with cycles detected';
-            recommendedAlgorithm = 'force-directed';
-        }
-        // Rule 4: Medium connectivity, no clear pattern -> Network
-        else if (density >= 0.1 && density <= 0.3) {
-            pattern = 'network';
-            confidence = 0.7;
-            reason = 'Medium connectivity, using force-directed layout';
-            recommendedAlgorithm = 'force-directed';
-        }
-        // Fallback: Grid
-        else {
-            pattern = 'grid';
-            confidence = 0.6;
-            reason = 'No clear pattern detected, using grid layout';
-            recommendedAlgorithm = 'grid';
-        }
-        return {
-            pattern,
-            confidence,
-            reason,
-            recommendedAlgorithm,
-            metrics: {
-                nodeCount,
-                edgeCount,
-                density,
-                avgDegree,
-                hasCycles,
-                isDirected,
-                connectedComponents,
-            },
-        };
-    }
-    /**
-     * Detect cycles in graph using DFS
-     */
-    detectCycles(adjacency, nodeIds) {
-        const visited = new Set();
-        const recursionStack = new Set();
-        const dfs = (nodeId) => {
-            visited.add(nodeId);
-            recursionStack.add(nodeId);
-            const neighbors = adjacency.get(nodeId) || new Set();
-            for (const neighbor of neighbors) {
-                if (!visited.has(neighbor)) {
-                    if (dfs(neighbor))
-                        return true;
-                }
-                else if (recursionStack.has(neighbor)) {
-                    return true; // Back edge found (cycle)
-                }
-            }
-            recursionStack.delete(nodeId);
-            return false;
-        };
-        for (const nodeId of nodeIds) {
-            if (!visited.has(nodeId)) {
-                if (dfs(nodeId))
-                    return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Count connected components using BFS
-     */
-    countConnectedComponents(adjacency, nodeIds) {
-        const visited = new Set();
-        let components = 0;
-        const bfs = (startId) => {
-            const queue = [startId];
-            visited.add(startId);
-            while (queue.length > 0) {
-                const nodeId = queue.shift();
-                const neighbors = adjacency.get(nodeId) || new Set();
-                for (const neighbor of neighbors) {
-                    if (!visited.has(neighbor)) {
-                        visited.add(neighbor);
-                        queue.push(neighbor);
-                    }
-                }
-            }
-        };
-        for (const nodeId of nodeIds) {
-            if (!visited.has(nodeId)) {
-                bfs(nodeId);
-                components++;
-            }
-        }
-        return components;
-    }
-    calculatePlacement(options) {
-        // For single node placement, we need to consider existing structure
-        const { existingNodes } = options;
-        // If no existing nodes, just use grid
-        if (existingNodes.length === 0) {
-            return this.gridAlgorithm.calculatePlacement(options);
-        }
-        // Quick heuristic: if we have a last detected pattern, use that algorithm
-        if (this.lastDetectedPattern) {
-            switch (this.lastDetectedPattern) {
-                case 'grid':
-                case 'sparse':
-                    return this.gridAlgorithm.calculatePlacement(options);
-                case 'tree':
-                    return this.hierarchicalAlgorithm.calculatePlacement(options);
-                case 'network':
-                    return this.forceDirectedAlgorithm.calculatePlacement(options);
-            }
-        }
-        // Fallback to grid for single placement
-        return this.gridAlgorithm.calculatePlacement(options);
-    }
-    reLayout(diagram, config) {
-        if (config) {
-            this.configure(config);
-        }
-        // Analyze the diagram structure
-        const analysis = this.analyzePattern(diagram);
-        this.lastDetectedPattern = analysis.pattern;
-        console.log('🔍 Hybrid Layout Analysis:', {
-            pattern: analysis.pattern,
-            confidence: `${(analysis.confidence * 100).toFixed(0)}%`,
-            reason: analysis.reason,
-            algorithm: analysis.recommendedAlgorithm,
-            metrics: analysis.metrics,
-        });
-        // Select and apply algorithm based on analysis
-        let positions;
-        if (analysis.confidence >= (this.hybridOptions.analysisThreshold || 0.7)) {
-            switch (analysis.recommendedAlgorithm) {
-                case 'grid':
-                    console.log('📊 Applying Grid Layout');
-                    positions = this.gridAlgorithm.reLayout(diagram, config);
-                    break;
-                case 'hierarchical':
-                    console.log('🌳 Applying Hierarchical Layout');
-                    positions = this.hierarchicalAlgorithm.reLayout(diagram, config);
-                    break;
-                case 'force-directed':
-                    console.log('🧲 Applying Force-Directed Layout');
-                    positions = this.forceDirectedAlgorithm.reLayout(diagram, config);
-                    break;
-                default:
-                    positions = this.gridAlgorithm.reLayout(diagram, config);
-            }
-        }
-        else {
-            // Low confidence, use fallback
-            const fallback = this.hybridOptions.fallbackAlgorithm || 'grid';
-            console.log(`⚠️ Low confidence (${(analysis.confidence * 100).toFixed(0)}%), using fallback: ${fallback}`);
-            switch (fallback) {
-                case 'grid':
-                    positions = this.gridAlgorithm.reLayout(diagram, config);
-                    break;
-                case 'hierarchical':
-                    positions = this.hierarchicalAlgorithm.reLayout(diagram, config);
-                    break;
-                case 'force-directed':
-                    positions = this.forceDirectedAlgorithm.reLayout(diagram, config);
-                    break;
-                default:
-                    positions = this.gridAlgorithm.reLayout(diagram, config);
-            }
-        }
-        return positions;
-    }
-    onActivate() {
-        console.log('🎯 Hybrid layout activated (intelligent pattern detection)');
-    }
-    onDeactivate() {
-        console.log('🎯 Hybrid layout deactivated');
-    }
-    /**
-     * Get the last detected pattern (useful for debugging/UI)
-     */
-    getLastDetectedPattern() {
-        return this.lastDetectedPattern;
-    }
-}
-exports.HybridLayoutAlgorithm = HybridLayoutAlgorithm;
-//# sourceMappingURL=HybridLayoutAlgorithm.js.map