@polagram/core 0.0.4 → 0.1.0

package/dist/src/generator/generators/mermaid.test.js

@@ -1,70 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { MermaidGeneratorVisitor } from './mermaid';
-describe('MermaidGeneratorVisitor', () => {
-    it('should generate sequence diagram header', () => {
-        const root = { kind: 'root', meta: { version: '1.0.0', source: 'mermaid' }, participants: [], groups: [], events: [] };
-        const visitor = new MermaidGeneratorVisitor();
-        const output = visitor.generate(root);
-        expect(output).toContain('sequenceDiagram');
-    });
-    it('should generate title if present', () => {
-        const root = { kind: 'root', meta: { version: '1.0.0', source: 'mermaid', title: 'My Diagram' }, participants: [], groups: [], events: [] };
-        const visitor = new MermaidGeneratorVisitor();
-        const output = visitor.generate(root);
-        expect(output).toContain('title My Diagram');
-    });
-    it('should generate participants', () => {
-        const root = {
-            kind: 'root',
-            meta: { version: '1.0.0', source: 'mermaid' },
-            participants: [
-                { id: 'A', name: 'Alice', type: 'participant' },
-                { id: 'B', name: 'Bob', type: 'actor' }
-            ],
-            groups: [],
-            events: []
-        };
-        const visitor = new MermaidGeneratorVisitor();
-        const output = visitor.generate(root);
-        expect(output).toContain('participant A as Alice');
-        expect(output).toContain('actor B as Bob');
-    });
-    it('should generate participant with multi-word name without extra quotes', () => {
-        const root = {
-            kind: 'root',
-            meta: { version: '1.0.0', source: 'mermaid' },
-            participants: [
-                { id: 'API', name: 'API Server', type: 'participant' }
-            ],
-            groups: [],
-            events: []
-        };
-        const visitor = new MermaidGeneratorVisitor();
-        const output = visitor.generate(root);
-        // We expect it NOT to be quoted if the user wants clean text
-        // But currently it IS quoted. checking what it does now vs what we want.
-        // If we want to fix it, we should expect "API Server" plain.
-        expect(output).toContain('participant API as API Server');
-    });
-    it('should generate messages', () => {
-        const msg = {
-            kind: 'message',
-            id: '1',
-            from: 'A',
-            to: 'B',
-            text: 'hello',
-            type: 'sync',
-            style: { line: 'solid', head: 'arrow' }
-        };
-        const root = {
-            kind: 'root',
-            meta: { version: '1.0.0', source: 'mermaid' },
-            participants: [],
-            groups: [],
-            events: [msg]
-        };
-        const visitor = new MermaidGeneratorVisitor();
-        const output = visitor.generate(root);
-        expect(output).toContain('A->>B: hello');
-    });
-});

package/dist/src/generator/generators/plantuml.d.ts

@@ -1,17 +0,0 @@
-import { ActivationNode, DividerNode, FragmentNode, MessageNode, NoteNode, Participant, ParticipantGroup, PolagramRoot, ReferenceNode, SpacerNode } from '../../ast';
-import { PolagramVisitor } from '../interface';
-export declare class PlantUMLGeneratorVisitor implements PolagramVisitor {
-    generate(root: PolagramRoot): string;
-    visitRoot(node: PolagramRoot): string;
-    visitParticipant(node: Participant): string;
-    visitGroup(node: ParticipantGroup, context?: Map<string, Participant>): string;
-    visitMessage(node: MessageNode): string;
-    visitFragment(node: FragmentNode): string;
-    private visitEvent;
-    visitNote(node: NoteNode): string;
-    visitActivation(node: ActivationNode): string;
-    visitParticipantGroup(_node: ParticipantGroup): string;
-    visitDivider(_node: DividerNode): string;
-    visitSpacer(_node: SpacerNode): string;
-    visitReference(_node: ReferenceNode): string;
-}

