@polagram/core 0.0.4 → 0.1.1

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

@@ -1,90 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { BaseLexer } from './lexer';
-import { BaseParser } from './parser';
-// Mocks
-class MockLexer extends BaseLexer {
-    constructor(tokens) {
-        super("");
-        Object.defineProperty(this, "tokens", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "index", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        this.tokens = tokens;
-    }
-    nextToken() {
-        if (this.index >= this.tokens.length) {
-            return { type: 'EOF', literal: '', line: 0, column: 0, start: 0, end: 0 };
-        }
-        return this.tokens[this.index++];
-    }
-}
-class TestParser extends BaseParser {
-    parse() {
-        return { kind: 'root', meta: { version: '1.0.0', source: 'unknown' }, participants: [], groups: [], events: [] };
-    }
-    // Expose protected methods
-    getCurr() { return this.currToken; }
-    getPeek() { return this.peekToken; }
-    testAdvance() { this.advance(); }
-    testCurTokenIs(t) { return this.curTokenIs(t); }
-    testPeakTokenIs(t) { return this.peekTokenIs(t); }
-    testExpectPeek(t) { return this.expectPeek(t); }
-}
-describe('BaseParser', () => {
-    const tokens = [
-        { type: 'IDENTIFIER', literal: 'A', line: 1, column: 0, start: 0, end: 1 },
-        { type: 'ARROW', literal: '->', line: 1, column: 1, start: 1, end: 3 },
-        { type: 'IDENTIFIER', literal: 'B', line: 1, column: 3, start: 3, end: 4 },
-    ];
-    it('should initialize curr and peek tokens', () => {
-        const lexer = new MockLexer(tokens);
-        const parser = new TestParser(lexer);
-        // Constructor called advance twice.
-        // 1st advance: curr=undefined, peek=Tokens[0]
-        // 2nd advance: curr=Tokens[0], peek=Tokens[1]
-        expect(parser.getCurr().type).toBe('IDENTIFIER');
-        expect(parser.getCurr().literal).toBe('A');
-        expect(parser.getPeek().type).toBe('ARROW');
-    });
-    it('should advance tokens', () => {
-        const lexer = new MockLexer(tokens);
-        const parser = new TestParser(lexer);
-        parser.testAdvance();
-        // curr=Tokens[1] (ARROW), peek=Tokens[2] (IDENTIFIER B)
-        expect(parser.getCurr().type).toBe('ARROW');
-        expect(parser.getPeek().type).toBe('IDENTIFIER');
-    });
-    it('should check current and peek token types', () => {
-        const lexer = new MockLexer(tokens);
-        const parser = new TestParser(lexer);
-        expect(parser.testCurTokenIs('IDENTIFIER')).toBe(true);
-        expect(parser.testPeakTokenIs('ARROW')).toBe(true);
-        expect(parser.testPeakTokenIs('EOF')).toBe(false);
-    });
-    it('should expect peek token and advance if match', () => {
-        const lexer = new MockLexer(tokens);
-        const parser = new TestParser(lexer);
-        // Peek is ARROW. Expect ARROW should likely succeed?
-        // Method signature: expectPeek(t). If peek matches, advance and return true.
-        const result = parser.testExpectPeek('ARROW');
-        expect(result).toBe(true);
-        // After advance, curr is ARROW.
-        expect(parser.getCurr().type).toBe('ARROW');
-    });
-    it('should expect peek token and return false if mismatch', () => {
-        const lexer = new MockLexer(tokens);
-        const parser = new TestParser(lexer);
-        const result = parser.testExpectPeek('EOF'); // Peek is ARROW
-        expect(result).toBe(false);
-        // Should not have advanced
-        expect(parser.getCurr().type).toBe('IDENTIFIER');
-    });
-});

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

@@ -1,18 +0,0 @@
-/**
- * Base token interface that all token types should extend.
- * Represents a lexical token with position information.
- */
-export interface BaseToken {
-    /** Token type identifier */
-    type: string;
-    /** Literal string value of the token */
-    literal: string;
-    /** Line number (1-indexed) */
-    line: number;
-    /** Column number (0-indexed) */
-    column: number;
-    /** Start position in source (0-indexed) */
-    start: number;
-    /** End position in source (0-indexed) */
-    end: number;
-}

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

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

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

@@ -1,8 +0,0 @@
-export interface BaseToken {
-    type: string;
-    literal: string;
-    line: number;
-    column: number;
-    start: number;
-    end: number;
-}

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

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

package/dist/src/parser/format-detector.d.ts

@@ -1,55 +0,0 @@
-/**
- * Supported diagram formats
- */
-export type DiagramFormat = 'mermaid' | 'plantuml';
-/**
- * Format detection utilities for diagram source code.
- * Detects diagram format based on file extension and content analysis.
- */
-export declare class FormatDetector {
-    /**
-     * File extensions mapped to their diagram formats
-     */
-    private static readonly EXTENSION_MAP;
-    /**
-     * Content patterns for format detection
-     */
-    private static readonly CONTENT_PATTERNS;
-    /**
-     * Detect diagram format from file path and content.
-     *
-     * @param filePath - Path to the diagram file
-     * @param content - Content of the diagram file
-     * @returns Detected format, or null if format cannot be determined
-     *
-     * @example
-     * ```typescript
-     * const format = FormatDetector.detect('diagram.puml', content);
-     * if (format === 'plantuml') {
-     *   // Process as PlantUML
-     * }
-     * ```
-     */
-    static detect(filePath: string, content: string): DiagramFormat | null;
-    /**
-     * Detect format based on file extension.
-     *
-     * @param filePath - Path to the diagram file
-     * @returns Detected format, or null if extension is not recognized
-     */
-    static detectByExtension(filePath: string): DiagramFormat | null;
-    /**
-     * Detect format based on content patterns.
-     *
-     * @param content - Content of the diagram file
-     * @returns Detected format, or null if no pattern matches
-     */
-    static detectByContent(content: string): DiagramFormat | null;
-    /**
-     * Get file extension for a given format.
-     *
-     * @param format - Diagram format
-     * @returns Default file extension for the format
-     */
-    static getDefaultExtension(format: DiagramFormat): string;
-}

package/dist/src/parser/format-detector.js

@@ -1,98 +0,0 @@
-/**
- * Format detection utilities for diagram source code.
- * Detects diagram format based on file extension and content analysis.
- */
-export class FormatDetector {
-    /**
-     * Detect diagram format from file path and content.
-     *
-     * @param filePath - Path to the diagram file
-     * @param content - Content of the diagram file
-     * @returns Detected format, or null if format cannot be determined
-     *
-     * @example
-     * ```typescript
-     * const format = FormatDetector.detect('diagram.puml', content);
-     * if (format === 'plantuml') {
-     *   // Process as PlantUML
-     * }
-     * ```
-     */
-    static detect(filePath, content) {
-        // Try extension-based detection first
-        const extensionFormat = this.detectByExtension(filePath);
-        if (extensionFormat) {
-            return extensionFormat;
-        }
-        // Fall back to content-based detection
-        return this.detectByContent(content);
-    }
-    /**
-     * Detect format based on file extension.
-     *
-     * @param filePath - Path to the diagram file
-     * @returns Detected format, or null if extension is not recognized
-     */
-    static detectByExtension(filePath) {
-        const ext = filePath.toLowerCase().match(/\.[^.]+$/)?.[0];
-        if (!ext) {
-            return null;
-        }
-        return this.EXTENSION_MAP[ext] || null;
-    }
-    /**
-     * Detect format based on content patterns.
-     *
-     * @param content - Content of the diagram file
-     * @returns Detected format, or null if no pattern matches
-     */
-    static detectByContent(content) {
-        for (const { pattern, format } of this.CONTENT_PATTERNS) {
-            if (pattern.test(content)) {
-                return format;
-            }
-        }
-        return null;
-    }
-    /**
-     * Get file extension for a given format.
-     *
-     * @param format - Diagram format
-     * @returns Default file extension for the format
-     */
-    static getDefaultExtension(format) {
-        switch (format) {
-            case 'plantuml':
-                return '.puml';
-            case 'mermaid':
-                return '.mmd';
-        }
-    }
-}
-/**
- * File extensions mapped to their diagram formats
- */
-Object.defineProperty(FormatDetector, "EXTENSION_MAP", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: {
-        '.puml': 'plantuml',
-        '.plantuml': 'plantuml',
-        '.pu': 'plantuml',
-        '.mmd': 'mermaid',
-        '.mermaid': 'mermaid',
-    }
-});
-/**
- * Content patterns for format detection
- */
-Object.defineProperty(FormatDetector, "CONTENT_PATTERNS", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: [
-        { pattern: /^\s*@startuml/m, format: 'plantuml' },
-        { pattern: /^\s*sequenceDiagram/m, format: 'mermaid' },
-    ]
-});

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

