@grafloria/element 0.3.20 → 0.3.22

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

@@ -1,521 +0,0 @@
-"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

@@ -1,136 +0,0 @@
-/**
- * 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;