yarn-spinner-runner-ts 0.1.4 → 0.1.5-a

package/src/tests/options.test.ts

@@ -34,39 +34,209 @@ Narrator: Choose one
 
 
 
-test("option markup is exposed", () => {
-  const script = `
-title: Start
----
-Narrator: Choose
--> [b]Bold[/b]
-    Narrator: Bold
--> [wave intensity=5]Custom[/wave]
-    Narrator: Custom
-===
-  `;
-
-  const doc = parseYarn(script);
-  const ir = compile(doc);
-  const runner = new YarnRunner(ir, { startAt: "Start" });
-
-  runner.advance(); // move to options
-  const result = runner.currentResult;
-  ok(result && result.type === "options", "Expected options result");
-  const options = result!.options;
-  ok(options[0].markup, "Expected markup on first option");
-  ok(options[1].markup, "Expected markup on second option");
-  const boldMarkup = options[0].markup!;
-  strictEqual(boldMarkup.text, "Bold");
-  ok(
-    boldMarkup.segments.some((segment) =>
-      segment.wrappers.some((wrapper) => wrapper.name === "b" && wrapper.type === "default")
-    ),
-    "Expected bold wrapper"
-  );
-  const customWrapper = options[1].markup!.segments
-    .flatMap((segment) => segment.wrappers)
-    .find((wrapper) => wrapper.name === "wave");
-  ok(customWrapper, "Expected custom wrapper on second option");
-  strictEqual(customWrapper!.properties.intensity, 5);
-});
+test("option markup is exposed", () => {
+  const script = `
+title: Start
+---
+Narrator: Choose
+-> [b]Bold[/b]
+    Narrator: Bold
+-> [wave intensity=5]Custom[/wave]
+    Narrator: Custom
+===
+  `;
+
+  const doc = parseYarn(script);
+  const ir = compile(doc);
+  const runner = new YarnRunner(ir, { startAt: "Start" });
+
+  runner.advance(); // move to options
+  const result = runner.currentResult;
+  ok(result && result.type === "options", "Expected options result");
+  const options = result!.options;
+  ok(options[0].markup, "Expected markup on first option");
+  ok(options[1].markup, "Expected markup on second option");
+  const boldMarkup = options[0].markup!;
+  strictEqual(boldMarkup.text, "Bold");
+  ok(
+    boldMarkup.segments.some((segment) =>
+      segment.wrappers.some((wrapper) => wrapper.name === "b" && wrapper.type === "default")
+    ),
+    "Expected bold wrapper"
+  );
+  const customWrapper = options[1].markup!.segments
+    .flatMap((segment) => segment.wrappers)
+    .find((wrapper) => wrapper.name === "wave");
+  ok(customWrapper, "Expected custom wrapper on second option");
+  strictEqual(customWrapper!.properties.intensity, 5);
+});
+
+test("option text interpolates variables", () => {
+  const script = `
+title: Start
+---
+<<set $cost to 150>>
+<<set $bribe to 300>>
+Narrator: Decide
+-> Pay {$cost}
+    Narrator: Paid
+ -> Haggle {$bribe}
+    Narrator: Haggle
+===
+`;
+
+  const doc = parseYarn(script);
+  const ir = compile(doc);
+  const runner = new YarnRunner(ir, { startAt: "Start" });
+
+  // First result is command for set
+  const initial = runner.currentResult;
+  strictEqual(initial?.type, "command", "Expected first <<set>> to emit a command result");
+  runner.advance(); // second <<set>> command
+  runner.advance(); // move to narration
+  runner.advance(); // move to options
+
+  const result = runner.currentResult;
+  if (!result || result.type !== "options") {
+    throw new Error("Expected to land on options");
+  }
+  const [pay, haggle] = result.options;
+  strictEqual(pay.text, "Pay 150", "Should replace placeholder with variable value");
+  strictEqual(haggle.text, "Haggle 300", "Should evaluate expressions inside placeholders");
+});
+
+test("conditional options respect once blocks and if statements", () => {
+  const script = `
+title: Start
+---
+<<declare $secret = false>>
+Narrator: Boot
+<<once>>
+    <<set $secret = true>>
+<<endonce>>
+Narrator: Menu
+<<if $secret>>
+    -> Secret Option
+        Narrator: Secret taken
+        <<set $secret = false>>
+        <<jump Start>>
+<<endif>>
+-> Regular Option
+    Narrator: Regular taken
+    <<jump Start>>
+===
+`;
+
+  const doc = parseYarn(script);
+  const ir = compile(doc);
+  const runner = new YarnRunner(ir, { startAt: "Start" });
+
+  const nextOptions = () => {
+    let guard = 25;
+    while (guard-- > 0) {
+      const result = runner.currentResult;
+      if (!result) throw new Error("Expected runtime result");
+      if (result.type === "options") {
+        return result;
+      }
+      runner.advance();
+    }
+    throw new Error("Failed to reach options result");
+  };
+
+  const secretMenu = nextOptions();
+  strictEqual(secretMenu.options.length, 1, "First pass should expose the conditional secret option");
+  strictEqual(secretMenu.options[0].text, "Secret Option");
+
+  // Consume the secret option to flip the flag off
+  runner.advance(0);
+
+  const fallbackMenu = nextOptions();
+  strictEqual(fallbackMenu.options.length, 1, "After the secret path is used, only the regular option should remain");
+  strictEqual(fallbackMenu.options[0].text, "Regular Option");
+});
+
+test("options allow space-indented bodies", () => {
+  const script = `
+title: Start
+---
+-> Pay
+  <<jump Pay>>
+-> Run
+  <<jump Run>>
+===
+
+title: Pay
+---
+Narrator: Pay branch
+===
+
+title: Run
+---
+Narrator: Run branch
+===
+`;
+
+  const doc = parseYarn(script);
+  const ir = compile(doc);
+  const runner = new YarnRunner(ir, { startAt: "Start" });
+
+  const initial = runner.currentResult;
+  if (initial?.type !== "options") {
+    runner.advance();
+  }
+  const optionsResult = runner.currentResult;
+  strictEqual(optionsResult?.type, "options", "Expected to reach options");
+  if (optionsResult?.type !== "options") throw new Error("Options not emitted");
+  strictEqual(optionsResult.options.length, 2, "Space indents should still group options together");
+  strictEqual(optionsResult.options[0].text, "Pay");
+  strictEqual(optionsResult.options[1].text, "Run");
+});
+
+test("inline [if] option condition filters options", () => {
+  const script = `
+title: StartFalse
+---
+<<declare $flag = false>>
+-> Hidden [if $flag]
+    Narrator: Hidden
+-> Visible
+    Narrator: Visible
+===
+
+title: StartTrue
+---
+<<declare $flag = true>>
+-> Hidden [if $flag]
+    Narrator: Hidden
+-> Visible
+    Narrator: Visible
+===
+`;
+
+  const doc = parseYarn(script);
+  const ir = compile(doc);
+
+  const getOptions = (startNode: string) => {
+    const runner = new YarnRunner(ir, { startAt: startNode });
+    let guard = 25;
+    while (guard-- > 0) {
+      const result = runner.currentResult;
+      if (!result) break;
+      if (result.type === "options") {
+        return { runner, options: result };
+      }
+      runner.advance();
+    }
+    throw new Error("Failed to reach options");
+  };
+
+  const { options: optionsFalse } = getOptions("StartFalse");
+  strictEqual(optionsFalse.options.length, 1, "Hidden option should be filtered out when condition is false");
+  strictEqual(optionsFalse.options[0].text, "Visible");
+
+  const { options: optionsTrue } = getOptions("StartTrue");
+  strictEqual(optionsTrue.options.length, 2, "Both options should appear when condition is true");
+  strictEqual(optionsTrue.options[0].text, "Hidden");
+  strictEqual(optionsTrue.options[1].text, "Visible");
+});