package/dist/src/generator/generators/plantuml.js

@@ -1,131 +0,0 @@
-export class PlantUMLGeneratorVisitor {
-    generate(root) {
-        return this.visitRoot(root);
-    }
-    visitRoot(node) {
-        const lines = ['@startuml'];
-        if (node.meta.title) {
-            lines.push(`title ${node.meta.title}`);
-        }
-        const participantsMap = new Map(node.participants.map(p => [p.id, p]));
-        const groupedParticipantIds = new Set();
-        // Groups
-        for (const group of node.groups) {
-            lines.push(this.visitGroup(group, participantsMap));
-            group.participantIds.forEach(id => groupedParticipantIds.add(id));
-        }
-        // Ungrouped Participants
-        for (const participant of node.participants) {
-            if (!groupedParticipantIds.has(participant.id)) {
-                lines.push(this.visitParticipant(participant));
-            }
-        }
-        // Events
-        for (const event of node.events) {
-            lines.push(this.visitEvent(event));
-        }
-        lines.push('@enduml');
-        return lines.join('\n');
-    }
-    visitParticipant(node) {
-        // If Name == ID, use concise format: "type ID"
-        // Otherwise use explicit format: "type "Name" as ID"
-        if (node.name === node.id) {
-            return `${node.type} ${node.id}`;
-        }
-        return `${node.type} "${node.name}" as ${node.id}`;
-    }
-    // Adjusted signature to pass context
-    visitGroup(node, context) {
-        const parts = [];
-        const color = node.style?.backgroundColor ? ` ${node.style.backgroundColor}` : '';
-        const title = node.name ? ` "${node.name}"` : '';
-        parts.push(`box${title}${color}`);
-        if (context) {
-            for (const pid of node.participantIds) {
-                const p = context.get(pid);
-                if (p) {
-                    parts.push(this.visitParticipant(p));
-                }
-            }
-        }
-        parts.push('end box');
-        return parts.join('\n');
-    }
-    visitMessage(node) {
-        const from = node.from || '[*]'; // Handle lost/found if needed
-        const to = node.to || '[*]';
-        let arrow = '->';
-        if (node.type === 'reply')
-            arrow = '-->';
-        else if (node.type === 'async')
-            arrow = '->>'; // PlantUML doesn't strictly distinguish async arrow head generally, but ->> is fine
-        // style override
-        if (node.style.line === 'dotted') {
-            // If reply, already --> (dotted). If sync but dotted: A -[dotted]-> B ?
-            // PlantUML: A ..> B
-            // But --> is usually standard reply.
-        }
-        return `${from} ${arrow} ${to}: ${node.text}`;
-    }
-    visitFragment(node) {
-        const lines = [];
-        const op = node.operator;
-        node.branches.forEach((branch, index) => {
-            if (index === 0) {
-                lines.push(`${op} ${branch.condition || ''}`.trim());
-            }
-            else {
-                lines.push(`else ${branch.condition || ''}`.trim());
-            }
-            for (const event of branch.events) {
-                // We need to recursively visit events (messages, nested fragments, etc.)
-                // But we can't easily call visitX because we don't know the type statically here or need a centralized dispatcher that returns string.
-                // But wait, visitRoot has a dispatcher. We should extract it to `visitEvent`.
-                // For now, let's duplicate the relevant dispatch logic or creating a helper.
-                lines.push(this.visitEvent(event));
-            }
-        });
-        lines.push('end');
-        return lines.join('\n');
-    }
-    visitEvent(event) {
-        switch (event.kind) {
-            case 'message': return this.visitMessage(event);
-            case 'fragment': return this.visitFragment(event);
-            case 'note': return this.visitNote(event);
-            case 'activation': return this.visitActivation(event);
-            case 'divider': return this.visitDivider(event);
-            case 'spacer': return this.visitSpacer(event);
-            case 'ref': return this.visitReference(event);
-            default: return '';
-        }
-    }
-    visitNote(node) {
-        const position = node.position || 'over';
-        const participants = node.participantIds.join(', ');
-        // note left of A: Text
-        // note over A, B: Text
-        // For 'over', we don't say 'of' in standard examples? "note over Alice", "note over Alice, Bob"
-        // But 'left of', 'right of' use 'of'.
-        const positionStr = (position === 'left' || position === 'right') ? `${position} of` : position;
-        return `note ${positionStr} ${participants}: ${node.text}`;
-    }
-    visitActivation(node) {
-        // activate A
-        // deactivate A
-        return `${node.action} ${node.participantId}`;
-    }
-    visitParticipantGroup(_node) {
-        return '';
-    }
-    visitDivider(_node) {
-        return '';
-    }
-    visitSpacer(_node) {
-        return '';
-    }
-    visitReference(_node) {
-        return '';
-    }
-}

