@polagram/core 0.0.3 → 0.0.4

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

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

@@ -8,3 +8,4 @@ export declare class ParserFactory {
     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,5 +1,6 @@
 var _a;
 import { mermaidParser } from './languages/mermaid';
+import { plantumlParser } from './languages/plantuml';
 /**
  * Parser Factory
  * Centralizes retrieval of parser strategies.
@@ -26,4 +27,7 @@ Object.defineProperty(ParserFactory, "parsers", {
 (() => {
     // 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/languages/mermaid/lexer.d.ts

@@ -1,6 +1,6 @@
 import { BaseLexer } from '../../base/lexer';
 import { Token } from './tokens';
-export declare class Lexer extends BaseLexer {
+export declare class Lexer extends BaseLexer<Token> {
     constructor(input: string);
     nextToken(): Token;
     private newToken;

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

@@ -1,7 +1,8 @@
 import { PolagramRoot } from '../../../ast';
 import { BaseParser } from '../../base/parser';
 import { Lexer } from './lexer';
-export declare class Parser extends BaseParser {
+import { Token } from './tokens';
+export declare class Parser extends BaseParser<Token> {
     private currentGroup;
     private idCounters;
     constructor(lexer: Lexer);

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

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

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

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

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

@@ -0,0 +1,143 @@
+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 '\n':
+                tok = this.newToken('NEWLINE', this.ch, start, startColumn);
+                break;
+            case '@':
+                if (this.peekString('startuml')) {
+                    this.readMulti(9);
+                    tok = this.newToken('START_UML', '@startuml', start, startColumn);
+                }
+                else if (this.peekString('enduml')) {
+                    this.readMulti(7);
+                    tok = this.newToken('END_UML', '@enduml', start, startColumn);
+                }
+                else {
+                    tok = this.newToken('UNKNOWN', this.ch, start, startColumn);
+                }
+                break;
+            case ',':
+                tok = this.newToken('COMMA', ',', start, startColumn);
+                break;
+            case '"':
+                const str = this.readString();
+                return this.newToken('STRING', str, start, startColumn);
+            case ':':
+                tok = this.newToken('COLON', ':', start, startColumn);
+                break;
+            case '-':
+                const arrow = this.readArrow();
+                if (arrow) {
+                    tok = this.newToken('ARROW', arrow, start, startColumn);
+                }
+                else {
+                    tok = this.newToken('UNKNOWN', 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 {
+                    tok = this.newToken('UNKNOWN', this.ch, start, startColumn);
+                }
+        }
+        this.readChar();
+        return tok;
+    }
+    newToken(type, literal, start, startColumn) {
+        const end = (this.position === start) ? start + literal.length : this.position;
+        return { type, literal, line: this.line, column: startColumn, start, end };
+    }
+    readIdentifier() {
+        const position = this.position;
+        while (this.isLetter(this.ch) || 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);
+        this.readChar();
+        return str;
+    }
+    lookupIdent(ident) {
+        const keywords = {
+            'title': 'TITLE',
+            'participant': 'PARTICIPANT',
+            'actor': 'ACTOR',
+            'database': 'DATABASE',
+            'as': 'AS',
+            'activate': 'ACTIVATE',
+            'deactivate': 'DEACTIVATE',
+            'note': 'NOTE',
+            'left': 'LEFT',
+            'right': 'RIGHT',
+            'over': 'OVER',
+            'of': 'OF',
+            'alt': 'ALT',
+            'opt': 'OPT',
+            'loop': 'LOOP',
+            'else': 'ELSE',
+            'end': 'END',
+            'box': 'BOX',
+            '@startuml': 'START_UML',
+            '@enduml': 'END_UML'
+        };
+        return keywords[ident] || 'IDENTIFIER';
+    }
+    readArrow() {
+        // We are at '-'
+        // Check for -->
+        if (this.peekString('->')) {
+            this.readMulti(2);
+            return '-->';
+        }
+        // Check for ->
+        if (this.peekExact('>')) {
+            this.readMulti(1);
+            return '->';
+        }
+        return null;
+    }
+    peekExact(char) {
+        return this.input[this.position + 1] === char;
+    }
+    peekString(str) {
+        for (let i = 0; i < str.length; i++) {
+            if (this.input[this.position + 1 + i] !== str[i])
+                return false;
+        }
+        return true;
+    }
+    readRestOfLine() {
+        const start = this.position;
+        while (this.input[this.position] !== '\n' && this.input[this.position] !== '' && this.position < this.input.length) {
+            this.readChar();
+        }
+        return this.input.slice(start, this.position).trim();
+    }
+    readMulti(count) {
+        for (let i = 0; i < count; i++)
+            this.readChar();
+    }
+}

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

@@ -0,0 +1,23 @@
+import { PolagramRoot } from '../../../ast';
+import { BaseParser } from '../../base/parser';
+import { Lexer } from './lexer';
+import { Token } from './tokens';
+export declare class Parser extends BaseParser<Token> {
+    constructor(lexer: Lexer);
+    /**
+     * Type-safe token type checker.
+     * Helps TypeScript understand token type after advance() calls.
+     */
+    private isTokenType;
+    parse(): PolagramRoot;
+    private parseGroup;
+    private parseFragment;
+    private parseStatement;
+    private parseNote;
+    private parseActivation;
+    private isParticipantToken;
+    private parseMessage;
+    private ensureParticipant;
+    private parseParticipant;
+    private readRestOfLine;
+}