package/src/tests/variables_flow_cmds.test.ts

@@ -2,32 +2,143 @@ import { test } from "node:test";
 import { strictEqual } from "node:assert";
 import { parseYarn, compile, YarnRunner } from "../index.js";
 
-test("variables, flow control, and commands", () => {
-  const script = `
-title: Start
----
-<<set $score to 10>>
-<<if $score >= 10>>
-    Narrator: High
-<<else>>
-    Narrator: Low
-<<endif>>
-===
-`;
-
-  const doc = parseYarn(script);
-  const ir = compile(doc);
-  const runner = new YarnRunner(ir, { startAt: "Start" });
-
-  // After command, expect if-branch 'High'
-  // First result should be command emission
-  const a = runner.currentResult!;
-  strictEqual(a.type, "command", "First result should be command");
-  runner.advance();
-  const b = runner.currentResult!;
-  strictEqual(b.type, "text", "Should be text after command");
-  if (b.type === "text") strictEqual(/High/.test(b.text), true, "Expected High branch");
-  strictEqual(runner.getVariable("score"), 10, "Variable should be set");
-});
-
+test("variables, flow control, and commands", () => {
+  const script = `
+title: Start
+---
+<<set $score to 10>>
+<<if $score >= 10>>
+    Narrator: High
+<<else>>
+    Narrator: Low
+<<endif>>
+===
+`;
+
+  const doc = parseYarn(script);
+  const ir = compile(doc);
+  const runner = new YarnRunner(ir, { startAt: "Start" });
+
+  // After command, expect if-branch 'High'
+  // First result should be command emission
+  const a = runner.currentResult!;
+  strictEqual(a.type, "command", "First result should be command");
+  runner.advance();
+  const b = runner.currentResult!;
+  strictEqual(b.type, "text", "Should be text after command");
+  if (b.type === "text") strictEqual(/High/.test(b.text), true, "Expected High branch");
+  strictEqual(runner.getVariable("score"), 10, "Variable should be set");
+});
+
+test("equality operators support ==, !=, and single =", () => {
+  const script = `
+title: Start
+---
+<<set $doorOpen to true>>
+<<if $doorOpen = true>>
+    Narrator: Single equals ok
+<<endif>>
+<<if $doorOpen == true>>
+    Narrator: Double equals ok
+<<endif>>
+<<if $doorOpen != false>>
+    Narrator: Not equals ok
+<<endif>>
+===
+`;
+
+  const doc = parseYarn(script);
+  const ir = compile(doc);
+  const runner = new YarnRunner(ir, { startAt: "Start" });
+
+  const seen: string[] = [];
+  let guard = 25;
+  while (guard-- > 0) {
+    const result = runner.currentResult;
+    if (!result) break;
+    if (result.type === "text" && result.text.trim()) {
+      seen.push(result.text.trim());
+    }
+    if (result.isDialogueEnd) {
+      break;
+    }
+    if (result.type === "options") {
+      runner.advance(0);
+    } else {
+      runner.advance();
+    }
+  }
+
+  strictEqual(seen.includes("Single equals ok"), true, "Single equals comparison should succeed");
+  strictEqual(seen.includes("Double equals ok"), true, "Double equals comparison should succeed");
+  strictEqual(seen.includes("Not equals ok"), true, "Not equals comparison should succeed");
+});
+
+test("set command supports equals syntax with arithmetic reassignment", () => {
+  const script = `
+title: StreetCred
+---
+<<set $reputation = 100>>
+<<set $reputation = $reputation - 25 >>
+Narrator: Current street cred: {$reputation}
+===
+`;
+
+  const doc = parseYarn(script);
+  const ir = compile(doc);
+  const runner = new YarnRunner(ir, { startAt: "StreetCred" });
+
+  const seen: string[] = [];
+  for (let guard = 0; guard < 20; guard++) {
+    const result = runner.currentResult;
+    if (!result) break;
+    if (result.type === "text" && result.text.trim()) {
+      seen.push(result.text.trim());
+    }
+    if (result.isDialogueEnd) break;
+    if (result.type === "options") {
+      runner.advance(0);
+    } else {
+      runner.advance();
+    }
+  }
+
+  strictEqual(seen.includes("Current street cred: 75"), true, "Should reflect arithmetic subtraction");
+  strictEqual(runner.getVariable("reputation"), 75, "Variable should store updated numeric value");
+});
+
+test("set command respects arithmetic precedence and parentheses", () => {
+  const script = `
+title: MathChecks
+---
+<<set $score = 10>>
+<<set $score = $score + 10 * 2>>
+<<set $score = ($score + 10) / 2>>
+Narrator: Score now {$score}
+===
+`;
+
+  const doc = parseYarn(script);
+  const ir = compile(doc);
+  const runner = new YarnRunner(ir, { startAt: "MathChecks" });
+
+  const lines: string[] = [];
+  for (let guard = 0; guard < 20; guard++) {
+    const result = runner.currentResult;
+    if (!result) break;
+    if (result.type === "text" && result.text.trim()) {
+      lines.push(result.text.trim());
+    }
+    if (result.isDialogueEnd) break;
+    if (result.type === "options") {
+      runner.advance(0);
+    } else {
+      runner.advance();
+    }
+  }
+
+  strictEqual(lines.includes("Score now 20"), true, "Should honor operator precedence and parentheses");
+  strictEqual(runner.getVariable("score"), 20, "Final numeric value should be 20");
+});
+