package/dist/src/generator/generators/plantuml.test.d.ts

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

package/dist/src/generator/generators/plantuml.test.js

@@ -1,143 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { PlantUMLGeneratorVisitor } from './plantuml';
-describe('PlantUML Generator', () => {
-    const generator = new PlantUMLGeneratorVisitor();
-    it('should generate basic document structure', () => {
-        const ast = {
-            kind: 'root',
-            meta: { version: '1.0.0', source: 'plantuml', title: 'My Diagram' },
-            participants: [],
-            groups: [],
-            events: []
-        };
-        const code = generator.generate(ast);
-        expect(code).toContain('@startuml');
-        expect(code).toContain('title My Diagram');
-        expect(code).toContain('@enduml');
-    });
-    it('should generate participants', () => {
-        const ast = {
-            kind: 'root',
-            meta: { version: '1.0.0', source: 'plantuml' },
-            participants: [
-                { id: 'User', name: 'User', type: 'actor' },
-                { id: 'DB', name: 'DB', type: 'database' },
-                { id: 'Svc', name: 'Service', type: 'participant' }
-            ],
-            groups: [],
-            events: []
-        };
-        const code = generator.generate(ast);
-        expect(code).toContain('actor User');
-        expect(code).toContain('database DB');
-        expect(code).toContain('participant "Service" as Svc');
-    });
-    it('should generate messages', () => {
-        const ast = {
-            kind: 'root',
-            meta: { version: '1.0.0', source: 'plantuml' },
-            participants: [
-                { id: 'A', name: 'A', type: 'participant' },
-                { id: 'B', name: 'B', type: 'participant' }
-            ],
-            groups: [],
-            events: [
-                { kind: 'message', id: 'm1', from: 'A', to: 'B', text: 'Sync', type: 'sync', style: { line: 'solid', head: 'arrow' } },
-                { kind: 'message', id: 'm2', from: 'B', to: 'A', text: 'Reply', type: 'reply', style: { line: 'dotted', head: 'arrow' } },
-                { kind: 'message', id: 'm3', from: 'A', to: 'A', text: 'Self', type: 'sync', style: { line: 'solid', head: 'arrow' } }
-            ]
-        };
-        const code = generator.generate(ast);
-        expect(code).toContain('A -> B: Sync');
-        expect(code).toContain('B --> A: Reply');
-        expect(code).toContain('A -> A: Self');
-    });
-    it('should generate fragments', () => {
-        const ast = {
-            kind: 'root',
-            meta: { version: '1.0.0', source: 'plantuml' },
-            participants: [],
-            groups: [],
-            events: [
-                {
-                    kind: 'fragment',
-                    id: 'f1',
-                    operator: 'alt',
-                    branches: [
-                        { id: 'b1', condition: 'success', events: [
-                                { kind: 'message', id: 'm1', from: 'A', to: 'B', text: 'OK', type: 'sync', style: { line: 'solid', head: 'arrow' } }
-                            ] },
-                        { id: 'b2', condition: 'failure', events: [
-                                { kind: 'message', id: 'm2', from: 'A', to: 'B', text: 'Fail', type: 'sync', style: { line: 'solid', head: 'arrow' } }
-                            ] }
-                    ]
-                }
-            ]
-        };
-        const code = generator.generate(ast);
-        expect(code).toContain('alt success');
-        expect(code).toContain('A -> B: OK');
-        expect(code).toContain('else failure');
-        expect(code).toContain('A -> B: Fail');
-        expect(code).toContain('end');
-    });
-    it('should generate notes', () => {
-        const ast = {
-            kind: 'root',
-            meta: { version: '1.0.0', source: 'plantuml' },
-            participants: [
-                { id: 'A', name: 'A', type: 'participant' }
-            ],
-            groups: [],
-            events: [
-                { kind: 'note', id: 'n1', text: 'My Note', position: 'right', participantIds: ['A'] },
-                { kind: 'note', id: 'n2', text: 'Over Note', position: 'over', participantIds: ['A'] }
-            ]
-        };
-        const code = generator.generate(ast);
-        expect(code).toContain('note right of A: My Note');
-        expect(code).toContain('note over A: Over Note');
-    });
-    it('should generate lifecycle events', () => {
-        const ast = {
-            kind: 'root',
-            meta: { version: '1.0.0', source: 'plantuml' },
-            participants: [
-                { id: 'A', name: 'A', type: 'participant' }
-            ],
-            groups: [],
-            events: [
-                { kind: 'activation', participantId: 'A', action: 'activate' },
-                // Some message presumably
-                { kind: 'activation', participantId: 'A', action: 'deactivate' }
-            ]
-        };
-        const code = generator.generate(ast);
-        expect(code).toContain('activate A');
-        expect(code).toContain('deactivate A');
-    });
-    it('should generate groups', () => {
-        const ast = {
-            kind: 'root',
-            meta: { version: '1.0.0', source: 'plantuml' },
-            participants: [
-                { id: 'A', name: 'A', type: 'participant' },
-                { id: 'B', name: 'B', type: 'participant' },
-                { id: 'C', name: 'C', type: 'participant' }
-            ],
-            groups: [
-                { kind: 'group', id: 'g1', name: 'Box1', type: 'box', participantIds: ['A', 'B'], style: { backgroundColor: '#LightBlue' } }
-            ],
-            events: []
-        };
-        const code = generator.generate(ast);
-        // Expect Box1 to contain A and B
-        // C should be outside
-        // Exact order depends on implementation, but box should be there
-        expect(code).toContain('box "Box1" #LightBlue');
-        expect(code).toContain('participant A');
-        expect(code).toContain('participant B');
-        expect(code).toContain('end box');
-        expect(code).toContain('participant C');
-    });
-});

