@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/dsl/generator/DiagramAnalyzer.js

@@ -1,361 +0,0 @@
-"use strict";
-/**
- * Diagram Analyzer - Analyzes diagram structure for DSL generation
- *
- * Determines optimal DSL representation by analyzing:
- * - Node types and shapes
- * - Link patterns and directions
- * - Hierarchical structure
- * - Layout direction
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiagramAnalyzer = void 0;
-class DiagramAnalyzer {
-    /**
-     * Analyze diagram structure
-     */
-    analyze(diagram) {
-        const nodes = diagram.getNodes();
-        const links = diagram.getLinks();
-        // Determine diagram type from metadata or node types
-        const diagramType = this.determineDiagramType(diagram, nodes);
-        // Determine optimal direction
-        const direction = this.determineDirection(diagram, nodes, links);
-        // Calculate node order for output
-        const nodeOrder = this.calculateNodeOrder(nodes, links);
-        // Detect node groups (subgraphs)
-        const nodeGroups = this.detectNodeGroups(diagram, nodes);
-        // Collect node metadata
-        const nodeMetadata = this.collectNodeMetadata(nodes);
-        // Collect link metadata
-        const linkMetadata = this.collectLinkMetadata(links);
-        // Calculate statistics
-        const stats = this.calculateStats(nodes, links);
-        return {
-            diagramType,
-            direction,
-            nodeOrder,
-            nodeGroups,
-            nodeMetadata,
-            linkMetadata,
-            stats,
-        };
-    }
-    /**
-     * Determine diagram type
-     */
-    determineDiagramType(diagram, nodes) {
-        // Check metadata first
-        const metaDiagramType = diagram.getMetadata('diagramType');
-        if (metaDiagramType) {
-            return metaDiagramType;
-        }
-        // Infer from node types
-        if (nodes.length === 0) {
-            return 'flowchart';
-        }
-        const types = nodes.map(n => n.type);
-        const hasFlowchart = types.some(t => t.startsWith('flowchart:'));
-        const hasBPMN = types.some(t => t.startsWith('bpmn:'));
-        const hasERD = types.some(t => t.startsWith('erd:'));
-        const hasUML = types.some(t => t.startsWith('uml:'));
-        if (hasBPMN)
-            return 'bpmn';
-        if (hasERD)
-            return 'erd';
-        if (hasUML)
-            return 'classDiagram';
-        return 'flowchart';
-    }
-    /**
-     * Determine optimal direction
-     */
-    determineDirection(diagram, nodes, links) {
-        // Check metadata first
-        const metaDirection = diagram.getMetadata('direction');
-        if (metaDirection) {
-            return metaDirection;
-        }
-        // Analyze node positions to infer direction
-        if (nodes.length < 2) {
-            return 'TD'; // Default
-        }
-        // Calculate average position deltas
-        let totalDx = 0;
-        let totalDy = 0;
-        let count = 0;
-        for (const link of links) {
-            const sourceNode = nodes.find(n => n.id === link.sourceNodeId);
-            const targetNode = nodes.find(n => n.id === link.targetNodeId);
-            if (sourceNode && targetNode) {
-                const dx = targetNode.position.x - sourceNode.position.x;
-                const dy = targetNode.position.y - sourceNode.position.y;
-                totalDx += dx;
-                totalDy += dy;
-                count++;
-            }
-        }
-        if (count === 0) {
-            return 'TD';
-        }
-        const avgDx = totalDx / count;
-        const avgDy = totalDy / count;
-        // Determine primary direction
-        if (Math.abs(avgDx) > Math.abs(avgDy)) {
-            // Horizontal flow
-            return avgDx > 0 ? 'LR' : 'RL';
-        }
-        else {
-            // Vertical flow
-            return avgDy > 0 ? 'TD' : 'BT';
-        }
-    }
-    /**
-     * Calculate node order for sequential output
-     * Uses topological sort for DAGs, or DFS for general graphs
-     */
-    calculateNodeOrder(nodes, links) {
-        var _a;
-        if (nodes.length === 0) {
-            return [];
-        }
-        // Build adjacency list
-        const outgoing = new Map();
-        const incoming = new Map();
-        for (const node of nodes) {
-            outgoing.set(node.id, new Set());
-            incoming.set(node.id, 0);
-        }
-        for (const link of links) {
-            const sourceId = link.sourceNodeId;
-            const targetId = link.targetNodeId;
-            if (sourceId && targetId) {
-                (_a = outgoing.get(sourceId)) === null || _a === void 0 ? void 0 : _a.add(targetId);
-                incoming.set(targetId, (incoming.get(targetId) || 0) + 1);
-            }
-        }
-        // Try topological sort (works for DAGs)
-        const sorted = this.topologicalSort(nodes, outgoing, incoming);
-        if (sorted.length === nodes.length) {
-            return sorted;
-        }
-        // Fallback: DFS order
-        return this.dfsOrder(nodes, outgoing);
-    }
-    /**
-     * Topological sort (Kahn's algorithm)
-     */
-    topologicalSort(nodes, outgoing, incoming) {
-        const result = [];
-        const queue = [];
-        // Find nodes with no incoming edges
-        for (const [nodeId, inCount] of incoming.entries()) {
-            if (inCount === 0) {
-                queue.push(nodeId);
-            }
-        }
-        const incomingCopy = new Map(incoming);
-        while (queue.length > 0) {
-            const nodeId = queue.shift();
-            result.push(nodeId);
-            const neighbors = outgoing.get(nodeId);
-            if (neighbors) {
-                for (const neighbor of neighbors) {
-                    const count = incomingCopy.get(neighbor) - 1;
-                    incomingCopy.set(neighbor, count);
-                    if (count === 0) {
-                        queue.push(neighbor);
-                    }
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * DFS order (fallback for cyclic graphs)
-     */
-    dfsOrder(nodes, outgoing) {
-        const result = [];
-        const visited = new Set();
-        const dfs = (nodeId) => {
-            if (visited.has(nodeId))
-                return;
-            visited.add(nodeId);
-            result.push(nodeId);
-            const neighbors = outgoing.get(nodeId);
-            if (neighbors) {
-                for (const neighbor of neighbors) {
-                    dfs(neighbor);
-                }
-            }
-        };
-        // Start from all unvisited nodes
-        for (const node of nodes) {
-            if (!visited.has(node.id)) {
-                dfs(node.id);
-            }
-        }
-        return result;
-    }
-    /**
-     * Detect node groups (for subgraph generation)
-     */
-    detectNodeGroups(diagram, nodes) {
-        const groups = new Map();
-        // Check for explicit groups
-        const diagramGroups = diagram.getGroups();
-        for (const group of diagramGroups) {
-            const memberIds = group.getMetadata('members') || [];
-            if (memberIds.length > 0) {
-                groups.set(group.id, memberIds);
-            }
-        }
-        // TODO: Add clustering analysis for implicit groups
-        return groups;
-    }
-    /**
-     * Collect node metadata
-     */
-    collectNodeMetadata(nodes) {
-        const metadata = new Map();
-        for (const node of nodes) {
-            const shape = node.getMetadata('dslShape') || node.getMetadata('shape') || 'rectangle';
-            const hasCustomStyle = this.hasCustomStyle(node.style);
-            metadata.set(node.id, { shape, hasCustomStyle });
-        }
-        return metadata;
-    }
-    /**
-     * Collect link metadata
-     */
-    collectLinkMetadata(links) {
-        const metadata = new Map();
-        for (const link of links) {
-            const hasLabel = !!link.getLabel(); // canonical read (metadata ?? legacy data)
-            const hasCustomStyle = this.hasCustomStyle(link.style);
-            metadata.set(link.id, { hasLabel, hasCustomStyle });
-        }
-        return metadata;
-    }
-    /**
-     * Check if entity has custom styling
-     */
-    hasCustomStyle(style) {
-        if (!style)
-            return false;
-        const defaultKeys = ['fill', 'stroke', 'strokeWidth'];
-        const customKeys = Object.keys(style).filter(k => !defaultKeys.includes(k));
-        return customKeys.length > 0 || this.hasNonDefaultValues(style);
-    }
-    /**
-     * Check if style has non-default values
-     */
-    hasNonDefaultValues(style) {
-        // Simple heuristic: check for common non-default values
-        if (style.strokeDasharray)
-            return true;
-        if (style.strokeWidth && style.strokeWidth !== 2)
-            return true;
-        return false;
-    }
-    /**
-     * Calculate statistics
-     */
-    calculateStats(nodes, links) {
-        var _a, _b;
-        const nodeCount = nodes.length;
-        const linkCount = links.length;
-        // Build adjacency list
-        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 sourceId = link.sourceNodeId;
-            const targetId = link.targetNodeId;
-            if (sourceId && targetId) {
-                (_a = outgoing.get(sourceId)) === null || _a === void 0 ? void 0 : _a.add(targetId);
-                (_b = incoming.get(targetId)) === null || _b === void 0 ? void 0 : _b.add(sourceId);
-            }
-        }
-        // Detect cycles
-        const hasCycles = this.detectCyclesDFS(nodes, outgoing);
-        // Calculate max depth
-        const maxDepth = this.calculateMaxDepthBFS(nodes, outgoing, incoming);
-        return {
-            nodeCount,
-            linkCount,
-            maxDepth,
-            hasCycles,
-        };
-    }
-    /**
-     * Detect cycles using DFS
-     */
-    detectCyclesDFS(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 max depth using BFS
-     */
-    calculateMaxDepthBFS(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; // Cyclic graph
-        }
-        let maxDepth = 0;
-        const depths = new Map();
-        // BFS from all roots
-        const queue = [];
-        for (const root of roots) {
-            queue.push({ nodeId: root.id, depth: 1 });
-            depths.set(root.id, 1);
-        }
-        while (queue.length > 0) {
-            const { nodeId, depth } = queue.shift();
-            maxDepth = Math.max(maxDepth, depth);
-            const neighbors = outgoing.get(nodeId);
-            if (neighbors) {
-                for (const neighbor of neighbors) {
-                    const currentDepth = depths.get(neighbor) || 0;
-                    if (depth + 1 > currentDepth) {
-                        depths.set(neighbor, depth + 1);
-                        queue.push({ nodeId: neighbor, depth: depth + 1 });
-                    }
-                }
-            }
-        }
-        return maxDepth;
-    }
-}
-exports.DiagramAnalyzer = DiagramAnalyzer;
-//# sourceMappingURL=DiagramAnalyzer.js.map

package/src/libs/engine/src/dsl/index.d.ts

@@ -1,35 +0,0 @@
-/**
- * DSL Module - Mermaid-compatible diagram text parsing
- *
- * Provides complete text-to-diagram conversion pipeline:
- * - Lexical analysis (Lexer)
- * - Syntax parsing (Parser)
- * - AST transformation (ASTTransformer)
- * - Layout detection (LayoutDetector)
- *
- * @example
- * ```typescript
- * import { DSL } from '@grafloria/engine/dsl';
- *
- * const dsl = new DSL({ autoLayout: true });
- * const diagram = dsl.parse(`
- *   flowchart LR
- *     A[Start] --> B[Process]
- *     B --> C[End]
- * `);
- *
- * console.log(diagram.getNodes().length); // 3 nodes
- * ```
- */
-export { DSL, type DSLOptions, type ParseResult } from './DSL';
-export { Lexer } from './lexer/Lexer';
-export { Parser, ParseError } from './parser/Parser';
-export { ASTTransformer, type TransformOptions } from './transformer/ASTTransformer';
-export { LayoutDetector, type LayoutSuggestion, type DiagramCharacteristics } from './detector/LayoutDetector';
-export { DSLGenerator, type GeneratorOptions } from './generator/DSLGenerator';
-export { DSLFormatter, type FormatterOptions } from './generator/DSLFormatter';
-export { DiagramAnalyzer, type DiagramAnalysis } from './generator/DiagramAnalyzer';
-export * from './sync';
-export * from './mermaid';
-export { type Token, TokenType, createToken, } from './types/Token';
-export { type ASTNode, type DiagramNode, type StatementNode, type NodeDefinitionNode, type EdgeDefinitionNode, type SubgraphNode, type StyleNode, type ClassDefNode, type Direction, type DiagramType, type NodeShape, type LinkType, type StyleProperties, type SourceLocation, type Position, isNodeDefinition, isEdgeDefinition, isSubgraph, isStyleNode, isClassDef, } from './types/ASTNode';

package/src/libs/engine/src/dsl/index.js

@@ -1,64 +0,0 @@
-"use strict";
-/**
- * DSL Module - Mermaid-compatible diagram text parsing
- *
- * Provides complete text-to-diagram conversion pipeline:
- * - Lexical analysis (Lexer)
- * - Syntax parsing (Parser)
- * - AST transformation (ASTTransformer)
- * - Layout detection (LayoutDetector)
- *
- * @example
- * ```typescript
- * import { DSL } from '@grafloria/engine/dsl';
- *
- * const dsl = new DSL({ autoLayout: true });
- * const diagram = dsl.parse(`
- *   flowchart LR
- *     A[Start] --> B[Process]
- *     B --> C[End]
- * `);
- *
- * console.log(diagram.getNodes().length); // 3 nodes
- * ```
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isClassDef = exports.isStyleNode = exports.isSubgraph = exports.isEdgeDefinition = exports.isNodeDefinition = exports.createToken = exports.TokenType = exports.DiagramAnalyzer = exports.DSLFormatter = exports.DSLGenerator = exports.LayoutDetector = exports.ASTTransformer = exports.ParseError = exports.Parser = exports.Lexer = exports.DSL = void 0;
-const tslib_1 = require("tslib");
-// Main DSL interface
-var DSL_1 = require("./DSL");
-Object.defineProperty(exports, "DSL", { enumerable: true, get: function () { return DSL_1.DSL; } });
-// Core components
-var Lexer_1 = require("./lexer/Lexer");
-Object.defineProperty(exports, "Lexer", { enumerable: true, get: function () { return Lexer_1.Lexer; } });
-var Parser_1 = require("./parser/Parser");
-Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return Parser_1.Parser; } });
-Object.defineProperty(exports, "ParseError", { enumerable: true, get: function () { return Parser_1.ParseError; } });
-var ASTTransformer_1 = require("./transformer/ASTTransformer");
-Object.defineProperty(exports, "ASTTransformer", { enumerable: true, get: function () { return ASTTransformer_1.ASTTransformer; } });
-var LayoutDetector_1 = require("./detector/LayoutDetector");
-Object.defineProperty(exports, "LayoutDetector", { enumerable: true, get: function () { return LayoutDetector_1.LayoutDetector; } });
-// Generator components (Phase 1.3)
-var DSLGenerator_1 = require("./generator/DSLGenerator");
-Object.defineProperty(exports, "DSLGenerator", { enumerable: true, get: function () { return DSLGenerator_1.DSLGenerator; } });
-var DSLFormatter_1 = require("./generator/DSLFormatter");
-Object.defineProperty(exports, "DSLFormatter", { enumerable: true, get: function () { return DSLFormatter_1.DSLFormatter; } });
-var DiagramAnalyzer_1 = require("./generator/DiagramAnalyzer");
-Object.defineProperty(exports, "DiagramAnalyzer", { enumerable: true, get: function () { return DiagramAnalyzer_1.DiagramAnalyzer; } });
-// Sync components (Phase 2)
-tslib_1.__exportStar(require("./sync"), exports);
-// Mermaid graph-family types beyond the flowchart (Phase 3):
-// erDiagram / classDiagram / stateDiagram-v2 — parser + generator + the
-// diagram-kit spec projections (erSpecFrom / umlSpecFrom).
-tslib_1.__exportStar(require("./mermaid"), exports);
-// Type definitions
-var Token_1 = require("./types/Token");
-Object.defineProperty(exports, "TokenType", { enumerable: true, get: function () { return Token_1.TokenType; } });
-Object.defineProperty(exports, "createToken", { enumerable: true, get: function () { return Token_1.createToken; } });
-var ASTNode_1 = require("./types/ASTNode");
-Object.defineProperty(exports, "isNodeDefinition", { enumerable: true, get: function () { return ASTNode_1.isNodeDefinition; } });
-Object.defineProperty(exports, "isEdgeDefinition", { enumerable: true, get: function () { return ASTNode_1.isEdgeDefinition; } });
-Object.defineProperty(exports, "isSubgraph", { enumerable: true, get: function () { return ASTNode_1.isSubgraph; } });
-Object.defineProperty(exports, "isStyleNode", { enumerable: true, get: function () { return ASTNode_1.isStyleNode; } });
-Object.defineProperty(exports, "isClassDef", { enumerable: true, get: function () { return ASTNode_1.isClassDef; } });
-//# sourceMappingURL=index.js.map

package/src/libs/engine/src/dsl/lexer/Lexer.d.ts

@@ -1,117 +0,0 @@
-/**
- * DSL Lexer - Tokenizes Mermaid-compatible diagram syntax
- *
- * Converts text input into a stream of tokens for the parser
- */
-import { Token } from '../types/Token';
-export declare class Lexer {
-    private input;
-    private position;
-    private line;
-    private column;
-    private tokens;
-    constructor(input: string);
-    /**
-     * Tokenize the entire input
-     */
-    tokenize(): Token[];
-    /**
-     * Scan a single token
-     */
-    private scanToken;
-    /**
-     * Scan square bracket combinations
-     */
-    private scanSquareBracket;
-    /**
-     * Scan the closing of a square-bracket shape. A ']' can close a rectangle
-     * ([x]), a stadium ([x] inside ([...]) → close is `])`), or a subroutine
-     * ([[x]] → close is `]]`). The lexer never emitted the compound closes, so
-     * stadium/subroutine parsing walked to EOF and threw.
-     */
-    private scanSquareClose;
-    /**
-     * Scan round bracket combinations
-     */
-    private scanRoundBracket;
-    /**
-     * Scan round bracket close combinations
-     */
-    private scanRoundBracketClose;
-    /**
-     * Scan curly bracket combinations
-     */
-    private scanCurlyBracket;
-    /**
-     * Scan curly bracket close combinations
-     */
-    private scanCurlyBracketClose;
-    /**
-     * Scan less-than combinations: <-->
-     */
-    private scanLessThan;
-    /**
-     * Scan dash combinations: -->, ---, -.->, -.-
-     */
-    private scanDash;
-    /**
-     * Scan equals combinations: ==>, ===
-     */
-    private scanEquals;
-    /**
-     * Scan dot (for dotted lines) - already handled in scanDash
-     */
-    private scanDot;
-    /**
-     * Scan string literal
-     */
-    private scanString;
-    /**
-     * Scan number literal
-     */
-    private scanNumber;
-    /**
-     * Scan identifier or keyword
-     */
-    private scanIdentifier;
-    /**
-     * Scan comment: %% comment text
-     */
-    private scanComment;
-    /**
-     * Get keyword token type
-     */
-    private getKeywordType;
-    /**
-     * Helper: Add token to list
-     */
-    private addToken;
-    /**
-     * Helper: Advance position and return current character
-     */
-    private advance;
-    /**
-     * Helper: Peek at current character without advancing
-     */
-    private peek;
-    /**
-     * Helper: Peek at next character
-     */
-    private peekNext;
-    /**
-     * Helper: Check if at end of input
-     */
-    private isAtEnd;
-    /**
-     * Helper: Check if character is a digit
-     */
-    private isDigit;
-    /**
-     * Helper: Check if character is alphabetic
-     */
-    private isAlpha;
-    /**
-     * Helper: Check if character is alphanumeric
-     */
-    private isAlphaNumeric;
-}