@polagram/core 0.0.2

package/dist/src/parser/languages/mermaid/constants.d.ts

@@ -0,0 +1,7 @@
+import { MessageNode } from '../../../ast';
+export declare const ARROW_MAPPING: Record<string, {
+    type: MessageNode['type'];
+    style: MessageNode['style'];
+}>;
+export declare const REVERSE_ARROW_MAPPING: Record<string, string>;
+export declare function getArrowString(type: MessageNode['type'], style: MessageNode['style']): string;

package/dist/src/parser/languages/mermaid/constants.js

@@ -0,0 +1,20 @@
+export const ARROW_MAPPING = {
+    '->': { type: 'sync', style: { line: 'solid', head: 'open' } },
+    '->>': { type: 'sync', style: { line: 'solid', head: 'arrow' } },
+    '-->': { type: 'reply', style: { line: 'dotted', head: 'open' } },
+    '-->>': { type: 'reply', style: { line: 'dotted', head: 'arrow' } },
+    '-)': { type: 'async', style: { line: 'solid', head: 'async' } },
+    '--)': { type: 'async', style: { line: 'dotted', head: 'async' } },
+    '-x': { type: 'destroy', style: { line: 'solid', head: 'cross' } },
+    '--x': { type: 'destroy', style: { line: 'dotted', head: 'cross' } },
+};
+export const REVERSE_ARROW_MAPPING = Object.entries(ARROW_MAPPING).reduce((acc, [key, value]) => {
+    // Create a unique key for the style + type combination to map back to the string
+    const lookupKey = JSON.stringify({ type: value.type, style: value.style });
+    acc[lookupKey] = key;
+    return acc;
+}, {});
+export function getArrowString(type, style) {
+    const key = JSON.stringify({ type, style });
+    return REVERSE_ARROW_MAPPING[key] || '->>'; // Default fallthrough
+}

package/dist/src/parser/languages/mermaid/index.d.ts

@@ -0,0 +1,4 @@
+import { DiagramParser } from '../../interface';
+export declare const mermaidParser: DiagramParser;
+export { Lexer } from './lexer';
+export { Parser } from './parser';

package/dist/src/parser/languages/mermaid/index.js

@@ -0,0 +1,11 @@
+import { Lexer } from './lexer';
+import { Parser } from './parser';
+export const mermaidParser = {
+    parse: (code) => {
+        const lexer = new Lexer(code);
+        const parser = new Parser(lexer);
+        return parser.parse();
+    }
+};
+export { Lexer } from './lexer';
+export { Parser } from './parser';

package/dist/src/parser/languages/mermaid/lexer.d.ts

@@ -0,0 +1,14 @@
+import { BaseLexer } from '../../base/lexer';
+import { Token } from './tokens';
+export declare class Lexer extends BaseLexer {
+    constructor(input: string);
+    nextToken(): Token;
+    private newToken;
+    private readIdentifier;
+    private readNumber;
+    private readString;
+    private isArrowStart;
+    private readArrow;
+    private readMulti;
+    private lookupIdent;
+}

package/dist/src/parser/languages/mermaid/lexer.js