package/dist/src/generator/interface.d.ts

@@ -1,17 +0,0 @@
-import { ActivationNode, DividerNode, FragmentNode, MessageNode, NoteNode, Participant, ParticipantGroup, PolagramRoot, ReferenceNode, SpacerNode } from '../ast';
-/**
- * Visitor interface for traversing the Polagram AST.
- * Implement this interface to create code generators, validators, etc.
- */
-export interface PolagramVisitor {
-    visitRoot(node: PolagramRoot): void;
-    visitParticipant(node: Participant): void;
-    visitParticipantGroup(node: ParticipantGroup): void;
-    visitMessage(node: MessageNode): void;
-    visitFragment(node: FragmentNode): void;
-    visitNote(node: NoteNode): void;
-    visitActivation(node: ActivationNode): void;
-    visitDivider(node: DividerNode): void;
-    visitSpacer(node: SpacerNode): void;
-    visitReference(node: ReferenceNode): void;
-}

package/dist/src/generator/interface.js

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

package/dist/src/index.d.ts

@@ -1,13 +0,0 @@
-export * from './ast';
-export { ParserFactory } from './parser';
-export { FormatDetector } from './parser/format-detector';
-export type { DiagramFormat } from './parser/format-detector';
-export type { DiagramParser } from './parser/interface';
-export { Traverser } from './generator/base/walker';
-export type { PolagramVisitor } from './generator/interface';
-export * from './config/schema';
-export { MermaidGeneratorVisitor } from './generator/generators/mermaid';
-export { PlantUMLGeneratorVisitor } from './generator/generators/plantuml';
-export * from './transformer';
-export { Polagram, PolagramBuilder } from './api';
-export * from './config';

