@grafloria/element 0.3.20 → 0.3.22

package/src/libs/engine/src/dsl/detector/LayoutDetector.js

@@ -1,333 +0,0 @@
-"use strict";
-/**
- * Layout Detector - Intelligently selects layout presets based on diagram characteristics
- *
- * Analyzes the diagram structure, AST metadata, and connection patterns
- * to automatically select the most appropriate layout algorithm.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LayoutDetector = void 0;
-class LayoutDetector {
-    /**
-     * Detect optimal layout for a diagram
-     */
-    detect(diagram, ast) {
-        const characteristics = this.analyzeCharacteristics(diagram, ast);
-        // Use diagram type and direction hints if available
-        if (ast === null || ast === void 0 ? void 0 : ast.diagramType) {
-            return this.detectFromDiagramType(ast.diagramType, characteristics, ast.direction);
-        }
-        // Fallback to structural analysis
-        return this.detectFromStructure(characteristics);
-    }
-    /**
-     * Detect layout based on diagram type
-     */
-    detectFromDiagramType(diagramType, characteristics, direction) {
-        switch (diagramType) {
-            case 'flowchart':
-                return this.detectFlowchartLayout(characteristics, direction);
-            case 'bpmn':
-                return this.detectBPMNLayout(characteristics, direction);
-            case 'erd':
-                return this.detectERDLayout(characteristics);
-            case 'classDiagram':
-                return this.detectClassDiagramLayout(characteristics);
-            default:
-                return this.detectFromStructure(characteristics);
-        }
-    }
-    /**
-     * Detect layout for flowcharts
-     */
-    detectFlowchartLayout(characteristics, direction) {
-        // Flowcharts typically use hierarchical or sequential layouts
-        if (characteristics.isTree) {
-            // Tree-like flowchart
-            if (direction === 'LR' || direction === 'RL') {
-                return {
-                    presetId: 'tree-left-to-right',
-                    confidence: 0.9,
-                    reasoning: 'Tree-structured flowchart with horizontal direction hint',
-                    alternatives: ['workflow-horizontal', 'data-flow'],
-                };
-            }
-            else {
-                return {
-                    presetId: 'tree-top-to-bottom',
-                    confidence: 0.9,
-                    reasoning: 'Tree-structured flowchart with vertical direction',
-                    alternatives: ['workflow-vertical', 'org-chart-compact'],
-                };
-            }
-        }
-        if (characteristics.isDAG) {
-            // DAG flowchart - use workflow layouts
-            if (direction === 'LR' || direction === 'RL') {
-                return {
-                    presetId: 'workflow-horizontal',
-                    confidence: 0.85,
-                    reasoning: 'Sequential flowchart with left-to-right flow',
-                    alternatives: ['data-flow', 'state-machine'],
-                };
-            }
-            else {
-                return {
-                    presetId: 'workflow-vertical',
-                    confidence: 0.85,
-                    reasoning: 'Sequential flowchart with top-to-bottom flow',
-                    alternatives: ['org-chart-spacious', 'component-diagram'],
-                };
-            }
-        }
-        // Cyclic flowchart
-        if (characteristics.hasCycles) {
-            return {
-                presetId: 'state-machine',
-                confidence: 0.8,
-                reasoning: 'Flowchart with cycles, likely a state machine or feedback loop',
-                alternatives: ['force-directed-balanced', 'workflow-horizontal'],
-            };
-        }
-        // Default horizontal workflow
-        return {
-            presetId: 'workflow-horizontal',
-            confidence: 0.75,
-            reasoning: 'General flowchart with horizontal layout',
-            alternatives: ['workflow-vertical', 'tree-left-to-right'],
-        };
-    }
-    /**
-     * Detect layout for BPMN diagrams
-     */
-    detectBPMNLayout(characteristics, direction) {
-        // BPMN typically uses horizontal workflows
-        if (direction === 'TB' || direction === 'BT') {
-            return {
-                presetId: 'workflow-vertical',
-                confidence: 0.85,
-                reasoning: 'BPMN process with vertical flow',
-                alternatives: ['component-diagram'],
-            };
-        }
-        return {
-            presetId: 'workflow-horizontal',
-            confidence: 0.9,
-            reasoning: 'BPMN process with standard left-to-right flow',
-            alternatives: ['data-flow', 'state-machine'],
-        };
-    }
-    /**
-     * Detect layout for ERD diagrams
-     */
-    detectERDLayout(characteristics) {
-        // ERD diagrams typically use force-directed or layered layouts
-        if (characteristics.nodeCount > 20) {
-            return {
-                presetId: 'force-directed-tight',
-                confidence: 0.8,
-                reasoning: 'Large ERD with many entities - compact force-directed layout',
-                alternatives: ['stress-minimization', 'force-directed-balanced'],
-            };
-        }
-        if (characteristics.nodeCount > 10) {
-            return {
-                presetId: 'force-directed-balanced',
-                confidence: 0.85,
-                reasoning: 'Medium ERD with balanced force-directed layout',
-                alternatives: ['stress-minimization', 'radial-center'],
-            };
-        }
-        return {
-            presetId: 'radial-center',
-            confidence: 0.8,
-            reasoning: 'Small ERD with radial layout around central entities',
-            alternatives: ['force-directed-balanced'],
-        };
-    }
-    /**
-     * Detect layout for class diagrams
-     */
-    detectClassDiagramLayout(characteristics) {
-        // Class diagrams often have inheritance hierarchies
-        if (characteristics.isTree || characteristics.maxDepth > 3) {
-            return {
-                presetId: 'tree-top-to-bottom',
-                confidence: 0.85,
-                reasoning: 'Class diagram with inheritance hierarchy',
-                alternatives: ['org-chart-spacious', 'component-diagram'],
-            };
-        }
-        return {
-            presetId: 'component-diagram',
-            confidence: 0.8,
-            reasoning: 'Class diagram with component-based layout',
-            alternatives: ['force-directed-balanced', 'microservices-layered'],
-        };
-    }
-    /**
-     * Detect layout from structure (fallback)
-     */
-    detectFromStructure(characteristics) {
-        // Hierarchical structures
-        if (characteristics.isTree) {
-            return {
-                presetId: 'tree-top-to-bottom',
-                confidence: 0.8,
-                reasoning: 'Tree structure detected',
-                alternatives: ['org-chart-compact', 'tree-left-to-right'],
-            };
-        }
-        // DAG structures
-        if (characteristics.isDAG) {
-            if (characteristics.maxDepth > 4) {
-                return {
-                    presetId: 'workflow-vertical',
-                    confidence: 0.75,
-                    reasoning: 'Deep DAG structure - vertical layout',
-                    alternatives: ['component-diagram', 'org-chart-spacious'],
-                };
-            }
-            else {
-                return {
-                    presetId: 'workflow-horizontal',
-                    confidence: 0.75,
-                    reasoning: 'Shallow DAG structure - horizontal workflow',
-                    alternatives: ['data-flow', 'microservices-layered'],
-                };
-            }
-        }
-        // Dense networks
-        if (characteristics.averageDegree > 4) {
-            return {
-                presetId: 'force-directed-tight',
-                confidence: 0.7,
-                reasoning: 'Dense network with many connections',
-                alternatives: ['stress-minimization', 'force-directed-balanced'],
-            };
-        }
-        // Sparse networks
-        if (characteristics.averageDegree < 2) {
-            return {
-                presetId: 'force-directed-balanced',
-                confidence: 0.7,
-                reasoning: 'Sparse network with few connections',
-                alternatives: ['radial-center', 'tree-top-to-bottom'],
-            };
-        }
-        // Default: force-directed for general graphs
-        return {
-            presetId: 'force-directed-balanced',
-            confidence: 0.65,
-            reasoning: 'General graph structure',
-            alternatives: ['stress-minimization', 'workflow-horizontal'],
-        };
-    }
-    /**
-     * Analyze diagram characteristics
-     */
-    analyzeCharacteristics(diagram, ast) {
-        var _a, _b;
-        const nodes = diagram.getNodes();
-        const links = diagram.getLinks();
-        const nodeCount = nodes.length;
-        const linkCount = links.length;
-        // Build adjacency lists
-        const outgoing = new Map();
-        const incoming = new Map();
-        for (const node of nodes) {
-            outgoing.set(node.id, new Set());
-            incoming.set(node.id, new Set());
-        }
-        for (const link of links) {
-            const sourceNode = diagram.getNode(link.sourceNodeId || '');
-            const targetNode = diagram.getNode(link.targetNodeId || '');
-            if (sourceNode && targetNode) {
-                (_a = outgoing.get(sourceNode.id)) === null || _a === void 0 ? void 0 : _a.add(targetNode.id);
-                (_b = incoming.get(targetNode.id)) === null || _b === void 0 ? void 0 : _b.add(sourceNode.id);
-            }
-        }
-        // Calculate degrees
-        const degrees = nodes.map((node) => { var _a, _b; return (((_a = outgoing.get(node.id)) === null || _a === void 0 ? void 0 : _a.size) || 0) + (((_b = incoming.get(node.id)) === null || _b === void 0 ? void 0 : _b.size) || 0); });
-        const averageDegree = degrees.reduce((a, b) => a + b, 0) / (nodeCount || 1);
-        const maxDegree = Math.max(...degrees, 0);
-        // Detect cycles using DFS
-        const hasCycles = this.detectCycles(nodes, outgoing);
-        // Calculate max depth (for trees/DAGs)
-        const maxDepth = this.calculateMaxDepth(nodes, outgoing, incoming);
-        // Check if tree
-        const isTree = !hasCycles && linkCount === nodeCount - 1;
-        // Check if DAG
-        const isDAG = !hasCycles;
-        return {
-            nodeCount,
-            linkCount,
-            hasCycles,
-            maxDepth,
-            averageDegree,
-            maxDegree,
-            isTree,
-            isDAG,
-            direction: ast === null || ast === void 0 ? void 0 : ast.direction,
-            diagramType: ast === null || ast === void 0 ? void 0 : ast.diagramType,
-        };
-    }
-    /**
-     * Detect cycles using DFS
-     */
-    detectCycles(nodes, outgoing) {
-        const visited = new Set();
-        const recursionStack = new Set();
-        const dfs = (nodeId) => {
-            visited.add(nodeId);
-            recursionStack.add(nodeId);
-            const neighbors = outgoing.get(nodeId);
-            if (neighbors) {
-                for (const neighbor of neighbors) {
-                    if (!visited.has(neighbor)) {
-                        if (dfs(neighbor))
-                            return true;
-                    }
-                    else if (recursionStack.has(neighbor)) {
-                        return true; // Cycle detected
-                    }
-                }
-            }
-            recursionStack.delete(nodeId);
-            return false;
-        };
-        for (const node of nodes) {
-            if (!visited.has(node.id)) {
-                if (dfs(node.id))
-                    return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Calculate maximum depth of the graph
-     */
-    calculateMaxDepth(nodes, outgoing, incoming) {
-        // Find root nodes (no incoming edges)
-        const roots = nodes.filter((node) => { var _a; return (((_a = incoming.get(node.id)) === null || _a === void 0 ? void 0 : _a.size) || 0) === 0; });
-        if (roots.length === 0) {
-            return 0; // No roots, likely cyclic
-        }
-        let maxDepth = 0;
-        const dfs = (nodeId, depth) => {
-            maxDepth = Math.max(maxDepth, depth);
-            const neighbors = outgoing.get(nodeId);
-            if (neighbors) {
-                for (const neighbor of neighbors) {
-                    dfs(neighbor, depth + 1);
-                }
-            }
-        };
-        for (const root of roots) {
-            dfs(root.id, 1);
-        }
-        return maxDepth;
-    }
-}
-exports.LayoutDetector = LayoutDetector;
-//# sourceMappingURL=LayoutDetector.js.map

package/src/libs/engine/src/dsl/extended/BPMNGenerator.d.ts

@@ -1,38 +0,0 @@
-/**
- * BPMN Generator - Generates BPMN flowchart DSL
- *
- * Converts DiagramModel with BPMN nodes into flowchart syntax.
- */
-import { DiagramModel } from '../../models/DiagramModel';
-export interface BPMNGeneratorOptions {
-    /**
-     * Include comments
-     */
-    includeComments?: boolean;
-    /**
-     * Direction (TD, LR, etc.)
-     */
-    direction?: 'TD' | 'TB' | 'LR' | 'RL';
-}
-export declare class BPMNGenerator {
-    /**
-     * Generate BPMN flowchart DSL
-     */
-    generate(diagram: DiagramModel, options?: BPMNGeneratorOptions): string;
-    /**
-     * Generate node definition
-     */
-    private generateNode;
-    /**
-     * Get brackets for BPMN node type
-     */
-    private getNodeBrackets;
-    /**
-     * Generate flow
-     */
-    private generateFlow;
-    /**
-     * Sanitize ID for DSL
-     */
-    private sanitizeId;
-}

package/src/libs/engine/src/dsl/extended/BPMNGenerator.js

@@ -1,90 +0,0 @@
-"use strict";
-/**
- * BPMN Generator - Generates BPMN flowchart DSL
- *
- * Converts DiagramModel with BPMN nodes into flowchart syntax.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BPMNGenerator = void 0;
-class BPMNGenerator {
-    /**
-     * Generate BPMN flowchart DSL
-     */
-    generate(diagram, options = {}) {
-        const { includeComments = true, direction = 'TD', } = options;
-        const lines = [];
-        // Header
-        if (includeComments) {
-            lines.push('%% BPMN Business Process Diagram');
-            lines.push('%%');
-        }
-        lines.push(`flowchart ${direction}`);
-        lines.push('');
-        // Generate nodes
-        const nodes = diagram.getNodes().filter(n => n.type.startsWith('bpmn:'));
-        for (const node of nodes) {
-            const nodeLine = this.generateNode(node);
-            lines.push('  ' + nodeLine);
-        }
-        lines.push('');
-        // Generate flows
-        const links = diagram.getLinks();
-        for (const link of links) {
-            const flowLine = this.generateFlow(link, diagram);
-            if (flowLine) {
-                lines.push('  ' + flowLine);
-            }
-        }
-        return lines.join('\n');
-    }
-    /**
-     * Generate node definition
-     */
-    generateNode(node) {
-        var _a;
-        const id = this.sanitizeId(node.id);
-        const label = (_a = node.getLabel()) !== null && _a !== void 0 ? _a : node.id; // canonical read
-        const brackets = this.getNodeBrackets(node.type);
-        return `${id}${brackets.open}${label}${brackets.close}`;
-    }
-    /**
-     * Get brackets for BPMN node type
-     */
-    getNodeBrackets(type) {
-        if (type.includes('event')) {
-            return { open: '([', close: '])' }; // Stadium for events
-        }
-        if (type.includes('gateway')) {
-            return { open: '{', close: '}' }; // Diamond for gateways
-        }
-        // Tasks use rectangles
-        return { open: '[', close: ']' };
-    }
-    /**
-     * Generate flow
-     */
-    generateFlow(link, diagram) {
-        const sourceNode = diagram.getNode(link.sourceNodeId || '');
-        const targetNode = diagram.getNode(link.targetNodeId || '');
-        if (!sourceNode || !targetNode)
-            return null;
-        const sourceId = this.sanitizeId(sourceNode.id);
-        const targetId = this.sanitizeId(targetNode.id);
-        let flow = `${sourceId} --> `;
-        // Add condition label if present
-        const label = link.getLabel(); // canonical read
-        if (label) {
-            flow += `|${label}| `;
-        }
-        flow += targetId;
-        return flow;
-    }
-    /**
-     * Sanitize ID for DSL
-     */
-    sanitizeId(id) {
-        return id.replace(/[^a-zA-Z0-9_]/g, '_');
-    }
-}
-exports.BPMNGenerator = BPMNGenerator;
-//# sourceMappingURL=BPMNGenerator.js.map

package/src/libs/engine/src/dsl/extended/BPMNParser.d.ts

@@ -1,83 +0,0 @@
-/**
- * BPMN Parser - Parses Business Process Model and Notation syntax
- *
- * Supports extended BPMN flowchart syntax:
- * - Tasks (task, user task, service task, etc.)
- * - Events (start, end, intermediate)
- * - Gateways (exclusive, parallel, inclusive)
- * - Sequence flows with conditions
- * - Pools and lanes (subgraphs)
- */
-export type BPMNNodeType = 'task' | 'user-task' | 'service-task' | 'manual-task' | 'script-task' | 'business-rule-task' | 'start-event' | 'end-event' | 'intermediate-event' | 'message-event' | 'timer-event' | 'error-event' | 'exclusive-gateway' | 'parallel-gateway' | 'inclusive-gateway';
-export interface BPMNNode {
-    id: string;
-    type: BPMNNodeType;
-    label: string;
-    shape?: string;
-}
-export interface BPMNFlow {
-    from: string;
-    to: string;
-    label?: string;
-    condition?: string;
-}
-export interface BPMNPool {
-    id: string;
-    label: string;
-    lanes: BPMNLane[];
-}
-export interface BPMNLane {
-    id: string;
-    label: string;
-    nodes: string[];
-}
-export interface BPMNDiagram {
-    nodes: Map<string, BPMNNode>;
-    flows: BPMNFlow[];
-    pools: BPMNPool[];
-}
-export declare class BPMNParser {
-    /**
-     * Parse BPMN flowchart text
-     *
-     * Extended flowchart syntax with BPMN notation:
-     * flowchart TD
-     *   Start([Start Event])
-     *   Task1[User Task]
-     *   Gateway{Exclusive Gateway}
-     *   End([End Event])
-     *
-     *   Start --> Task1
-     *   Task1 --> Gateway
-     *   Gateway -->|Approved| End
-     */
-    parse(text: string): BPMNDiagram;
-    /**
-     * Check if line is a node definition
-     */
-    private isNodeDefinition;
-    /**
-     * Check if line is a flow definition
-     */
-    private isFlowDefinition;
-    /**
-     * Parse node definition
-     */
-    private parseNode;
-    /**
-     * Extract shape from brackets
-     */
-    private extractShape;
-    /**
-     * Extract label from brackets
-     */
-    private extractLabel;
-    /**
-     * Infer BPMN node type
-     */
-    private inferNodeType;
-    /**
-     * Parse flow definition
-     */
-    private parseFlow;
-}