@polagram/core 0.0.4 → 0.1.1

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

@@ -1,143 +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 '\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

@@ -1,23 +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> {
-    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;
-}

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

@@ -1,481 +0,0 @@
-import { BaseParser } from '../../base/parser';
-export class Parser extends BaseParser {
-    constructor(lexer) {
-        super(lexer);
-    }
-    /**
-     * Type-safe token type checker.
-     * Helps TypeScript understand token type after advance() calls.
-     */
-    isTokenType(type) {
-        return this.currToken.type === type;
-    }
-    parse() {
-        const root = {
-            kind: 'root',
-            meta: { version: '1.0.0', source: 'plantuml' },
-            participants: [],
-            groups: [],
-            events: []
-        };
-        while (this.currToken.type !== 'EOF') {
-            if (this.currToken.type === 'START_UML') {
-                this.advance();
-                continue;
-            }
-            if (this.currToken.type === 'END_UML') {
-                this.advance();
-                continue;
-            }
-            if (this.currToken.type === 'TITLE') {
-                this.advance(); // eat title
-                root.meta.title = this.readRestOfLine().trim();
-                continue;
-            }
-            if (['PARTICIPANT', 'ACTOR', 'DATABASE'].includes(this.currToken.type)) {
-                this.parseParticipant(root);
-                continue;
-            }
-            // Implicit message/participant detection
-            // A -> B : text
-            // Identifier/String -> Arrow...
-            if (this.isParticipantToken(this.currToken)) {
-                const probMsg = this.parseMessage(root);
-                if (probMsg) {
-                    root.events.push(probMsg);
-                    continue;
-                }
-            }
-            if (this.currToken.type === 'ACTIVATE' || this.currToken.type === 'DEACTIVATE') {
-                const act = this.parseActivation(root);
-                if (act)
-                    root.events.push(act);
-                continue;
-            }
-            if (this.currToken.type === 'NOTE') {
-                const note = this.parseNote(root);
-                if (note)
-                    root.events.push(note);
-                continue;
-            }
-            if (['ALT', 'OPT', 'LOOP'].includes(this.currToken.type)) {
-                const fragment = this.parseFragment(root);
-                if (fragment)
-                    root.events.push(fragment);
-                continue;
-            }
-            // Handle standalone 'end' if it appears outside (shouldn't if parsed recursively, but safeguard)
-            if (this.currToken.type === 'END') {
-                // If we are at root, 'end' might be closing a fragment. 
-                // But parseFragment consumes until end. 
-                // If we see it here, it's unmatched or nested logic needed.
-                // For simple recursive descent, we return to caller.
-                return root;
-            }
-            if (this.currToken.type === 'BOX') {
-                const group = this.parseGroup(root);
-                if (group)
-                    root.groups.push(group);
-                continue;
-            }
-            this.advance();
-        }
-        return root;
-    }
-    parseGroup(root) {
-        this.advance(); // eat box
-        let name = '';
-        let backgroundColor;
-        // box "Title" #Color
-        if (this.currToken.type === 'STRING') {
-            name = this.currToken.literal;
-            this.advance();
-        }
-        // Check for color (starts with # usually, but lexer might tokenize it as UNKNOWN or need handling)
-        // PlantUML #Color is just text heavily.
-        // My lexer tokenizes # as UNKNOWN?
-        // Let's check lexer. It has no case for '#'. 
-        // So it returns UNKNOWN.
-        if (this.currToken.type === 'UNKNOWN' && this.currToken.literal === '#') {
-            // Read color
-            // #LightBlue
-            // We need to read identifiers after #?
-            // Currently I don't have good color support in lexer.
-            // Quick hack: assume we are at #. Read next identifier.
-            this.advance(); // eat #
-            if (this.isTokenType('IDENTIFIER')) {
-                backgroundColor = '#' + this.currToken.literal;
-                this.advance();
-            }
-        }
-        const participantIds = [];
-        // Parse content until 'end box' (or just 'end')
-        while (this.currToken.type !== 'EOF') {
-            if (this.currToken.type === 'END') {
-                this.advance(); // eat end
-                if (this.isTokenType('BOX')) {
-                    this.advance(); // eat box
-                }
-                break;
-            }
-            // We expect participant declarations inside box usually.
-            if (['PARTICIPANT', 'ACTOR', 'DATABASE'].includes(this.currToken.type)) {
-                // We need to capture the ID of the participant created.
-                // parseParticipant pushes to root.participants.
-                // We can check root.participants.length before and after? Or return ID from parseParticipant.
-                const lenBefore = root.participants.length;
-                this.parseParticipant(root);
-                const lenAfter = root.participants.length;
-                if (lenAfter > lenBefore) {
-                    participantIds.push(root.participants[lenAfter - 1].id);
-                }
-                continue;
-            }
-            // If implicit participant? 'A'
-            if (this.currToken.type === 'IDENTIFIER') {
-                // Check if it is a participant decl without keyword? (PlantUML allows it)
-                // OR check if it is start of message?
-                // If start of message, participants might be already capable of being in group? 
-                // Usually checking 'participant A' is safe.
-                // But implicit participants in box:
-                // box "Foo"
-                //   A
-                // end box
-                // This declares A in box.
-                // But A -> B inside box?
-                // The message is an event. The participants are in the box?
-                // Only if they are first declared here.
-                // For MVP: Support explicit 'participant' inside box, OR just parse statements.
-                // If parseStatement returns null (participant decl), we need to capture ID.
-                // Let's rely on explicit participant keywords for now as per test case.
-                this.advance(); // skip other things
-                continue;
-            }
-            this.advance();
-        }
-        return {
-            kind: 'group',
-            id: 'group_' + (root.groups.length + 1),
-            name,
-            type: 'box',
-            participantIds,
-            style: backgroundColor ? { backgroundColor } : undefined
-        };
-    }
-    parseFragment(root) {
-        const kind = 'fragment';
-        const operator = this.currToken.literal.toLowerCase(); // alt, opt, loop
-        this.advance(); // eat keyword
-        const condition = this.readRestOfLine().trim();
-        const branches = [];
-        let currentEvents = [];
-        const currentBranch = { condition, events: currentEvents };
-        branches.push(currentBranch);
-        // We need to parse block content until ELSE or END
-        while (this.currToken.type !== 'EOF') {
-            if (this.currToken.type === 'END') {
-                this.advance(); // eat end
-                // Check if it is 'end box' or just 'end'? 
-                // PlantUML has 'end' for fragments.
-                // Also 'end note', 'end box'.
-                // For now assume 'end' closes fragment.
-                break;
-            }
-            if (this.currToken.type === 'ELSE') {
-                this.advance(); // eat else
-                // New branch
-                const elseCond = this.readRestOfLine().trim();
-                currentEvents = [];
-                branches.push({ condition: elseCond, events: currentEvents });
-                continue;
-            }
-            // Parse single line event or nested structure
-            // We can reuse the main loop logic effectively if we refactor 'parseBlock'
-            // For now, let's duplicate the switch logic or call a recursive 'parseStatement'
-            // Simulating parseStatement step:
-            if (this.currToken.type === 'NEWLINE') {
-                this.advance();
-                continue;
-            }
-            // Recursively call a helper that processes ONE statement
-            const event = this.parseStatement(root); // We need this helper!
-            if (event) {
-                currentEvents.push(event);
-            }
-            else {
-                // If not returned an event (e.g. participant decl), we might still advance?
-                // parseStatement should handle everything inside block.
-                // But 'parseStatement' needs to be extracted from parse().
-            }
-        }
-        return {
-            kind,
-            id: 'frag_' + (root.events.length + 1),
-            operator,
-            branches
-        };
-    }
-    // Refactor parse() to use parseStatement
-    parseStatement(root) {
-        if (['PARTICIPANT', 'ACTOR', 'DATABASE'].includes(this.currToken.type)) {
-            this.parseParticipant(root);
-            return null; // Not an event
-        }
-        if (this.isParticipantToken(this.currToken)) {
-            const probMsg = this.parseMessage(root);
-            if (probMsg)
-                return probMsg;
-        }
-        if (this.currToken.type === 'ACTIVATE' || this.currToken.type === 'DEACTIVATE') {
-            return this.parseActivation(root);
-        }
-        if (this.currToken.type === 'NOTE') {
-            return this.parseNote(root);
-        }
-        if (['ALT', 'OPT', 'LOOP'].includes(this.currToken.type)) {
-            return this.parseFragment(root);
-        }
-        this.advance();
-        return null;
-    }
-    parseNote(root) {
-        this.advance(); // eat note
-        let position = 'over'; // default
-        // note left of A
-        // note right of A
-        // note over A
-        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();
-        }
-        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().trim();
-        }
-        else {
-            // Multi-line note
-            if (this.currToken.type === 'NEWLINE') {
-                this.advance();
-            }
-            const start = this.currToken.start;
-            let end = start;
-            while (this.currToken.type !== 'EOF') {
-                if (this.currToken.type === 'END' && this.peekToken.type === 'NOTE') {
-                    end = this.currToken.start;
-                    this.advance(); // eat end
-                    this.advance(); // eat note
-                    break;
-                }
-                this.advance();
-            }
-            const input = this.lexer.getInput();
-            text = input.slice(start, end).trim();
-        }
-        return {
-            kind: 'note',
-            id: 'note_' + (root.events.length + 1),
-            position,
-            participantIds,
-            text
-        };
-    }
-    parseActivation(root) {
-        const action = this.currToken.type === 'ACTIVATE' ? 'activate' : 'deactivate';
-        this.advance(); // eat keyword
-        let participantId = '';
-        if (this.isParticipantToken(this.currToken)) {
-            participantId = this.currToken.literal;
-            this.ensureParticipant(root, participantId);
-            this.advance();
-        }
-        else {
-            return null; // Error
-        }
-        return {
-            kind: 'activation',
-            participantId,
-            action
-        };
-    }
-    isParticipantToken(tok) {
-        return tok.type === 'IDENTIFIER' || tok.type === 'STRING';
-    }
-    parseMessage(root) {
-        if (this.peekToken.type !== 'ARROW') {
-            // Maybe it's just a participant declaration implied? 'A' on its own line?
-            // PlantUML 'A' is valid. It creates participant A.
-            // But here we look for message.
-            return null;
-        }
-        const fromId = this.currToken.literal; // simple ID for now. If quoted string, use it as ID/Name.
-        this.ensureParticipant(root, fromId);
-        this.advance(); // eat from
-        const arrow = this.currToken.literal; // -> or -->
-        this.advance(); // eat arrow
-        if (!this.isParticipantToken(this.currToken)) {
-            return null; // Error?
-        }
-        const toId = this.currToken.literal;
-        this.ensureParticipant(root, toId);
-        this.advance(); // eat to
-        let text = '';
-        if (this.currToken.type === 'COLON') {
-            this.advance(); // eat colon
-            text = this.readRestOfLine().trim();
-        }
-        // Resolve arrow style
-        let type = 'sync';
-        let style = { line: 'solid', head: 'arrow' };
-        if (arrow === '-->') {
-            type = 'reply';
-            style = { line: 'dotted', head: 'arrow' };
-        }
-        else if (arrow === '->') {
-            type = 'sync';
-            style = { line: 'solid', head: 'arrow' };
-        }
-        return {
-            kind: 'message',
-            id: 'msg_' + (root.events.length + 1), // Simple ID generation
-            from: fromId,
-            to: toId,
-            text,
-            type,
-            style
-        };
-    }
-    ensureParticipant(root, id) {
-        if (!root.participants.find(p => p.id === id)) {
-            root.participants.push({
-                id,
-                name: id,
-                type: 'participant'
-            });
-        }
-    }
-    parseParticipant(root) {
-        const typeStr = this.currToken.type; // ACTOR, DATABASE, PARTICIPANT
-        let type = 'participant'; // Default
-        if (typeStr === 'ACTOR')
-            type = 'actor';
-        if (typeStr === 'DATABASE')
-            type = 'database';
-        this.advance(); // eat keyword
-        // console.log('DEBUG: parseParticipant token:', this.currToken.type, this.currToken.literal);
-        let name = '';
-        let id = '';
-        // Name/ID
-        if (this.currToken.type === 'STRING' || this.currToken.type === 'IDENTIFIER') {
-            name = this.currToken.literal;
-            id = name; // Default ID is name (unless as is used)
-            // If name has spaces (quoted), ID usually needs alias to be usable without quotes?
-            // PlantUML: participant "Long Name" as A
-            // ID = A, Name = "Long Name"
-            // PlantUML: participant A
-            // ID = A, Name = A
-            // But strict PlantUML uses the Alias as the ID for arrows.
-            this.advance();
-        }
-        if (this.currToken.type === 'AS') {
-            this.advance(); // eat as
-            if (this.isTokenType('IDENTIFIER')) {
-                id = this.currToken.literal; // "Long Name" as Svc -> Svc is ID
-                this.advance();
-            }
-        }
-        else {
-            // If "Long Name" is given without 'as', usually we treat name as ID if safe?
-            // But usually we sanitize.
-            // For now follow logic: A as B -> ID=B, Name=A.
-            // If just A -> ID=A, Name=A.
-            // If "A B" -> ID="A B", Name="A B".
-            // In Core AST, ID is the references key.
-            // If name was quoted "Service Wrapper", without ID, it is hard to reference.
-            // Unless we reference using Quotes?
-            // Let's assume input is valid alias for now.
-            // Wait, Step 93 test case:
-            // participant "Service Wrapper" as Svc
-            // name="Service Wrapper", id="Svc"
-        }
-        // If we found 'as', id was updated.
-        // If we didn't find 'as' (e.g. actor User), id = User, name = User.
-        // But wait:
-        // case: participant "Service Wrapper" as Svc
-        // 1. Keyword participant.
-        // 2. String "Service Wrapper". name = "Service Wrapper", id="Service Wrapper".
-        // 3. AS.
-        // 4. Identifier Svc. id="Svc".
-        // correct.
-        root.participants.push({
-            id,
-            name,
-            type
-        });
-    }
-    readRestOfLine() {
-        // We need to sync/consume tokens until NEWLINE
-        // But since we want raw text, we should ask lexer.
-        // However, we effectively already consumed 'current token' if we are here?
-        // Usually we call readRestOfLine AFTER consuming the label (e.g. COLON).
-        // So currToken should be the first token of the text?
-        // But lexer might have already tokenized it into multiple tokens.
-        // If we simply call lexer.readRestOfLine(), it continues from CURRENT lexer position.
-        // currToken is the token *already read*.
-        // peekToken is the next one.
-        // Parser is usually one step behind or ahead?
-        // BaseParser: this.currToken, this.peekToken.
-        // Parsing process:
-        // 1. nextToken called for currToken.
-        // 2. nextToken called for peekToken.
-        // So Lexer is at position AFTER peekToken.
-        // If we want "rest of line from currToken", we are in trouble because Lexer is far ahead.
-        // Alternative:
-        // Reconstruct text from tokens until NEWLINE.
-        // But tokens don't enforce whitespace rules strictly? 
-        // We capture literal.
-        // Wait, `Token` has `start` and `end`?
-        // Yes: { type, literal, start, end }
-        // We can use the start of currToken and end of the last token before NEWLINE to slice from source?
-        // We don't have easy access to source in strict BaseParser (it's in Lexer).
-        // But we can access `(this.lexer as Lexer).input`.
-        if (this.currToken.type === 'NEWLINE' || this.currToken.type === 'EOF')
-            return '';
-        const start = this.currToken.start;
-        let end = this.currToken.end;
-        while (!this.isTokenType('NEWLINE') && !this.isTokenType('EOF')) {
-            end = this.currToken.end;
-            this.advance();
-        }
-        // We advanced past the last text token. currToken is now NEWLINE.
-        // The previous token ended at `end`.
-        // We need access to input.
-        const input = this.lexer.getInput(); // BaseLexer usually carries input? 
-        // BaseLexer: protected input: string;
-        // We might need to make it public accessor or cast.
-        return input.slice(start, end).trim();
-    }
-}

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

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