package/dist/src/index.js

@@ -1,21 +0,0 @@
-// Public API Exports
-// AST
-export * from './ast';
-// Parsers (Factory & Strategy)
-export { ParserFactory } from './parser';
-export { FormatDetector } from './parser/format-detector';
-// Generators
-export { Traverser } from './generator/base/walker';
-// Default Implementations (Optional, or force users to use Factory)
-// We export Mermaid Generator specifically as it might be used directly or via a future Factory
-// Config & Validation
-export * from './config/schema';
-export { MermaidGeneratorVisitor } from './generator/generators/mermaid';
-export { PlantUMLGeneratorVisitor } from './generator/generators/plantuml';
-// Transformation Engine
-export * from './transformer';
-// Fluent API (Recommended for most users)
-export { Polagram, PolagramBuilder } from './api';
-// Legacy compatibility or convenience helpers could go here if needed.
-// Configuration & Schema
-export * from './config';

package/dist/src/parser/base/lexer.d.ts

@@ -1,18 +0,0 @@
-import { BaseToken } from './token';
-export declare abstract class BaseLexer<T extends BaseToken = BaseToken> {
-    protected input: string;
-    protected position: number;
-    protected readPosition: number;
-    protected ch: string;
-    protected line: number;
-    protected column: number;
-    constructor(input: string);
-    getInput(): string;
-    abstract nextToken(): T;
-    protected readChar(): void;
-    protected peekChar(): string;
-    protected skipWhitespace(): void;
-    protected readWhile(predicate: (ch: string) => boolean): string;
-    protected isLetter(ch: string): boolean;
-    protected isDigit(ch: string): boolean;
-}

package/dist/src/parser/base/lexer.js

@@ -1,95 +0,0 @@
-export class BaseLexer {
-    constructor(input) {
-        Object.defineProperty(this, "input", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: input
-        });
-        Object.defineProperty(this, "position", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "readPosition", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "ch", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ''
-        });
-        Object.defineProperty(this, "line", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 1
-        });
-        Object.defineProperty(this, "column", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        this.readChar();
-    }
-    getInput() {
-        return this.input;
-    }
-    readChar() {
-        if (this.readPosition >= this.input.length) {
-            this.ch = '';
-        }
-        else {
-            this.ch = this.input[this.readPosition];
-        }
-        this.position = this.readPosition;
-        this.readPosition += 1;
-        this.column += 1;
-        if (this.ch === '\n') {
-            this.line += 1;
-            this.column = 0;
-        }
-    }
-    peekChar() {
-        if (this.readPosition >= this.input.length) {
-            return '';
-        }
-        return this.input[this.readPosition];
-    }
-    skipWhitespace() {
-        while (this.ch === ' ' || this.ch === '\t' || this.ch === '\r') {
-            this.readChar();
-        }
-    }
-    readWhile(predicate) {
-        const position = this.position;
-        while (predicate(this.ch)) {
-            this.readChar();
-        }
-        return this.input.slice(position, this.position);
-    }
-    isLetter(ch) {
-        // Support ASCII letters and underscore
-        if (('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') || ch === '_') {
-            return true;
-        }
-        // Support Unicode letters (including Japanese, Chinese, Korean, etc.)
-        // This uses a simple check: if the character code is > 127 (non-ASCII)
-        // and it's not a digit or whitespace, treat it as a letter
-        const code = ch.charCodeAt(0);
-        if (code > 127) {
-            // Exclude Unicode digits and whitespace
-            return !/[\s\d]/.test(ch);
-        }
-        return false;
-    }
-    isDigit(ch) {
-        return '0' <= ch && ch <= '9';
-    }
-}

