@polagram/core 0.0.4 → 0.1.0

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

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

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

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

@@ -1,252 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Lexer } from './lexer';
-import { Parser } from './parser';
-describe('Mermaid Parser', () => {
-    const parse = (input) => {
-        const lexer = new Lexer(input);
-        const parser = new Parser(lexer);
-        return parser.parse();
-    };
-    describe('Basic Document Structure', () => {
-        it('should parse "sequenceDiagram" header', () => {
-            const input = `sequenceDiagram`;
-            const ast = parse(input);
-            expect(ast.kind).toBe('root');
-            expect(ast.meta.source).toBe('mermaid');
-            expect(ast.participants).toEqual([]);
-            expect(ast.events).toEqual([]);
-        });
-        it('should handle newlines around header', () => {
-            const input = `
-sequenceDiagram
-`;
-            const ast = parse(input);
-            expect(ast.meta.source).toBe('mermaid');
-        });
-    });
-    describe('Participant Definitions', () => {
-        it('should parse simple participant', () => {
-            const input = `
-sequenceDiagram
-participant Alice
-participant Bob
-`;
-            const ast = parse(input);
-            expect(ast.participants).toHaveLength(2);
-            expect(ast.participants[0]).toMatchObject({
-                id: 'Alice',
-                name: 'Alice',
-                type: 'participant'
-            });
-            expect(ast.participants[1]).toMatchObject({
-                id: 'Bob',
-                name: 'Bob',
-                type: 'participant'
-            });
-        });
-        it('should parse participant with multi-word alias', () => {
-            const input = `
-sequenceDiagram
-participant API as API Server
-participant DB as Database System
-API->>DB: Query
-`;
-            const ast = parse(input);
-            const api = ast.participants.find(p => p.id === 'API');
-            expect(api).toBeDefined();
-            expect(api?.name).toBe('API Server');
-        });
-    });
-    describe('Message Definitions', () => {
-        it('should parse sync message and implicit participants', () => {
-            const input = `
-sequenceDiagram
-A->B: Hello
-`;
-            const ast = parse(input);
-            expect(ast.participants).toHaveLength(2);
-            expect(ast.participants).toMatchObject([
-                { id: 'A', name: 'A' },
-                { id: 'B', name: 'B' }
-            ]);
-            expect(ast.events).toHaveLength(1);
-            expect(ast.events[0]).toMatchObject({
-                kind: 'message',
-                from: 'A',
-                to: 'B',
-                text: 'Hello',
-                type: 'sync',
-                style: { line: 'solid', head: 'open' }
-            });
-        });
-        it('should parse various arrow types', () => {
-            const input = `
-sequenceDiagram
-A->>B: Arrow
-A-->>B: Reply Arrow
-A-->B: Dotted Open
-A-xB: Cross
-`;
-            const ast = parse(input);
-            expect(ast.events).toHaveLength(4);
-            const m1 = ast.events[0];
-            const m2 = ast.events[1];
-            const m3 = ast.events[2];
-            const m4 = ast.events[3];
-            // ->> : sync, solid, arrow
-            expect(m1).toMatchObject({
-                kind: 'message',
-                type: 'sync',
-                style: { line: 'solid', head: 'arrow' }
-            });
-            // -->> : reply, dotted, arrow
-            expect(m2).toMatchObject({
-                kind: 'message',
-                type: 'reply',
-                style: { line: 'dotted', head: 'arrow' }
-            });
-            // --> : reply, dotted, open
-            expect(m3).toMatchObject({
-                kind: 'message',
-                type: 'reply',
-                style: { line: 'dotted', head: 'open' }
-            });
-            // -x : destroy, solid, cross
-            expect(m4).toMatchObject({
-                kind: 'message',
-                type: 'destroy',
-                style: { line: 'solid', head: 'cross' }
-            });
-        });
-        it('should parse lifecycle activations in messages', () => {
-            const input = `
-sequenceDiagram
-A->>+B: Activate Target
-B-->>-A: Deactivate Source
-`;
-            const ast = parse(input);
-            const m1 = ast.events[0];
-            const m2 = ast.events[1];
-            if (m1.kind !== 'message' || m2.kind !== 'message') {
-                throw new Error('Expected message events');
-            }
-            expect(m1.lifecycle).toMatchObject({ activateTarget: true, deactivateSource: false });
-            expect(m2.lifecycle).toMatchObject({ activateTarget: false, deactivateSource: true });
-        });
-    });
-    describe('Lifecycle Definitions', () => {
-        it('should parse standalone activate/deactivate', () => {
-            const input = `
-sequenceDiagram
-activate A
-deactivate A
-`;
-            const ast = parse(input);
-            expect(ast.events).toHaveLength(2);
-            expect(ast.events[0]).toMatchObject({ kind: 'activation', participantId: 'A', action: 'activate' });
-            expect(ast.events[1]).toMatchObject({ kind: 'activation', participantId: 'A', action: 'deactivate' });
-        });
-    });
-    describe('Note Definitions', () => {
-        it('should parse note positions', () => {
-            const input = `
-sequenceDiagram
-note left of A: Note Left
-note right of A: Note Right
-note over A: Note Over
-`;
-            const ast = parse(input);
-            expect(ast.events).toHaveLength(3);
-            expect(ast.events[0]).toMatchObject({ kind: 'note', position: 'left', participantIds: ['A'], text: 'Note Left' });
-            expect(ast.events[1]).toMatchObject({ kind: 'note', position: 'right', participantIds: ['A'], text: 'Note Right' });
-            expect(ast.events[2]).toMatchObject({ kind: 'note', position: 'over', participantIds: ['A'], text: 'Note Over' });
-        });
-        it('should parse note over multiple participants', () => {
-            const input = `sequenceDiagram\nnote over A,B: Shared Note`;
-            const ast = parse(input);
-            expect(ast.events[0]).toMatchObject({ kind: 'note', position: 'over', participantIds: ['A', 'B'], text: 'Shared Note' });
-        });
-    });
-    describe('Fragment Definitions', () => {
-        it('should parse loop fragment', () => {
-            const input = `
-sequenceDiagram
-loop Every minute
-  A->B: Check
-end
-`;
-            const ast = parse(input);
-            expect(ast.events).toHaveLength(1);
-            const fragment = ast.events[0];
-            expect(fragment.kind).toBe('fragment');
-            if (fragment.kind !== 'fragment')
-                return; // type guard
-            expect(fragment.operator).toBe('loop');
-            expect(fragment.branches).toHaveLength(1);
-            expect(fragment.branches[0].condition).toBe('Every minute');
-            expect(fragment.branches[0].events).toHaveLength(1);
-            expect(fragment.branches[0].events[0].kind).toBe('message');
-        });
-        it('should parse alt/else fragment', () => {
-            const input = `
-sequenceDiagram
-alt Success
-    A->B: OK
-else Failure
-    A->B: Error
-end
-`;
-            const ast = parse(input);
-            const fragment = ast.events[0];
-            expect(fragment.kind).toBe('fragment');
-            expect(fragment.operator).toBe('alt');
-            expect(fragment.branches).toHaveLength(2);
-            expect(fragment.branches[0].condition).toBe('Success');
-            expect(fragment.branches[0].events).toHaveLength(1);
-            expect(fragment.branches[1].condition).toBe('Failure');
-            expect(fragment.branches[1].events).toHaveLength(1);
-        });
-    });
-    describe('Box/Group Definitions', () => {
-        it('should parse box definition with color and name', () => {
-            const code = `
-  sequenceDiagram
-  box "Frontend" #eef
-      participant A
-      participant B
-  end
-  box Backend
-      participant C
-  end
-  A->>C: Request
-  C-->>A: Response
-      `;
-            const ast = parse(code);
-            // Verify participants
-            expect(ast.participants).toHaveLength(3);
-            expect(ast.participants.map(p => p.id)).toEqual(['A', 'B', 'C']);
-            // Verify groups
-            expect(ast.groups).toHaveLength(2);
-            const group1 = ast.groups[0];
-            expect(group1.name).toContain('Frontend');
-            expect(group1.participantIds).toEqual(['A', 'B']);
-            const group2 = ast.groups[1];
-            expect(group2.name).toBe('Backend');
-            expect(group2.participantIds).toEqual(['C']);
-        });
-        it('should handle messages inside box block', () => {
-            const code = `
-  sequenceDiagram
-  participant U
-  box App
-      participant A
-      U->>A: inside box
-  end
-      `;
-            const ast = parse(code);
-            expect(ast.events).toHaveLength(1);
-            expect(ast.events[0].kind).toBe('message');
-            expect(ast.groups[0].participantIds).toEqual(['A']);
-        });
-    });
-});

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

@@ -1,9 +0,0 @@
-export type TokenType = 'SEQUENCE_DIAGRAM' | 'NEWLINE' | 'EOF' | 'PARTICIPANT' | 'COLON' | 'IDENTIFIER' | 'STRING' | 'ARROW' | 'LOOP' | 'ALT' | 'OPT' | 'END' | 'ELSE' | 'UNKNOWN' | 'AS' | 'ACTOR' | 'TITLE' | 'NOTE' | 'LEFT' | 'RIGHT' | 'OVER' | 'OF' | 'ACTIVATE' | 'DEACTIVATE' | 'PLUS' | 'MINUS' | 'COMMA' | 'BOX';
-export interface Token {
-    type: TokenType;
-    literal: string;
-    line: number;
-    column: number;
-    start: number;
-    end: number;
-}

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

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

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

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

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

@@ -1,11 +0,0 @@
-import { Lexer } from './lexer';
-import { Parser } from './parser';
-export const plantumlParser = {
-    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/plantuml/lexer.d.ts

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