ttrpg-tools/src/yarn-spinner/compile/compiler.ts

import type { YarnDocument, Statement, Line, Option } from "../model/ast";
import type { IRProgram, IRNode, IRNodeGroup, IRInstruction } from "./ir";

export interface CompileOptions {
    generateOnceIds?: (ctx: { node: string; index: number }) => string;
}

export function compile(doc: YarnDocument, opts: CompileOptions = {}): IRProgram {
    const program: IRProgram = { enums: {}, nodes: {} };
    // Store enum definitions
    for (const enumDef of doc.enums) {
        program.enums[enumDef.name] = enumDef.cases;
    }
    const genOnce = opts.generateOnceIds ?? ((x) => `${x.node}#once#${x.index}`);
    let globalLineCounter = 0;

    function ensureLineId(tags?: string[]): string[] | undefined {
        const t = tags ? [...tags] : [];
        if (!t.some((x) => x.startsWith("line:"))) {
            t.push(`line:${(globalLineCounter++).toString(16)}`);
        }
        return t;
    }

    // Group nodes by title to handle node groups
    const nodesByTitle = new Map<string, typeof doc.nodes>();
    for (const node of doc.nodes) {
        if (!nodesByTitle.has(node.title)) {
            nodesByTitle.set(node.title, []);
        }
        nodesByTitle.get(node.title)!.push(node);
    }

    for (const [title, nodesWithSameTitle] of nodesByTitle) {
        // If only one node with this title, treat as regular node
        if (nodesWithSameTitle.length === 1) {
            const node = nodesWithSameTitle[0];
            const instructions: IRInstruction[] = [];
            let onceCounter = 0;
            function emitBlock(stmts: Statement[]): IRInstruction[] {
                const block: IRInstruction[] = [];
                for (const s of stmts) {
                    switch (s.type) {
                        case "Line":
                        {
                            const line = s as Line;
                            block.push({ op: "line", speaker: line.speaker, text: line.text, tags: ensureLineId(line.tags), markup: line.markup });
                        }
                            break;
                        case "Command":
                            block.push({ op: "command", content: s.content });
                            break;
                        case "Jump":
                            block.push({ op: "jump", target: s.target });
                            break;
                        case "Detour":
                            block.push({ op: "detour", target: s.target });
                            break;
                        case "OptionGroup": {
                            // Add #lastline tag to the most recent line, if present
                            for (let i = block.length - 1; i >= 0; i--) {
                                const ins = block[i];
                                if (ins.op === "line") {
                                    const tags = new Set(ins.tags ?? []);
                                    if (![...tags].some((x) => x === "lastline" || x === "#lastline")) {
                                        tags.add("lastline");
                                    }
                                    ins.tags = Array.from(tags);
                                    break;
                                }
                                if (ins.op !== "command") break; // stop if non-line non-command before options
                            }
                            block.push({
                                op: "options",
                                options: s.options.map((o: Option) => ({ text: o.text, tags: ensureLineId(o.tags), css: (o as any).css, markup: o.markup, condition: o.condition, block: emitBlock(o.body) })),
                            });
                            break;
                        }
                        case "If":
                            block.push({
                                op: "if",
                                branches: s.branches.map((b) => ({ condition: b.condition, block: emitBlock(b.body) })),
                            });
                            break;
                        case "Once":
                            block.push({ op: "once", id: genOnce({ node: node.title, index: onceCounter++ }), block: emitBlock(s.body) });
                            break;
                        case "Enum":
                            // Enums are metadata, skip during compilation (already stored in program.enums)
                            break;
                    }
                }
                return block;
            }
            instructions.push(...emitBlock(node.body));
            const irNode: IRNode = {
                title: node.title,
                instructions,
                when: node.when,
                css: (node as any).css,
                scene: node.headers.scene?.trim() || undefined
            };
            program.nodes[node.title] = irNode;
        } else {
            // Multiple nodes with same title - create node group
            const groupNodes: IRNode[] = [];
            for (const node of nodesWithSameTitle) {
                const instructions: IRInstruction[] = [];
                let onceCounter = 0;
                function emitBlock(stmts: Statement[]): IRInstruction[] {
                    const block: IRInstruction[] = [];
                    for (const s of stmts) {
                        switch (s.type) {
                            case "Line":
                            {
                                const line = s as Line;
                                block.push({ op: "line", speaker: line.speaker, text: line.text, tags: ensureLineId(line.tags), markup: line.markup });
                            }
                                break;
                            case "Command":
                                block.push({ op: "command", content: s.content });
                                break;
                            case "Jump":
                                block.push({ op: "jump", target: s.target });
                                break;
                            case "Detour":
                                block.push({ op: "detour", target: s.target });
                                break;
                            case "OptionGroup": {
                                for (let i = block.length - 1; i >= 0; i--) {
                                    const ins = block[i];
                                    if (ins.op === "line") {
                                        const tags = new Set(ins.tags ?? []);
                                        if (![...tags].some((x) => x === "lastline" || x === "#lastline")) {
                                            tags.add("lastline");
                                        }
                                        ins.tags = Array.from(tags);
                                        break;
                                    }
                                    if (ins.op !== "command") break;
                                }
                                block.push({
                                    op: "options",
                                    options: s.options.map((o: Option) => ({ text: o.text, tags: ensureLineId(o.tags), css: (o as any).css, markup: o.markup, condition: o.condition, block: emitBlock(o.body) })),
                                });
                                break;
                            }
                            case "If":
                                block.push({
                                    op: "if",
                                    branches: s.branches.map((b) => ({ condition: b.condition, block: emitBlock(b.body) })),
                                });
                                break;
                            case "Once":
                                block.push({ op: "once", id: genOnce({ node: node.title, index: onceCounter++ }), block: emitBlock(s.body) });
                                break;
                            case "Enum":
                                break;
                        }
                    }
                    return block;
                }
                instructions.push(...emitBlock(node.body));
                groupNodes.push({
                    title: node.title,
                    instructions,
                    when: node.when,
                    css: (node as any).css,
                    scene: node.headers.scene?.trim() || undefined
                });
            }
            const group: IRNodeGroup = {
                title,
                nodes: groupNodes
            };
            program.nodes[title] = group;
        }
    }

    return program;
}