@@ -1,11 +0,0 @@
-import { DiagramParser } from './interface';
-/**
- * Parser Factory
- * Centralizes retrieval of parser strategies.
- */
-export declare class ParserFactory {
-    private static parsers;
-    static register(language: string, parser: DiagramParser): void;
-    static getParser(language: string): DiagramParser;
-}
-export { FormatDetector, type DiagramFormat } from './format-detector';

package/dist/src/parser/index.js

@@ -1,33 +0,0 @@
-var _a;
-import { mermaidParser } from './languages/mermaid';
-import { plantumlParser } from './languages/plantuml';
-/**
- * Parser Factory
- * Centralizes retrieval of parser strategies.
- */
-export class ParserFactory {
-    static register(language, parser) {
-        this.parsers.set(language, parser);
-    }
-    static getParser(language) {
-        const parser = this.parsers.get(language);
-        if (!parser) {
-            throw new Error(`Parser for language '${language}' not found.`);
-        }
-        return parser;
-    }
-}
-_a = ParserFactory;
-Object.defineProperty(ParserFactory, "parsers", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: new Map()
-});
-(() => {
-    // Register built-in parsers
-    _a.register('mermaid', mermaidParser);
-    _a.register('plantuml', plantumlParser);
-})();
-// Re-export format detector
-export { FormatDetector } from './format-detector';

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

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

