@kawaijs/parser 0.1.11 → 0.1.13

package/dist/parser.js

@@ -1,5 +1,6 @@
 import { createLocation } from '@kawaijs/ast';
 import { KawaError } from './diagnostic.js';
+import { unexpectedStatementHint } from './suggest.js';
 import { Lexer } from './lexer.js';
 export class Parser {
     tokens;
@@ -40,6 +41,8 @@ export class Parser {
         switch (token.type) {
             case 'CHARACTER':
                 return this.parseCharacterDecl();
+            case 'DEFINE':
+                return this.parseDefineDecl();
             case 'LABEL':
                 return this.parseLabelDecl();
             case 'SCENE':
@@ -52,6 +55,8 @@ export class Parser {
                 return this.parseMenuStmt();
             case 'JUMP':
                 return this.parseJumpStmt();
+            case 'CALL':
+                return this.parseCallStmt();
             case 'RETURN':
                 return this.parseReturnStmt();
             case 'SET':
@@ -62,6 +67,32 @@ export class Parser {
                 return this.parsePlayStmt();
             case 'STOP':
                 return this.parseStopStmt();
+            case 'VFX':
+                return this.parseVfxStmt();
+            case 'CAMERA':
+                return this.parseCameraStmt();
+            case 'PAUSE':
+                return this.parsePauseStmt();
+            case 'CG':
+                return this.parseCgStmt();
+            case 'INPUT':
+                return this.parseInputStmt();
+            case 'WINDOW':
+                return this.parseWindowStmt();
+            case 'THEME':
+                return this.parseThemeStmt();
+            case 'STYLE':
+                return this.parseStyleStmt();
+            case 'HOTSPOT':
+                return this.parseHotspotStmt();
+            case 'LAYER':
+                return this.parseLayerStmt();
+            case 'ANIMATE':
+                return this.parseAnimateStmt();
+            case 'UNLOCK':
+                return this.parseUnlockStmt();
+            case 'LANG':
+                return this.parseLangStmt();
             case 'STRING':
                 // Narration without speaker identifier
                 return this.parseDialogueStmt();
@@ -74,9 +105,10 @@ export class Parser {
                 }
                 throw new KawaError({
                     code: 'E0100',
-                    message: `Unexpected identifier '${token.value}'. Did you mean to use a command like 'show', 'scene', 'jump' or a dialogue statement?`,
+                    message: `Unexpected statement '${token.value}'.`,
                     severity: 'error',
-                    loc: token.loc
+                    loc: token.loc,
+                    hint: unexpectedStatementHint(token.value)
                 });
             }
             default:
@@ -84,7 +116,8 @@ export class Parser {
                     code: 'E0101',
                     message: `Unexpected token '${token.value}' (${token.type})`,
                     severity: 'error',
-                    loc: token.loc
+                    loc: token.loc,
+                    hint: unexpectedStatementHint(token.value)
                 });
         }
     }
@@ -154,17 +187,40 @@ export class Parser {
         const startTok = this.consume('SHOW', 'Expected "show" keyword');
         const charTok = this.consume('IDENTIFIER', 'Expected character name after "show"');
         let expression;
-        if (this.check('IDENTIFIER') && this.peek().value !== 'at' && this.peek().value !== 'with') {
+        if (this.check('IDENTIFIER') &&
+            !['at', 'with', 'z', 'layer'].includes(this.peek().value.toLowerCase())) {
             expression = this.advance().value;
         }
         let position;
         if (this.match('AT')) {
             position = this.consume('IDENTIFIER', 'Expected position identifier after "at" (e.g. left, center, right)').value;
         }
+        let layer;
+        let z;
+        // Optional `layer <name>` and/or `z <number>` in either order
+        while (!this.check('NEWLINE') && !this.check('DEDENT') && !this.check('EOF') && !this.check('WITH')) {
+            if (this.match('LAYER') || (this.check('IDENTIFIER') && this.peek().value.toLowerCase() === 'layer')) {
+                if (this.check('IDENTIFIER') && this.peek().value.toLowerCase() === 'layer') {
+                    this.advance();
+                }
+                layer = this.check('STRING')
+                    ? this.advance().value
+                    : this.consume('IDENTIFIER', 'Expected layer name after "layer"').value;
+                continue;
+            }
+            if (this.check('IDENTIFIER') && this.peek().value.toLowerCase() === 'z') {
+                this.advance();
+                const zTok = this.consume('NUMBER', 'Expected z-index number after "z"');
+                z = Number(zTok.value);
+                continue;
+            }
+            break;
+        }
         let transition;
         if (this.match('WITH')) {
             transition = this.parseTransitionName();
         }
+        // Allow z/layer also after with (rare) — already handled above before with
         this.consumeOptionalNewline();
         return {
             type: 'ShowStmt',
@@ -172,6 +228,8 @@ export class Parser {
             expression,
             position,
             transition,
+            layer,
+            z: Number.isFinite(z) ? z : undefined,
             loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
         };
     }
@@ -209,6 +267,11 @@ export class Parser {
             speaker = spkTok.value;
             startLoc = spkTok.loc;
         }
+        else if (this.check('STRING') && this.peek(1).type === 'STRING') {
+            const spkTok = this.advance();
+            speaker = spkTok.value;
+            startLoc = spkTok.loc;
+        }
         const textTok = this.consume('STRING', 'Expected dialogue string');
         this.consumeOptionalNewline();
         return {
@@ -229,12 +292,17 @@ export class Parser {
             if (this.check('DEDENT') || this.isAtEnd())
                 break;
             const choiceTextTok = this.consume('STRING', 'Expected choice option string (e.g. "Say hello":)');
+            let condition;
+            if (this.match('IF')) {
+                condition = this.readUntilColon().trim();
+            }
             this.consume('COLON', 'Expected ":" after choice string');
             this.consumeOptionalNewline();
             const choiceBody = this.parseBlock();
             choices.push({
                 type: 'ChoiceItem',
                 text: choiceTextTok.value,
+                condition,
                 body: choiceBody,
                 loc: createLocation(this.file, choiceTextTok.loc.start, this.previousLocation().end)
             });
@@ -257,6 +325,16 @@ export class Parser {
             loc: createLocation(this.file, startTok.loc.start, labelTok.loc.end)
         };
     }
+    parseCallStmt() {
+        const startTok = this.consume('CALL', 'Expected "call" keyword');
+        const labelTok = this.consume('IDENTIFIER', 'Expected target label name after "call"');
+        this.consumeOptionalNewline();
+        return {
+            type: 'CallStmt',
+            targetLabel: labelTok.value,
+            loc: createLocation(this.file, startTok.loc.start, labelTok.loc.end)
+        };
+    }
     parseReturnStmt() {
         const startTok = this.consume('RETURN', 'Expected "return" keyword');
         this.consumeOptionalNewline();
@@ -287,8 +365,10 @@ export class Parser {
             });
         }
         let value;
+        let isVariable = false;
         if (this.check('STRING')) {
             value = this.advance().value;
+            isVariable = false;
         }
         else if (this.check('NUMBER')) {
             value = Number(this.advance().value);
@@ -298,6 +378,7 @@ export class Parser {
         }
         else if (this.check('IDENTIFIER')) {
             value = this.advance().value;
+            isVariable = true;
         }
         else {
             throw new KawaError({
@@ -313,6 +394,7 @@ export class Parser {
             variable: varTok.value,
             operator,
             value,
+            isVariable,
             loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
         };
     }
@@ -368,7 +450,15 @@ export class Parser {
                 loc: channelTok.loc
             });
         }
-        const trackTok = this.consume('IDENTIFIER', 'Expected audio track name');
+        if (!this.check('IDENTIFIER') && !this.check('STRING') && !this.checkSoftIdentifier()) {
+            throw new KawaError({
+                code: 'E0104',
+                message: 'Expected audio track name (identifier or string literal) after audio channel',
+                severity: 'error',
+                loc: this.currentLocation()
+            });
+        }
+        const trackTok = this.advance();
         let fade;
         let loop = channelTok.type === 'MUSIC';
         while (this.check('FADEIN') || this.check('LOOP')) {
@@ -412,6 +502,363 @@ export class Parser {
             loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
         };
     }
+    parseVfxStmt() {
+        const startTok = this.consume('VFX', 'Expected "vfx" keyword');
+        const effectTok = this.advance();
+        const effectName = effectTok.value.toLowerCase();
+        const validEffects = ['rain', 'snow', 'sakura', 'fog', 'tint', 'stop'];
+        if (!validEffects.includes(effectName)) {
+            throw new KawaError({
+                code: 'E0107',
+                message: `Invalid VFX effect '${effectTok.value}'. Expected one of: ${validEffects.join(', ')}`,
+                severity: 'error',
+                loc: effectTok.loc
+            });
+        }
+        let intensity;
+        let color;
+        if (effectName === 'tint') {
+            if (this.check('COLOR')) {
+                color = this.advance().value;
+            }
+            else if (this.check('STRING')) {
+                color = this.advance().value;
+            }
+            else if (this.check('IDENTIFIER')) {
+                color = this.advance().value;
+            }
+        }
+        else if (effectName !== 'stop') {
+            if (this.check('NUMBER')) {
+                intensity = Number(this.advance().value);
+            }
+            else if (this.check('IDENTIFIER')) {
+                intensity = this.advance().value;
+            }
+        }
+        this.consumeOptionalNewline();
+        return {
+            type: 'VfxStmt',
+            effect: effectName,
+            intensity,
+            color,
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
+    parseCameraStmt() {
+        const startTok = this.consume('CAMERA', 'Expected "camera" keyword');
+        const actionTok = this.advance();
+        const actionName = actionTok.value.toLowerCase();
+        const validActions = ['shake', 'vpunch', 'hpunch', 'flash'];
+        if (!validActions.includes(actionName)) {
+            throw new KawaError({
+                code: 'E0108',
+                message: `Invalid camera action '${actionTok.value}'. Expected one of: ${validActions.join(', ')}`,
+                severity: 'error',
+                loc: actionTok.loc
+            });
+        }
+        let duration;
+        if (this.check('NUMBER')) {
+            duration = Number(this.advance().value);
+        }
+        this.consumeOptionalNewline();
+        return {
+            type: 'CameraStmt',
+            action: actionName,
+            duration,
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
+    parsePauseStmt() {
+        const startTok = this.consume('PAUSE', 'Expected "pause" keyword');
+        let duration;
+        if (this.check('NUMBER')) {
+            duration = Number(this.advance().value);
+        }
+        this.consumeOptionalNewline();
+        return {
+            type: 'PauseStmt',
+            duration,
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
+    parseCgStmt() {
+        const startTok = this.consume('CG', 'Expected "cg" keyword');
+        const imageTok = this.consume('STRING', 'Expected image filename or path in quotes after "cg"');
+        let unlockId;
+        if (this.match('AS')) {
+            if (this.check('STRING')) {
+                unlockId = this.advance().value;
+            }
+            else {
+                unlockId = this.consume('IDENTIFIER', 'Expected unlock identifier after "as"').value;
+            }
+        }
+        this.consumeOptionalNewline();
+        return {
+            type: 'CgStmt',
+            image: imageTok.value,
+            unlockId,
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
+    parseDefineDecl() {
+        const startTok = this.consume('DEFINE', 'Expected "define" keyword');
+        const nameParts = [];
+        while (this.checkSoftIdentifier()) {
+            nameParts.push(this.advance().value);
+            if (this.check('EQUALS') || this.check('STRING'))
+                break;
+        }
+        if (nameParts.length === 0) {
+            throw new KawaError({
+                code: 'E0110',
+                message: 'Expected alias name after "define"',
+                severity: 'error',
+                loc: this.currentLocation()
+            });
+        }
+        this.consume('EQUALS', 'Expected "=" after define name');
+        const valueTok = this.consume('STRING', 'Expected string value after "define ... ="');
+        this.consumeOptionalNewline();
+        return {
+            type: 'DefineDecl',
+            name: nameParts.join(' '),
+            value: valueTok.value,
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
+    parseInputStmt() {
+        const startTok = this.consume('INPUT', 'Expected "input" keyword');
+        const varTok = this.consume('IDENTIFIER', 'Expected variable name after "input"');
+        let prompt = 'Enter text';
+        if (this.check('STRING')) {
+            prompt = this.advance().value;
+        }
+        this.consumeOptionalNewline();
+        return {
+            type: 'InputStmt',
+            variable: varTok.value,
+            prompt,
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
+    parseWindowStmt() {
+        const startTok = this.consume('WINDOW', 'Expected "window" keyword');
+        let actionRaw;
+        if (this.check('SHOW') || this.check('HIDE') || this.check('IDENTIFIER')) {
+            actionRaw = this.advance().value.toLowerCase();
+        }
+        else {
+            throw new KawaError({
+                code: 'E0111',
+                message: 'Expected "show" or "hide" after "window"',
+                severity: 'error',
+                loc: this.currentLocation()
+            });
+        }
+        if (actionRaw !== 'show' && actionRaw !== 'hide') {
+            throw new KawaError({
+                code: 'E0111',
+                message: `Invalid window action '${actionRaw}'. Expected "show" or "hide".`,
+                severity: 'error',
+                loc: startTok.loc
+            });
+        }
+        this.consumeOptionalNewline();
+        return {
+            type: 'WindowStmt',
+            action: actionRaw,
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
+    parseThemeStmt() {
+        const startTok = this.consume('THEME', 'Expected "theme" keyword');
+        let name;
+        if (this.check('STRING') || this.checkSoftIdentifier()) {
+            name = this.advance().value;
+        }
+        else {
+            throw new KawaError({
+                code: 'E0112',
+                message: 'Expected theme name after "theme"',
+                severity: 'error',
+                loc: this.currentLocation(),
+                hint: 'Example: theme "noir"   or   theme sakura'
+            });
+        }
+        this.consumeOptionalNewline();
+        return {
+            type: 'ThemeStmt',
+            name,
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
+    parseStyleStmt() {
+        const startTok = this.consume('STYLE', 'Expected "style" keyword');
+        if (!this.check('STRING') && !this.checkSoftIdentifier()) {
+            throw new KawaError({
+                code: 'E0113',
+                message: 'Expected style target after "style"',
+                severity: 'error',
+                loc: this.currentLocation(),
+                hint: 'Example: style dialogue glass\n     Targets: dialogue, stage, root, choices'
+            });
+        }
+        const targetTok = this.advance();
+        if (!this.check('STRING') && !this.checkSoftIdentifier()) {
+            throw new KawaError({
+                code: 'E0113',
+                message: 'Expected style name after target',
+                severity: 'error',
+                loc: this.currentLocation(),
+                hint: 'Example: style dialogue glass'
+            });
+        }
+        const nameTok = this.advance();
+        this.consumeOptionalNewline();
+        return {
+            type: 'StyleStmt',
+            target: targetTok.value.toLowerCase(),
+            name: nameTok.value,
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
+    parseHotspotStmt() {
+        const startTok = this.consume('HOTSPOT', 'Expected "hotspot" keyword');
+        let id;
+        if (this.check('STRING') || this.checkSoftIdentifier()) {
+            id = this.advance().value;
+        }
+        else {
+            throw new KawaError({
+                code: 'E0114',
+                message: 'Expected hotspot id after "hotspot"',
+                severity: 'error',
+                loc: this.currentLocation(),
+                hint: 'Example: hotspot door 40 50 18 12 jump courtyard\n     Coordinates are percent of the stage (0–100) or fractions (0–1).'
+            });
+        }
+        const readCoord = (label) => {
+            if (!this.check('NUMBER')) {
+                throw new KawaError({
+                    code: 'E0114',
+                    message: `Expected ${label} coordinate after hotspot id`,
+                    severity: 'error',
+                    loc: this.currentLocation(),
+                    hint: 'Example: hotspot door 40 50 18 12 jump courtyard'
+                });
+            }
+            return Number(this.advance().value);
+        };
+        const x = readCoord('x');
+        const y = readCoord('y');
+        const w = readCoord('w');
+        const h = readCoord('h');
+        if (!this.check('JUMP')) {
+            throw new KawaError({
+                code: 'E0114',
+                message: 'Expected "jump" after hotspot rectangle',
+                severity: 'error',
+                loc: this.currentLocation(),
+                hint: 'Example: hotspot door 40 50 18 12 jump courtyard'
+            });
+        }
+        this.advance();
+        const target = this.consume('IDENTIFIER', 'Expected target label after hotspot jump').value;
+        this.consumeOptionalNewline();
+        return {
+            type: 'HotspotStmt',
+            id,
+            x,
+            y,
+            w,
+            h,
+            targetLabel: target,
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
+    parseLayerStmt() {
+        const startTok = this.consume('LAYER', 'Expected "layer" keyword');
+        const name = this.check('STRING')
+            ? this.advance().value
+            : this.consume('IDENTIFIER', 'Expected layer name (e.g. master, overlay)').value;
+        this.consumeOptionalNewline();
+        return {
+            type: 'LayerStmt',
+            name,
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
+    parseAnimateStmt() {
+        const startTok = this.consume('ANIMATE', 'Expected "animate" keyword');
+        const charTok = this.consume('IDENTIFIER', 'Expected character name after "animate"');
+        this.consume('WITH', 'Expected "with" after character in animate statement');
+        let animation;
+        let durationMs;
+        if (this.check('STRING')) {
+            const raw = this.advance().value.trim();
+            // "slide-in 400ms" | "slide-in 400" | "slide-in"
+            const match = raw.match(/^([a-zA-Z0-9_-]+)\s*(\d+)\s*(ms)?$/i) || raw.match(/^([a-zA-Z0-9_-]+)$/);
+            if (match) {
+                animation = match[1];
+                if (match[2])
+                    durationMs = Number(match[2]);
+            }
+            else {
+                animation = raw.replace(/\s+/g, '-');
+            }
+        }
+        else {
+            animation = this.consume('IDENTIFIER', 'Expected animation name after "with"').value;
+            if (this.check('NUMBER')) {
+                durationMs = Number(this.advance().value);
+            }
+        }
+        this.consumeOptionalNewline();
+        return {
+            type: 'AnimateStmt',
+            character: charTok.value,
+            animation: animation.toLowerCase(),
+            durationMs: Number.isFinite(durationMs) ? durationMs : undefined,
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
+    parseUnlockStmt() {
+        const startTok = this.consume('UNLOCK', 'Expected "unlock" keyword');
+        const id = this.check('STRING')
+            ? this.advance().value
+            : this.consume('IDENTIFIER', 'Expected achievement id after "unlock"').value;
+        let title;
+        let description;
+        if (this.check('STRING')) {
+            title = this.advance().value;
+            if (this.check('STRING')) {
+                description = this.advance().value;
+            }
+        }
+        this.consumeOptionalNewline();
+        return {
+            type: 'UnlockStmt',
+            id,
+            title,
+            description,
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
+    parseLangStmt() {
+        const startTok = this.consume('LANG', 'Expected "lang" keyword');
+        const code = this.check('STRING')
+            ? this.advance().value
+            : this.consume('IDENTIFIER', 'Expected language code after "lang" (e.g. it, en)').value;
+        this.consumeOptionalNewline();
+        return {
+            type: 'LangStmt',
+            code: code.toLowerCase(),
+            loc: createLocation(this.file, startTok.loc.start, this.previousLocation().end)
+        };
+    }
     parseBlock() {
         this.consume('INDENT', 'Expected indented block');
         const statements = [];
@@ -431,7 +878,13 @@ export class Parser {
     readUntilColon() {
         const parts = [];
         while (!this.check('COLON') && !this.check('NEWLINE') && !this.isAtEnd()) {
-            parts.push(this.advance().value);
+            const tok = this.advance();
+            if (tok.type === 'STRING') {
+                parts.push(JSON.stringify(tok.value));
+            }
+            else {
+                parts.push(tok.value);
+            }
         }
         return parts.join(' ');
     }
@@ -445,6 +898,40 @@ export class Parser {
             this.advance();
         }
     }
+    checkSoftIdentifier() {
+        if (this.isAtEnd())
+            return false;
+        const t = this.peek().type;
+        if (t === 'IDENTIFIER')
+            return true;
+        // Keywords may appear as names (e.g. `define music theme`, `hotspot window`, `play music theme`)
+        switch (t) {
+            case 'NEWLINE':
+            case 'INDENT':
+            case 'DEDENT':
+            case 'EOF':
+            case 'COLON':
+            case 'EQUALS':
+            case 'PLUS_EQUALS':
+            case 'MINUS_EQUALS':
+            case 'DOUBLE_EQUALS':
+            case 'NOT_EQUALS':
+            case 'GREATER_EQUALS':
+            case 'LESS_EQUALS':
+            case 'GREATER':
+            case 'LESS':
+            case 'PLUS':
+            case 'MINUS':
+            case 'COMMA':
+            case 'STRING':
+            case 'NUMBER':
+            case 'BOOLEAN':
+            case 'COLOR':
+                return false;
+            default:
+                return true;
+        }
+    }
     match(type) {
         if (this.check(type)) {
             this.advance();