@yagejs-addons/dialogue 0.1.0 → 0.2.0

package/dist/yaml.cjs

@@ -0,0 +1,726 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/yaml.ts
+var yaml_exports = {};
+__export(yaml_exports, {
+  loadYaml: () => loadYaml
+});
+module.exports = __toCommonJS(yaml_exports);
+
+// src/core/formats/yaml.ts
+var import_yaml = require("yaml");
+
+// src/core/expr.ts
+function isExpr(value) {
+  return typeof value === "object" && value !== null && "kind" in value;
+}
+__name(isExpr, "isExpr");
+
+// src/core/i18n.ts
+var TOKEN = /\{(\w+)\}/g;
+function tokensIn(text) {
+  const names = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(TOKEN)) names.add(m[1]);
+  return [...names];
+}
+__name(tokensIn, "tokensIn");
+
+// src/core/validate.ts
+var DialogueScriptError = class extends Error {
+  static {
+    __name(this, "DialogueScriptError");
+  }
+};
+var NUMERIC_OPS = /* @__PURE__ */ new Set([">", ">=", "<", "<="]);
+var NUMERIC_EXPR_OPS = /* @__PURE__ */ new Set([
+  ">",
+  "<",
+  ">=",
+  "<=",
+  "gt",
+  "lt",
+  "gte",
+  "lte",
+  "-",
+  "*",
+  "/",
+  "%"
+]);
+var BUILTIN_COMMANDS = /* @__PURE__ */ new Set(["set"]);
+function operandRequirement(op) {
+  if (op === "+") return "numberOrString";
+  return NUMERIC_EXPR_OPS.has(op) ? "number" : null;
+}
+__name(operandRequirement, "operandRequirement");
+var analysisCache = /* @__PURE__ */ new WeakMap();
+function analyzeScript(script) {
+  const cached = analysisCache.get(script);
+  if (cached) return cached;
+  const analysis = computeAnalysis(script);
+  analysisCache.set(script, analysis);
+  return analysis;
+}
+__name(analyzeScript, "analyzeScript");
+function computeAnalysis(script) {
+  const declaredTypes = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(script.declare ?? {})) {
+    declaredTypes.set(name, valueType(value));
+  }
+  const readVars = /* @__PURE__ */ new Set();
+  const setTargets = /* @__PURE__ */ new Set();
+  const calledFunctions = /* @__PURE__ */ new Set();
+  const commandTypes = /* @__PURE__ */ new Set();
+  const collectExpr = /* @__PURE__ */ __name((expr, where) => {
+    switch (expr.kind) {
+      case "literal":
+        return;
+      case "varRef":
+        readVars.add(expr.name);
+        return;
+      case "call":
+        calledFunctions.add(expr.fn);
+        for (const arg of expr.args ?? []) collectExpr(arg, where);
+        return;
+      case "group":
+        collectExpr(expr.expr, where);
+        return;
+      case "unary":
+        collectExpr(expr.operand, where);
+        return;
+      case "binary":
+        collectExpr(expr.left, where);
+        collectExpr(expr.right, where);
+        checkBinaryOperands(expr, where);
+        return;
+    }
+  }, "collectExpr");
+  const checkBinaryOperands = /* @__PURE__ */ __name((expr, where) => {
+    const req = operandRequirement(expr.op);
+    if (!req) return;
+    const expected = req === "numberOrString" ? "a number or string" : "a number";
+    for (const operand of [expr.left, expr.right]) {
+      if (operand.kind === "literal") {
+        const t = valueType(operand.value);
+        if (t === "number" || req === "numberOrString" && t === "string") continue;
+        throw new DialogueScriptError(
+          `${where}: operator "${expr.op}" expects ${expected}, got ${t}`
+        );
+      }
+      if (operand.kind === "varRef" && req === "number") {
+        const t = declaredTypes.get(operand.name);
+        if (t !== void 0 && t !== "number" && t !== "null") {
+          throw new DialogueScriptError(
+            `${where}: operator "${expr.op}" needs a number; "${operand.name}" is ${t}`
+          );
+        }
+      }
+    }
+  }, "checkBinaryOperands");
+  const checkTokens = /* @__PURE__ */ __name((text) => {
+    if (!text) return;
+    for (const token of tokensIn(text)) readVars.add(token);
+  }, "checkTokens");
+  const checkCondition = /* @__PURE__ */ __name((condition, where) => {
+    if (condition === void 0 || typeof condition === "function") return;
+    if (typeof condition === "string") {
+      readVars.add(condition);
+      return;
+    }
+    if (isExpr(condition)) {
+      collectExpr(condition, where);
+      return;
+    }
+    readVars.add(condition.var);
+    if (NUMERIC_OPS.has(condition.op)) {
+      const t = declaredTypes.get(condition.var);
+      if (t !== void 0 && t !== "number" && t !== "null") {
+        throw new DialogueScriptError(
+          `${where}: operator "${condition.op}" needs a number; "${condition.var}" is ${t}`
+        );
+      }
+      if (typeof condition.value !== "number") {
+        throw new DialogueScriptError(
+          `${where}: operator "${condition.op}" compares against a number, got ${typeof condition.value}`
+        );
+      }
+    }
+  }, "checkCondition");
+  const checkSetLiteralType = /* @__PURE__ */ __name((target, value, where) => {
+    const declared = declaredTypes.get(target);
+    if (declared !== void 0 && declared !== "null" && value !== null && typeof value !== declared) {
+      throw new DialogueScriptError(
+        `${where}: set "${target}" expects ${declared}, got ${typeof value}`
+      );
+    }
+  }, "checkSetLiteralType");
+  const checkCommands = /* @__PURE__ */ __name((commands, where) => {
+    for (const cmd of commands ?? []) {
+      if (cmd.type === "set") {
+        const target = cmd["var"];
+        if (typeof target !== "string") {
+          throw new DialogueScriptError(`${where}: set command has no string "var"`);
+        }
+        setTargets.add(target);
+        const value = cmd["value"];
+        if (value === void 0) {
+          throw new DialogueScriptError(`${where}: set "${target}" has no value`);
+        }
+        if (isExpr(value)) {
+          collectExpr(value, where);
+          if (value.kind === "literal") checkSetLiteralType(target, value.value, where);
+        } else {
+          checkSetLiteralType(target, value, where);
+        }
+        continue;
+      }
+      if (!BUILTIN_COMMANDS.has(cmd.type)) commandTypes.add(cmd.type);
+    }
+  }, "checkCommands");
+  for (const speaker of Object.values(script.speakers ?? {})) {
+    checkTokens(speaker.name);
+  }
+  for (const node of Object.values(script.nodes)) {
+    const where = `node "${node.id}"`;
+    for (const step of node.steps) {
+      switch (step.kind) {
+        case "say": {
+          const s = step;
+          checkTokens(s.text);
+          checkCommands(s.commands, `${where} say`);
+          break;
+        }
+        case "choice": {
+          const c = step;
+          checkTokens(c.text);
+          for (const opt of c.options) {
+            checkTokens(opt.text);
+            checkTokens(opt.disabledReason);
+            checkCondition(opt.condition, `${where} choice option "${opt.text}"`);
+            checkCommands(opt.commands, `${where} choice option "${opt.text}"`);
+          }
+          break;
+        }
+        case "command": {
+          const cs = step;
+          checkCommands(cs.commands, `${where} command`);
+          checkCondition(cs.condition, `${where} command`);
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  }
+  return { declaredTypes, readVars, setTargets, calledFunctions, commandTypes };
+}
+__name(computeAnalysis, "computeAnalysis");
+function valueType(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  return "boolean";
+}
+__name(valueType, "valueType");
+
+// src/core/expr-parse.ts
+var DialogueExprError = class extends DialogueScriptError {
+  static {
+    __name(this, "DialogueExprError");
+  }
+  line;
+  col;
+  constructor(message, line, col) {
+    super(`${message} (at ${line}:${col})`);
+    this.name = "DialogueExprError";
+    this.line = line;
+    this.col = col;
+  }
+};
+function parseExpr(src) {
+  const tokens = tokenize(src);
+  return new Parser(tokens).parse();
+}
+__name(parseExpr, "parseExpr");
+var KEYWORDS = {
+  and: "&&",
+  or: "||",
+  not: "!",
+  xor: "xor",
+  is: "==",
+  eq: "==",
+  neq: "!=",
+  gt: ">",
+  lt: "<",
+  gte: ">=",
+  lte: "<=",
+  true: "true",
+  false: "false",
+  null: "null"
+};
+var isDigit = /* @__PURE__ */ __name((c) => c >= "0" && c <= "9", "isDigit");
+var isIdentStart = /* @__PURE__ */ __name((c) => c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c === "_" || c === "$", "isIdentStart");
+var isIdentPart = /* @__PURE__ */ __name((c) => isIdentStart(c) || isDigit(c) || c === ".", "isIdentPart");
+function tokenize(src) {
+  const tokens = [];
+  let i = 0;
+  let line = 1;
+  let col = 1;
+  const advance = /* @__PURE__ */ __name((n = 1) => {
+    for (let k = 0; k < n; k++) {
+      if (src[i] === "\n") {
+        line++;
+        col = 1;
+      } else {
+        col++;
+      }
+      i++;
+    }
+  }, "advance");
+  while (i < src.length) {
+    const c = src[i];
+    if (c === " " || c === "	" || c === "\n" || c === "\r") {
+      advance();
+      continue;
+    }
+    const startLine = line;
+    const startCol = col;
+    if (isDigit(c)) {
+      let text = "";
+      while (i < src.length && isDigit(src[i])) {
+        text += src[i];
+        advance();
+      }
+      if (src[i] === "." && isDigit(src[i + 1] ?? "")) {
+        text += ".";
+        advance();
+        while (i < src.length && isDigit(src[i])) {
+          text += src[i];
+          advance();
+        }
+      }
+      tokens.push({ kind: "number", value: Number(text), line: startLine, col: startCol });
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      const quote = c;
+      advance();
+      let text = "";
+      while (i < src.length && src[i] !== quote) {
+        if (src[i] === "\\") {
+          advance();
+          if (i >= src.length) break;
+          text += unescape(src[i]);
+        } else {
+          text += src[i];
+        }
+        advance();
+      }
+      if (src[i] !== quote) {
+        throw new DialogueExprError("unterminated string literal", startLine, startCol);
+      }
+      advance();
+      tokens.push({ kind: "string", value: text, line: startLine, col: startCol });
+      continue;
+    }
+    if (isIdentStart(c)) {
+      let text = "";
+      while (i < src.length && isIdentPart(src[i])) {
+        text += src[i];
+        advance();
+      }
+      const keyword = KEYWORDS[text];
+      if (keyword === void 0) {
+        tokens.push({ kind: "ident", value: text, line: startLine, col: startCol });
+      } else if (keyword === "true" || keyword === "false" || keyword === "null") {
+        const value = keyword === "true" ? true : keyword === "false" ? false : null;
+        tokens.push({ kind: keyword, value, line: startLine, col: startCol });
+      } else {
+        tokens.push({ kind: keyword, line: startLine, col: startCol });
+      }
+      continue;
+    }
+    const two = src.slice(i, i + 2);
+    if (two === "&&" || two === "||" || two === "==" || two === "!=" || two === ">=" || two === "<=") {
+      tokens.push({ kind: two, line: startLine, col: startCol });
+      advance(2);
+      continue;
+    }
+    if (c === ">" || c === "<" || c === "!" || c === "+" || c === "-" || c === "(" || c === ")" || c === ",") {
+      tokens.push({ kind: c, line: startLine, col: startCol });
+      advance();
+      continue;
+    }
+    throw new DialogueExprError(`unexpected character "${c}"`, startLine, startCol);
+  }
+  tokens.push({ kind: "eof", line, col });
+  return tokens;
+}
+__name(tokenize, "tokenize");
+function unescape(c) {
+  switch (c) {
+    case "n":
+      return "\n";
+    case "t":
+      return "	";
+    case "r":
+      return "\r";
+    default:
+      return c;
+  }
+}
+__name(unescape, "unescape");
+var INFIX_BP = {
+  "||": 1,
+  "&&": 2,
+  "==": 3,
+  "!=": 3,
+  ">": 3,
+  "<": 3,
+  ">=": 3,
+  "<=": 3,
+  "+": 4,
+  "-": 4
+};
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  tokens;
+  static {
+    __name(this, "Parser");
+  }
+  pos = 0;
+  parse() {
+    const expr = this.parseBinary(0);
+    const t = this.peek();
+    if (t.kind !== "eof") {
+      throw new DialogueExprError(`unexpected trailing token "${describe(t)}"`, t.line, t.col);
+    }
+    return expr;
+  }
+  parseBinary(minBp) {
+    let left = this.parseUnary();
+    for (; ; ) {
+      const t = this.peek();
+      const bp = INFIX_BP[t.kind];
+      if (bp === void 0 || bp < minBp) break;
+      this.next();
+      const right = this.parseBinary(bp + 1);
+      left = { kind: "binary", op: t.kind, left, right };
+    }
+    return left;
+  }
+  parseUnary() {
+    const t = this.peek();
+    if (t.kind === "!" || t.kind === "-") {
+      this.next();
+      const operand = this.parseUnary();
+      return { kind: "unary", op: t.kind === "!" ? "!" : "-", operand };
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const t = this.peek();
+    switch (t.kind) {
+      case "number":
+      case "string":
+        this.next();
+        return { kind: "literal", value: t.value };
+      case "true":
+      case "false":
+      case "null":
+        this.next();
+        return { kind: "literal", value: t.value };
+      case "ident": {
+        this.next();
+        const name = t.value;
+        if (this.peek().kind === "(") {
+          this.next();
+          const args = this.parseArgs();
+          return { kind: "call", fn: name, args };
+        }
+        return { kind: "varRef", name };
+      }
+      case "(": {
+        this.next();
+        const inner = this.parseBinary(0);
+        this.expect(")");
+        return { kind: "group", expr: inner };
+      }
+      default:
+        throw new DialogueExprError(`unexpected ${describe(t)}`, t.line, t.col);
+    }
+  }
+  /** Parse a comma-separated argument list; the opening `(` is already consumed. */
+  parseArgs() {
+    const args = [];
+    if (this.peek().kind === ")") {
+      this.next();
+      return args;
+    }
+    for (; ; ) {
+      args.push(this.parseBinary(0));
+      const t = this.peek();
+      if (t.kind === ",") {
+        this.next();
+        continue;
+      }
+      if (t.kind === ")") {
+        this.next();
+        return args;
+      }
+      throw new DialogueExprError(`expected "," or ")" in argument list, got ${describe(t)}`, t.line, t.col);
+    }
+  }
+  expect(kind) {
+    const t = this.peek();
+    if (t.kind !== kind) {
+      throw new DialogueExprError(`expected "${kind}", got ${describe(t)}`, t.line, t.col);
+    }
+    this.next();
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  next() {
+    return this.tokens[this.pos++];
+  }
+};
+function describe(t) {
+  if (t.kind === "eof") return "end of input";
+  if (t.kind === "ident") return `"${String(t.value)}"`;
+  if (t.kind === "string") return `string "${String(t.value)}"`;
+  if (t.kind === "number") return `number ${String(t.value)}`;
+  return `"${t.kind}"`;
+}
+__name(describe, "describe");
+
+// src/core/formats/canonical.ts
+function loadScript(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new DialogueScriptError("script must be an object");
+  }
+  if (!raw.id) throw new DialogueScriptError("script.id is required");
+  if (!raw.nodes || typeof raw.nodes !== "object") {
+    throw new DialogueScriptError(`script "${raw.id}" has no nodes`);
+  }
+  const nodeIds = Object.keys(raw.nodes);
+  if (nodeIds.length === 0) {
+    throw new DialogueScriptError(`script "${raw.id}" has no nodes`);
+  }
+  const start = raw.start ?? nodeIds[0];
+  if (!raw.nodes[start]) {
+    throw new DialogueScriptError(`start node "${start}" not found in "${raw.id}"`);
+  }
+  for (const [key, speaker] of Object.entries(raw.speakers ?? {})) {
+    if (speaker.id !== key) {
+      throw new DialogueScriptError(
+        `speaker key "${key}" != speaker.id "${speaker.id}"`
+      );
+    }
+  }
+  for (const [id, node] of Object.entries(raw.nodes)) {
+    validateNode(raw, id, node);
+  }
+  const resolved = resolveExpressions(raw);
+  const script = Object.freeze({ ...resolved, start });
+  analyzeScript(script);
+  return script;
+}
+__name(loadScript, "loadScript");
+function validateNode(script, id, node) {
+  if (node.id !== id) {
+    throw new DialogueScriptError(`node key "${id}" != node.id "${node.id}"`);
+  }
+  if (!Array.isArray(node.steps) || node.steps.length === 0) {
+    throw new DialogueScriptError(`node "${id}" has no steps`);
+  }
+  for (const step of node.steps) validateStep(script, id, step);
+}
+__name(validateNode, "validateNode");
+function validateStep(script, nodeId, step) {
+  const targetExists = /* @__PURE__ */ __name((t) => {
+    if (t !== void 0 && !script.nodes[t]) {
+      throw new DialogueScriptError(
+        `node "${nodeId}": jump target "${t}" does not exist`
+      );
+    }
+  }, "targetExists");
+  const speakerExists = /* @__PURE__ */ __name((s) => {
+    if (s !== void 0 && !script.speakers?.[s]) {
+      throw new DialogueScriptError(
+        `node "${nodeId}": speaker "${s}" is not in script.speakers`
+      );
+    }
+  }, "speakerExists");
+  switch (step.kind) {
+    case "say":
+      if (typeof step.text !== "string") {
+        throw new DialogueScriptError(`node "${nodeId}": say.text must be a string`);
+      }
+      speakerExists(step.speaker);
+      break;
+    case "choice":
+      if (!Array.isArray(step.options) || step.options.length === 0) {
+        throw new DialogueScriptError(`node "${nodeId}": choice has no options`);
+      }
+      speakerExists(step.speaker);
+      for (const opt of step.options) targetExists(opt.target);
+      break;
+    case "command":
+      targetExists(step.target);
+      break;
+    case "goto":
+      if (step.target === void 0) {
+        throw new DialogueScriptError(`node "${nodeId}": goto has no target`);
+      }
+      targetExists(step.target);
+      break;
+    case "end":
+      break;
+    default:
+      throw new DialogueScriptError(
+        `node "${nodeId}": unknown step kind "${step.kind}"`
+      );
+  }
+}
+__name(validateStep, "validateStep");
+function resolveExpressions(script) {
+  let nodesChanged = false;
+  const nodes = {};
+  for (const [id, node] of Object.entries(script.nodes)) {
+    let stepsChanged = false;
+    const steps = node.steps.map((step) => {
+      const next = resolveStep(step);
+      if (next !== step) stepsChanged = true;
+      return next;
+    });
+    if (stepsChanged) {
+      nodes[id] = { ...node, steps };
+      nodesChanged = true;
+    } else {
+      nodes[id] = node;
+    }
+  }
+  return nodesChanged ? { ...script, nodes } : script;
+}
+__name(resolveExpressions, "resolveExpressions");
+function resolveStep(step) {
+  switch (step.kind) {
+    case "say":
+      return resolveSay(step);
+    case "choice":
+      return resolveChoice(step);
+    case "command":
+      return resolveCommandStep(step);
+    case "goto":
+    case "end":
+      return step;
+  }
+}
+__name(resolveStep, "resolveStep");
+function resolveSay(step) {
+  const commands = rewriteCommands(step.commands);
+  return commands ? { ...step, commands } : step;
+}
+__name(resolveSay, "resolveSay");
+function resolveCommandStep(step) {
+  const condition = rewriteCondition(step.condition);
+  const commands = rewriteCommands(step.commands);
+  if (!condition && !commands) return step;
+  return {
+    ...step,
+    ...condition ? { condition } : {},
+    ...commands ? { commands } : {}
+  };
+}
+__name(resolveCommandStep, "resolveCommandStep");
+function resolveChoice(step) {
+  let changed = false;
+  const options = step.options.map((opt) => {
+    const next = rewriteOption(opt);
+    if (next) {
+      changed = true;
+      return next;
+    }
+    return opt;
+  });
+  return changed ? { ...step, options } : step;
+}
+__name(resolveChoice, "resolveChoice");
+function rewriteOption(opt) {
+  const condition = rewriteCondition(opt.condition);
+  const commands = rewriteCommands(opt.commands);
+  if (!condition && !commands) return void 0;
+  return {
+    ...opt,
+    ...condition ? { condition } : {},
+    ...commands ? { commands } : {}
+  };
+}
+__name(rewriteOption, "rewriteOption");
+function rewriteCondition(condition) {
+  return typeof condition === "string" ? parseExpr(condition) : void 0;
+}
+__name(rewriteCondition, "rewriteCondition");
+function rewriteCommands(commands) {
+  if (!commands) return void 0;
+  let changed = false;
+  const out = commands.map((cmd) => {
+    if (cmd.type === "set" && typeof cmd.value === "string") {
+      changed = true;
+      return { ...cmd, value: parseExpr(cmd.value) };
+    }
+    return cmd;
+  });
+  return changed ? out : void 0;
+}
+__name(rewriteCommands, "rewriteCommands");
+
+// src/core/formats/yaml.ts
+function loadYaml(text) {
+  let raw;
+  try {
+    raw = (0, import_yaml.parse)(text);
+  } catch (e) {
+    throw new DialogueScriptError(
+      `YAML parse error: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new DialogueScriptError(
+      `YAML root must be a mapping (the script object), got ${describeRoot(raw, text)}`
+    );
+  }
+  return loadScript(raw);
+}
+__name(loadYaml, "loadYaml");
+function describeRoot(v, text) {
+  if (v === null) return text.trim() === "" ? "an empty document" : "null";
+  if (Array.isArray(v)) return "an array";
+  return `a ${typeof v}`;
+}
+__name(describeRoot, "describeRoot");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadYaml
+});
+//# sourceMappingURL=yaml.cjs.map