@grafloria/element 0.3.18 → 0.3.20

package/src/libs/engine/src/dsl/lexer/Lexer.js

@@ -0,0 +1,521 @@
+"use strict";
+/**
+ * DSL Lexer - Tokenizes Mermaid-compatible diagram syntax
+ *
+ * Converts text input into a stream of tokens for the parser
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lexer = void 0;
+const Token_1 = require("../types/Token");
+class Lexer {
+    constructor(input) {
+        this.position = 0;
+        this.line = 1;
+        this.column = 1;
+        this.tokens = [];
+        this.input = input;
+    }
+    /**
+     * Tokenize the entire input
+     */
+    tokenize() {
+        this.tokens = [];
+        this.position = 0;
+        this.line = 1;
+        this.column = 1;
+        while (!this.isAtEnd()) {
+            this.scanToken();
+        }
+        // Add EOF token
+        this.addToken(Token_1.TokenType.EOF, '', this.position, this.position);
+        return this.tokens;
+    }
+    /**
+     * Scan a single token
+     */
+    scanToken() {
+        const start = this.position;
+        const startColumn = this.column;
+        const char = this.advance();
+        switch (char) {
+            case '\n':
+                this.addToken(Token_1.TokenType.NEWLINE, char, start, this.position);
+                this.line++;
+                this.column = 1;
+                break;
+            case ' ':
+            case '\t':
+            case '\r':
+                // Skip whitespace (don't create tokens)
+                break;
+            case '%':
+                // Comment: %% comment text
+                if (this.peek() === '%') {
+                    this.scanComment(start);
+                }
+                else {
+                    this.addToken(Token_1.TokenType.UNKNOWN, char, start, this.position);
+                }
+                break;
+            case ':':
+                if (this.peek() === ':' && this.peekNext() === ':') {
+                    this.advance();
+                    this.advance();
+                    this.addToken(Token_1.TokenType.TRIPLE_COLON, ':::', start, this.position);
+                }
+                else {
+                    this.addToken(Token_1.TokenType.COLON, char, start, this.position);
+                }
+                break;
+            case ';':
+                this.addToken(Token_1.TokenType.SEMICOLON, char, start, this.position);
+                break;
+            case ',':
+                this.addToken(Token_1.TokenType.COMMA, char, start, this.position);
+                break;
+            case '|':
+                this.addToken(Token_1.TokenType.PIPE, char, start, this.position);
+                break;
+            case '&':
+                this.addToken(Token_1.TokenType.AMPERSAND, char, start, this.position);
+                break;
+            case '#':
+                // Hex colour (#f9f, #ff0000, #333) — style/classDef values. Emitted as
+                // an IDENTIFIER carrying the leading '#' so the style parser reads it
+                // verbatim. Was UNKNOWN, which broke every `fill:#…`.
+                while (this.isAlphaNumeric(this.peek()))
+                    this.advance();
+                this.addToken(Token_1.TokenType.IDENTIFIER, this.input.substring(start, this.position), start, this.position);
+                break;
+            case '[':
+                this.scanSquareBracket(start, startColumn);
+                break;
+            case ']':
+                this.scanSquareClose(start);
+                break;
+            case '(':
+                this.scanRoundBracket(start, startColumn);
+                break;
+            case ')':
+                this.scanRoundBracketClose(start, startColumn);
+                break;
+            case '{':
+                this.scanCurlyBracket(start, startColumn);
+                break;
+            case '}':
+                this.scanCurlyBracketClose(start, startColumn);
+                break;
+            case '>':
+                this.addToken(Token_1.TokenType.ASYMMETRIC_OPEN, char, start, this.position);
+                break;
+            case '<':
+                this.scanLessThan(start, startColumn);
+                break;
+            case '/':
+                if (this.peek() === ']') {
+                    this.advance();
+                    this.addToken(Token_1.TokenType.TRAPEZOID_CLOSE, '/]', start, this.position);
+                }
+                else {
+                    this.addToken(Token_1.TokenType.UNKNOWN, '/', start, this.position);
+                }
+                break;
+            case '\\':
+                if (this.peek() === ']') {
+                    this.advance();
+                    this.addToken(Token_1.TokenType.TRAPEZOID_CLOSE, '\\]', start, this.position);
+                }
+                else {
+                    this.addToken(Token_1.TokenType.UNKNOWN, '\\', start, this.position);
+                }
+                break;
+            case '@':
+                this.addToken(Token_1.TokenType.AT, '@', start, this.position);
+                break;
+            case '-':
+                this.scanDash(start, startColumn);
+                break;
+            case '=':
+                this.scanEquals(start, startColumn);
+                break;
+            case '.':
+                this.scanDot(start, startColumn);
+                break;
+            case '"':
+            case "'":
+                this.scanString(char, start, startColumn);
+                break;
+            default:
+                if (this.isDigit(char)) {
+                    this.scanNumber(start, startColumn);
+                }
+                else if (this.isAlpha(char)) {
+                    this.scanIdentifier(start, startColumn);
+                }
+                else {
+                    this.addToken(Token_1.TokenType.UNKNOWN, char, start, this.position);
+                }
+                break;
+        }
+    }
+    /**
+     * Scan square bracket combinations
+     */
+    scanSquareBracket(start, startColumn) {
+        const next = this.peek();
+        if (next === '[') {
+            // Subroutine: [[
+            this.advance();
+            this.addToken(Token_1.TokenType.SUBROUTINE_OPEN, '[[', start, this.position);
+        }
+        else if (next === '(') {
+            // Cylindrical: [(
+            this.advance();
+            this.addToken(Token_1.TokenType.CYLINDRICAL_OPEN, '[(', start, this.position);
+        }
+        else if (next === '/') {
+            // Trapezoid: [/
+            this.advance();
+            this.addToken(Token_1.TokenType.TRAPEZOID_OPEN, '[/', start, this.position);
+        }
+        else if (next === '\\') {
+            // Trapezoid alt: [\
+            this.advance();
+            this.addToken(Token_1.TokenType.TRAPEZOID_OPEN, '[\\', start, this.position);
+        }
+        else {
+            // Regular square: [
+            this.addToken(Token_1.TokenType.SQUARE_OPEN, '[', start, this.position);
+        }
+    }
+    /**
+     * 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.
+     */
+    scanSquareClose(start) {
+        const next = this.peek();
+        if (next === ')') {
+            this.advance();
+            this.addToken(Token_1.TokenType.STADIUM_CLOSE, '])', start, this.position);
+        }
+        else if (next === ']') {
+            this.advance();
+            this.addToken(Token_1.TokenType.SUBROUTINE_CLOSE, ']]', start, this.position);
+        }
+        else {
+            this.addToken(Token_1.TokenType.SQUARE_CLOSE, ']', start, this.position);
+        }
+    }
+    /**
+     * Scan round bracket combinations
+     */
+    scanRoundBracket(start, startColumn) {
+        const next = this.peek();
+        if (next === '(') {
+            // Circle: ((
+            this.advance();
+            this.addToken(Token_1.TokenType.CIRCLE_OPEN, '((', start, this.position);
+        }
+        else if (next === '[') {
+            // Stadium: ([
+            this.advance();
+            this.addToken(Token_1.TokenType.STADIUM_OPEN, '([', start, this.position);
+        }
+        else {
+            // Regular round: (
+            this.addToken(Token_1.TokenType.ROUND_OPEN, '(', start, this.position);
+        }
+    }
+    /**
+     * Scan round bracket close combinations
+     */
+    scanRoundBracketClose(start, startColumn) {
+        const next = this.peek();
+        if (next === ')') {
+            // Circle close: ))
+            this.advance();
+            this.addToken(Token_1.TokenType.CIRCLE_CLOSE, '))', start, this.position);
+        }
+        else if (next === ']') {
+            // Cylindrical close: )]
+            this.advance();
+            this.addToken(Token_1.TokenType.CYLINDRICAL_CLOSE, ')]', start, this.position);
+        }
+        else {
+            // Regular round close: )
+            this.addToken(Token_1.TokenType.ROUND_CLOSE, ')', start, this.position);
+        }
+    }
+    /**
+     * Scan curly bracket combinations
+     */
+    scanCurlyBracket(start, startColumn) {
+        const next = this.peek();
+        if (next === '{') {
+            // Hexagon: {{
+            this.advance();
+            this.addToken(Token_1.TokenType.HEXAGON_OPEN, '{{', start, this.position);
+        }
+        else {
+            // Regular rhombus: {
+            this.addToken(Token_1.TokenType.RHOMBUS_OPEN, '{', start, this.position);
+        }
+    }
+    /**
+     * Scan curly bracket close combinations
+     */
+    scanCurlyBracketClose(start, startColumn) {
+        const next = this.peek();
+        if (next === '}') {
+            // Hexagon close: }}
+            this.advance();
+            this.addToken(Token_1.TokenType.HEXAGON_CLOSE, '}}', start, this.position);
+        }
+        else {
+            // Regular rhombus close: }
+            this.addToken(Token_1.TokenType.RHOMBUS_CLOSE, '}', start, this.position);
+        }
+    }
+    /**
+     * Scan less-than combinations: <-->
+     */
+    scanLessThan(start, startColumn) {
+        if (this.peek() === '-' && this.peekNext() === '-') {
+            this.advance(); // -
+            this.advance(); // -
+            if (this.peek() === '>') {
+                this.advance(); // >
+                this.addToken(Token_1.TokenType.BIDIRECTIONAL, '<-->', start, this.position);
+            }
+            else {
+                // Just <-- (not standard, treat as unknown)
+                this.addToken(Token_1.TokenType.UNKNOWN, this.input.substring(start, this.position), start, this.position);
+            }
+        }
+        else {
+            this.addToken(Token_1.TokenType.UNKNOWN, '<', start, this.position);
+        }
+    }
+    /**
+     * Scan dash combinations: -->, ---, -.->, -.-
+     */
+    scanDash(start, _startColumn) {
+        if (this.peek() === '-') {
+            // Solid edge, ANY length: --, ---, ----, … Mermaid uses extra dashes to
+            // ask for a longer edge; the semantics are identical, so one token type
+            // covers them all. (Old code hard-coded exactly two/three dashes, so
+            // `--->` broke into LINE + `->`.)
+            while (this.peek() === '-')
+                this.advance();
+            const terminator = this.peek();
+            if (terminator === '>') {
+                this.advance();
+                this.addToken(Token_1.TokenType.ARROW, this.input.substring(start, this.position), start, this.position);
+            }
+            else if (terminator === 'o') {
+                this.advance();
+                this.addToken(Token_1.TokenType.CIRCLE_EDGE, this.input.substring(start, this.position), start, this.position);
+            }
+            else if (terminator === 'x') {
+                this.advance();
+                this.addToken(Token_1.TokenType.CROSS_EDGE, this.input.substring(start, this.position), start, this.position);
+            }
+            else {
+                this.addToken(Token_1.TokenType.LINE, this.input.substring(start, this.position), start, this.position);
+            }
+        }
+        else if (this.peek() === '.') {
+            // Dotted edge, ANY length: -.-, -.->, -..-> (extra dots lengthen it).
+            while (this.peek() === '.' || this.peek() === '-')
+                this.advance();
+            if (this.peek() === '>') {
+                this.advance();
+                this.addToken(Token_1.TokenType.DOTTED_ARROW, this.input.substring(start, this.position), start, this.position);
+            }
+            else {
+                this.addToken(Token_1.TokenType.DOTTED_LINE, this.input.substring(start, this.position), start, this.position);
+            }
+        }
+        else {
+            this.addToken(Token_1.TokenType.UNKNOWN, '-', start, this.position);
+        }
+    }
+    /**
+     * Scan equals combinations: ==>, ===
+     */
+    scanEquals(start, startColumn) {
+        if (this.peek() === '=' && this.peekNext() === '=') {
+            this.advance(); // second =
+            this.advance(); // third =
+            if (this.peek() === '>') {
+                // Thick arrow: ==>
+                this.advance(); // >
+                this.addToken(Token_1.TokenType.THICK_ARROW, '==>', start, this.position);
+            }
+            else {
+                // Thick line: ===
+                this.addToken(Token_1.TokenType.THICK_LINE, '===', start, this.position);
+            }
+        }
+        else {
+            // Single = (unknown)
+            this.addToken(Token_1.TokenType.UNKNOWN, '=', start, this.position);
+        }
+    }
+    /**
+     * Scan dot (for dotted lines) - already handled in scanDash
+     */
+    scanDot(start, startColumn) {
+        this.addToken(Token_1.TokenType.UNKNOWN, '.', start, this.position);
+    }
+    /**
+     * Scan string literal
+     */
+    scanString(quote, start, startColumn) {
+        let value = '';
+        while (!this.isAtEnd() && this.peek() !== quote) {
+            if (this.peek() === '\n') {
+                this.line++;
+                this.column = 0;
+            }
+            value += this.advance();
+        }
+        if (this.isAtEnd()) {
+            // Unterminated string
+            this.addToken(Token_1.TokenType.UNKNOWN, quote + value, start, this.position);
+            return;
+        }
+        // Consume closing quote
+        this.advance();
+        this.addToken(Token_1.TokenType.STRING, value, start, this.position);
+    }
+    /**
+     * Scan number literal
+     */
+    scanNumber(start, startColumn) {
+        while (this.isDigit(this.peek())) {
+            this.advance();
+        }
+        // Check for decimal
+        if (this.peek() === '.' && this.isDigit(this.peekNext())) {
+            this.advance(); // .
+            while (this.isDigit(this.peek())) {
+                this.advance();
+            }
+        }
+        const value = this.input.substring(start, this.position);
+        this.addToken(Token_1.TokenType.NUMBER, value, start, this.position);
+    }
+    /**
+     * Scan identifier or keyword
+     */
+    scanIdentifier(start, startColumn) {
+        // A '-' belongs to the identifier ONLY when a letter/digit follows it
+        // (hyphenated ids like `my-node`). A '-' before another '-' or a '.'
+        // begins an edge (`-->`, `-.->`) and must end the identifier — this is
+        // the glued-arrow fix: `a-->b` was lexing `a--` as one identifier.
+        while (this.isAlphaNumeric(this.peek()) ||
+            this.peek() === '_' ||
+            (this.peek() === '-' && this.isAlphaNumeric(this.peekNext()))) {
+            this.advance();
+        }
+        const value = this.input.substring(start, this.position);
+        const type = this.getKeywordType(value);
+        this.addToken(type, value, start, this.position);
+    }
+    /**
+     * Scan comment: %% comment text
+     */
+    scanComment(start) {
+        this.advance(); // Second %
+        let value = '%%';
+        while (!this.isAtEnd() && this.peek() !== '\n') {
+            value += this.advance();
+        }
+        this.addToken(Token_1.TokenType.COMMENT, value, start, this.position);
+    }
+    /**
+     * Get keyword token type
+     */
+    getKeywordType(value) {
+        const lower = value.toLowerCase();
+        const keywords = {
+            'flowchart': Token_1.TokenType.FLOWCHART,
+            'graph': Token_1.TokenType.GRAPH,
+            'subgraph': Token_1.TokenType.SUBGRAPH,
+            'end': Token_1.TokenType.END,
+            'bpmn': Token_1.TokenType.BPMN,
+            'erd': Token_1.TokenType.ERD,
+            'classDiagram': Token_1.TokenType.CLASSDIAAGRAM,
+            'TD': Token_1.TokenType.TD,
+            'TB': Token_1.TokenType.TB,
+            'BT': Token_1.TokenType.BT,
+            'RL': Token_1.TokenType.RL,
+            'LR': Token_1.TokenType.LR,
+        };
+        return keywords[lower] || keywords[value] || Token_1.TokenType.IDENTIFIER;
+    }
+    /**
+     * Helper: Add token to list
+     */
+    addToken(type, value, start, end) {
+        const token = (0, Token_1.createToken)(type, value, this.line, this.column - value.length, start, end);
+        this.tokens.push(token);
+    }
+    /**
+     * Helper: Advance position and return current character
+     */
+    advance() {
+        const char = this.input[this.position];
+        this.position++;
+        this.column++;
+        return char;
+    }
+    /**
+     * Helper: Peek at current character without advancing
+     */
+    peek() {
+        if (this.isAtEnd())
+            return '\0';
+        return this.input[this.position];
+    }
+    /**
+     * Helper: Peek at next character
+     */
+    peekNext() {
+        if (this.position + 1 >= this.input.length)
+            return '\0';
+        return this.input[this.position + 1];
+    }
+    /**
+     * Helper: Check if at end of input
+     */
+    isAtEnd() {
+        return this.position >= this.input.length;
+    }
+    /**
+     * Helper: Check if character is a digit
+     */
+    isDigit(char) {
+        return char >= '0' && char <= '9';
+    }
+    /**
+     * Helper: Check if character is alphabetic
+     */
+    isAlpha(char) {
+        // Any Unicode letter — not ASCII-only. With the ASCII test every Arabic /
+        // CJK / Cyrillic character lexed as its own UNKNOWN token and labels came
+        // back through the parser one-character-at-a-time ("مرحبا" → "م ر ح ب ا").
+        return /\p{L}/u.test(char);
+    }
+    /**
+     * Helper: Check if character is alphanumeric
+     */
+    isAlphaNumeric(char) {
+        return this.isAlpha(char) || this.isDigit(char);
+    }
+}
+exports.Lexer = Lexer;
+//# sourceMappingURL=Lexer.js.map