package/dist/src/parser/base/lexer.test.d.ts

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

package/dist/src/parser/base/lexer.test.js

@@ -1,53 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { BaseLexer } from './lexer';
-// Concrete implementation for testing abstract class
-class TestLexer extends BaseLexer {
-    nextToken() {
-        this.skipWhitespace();
-        if (this.readPosition > this.input.length) { // fixed EOF logic for test, check base-lexer readChar behavior
-            // BaseLexer: readPosition moves past End.
-            return { type: 'EOF', literal: '', line: this.line, column: this.column, start: this.position, end: this.position };
-        }
-        const char = this.ch;
-        const start = this.position;
-        this.readChar();
-        return {
-            type: 'UNKNOWN', // Dummy type
-            literal: char,
-            line: this.line,
-            column: this.column,
-            start,
-            end: this.position
-        };
-    }
-    // Expose protected methods for testing
-    testReadIdentifier() { return this.readWhile(c => this.isLetter(c)); }
-    testIsDigit(c) { return this.isDigit(c); }
-    testIsLetter(c) { return this.isLetter(c); }
-    getChar() { return this.ch; }
-}
-describe('BaseLexer', () => {
-    it('should initialize correctly', () => {
-        const input = "abc";
-        const lexer = new TestLexer(input);
-        expect(lexer.getInput()).toBe(input);
-        expect(lexer.getChar()).toBe('a');
-    });
-    it('should identify digits', () => {
-        const lexer = new TestLexer("");
-        expect(lexer.testIsDigit('1')).toBe(true);
-        expect(lexer.testIsDigit('a')).toBe(false);
-    });
-    it('should identify letters', () => {
-        const lexer = new TestLexer("");
-        expect(lexer.testIsLetter('a')).toBe(true);
-        expect(lexer.testIsLetter('_')).toBe(true);
-        expect(lexer.testIsLetter('1')).toBe(false);
-    });
-    it('should read characters while predicate matches', () => {
-        const lexer = new TestLexer("abc 123");
-        const ident = lexer.testReadIdentifier();
-        expect(ident).toBe("abc");
-        expect(lexer.getChar()).toBe(" "); // Stops at space
-    });
-});

package/dist/src/parser/base/parser.d.ts

@@ -1,14 +0,0 @@
-import { PolagramRoot } from '../../ast';
-import { BaseLexer } from './lexer';
-import { BaseToken } from './token';
-export declare abstract class BaseParser<T extends BaseToken = BaseToken> {
-    protected lexer: BaseLexer<T>;
-    protected currToken: T;
-    protected peekToken: T;
-    constructor(lexer: BaseLexer<T>);
-    protected advance(): void;
-    abstract parse(): PolagramRoot;
-    protected curTokenIs(t: string): boolean;
-    protected peekTokenIs(t: string): boolean;
-    protected expectPeek(t: string): boolean;
-}

package/dist/src/parser/base/parser.js

@@ -1,43 +0,0 @@
-export class BaseParser {
-    constructor(lexer) {
-        Object.defineProperty(this, "lexer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: lexer
-        });
-        Object.defineProperty(this, "currToken", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "peekToken", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.advance();
-        this.advance();
-    }
-    advance() {
-        this.currToken = this.peekToken;
-        this.peekToken = this.lexer.nextToken();
-    }
-    curTokenIs(t) {
-        return this.currToken.type === t;
-    }
-    peekTokenIs(t) {
-        return this.peekToken.type === t;
-    }
-    expectPeek(t) {
-        if (this.peekTokenIs(t)) {
-            this.advance();
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-}

package/dist/src/parser/base/parser.test.d.ts

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