yarn-spinner-runner-ts 0.1.0

package/src/compile/compiler.ts

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

package/src/compile/ir.ts

@@ -0,0 +1,28 @@
+export type IRProgram = {
+  enums: Record<string, string[]>; // enum name -> cases
+  nodes: Record<string, IRNode | IRNodeGroup>; // can be single node or group
+};
+
+export type IRNode = {
+  title: string;
+  instructions: IRInstruction[];
+  when?: string[]; // Array of when conditions
+  css?: string;
+  scene?: string; // Scene name from node header
+};
+
+export type IRNodeGroup = {
+  title: string;
+  nodes: IRNode[]; // Multiple nodes with same title, different when conditions
+};
+
+export type IRInstruction =
+  | { op: "line"; speaker?: string; text: string; tags?: string[] }
+  | { op: "command"; content: string }
+  | { op: "jump"; target: string }
+  | { op: "detour"; target: string }
+  | { op: "options"; options: Array<{ text: string; tags?: string[]; css?: string; block: IRInstruction[] }> }
+  | { op: "if"; branches: Array<{ condition: string | null; block: IRInstruction[] }> }
+  | { op: "once"; id: string; block: IRInstruction[] };
+
+

package/src/index.ts

@@ -0,0 +1,17 @@
+export * from "./model/ast.js";
+export * from "./parse/lexer.js";
+export * from "./parse/parser.js";
+export * from "./compile/ir.js";
+export * from "./compile/compiler.js";
+export * from "./runtime/results.js";
+export * from "./runtime/evaluator.js";
+export * from "./runtime/commands.js";
+export * from "./runtime/runner.js";
+export * from "./types.js";
+export * from "./scene/types.js";
+export * from "./scene/parser.js";
+export * from "./react/useYarnRunner.js";
+export * from "./react/DialogueView.js";
+export * from "./react/DialogueExample.js";
+export * from "./react/DialogueScene.js";
+

package/src/model/ast.ts

@@ -0,0 +1,93 @@
+export type Position = { line: number; column: number };
+
+export interface NodeHeaderMap {
+  [key: string]: string;
+}
+
+export interface YarnDocument {
+  type: "Document";
+  enums: EnumDefinition[];
+  nodes: YarnNode[];
+}
+
+export interface EnumDefinition {
+  type: "Enum";
+  name: string;
+  cases: string[];
+}
+
+export interface YarnNode {
+  type: "Node";
+  title: string;
+  headers: NodeHeaderMap;
+  nodeTags?: string[];
+  when?: string[]; // Array of when conditions (can be "once", "always", or expression like "$has_sword")
+  css?: string; // Custom CSS style for node
+  body: Statement[];
+}
+
+export type Statement =
+  | Line
+  | Command
+  | OptionGroup
+  | IfBlock
+  | OnceBlock
+  | Jump
+  | Detour
+  | EnumBlock;
+
+export interface Line {
+  type: "Line";
+  speaker?: string;
+  text: string;
+  tags?: string[];
+}
+
+export interface Command {
+  type: "Command";
+  content: string; // inside << >>
+}
+
+export interface Jump {
+  type: "Jump";
+  target: string;
+}
+
+export interface Detour {
+  type: "Detour";
+  target: string;
+}
+
+export interface OptionGroup {
+  type: "OptionGroup";
+  options: Option[];
+}
+
+export interface Option {
+  type: "Option";
+  text: string;
+  body: Statement[]; // executed if chosen
+  tags?: string[];
+  css?: string; // Custom CSS style for option
+}
+
+export interface IfBlock {
+  type: "If";
+  branches: Array<{
+    condition: string | null; // null for else
+    body: Statement[];
+  }>;
+}
+
+export interface OnceBlock {
+  type: "Once";
+  body: Statement[];
+}
+
+export interface EnumBlock {
+  type: "Enum";
+  name: string;
+  cases: string[];
+}
+
+

package/src/parse/lexer.ts

@@ -0,0 +1,108 @@
+export interface Token {
+  type:
+    | "HEADER_KEY"
+    | "HEADER_VALUE"
+    | "NODE_START" // ---
+    | "NODE_END" // ===
+    | "OPTION" // ->
+    | "COMMAND" // <<...>> (single-line)
+    | "TEXT" // any non-empty content line
+    | "EMPTY"
+    | "INDENT"
+    | "DEDENT"
+    | "EOF";
+  text: string;
+  line: number;
+  column: number;
+}
+
+// Minimal indentation-sensitive lexer to support options and their bodies.
+export function lex(input: string): Token[] {
+  const lines = input.replace(/\r\n?/g, "\n").split("\n");
+  const tokens: Token[] = [];
+  const indentStack: number[] = [0];
+
+  let inHeaders = true;
+
+  function push(type: Token["type"], text: string, line: number, column: number) {
+    tokens.push({ type, text, line, column });
+  }
+
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const lineNum = i + 1;
+    const indent = raw.match(/^[ \t]*/)?.[0] ?? "";
+    const content = raw.slice(indent.length);
+
+    // Manage indentation tokens only within node bodies
+    if (!inHeaders) {
+      const prev = indentStack[indentStack.length - 1];
+      if (indent.length > prev) {
+        indentStack.push(indent.length);
+        push("INDENT", "", lineNum, 1);
+      } else if (indent.length < prev) {
+        while (indentStack.length && indent.length < indentStack[indentStack.length - 1]) {
+          indentStack.pop();
+          push("DEDENT", "", lineNum, 1);
+        }
+      }
+    }
+
+    if (content.trim() === "") {
+      push("EMPTY", "", lineNum, 1);
+      continue;
+    }
+
+    if (content === "---") {
+      inHeaders = false;
+      push("NODE_START", content, lineNum, indent.length + 1);
+      continue;
+    }
+    if (content === "===") {
+      inHeaders = true;
+      // flush indentation to root
+      while (indentStack.length > 1) {
+        indentStack.pop();
+        push("DEDENT", "", lineNum, 1);
+      }
+      push("NODE_END", content, lineNum, indent.length + 1);
+      continue;
+    }
+
+    // Header: key: value (only valid while inHeaders)
+    if (inHeaders) {
+      const m = content.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.*)$/);
+      if (m) {
+        push("HEADER_KEY", m[1], lineNum, indent.length + 1);
+        push("HEADER_VALUE", m[2], lineNum, indent.length + 1 + m[0].indexOf(m[2]));
+        continue;
+      }
+    }
+
+    if (content.startsWith("->")) {
+      push("OPTION", content.slice(2).trim(), lineNum, indent.length + 1);
+      continue;
+    }
+
+    // Commands like <<...>> (single line)
+    const cmd = content.match(/^<<(.+?)>>\s*$/);
+    if (cmd) {
+      push("COMMAND", cmd[1].trim(), lineNum, indent.length + 1);
+      continue;
+    }
+
+    // Plain text line
+    push("TEXT", content, lineNum, indent.length + 1);
+  }
+
+  // close remaining indentation at EOF
+  while (indentStack.length > 1) {
+    indentStack.pop();
+    tokens.push({ type: "DEDENT", text: "", line: lines.length, column: 1 });
+  }
+
+  tokens.push({ type: "EOF", text: "", line: lines.length + 1, column: 1 });
+  return tokens;
+}
+
+