@@ -0,0 +1,152 @@
+import { BaseLexer } from '../../base/lexer';
+export class Lexer extends BaseLexer {
+    constructor(input) {
+        super(input);
+    }
+    nextToken() {
+        this.skipWhitespace();
+        const start = this.position;
+        const startColumn = this.column;
+        let tok;
+        switch (this.ch) {
+            case ':':
+                tok = this.newToken('COLON', this.ch, start, startColumn);
+                break;
+            case ',':
+                tok = this.newToken('COMMA', this.ch, start, startColumn);
+                break;
+            case '+':
+                tok = this.newToken('PLUS', this.ch, start, startColumn);
+                break;
+            case '-':
+                if (this.isArrowStart()) {
+                    const literal = this.readArrow();
+                    tok = this.newToken('ARROW', literal, start, startColumn);
+                    return tok;
+                }
+                else {
+                    tok = this.newToken('MINUS', this.ch, start, startColumn);
+                }
+                break;
+            case '"':
+                // eslint-disable-next-line no-case-declarations
+                const str = this.readString();
+                tok = this.newToken('STRING', str, start, startColumn);
+                return tok;
+            case '\n':
+                tok = this.newToken('NEWLINE', this.ch, start, startColumn);
+                break;
+            case '':
+                tok = this.newToken('EOF', '', start, startColumn);
+                break;
+            default:
+                if (this.isLetter(this.ch)) {
+                    const literal = this.readIdentifier();
+                    const type = this.lookupIdent(literal);
+                    return this.newToken(type, literal, start, startColumn);
+                }
+                else if (this.isDigit(this.ch)) {
+                    const literal = this.readNumber();
+                    return this.newToken('IDENTIFIER', literal, start, startColumn);
+                }
+                else {
+                    tok = this.newToken('UNKNOWN', this.ch, start, startColumn);
+                }
+        }
+        this.readChar();
+        return tok;
+    }
+    newToken(type, literal, start, startColumn) {
+        return {
+            type: type,
+            literal,
+            line: this.line,
+            column: startColumn,
+            start,
+            // If the lexer position has advanced beyond the start (consumed tokens like String/Arrow), use that position.
+            // Otherwise (simple chars), assume length-based calculation.
+            end: (this.position > start) ? this.position : start + literal.length
+        };
+    }
+    readIdentifier() {
+        const position = this.position;
+        while (this.isLetter(this.ch) || this.isDigit(this.ch)) {
+            this.readChar();
+        }
+        return this.input.slice(position, this.position);
+    }
+    readNumber() {
+        const position = this.position;
+        while (this.isDigit(this.ch)) {
+            this.readChar();
+        }
+        return this.input.slice(position, this.position);
+    }
+    readString() {
+        const position = this.position + 1;
+        this.readChar();
+        while (this.ch !== '"' && this.ch !== '' && this.ch !== '\n') {
+            this.readChar();
+        }
+        const str = this.input.slice(position, this.position);
+        if (this.ch === '"') {
+            // Logic handled in nextToken via readChar or here?
+            // In BaseLexer readChar advances. 
+            // Original logic was slightly tricky.
+            // Let's keep consistent with valid implementation.
+        }
+        this.readChar();
+        return str;
+    }
+    isArrowStart() {
+        if (this.ch !== '-')
+            return false;
+        const next = this.peekChar();
+        return next === '>' || next === '-' || next === ')' || next === 'x';
+    }
+    readArrow() {
+        const potential4 = this.input.slice(this.position, this.position + 4);
+        if (potential4 === '-->>') {
+            this.readMulti(4);
+            return '-->>';
+        }
+        const potential3 = this.input.slice(this.position, this.position + 3);
+        if (potential3 === '-->' || potential3 === '--)' || potential3 === '->>' || potential3 === '--x') {
+            this.readMulti(3);
+            return potential3;
+        }
+        const potential2 = this.input.slice(this.position, this.position + 2);
+        if (potential2 === '->' || potential2 === '-)' || potential2 === '-x') {
+            this.readMulti(2);
+            return potential2;
+        }
+        return '-';
+    }
+    readMulti(count) {
+        for (let i = 0; i < count; i++)
+            this.readChar();
+    }
+    lookupIdent(ident) {
+        const keywords = {
+            'sequenceDiagram': 'SEQUENCE_DIAGRAM',
+            'participant': 'PARTICIPANT',
+            'actor': 'ACTOR',
+            'loop': 'LOOP',
+            'alt': 'ALT',
+            'opt': 'OPT',
+            'end': 'END',
+            'else': 'ELSE',
+            'note': 'NOTE',
+            'left': 'LEFT',
+            'right': 'RIGHT',
+            'over': 'OVER',
+            'of': 'OF',
+            'as': 'AS',
+            'title': 'TITLE',
+            'activate': 'ACTIVATE',
+            'deactivate': 'DEACTIVATE',
+            'box': 'BOX'
+        };
+        return keywords[ident] || 'IDENTIFIER';
+    }
+}