package/dist/src/parser/index.test.js

@@ -1,23 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ParserFactory } from './index';
-describe('ParserFactory', () => {
-    it('should retrieve registered parser', () => {
-        const parser = ParserFactory.getParser('mermaid');
-        expect(parser).toBeDefined();
-        // Since we import implemented parser, we expect checking it conforms to interface
-        expect(typeof parser.parse).toBe('function');
-    });
-    it('should throw error for unknown language', () => {
-        expect(() => {
-            ParserFactory.getParser('unknown-lang');
-        }).toThrow("Parser for language 'unknown-lang' not found.");
-    });
-    it('should allow registering new parser', () => {
-        const mockParser = {
-            parse: (_code) => ({ kind: 'root', meta: { version: '1.0.0', source: 'unknown' }, participants: [], groups: [], events: [] })
-        };
-        ParserFactory.register('test-lang', mockParser);
-        const retrieved = ParserFactory.getParser('test-lang');
-        expect(retrieved).toBe(mockParser);
-    });
-});

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

@@ -1,8 +0,0 @@
-import { PolagramRoot } from '../ast';
-/**
- * Strategy Interface for Diagram Parsing.
- * Implements the Strategy Pattern: different formats implement this interface.
- */
-export interface DiagramParser {
-    parse(code: string): PolagramRoot;
-}

package/dist/src/parser/interface.js

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

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

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

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

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

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

@@ -1,14 +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 readNumber;
-    private readString;
-    private isArrowStart;
-    private readArrow;
-    private readMulti;
-    private lookupIdent;
-}

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

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

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

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

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

@@ -1,22 +0,0 @@
-import { PolagramRoot } from '../../../ast';
-import { BaseParser } from '../../base/parser';
-import { Lexer } from './lexer';
-import { Token } from './tokens';
-export declare class Parser extends BaseParser<Token> {
-    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;
-}