package/src/libs/engine/src/dsl/mermaid/MermaidClass.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Mermaid `classDiagram` — parser, model builder and generator (Phase 3).
+ *
+ * Replaces `extended/UMLParser`, which produced ZERO nodes on canonical input:
+ * it only recognised `class X` when the `{` sat on the FOLLOWING line, ignored
+ * the `Animal : +int age` member form entirely, and its relationship regex
+ * could not tell `<|--` from `<--`.
+ *
+ * The target representation is the diagram kit's `umlDiagram({classes,
+ * relationships})`: three-compartment cards and the full 7-kind notation
+ * vocabulary. Two facts about the mapping are worth stating, because they are
+ * where a naive port goes wrong:
+ *
+ *  1. MEMBERS ARE KEPT AS RAW TEXT. The kit renders `attributes: string[]` /
+ *     `methods: string[]` verbatim, and Mermaid itself accepts several member
+ *     spellings (`+int age`, `+age: int`, `+area() float`, `+area() : float`).
+ *     Re-formatting them would silently rewrite the author's diagram; we parse
+ *     visibility for structure and keep the text for display and re-emission.
+ *  2. DIRECTION IS NORMALIZED FOR THE KIT, NOT FOR THE MODEL. Mermaid's
+ *     `Animal <|-- Duck` puts the hollow triangle on the LEFT operand, while
+ *     the kit's `inheritance` always draws it at `to`. So the kit spec flips
+ *     the ends (and the multiplicity pair with them) while the model keeps the
+ *     literal operator and operand order — which is what lets the generator
+ *     re-emit the author's own syntax.
+ *  3. THE OPERATOR SET IS DERIVED FROM THE GRAMMAR, NOT ENUMERATED. See
+ *     `UmlOperator` below: Mermaid composes `relationType? lineType
+ *     relationType?`, which is 72 legal spellings. Listing a subset by hand is
+ *     how the lollipop family (`bar ()-- foo`) and every mixed operator
+ *     (`A <|--* B`) came to be dropped in silence.
+ */
+import { DiagramModel } from '../../models/DiagramModel';
+export type UmlVisibility = '+' | '-' | '#' | '~';
+export interface MermaidClassMember {
+    /** The member exactly as written (minus the visibility marker's whitespace). */
+    raw: string;
+    visibility?: UmlVisibility;
+    name: string;
+    isMethod: boolean;
+    /** `$` (static) / `*` (abstract) classifier suffixes Mermaid supports. */
+    classifier?: '$' | '*';
+}
+export interface MermaidClassDef {
+    id: string;
+    /** Display name — `class Foo["Bar"]` label, else the id (generics included). */
+    name: string;
+    /** `<<interface>>` / `<<abstract>>` / `<<enum>>` / … */
+    stereotype?: string;
+    /** `class Square~Shape~` generic parameter. */
+    generic?: string;
+    attributes: MermaidClassMember[];
+    methods: MermaidClassMember[];
+    /** `:::css` style classes applied to the node. */
+    cssClasses: string[];
+}
+/**
+ * Mermaid's class relationship grammar is COMPOSITIONAL, not a fixed list:
+ *
+ *     relation := relationType? lineType relationType?
+ *
+ * with `relationType` ∈ {`<|`/`|>` extension, `*` composition, `o` aggregation,
+ * `<`/`>` dependency, `()` lollipop} and `lineType` ∈ {`--` solid, `..` dotted}.
+ * That is **72 legal spellings**, every one of which mermaid 11.16 accepts
+ * (verified operator-by-operator against the real parser). The previous
+ * hand-written table listed 17 of them, and a line using any of the other 55 —
+ * `A <|--* B`, `A o--|> B`, the whole lollipop family — matched no rule at all,
+ * so the line was skipped and BOTH classes vanished: an empty diagram, silently.
+ */
+export type UmlLeftMarker = '' | '<|' | '*' | 'o' | '<' | '()';
+export type UmlRightMarker = '' | '|>' | '*' | 'o' | '>' | '()';
+export type UmlLineType = '--' | '..';
+/** The literal Mermaid operator, kept so generation is not a guess. */
+export type UmlOperator = `${UmlLeftMarker}${UmlLineType}${UmlRightMarker}`;
+/** The diagram kit's relationship vocabulary. */
+export type UmlKind = 'inheritance' | 'realization' | 'association' | 'directed-association' | 'aggregation' | 'composition' | 'dependency';
+export interface MermaidClassRelationship {
+    /** Left operand, exactly as written. */
+    from: string;
+    /** Right operand, exactly as written. */
+    to: string;
+    operator: UmlOperator;
+    label?: string;
+    /** Multiplicity as written: [left-of-operator, right-of-operator]. */
+    multiplicity?: [string, string];
+}
+export interface MermaidClassModel {
+    classes: MermaidClassDef[];
+    relationships: MermaidClassRelationship[];
+    direction?: string;
+    /** `note "text"` / `note for X "text"` — kept so export does not drop them. */
+    notes: Array<{
+        for?: string;
+        text: string;
+    }>;
+}
+/**
+ * Operator → (kit kind, whether the kit's ends are the REVERSE of Mermaid's),
+ * derived from the grammar rather than enumerated. This reproduces the previous
+ * 17-row table exactly and covers the other 55 spellings for free.
+ */
+export declare function umlRelationKind(operator: string): {
+    kind: UmlKind;
+    reversed: boolean;
+};
+/**
+ * Parse a `classDiagram` body. Unknown lines (`click`, `style`, `namespace`,
+ * `callback`, future syntax) are skipped — never turned into a class.
+ */
+export declare function parseMermaidClass(text: string): MermaidClassModel;
+export interface UmlSpecClass {
+    id: string;
+    name: string;
+    stereotype?: string;
+    abstract?: boolean;
+    attributes: string[];
+    methods: string[];
+}
+export interface UmlSpecRelationship {
+    from: string;
+    to: string;
+    kind: UmlKind;
+    label?: string;
+    multiplicity?: [string, string];
+}
+export interface UmlSpec {
+    classes: UmlSpecClass[];
+    relationships: UmlSpecRelationship[];
+}
+/**
+ * Project onto `umlDiagram()` options — this is where Mermaid's
+ * arrowhead-first operators are flipped into the kit's from→to convention.
+ */
+export declare function umlSpecFrom(model: MermaidClassModel): UmlSpec;
+export declare function classModelToDiagram(model: MermaidClassModel): DiagramModel;
+export declare function classModelFromDiagram(diagram: DiagramModel): MermaidClassModel;
+export declare function generateMermaidClass(model: MermaidClassModel): string;
+export declare function generateClassFromDiagram(diagram: DiagramModel): string;