package/dist/src/parser/languages/mermaid/lexer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/parser/languages/mermaid/lexer.test.js

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest';
+import { Lexer } from './lexer';
+describe('Mermaid Lexer', () => {
+    const checkValues = (input, expected) => {
+        const lexer = new Lexer(input);
+        for (const [type, literal] of expected) {
+            const token = lexer.nextToken();
+            expect(token.type).toBe(type);
+            expect(token.literal).toBe(literal);
+        }
+    };
+    it('should parse simple tokens', () => {
+        const input = 'sequenceDiagram participant :';
+        checkValues(input, [
+            ['SEQUENCE_DIAGRAM', 'sequenceDiagram'],
+            ['PARTICIPANT', 'participant'],
+            ['COLON', ':']
+        ]);
+    });
+    it('should parse keywords correctly', () => {
+        // Re-verify 'participant'
+        const lexer = new Lexer('participant actor loop');
+        const t1 = lexer.nextToken();
+        expect(t1.type).toBe('PARTICIPANT');
+        const t2 = lexer.nextToken();
+        expect(t2.type).toBe('ACTOR');
+        const t3 = lexer.nextToken();
+        expect(t3.type).toBe('LOOP');
+    });
+    it('should parse arrows', () => {
+        checkValues('-> --> ->> -->> -) --) -x --x', [
+            ['ARROW', '->'],
+            ['ARROW', '-->'],
+            ['ARROW', '->>'],
+            ['ARROW', '-->>'],
+            ['ARROW', '-)'],
+            ['ARROW', '--)'],
+            // Let's debug my lexer readArrow implementation logic mentally.
+            // potential3: '--)' is checked.
+            // So expected is ARROW '--)'
+        ]);
+        const l2 = new Lexer('--)');
+        const t = l2.nextToken();
+        expect(t.type).toBe('ARROW');
+        expect(t.literal).toBe('--)');
+    });
+    it('should parse strings', () => {
+        checkValues('"hello world"', [
+            ['STRING', 'hello world']
+        ]);
+    });
+    it('should parse plus and minus', () => {
+        checkValues('+ -', [
+            ['PLUS', '+'],
+            ['MINUS', '-']
+        ]);
+    });
+});

package/dist/src/parser/languages/mermaid/parser.d.ts

@@ -0,0 +1,21 @@
+import { PolagramRoot } from '../../../ast';
+import { BaseParser } from '../../base/parser';
+import { Lexer } from './lexer';
+export declare class Parser extends BaseParser {
+    private currentGroup;
+    private idCounters;
+    constructor(lexer: Lexer);
+    parse(): PolagramRoot;
+    private parseBlock;
+    private isParticipantToken;
+    private parseGroup;
+    private parseFragment;
+    private parseParticipant;
+    private parseNote;
+    private parseActivation;
+    private parseMessage;
+    private resolveArrow;
+    private generateId;
+    private readRestOfLine;
+    private ensureParticipant;
+}

package/dist/src/parser/languages/mermaid/parser.js

@@ -0,0 +1,340 @@
+import { BaseParser } from '../../base/parser';
+import { ARROW_MAPPING } from './constants';
+export class Parser extends BaseParser {
+    constructor(lexer) {
+        super(lexer);
+        Object.defineProperty(this, "currentGroup", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "idCounters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                evt: 0,
+                frag: 0,
+                br: 0,
+                note: 0,
+                group: 0,
+            }
+        });
+    }
+    parse() {
+        const root = {
+            kind: 'root',
+            meta: { version: '1.0.0', source: 'unknown' },
+            participants: [],
+            groups: [],
+            events: []
+        };
+        root.events = this.parseBlock(root);
+        return root;
+    }
+    parseBlock(root, stopTokens = []) {
+        const events = [];
+        while (this.currToken.type !== 'EOF') {
+            const type = this.currToken.type;
+            if (stopTokens.includes(type)) {
+                return events;
+            }
+            if (type === 'NEWLINE') {
+                this.advance();
+                continue;
+            }
+            if (type === 'SEQUENCE_DIAGRAM') {
+                root.meta.source = 'mermaid';
+                this.advance();
+                continue;
+            }
+            if (type === 'TITLE') {
+                this.advance(); // eat TITLE
+                root.meta.title = this.readRestOfLine();
+                continue;
+            }
+            if (type === 'BOX') {
+                const groupEvents = this.parseGroup(root);
+                events.push(...groupEvents);
+                continue;
+            }
+            if (type === 'PARTICIPANT' || type === 'ACTOR') {
+                this.parseParticipant(root);
+                continue;
+            }
+            if (type === 'LOOP' || type === 'ALT' || type === 'OPT') {
+                events.push(this.parseFragment(root));
+                continue;
+            }
+            if (type === 'NOTE') {
+                events.push(this.parseNote(root));
+                continue;
+            }
+            if (type === 'ACTIVATE' || type === 'DEACTIVATE') {
+                events.push(this.parseActivation(root));
+                continue;
+            }
+            if (this.isParticipantToken(this.currToken)) {
+                const msg = this.parseMessage(root);
+                if (msg) {
+                    events.push(msg);
+                    continue;
+                }
+            }
+            // Skip unknown or unhandled
+            this.advance();
+        }
+        return events;
+    }
+    isParticipantToken(tok) {
+        return tok.type === 'IDENTIFIER' || tok.type === 'STRING';
+    }
+    parseGroup(root) {
+        this.advance(); // eat 'box'
+        const rawAttrs = this.readRestOfLine().trim();
+        let name = rawAttrs;
+        let color;
+        const parts = rawAttrs.split(/\s+/);
+        if (parts.length > 0) {
+            const first = parts[0];
+            if (first.startsWith('#') || ['rgb', 'rgba', 'transparent', 'aqua', 'grey', 'gray', 'purple', 'red', 'blue', 'green'].includes(first.toLowerCase())) {
+                color = first;
+                name = parts.slice(1).join(' ');
+            }
+        }
+        if (!name)
+            name = `Group ${this.idCounters.group + 1}`;
+        const group = {
+            kind: 'group',
+            id: this.generateId('group'),
+            name: name,
+            type: 'box',
+            participantIds: [],
+            style: color ? { backgroundColor: color } : undefined
+        };
+        root.groups.push(group);
+        // Set current group context
+        const previousGroup = this.currentGroup;
+        this.currentGroup = group;
+        // Parse content until 'end'
+        const events = this.parseBlock(root, ['END']);
+        // Restore context
+        this.currentGroup = previousGroup;
+        if (this.currToken.type === 'END') {
+            this.advance(); // eat 'end'
+        }
+        return events;
+    }
+    parseFragment(root) {
+        const type = this.currToken.type;
+        let operator = 'loop';
+        if (type === 'ALT')
+            operator = 'alt';
+        if (type === 'OPT')
+            operator = 'opt';
+        this.advance(); // eat operator
+        const condition = this.readRestOfLine();
+        const branches = [];
+        const events = this.parseBlock(root, ['END', 'ELSE']);
+        branches.push({
+            id: this.generateId('br'),
+            condition,
+            events
+        });
+        while (this.currToken.type === 'ELSE') {
+            this.advance();
+            const elseCond = this.readRestOfLine();
+            const elseEvents = this.parseBlock(root, ['END', 'ELSE']);
+            branches.push({
+                id: this.generateId('br'),
+                condition: elseCond,
+                events: elseEvents
+            });
+        }
+        if (this.currToken.type === 'END') {
+            this.advance();
+        }
+        return {
+            kind: 'fragment',
+            id: this.generateId('frag'),
+            operator,
+            branches
+        };
+    }
+    parseParticipant(root) {
+        const isActor = this.currToken.type === 'ACTOR';
+        this.advance(); // eat 'participant' or 'actor'
+        let id = '';
+        let name = '';
+        if (this.isParticipantToken(this.currToken)) {
+            id = this.currToken.literal;
+            name = id;
+            this.advance();
+        }
+        // Check for 'as'
+        if (this.currToken.type === 'AS') {
+            this.advance(); // eat 'as'
+            // Use readRestOfLine to capture multi-word aliases (e.g., "API Server")
+            const alias = this.readRestOfLine().trim();
+            if (alias) {
+                name = alias;
+            }
+        }
+        const existing = root.participants.find(p => p.id === id);
+        if (!existing) {
+            root.participants.push({
+                id,
+                name,
+                type: isActor ? 'actor' : 'participant'
+            });
+        }
+        else {
+            if (name !== id)
+                existing.name = name;
+            if (isActor)
+                existing.type = 'actor';
+        }
+        // Assign to current group if exists
+        if (this.currentGroup) {
+            if (!this.currentGroup.participantIds.includes(id)) {
+                this.currentGroup.participantIds.push(id);
+            }
+        }
+    }
+    parseNote(root) {
+        this.advance(); // eat 'note'
+        let position = 'over'; // default
+        if (this.currToken.type === 'LEFT') {
+            position = 'left';
+            this.advance();
+        }
+        else if (this.currToken.type === 'RIGHT') {
+            position = 'right';
+            this.advance();
+        }
+        else if (this.currToken.type === 'OVER') {
+            position = 'over';
+            this.advance();
+        }
+        // consume 'of' if present (optional in some cases but usually note right of A)
+        if (this.currToken.type === 'OF') {
+            this.advance();
+        }
+        const participantIds = [];
+        while (this.isParticipantToken(this.currToken)) {
+            participantIds.push(this.currToken.literal);
+            this.ensureParticipant(root, this.currToken.literal);
+            this.advance();
+            if (this.currToken.type === 'COMMA') {
+                this.advance();
+            }
+            else {
+                break;
+            }
+        }
+        let text = '';
+        if (this.currToken.type === 'COLON') {
+            this.advance();
+            text = this.readRestOfLine();
+        }
+        return {
+            kind: 'note',
+            id: this.generateId('note'),
+            position,
+            participantIds,
+            text
+        };
+    }
+    parseActivation(root) {
+        const action = this.currToken.type === 'ACTIVATE' ? 'activate' : 'deactivate';
+        this.advance(); // eat command
+        let participantId = '';
+        if (this.isParticipantToken(this.currToken)) {
+            participantId = this.currToken.literal;
+            this.ensureParticipant(root, participantId);
+            this.advance();
+        }
+        return {
+            kind: 'activation',
+            participantId,
+            action
+        };
+    }
+    parseMessage(root) {
+        if (this.peekToken.type !== 'ARROW') {
+            return null;
+        }
+        const fromId = this.currToken.literal;
+        this.ensureParticipant(root, fromId);
+        this.advance(); // eat from
+        if (this.currToken.type !== 'ARROW') {
+            return null;
+        }
+        const arrowLiteral = this.currToken.literal;
+        this.advance(); // eat arrow
+        let activateTarget = false;
+        let deactivateSource = false;
+        if (this.currToken.type === 'PLUS') {
+            activateTarget = true;
+            this.advance();
+        }
+        if (this.currToken.type === 'MINUS') {
+            deactivateSource = true;
+            this.advance();
+        }
+        if (!this.isParticipantToken(this.currToken))
+            return null;
+        const toId = this.currToken.literal;
+        this.ensureParticipant(root, toId);
+        this.advance(); // eat to
+        let text = '';
+        if (this.currToken.type === 'COLON') {
+            this.advance();
+            text = this.readRestOfLine();
+        }
+        const { type, style } = this.resolveArrow(arrowLiteral);
+        return {
+            kind: 'message',
+            id: this.generateId('evt'),
+            from: fromId,
+            to: toId,
+            text: text,
+            type: type,
+            style: style,
+            lifecycle: (activateTarget || deactivateSource) ? { activateTarget, deactivateSource } : undefined
+        };
+    }
+    resolveArrow(arrow) {
+        const mapping = ARROW_MAPPING[arrow];
+        if (mapping) {
+            return mapping;
+        }
+        return { type: 'sync', style: { line: 'solid', head: 'arrow' } };
+    }
+    generateId(prefix) {
+        this.idCounters[prefix]++;
+        return `${prefix}_${this.idCounters[prefix]}`;
+    }
+    readRestOfLine() {
+        if (this.currToken.type === 'NEWLINE' || this.currToken.type === 'EOF') {
+            return '';
+        }
+        const start = this.currToken.start;
+        let end = this.currToken.end;
+        while (this.currToken.type !== 'NEWLINE' && this.currToken.type !== 'EOF') {
+            end = this.currToken.end;
+            this.advance();
+        }
+        return this.lexer.getInput().slice(start, end);
+    }
+    ensureParticipant(root, id) {
+        if (!root.participants.find(p => p.id === id)) {
+            root.participants.push({
+                id,
+                name: id,
+                type: 'participant'
+            });
+        }
+    }
+}

package/dist/src/parser/languages/mermaid/parser.test.d.ts

@@ -0,0 +1 @@
+export {};