yarn-spinner-runner-ts 0.1.3 → 0.1.4-b

package/src/react/MarkupRenderer.tsx

@@ -1,7 +1,7 @@
 import React from "react";
 import type { MarkupParseResult, MarkupWrapper } from "../markup/types.js";
 
-const DEFAULT_HTML_TAGS = new Set(["b", "em", "small", "strong", "sub", "sup", "ins", "del", "mark"]);
+const DEFAULT_HTML_TAGS = new Set(["b", "em", "small", "strong", "sub", "sup", "ins", "del", "mark", "br"]);
 
 interface RenderPiece {
   text: string;
@@ -107,4 +107,3 @@ function createWrapperElement(
 function sanitizeClassName(name: string): string {
   return name.toLowerCase().replace(/[^a-z0-9_-]/g, "-");
 }
-

package/src/react/useYarnRunner.tsx

@@ -13,11 +13,23 @@ export function useYarnRunner(
 } {
   const runnerRef = useRef<YarnRunner | null>(null);
   const [result, setResult] = useState<RuntimeResult | null>(null);
+  const optionsRef = useRef(options);
 
-  // Initialize runner only once
+  // Update runner if functions change
+  if (
+    runnerRef.current &&
+    JSON.stringify(optionsRef.current.functions) !== JSON.stringify(options.functions)
+  ) {
+    runnerRef.current = new YarnRunner(program, options);
+    setResult(runnerRef.current.currentResult);
+    optionsRef.current = options;
+  }
+
+  // Initialize runner if not exists
   if (!runnerRef.current) {
     runnerRef.current = new YarnRunner(program, options);
     setResult(runnerRef.current.currentResult);
+    optionsRef.current = options;
   }
 
   const runner = runnerRef.current;

package/src/runtime/commands.ts

@@ -29,6 +29,14 @@ export function parseCommand(content: string): ParsedCommand {
     const char = trimmed[i];
 
     if ((char === '"' || char === "'") && !inQuotes) {
+      // If we have accumulated non-quoted content (e.g. a function name and "(")
+      // push it as its own part before entering quoted mode. This prevents the
+      // surrounding text from being merged into the quoted content when we
+      // later push the quoted value.
+      if (current.trim()) {
+        parts.push(current.trim());
+        current = "";
+      }
       inQuotes = true;
       quoteChar = char;
       continue;
@@ -36,8 +44,11 @@ export function parseCommand(content: string): ParsedCommand {
 
     if (char === quoteChar && inQuotes) {
       inQuotes = false;
+      // Preserve the surrounding quotes in the parsed part so callers that
+      // reassemble the expression (e.g. declare handlers) keep string literals
+      // intact instead of losing quote characters.
+      parts.push(quoteChar + current + quoteChar);
       quoteChar = "";
-      parts.push(current);
       current = "";
       continue;
     }
@@ -129,11 +140,13 @@ export class CommandHandler {
     this.register("declare", (args, evaluator) => {
       if (!evaluator) return;
       if (args.length < 3) return; // name, '=', expr
+      
       const varNameRaw = args[0];
       let exprParts = args.slice(1);
       if (exprParts[0] === "=") exprParts = exprParts.slice(1);
       const expr = exprParts.join(" ");
       
+      
       const key = varNameRaw.startsWith("$") ? varNameRaw.slice(1) : varNameRaw;
       
       // Check if expression is "smart" (contains operators, comparisons, or variable references)

package/src/runtime/runner.ts

@@ -10,6 +10,7 @@ export interface RunnerOptions {
   functions?: Record<string, (...args: unknown[]) => unknown>;
   handleCommand?: (command: string, parsed?: ReturnType<typeof parseCommand>) => void;
   commandHandler?: CommandHandler;
+  onStoryEnd?: (payload: { variables: Readonly<Record<string, unknown>>; storyEnd: true }) => void;
 }
 
 const globalOnceSeen = new Set<string>();
@@ -23,6 +24,8 @@ export class YarnRunner {
   private readonly commandHandler: CommandHandler;
   private readonly evaluator: ExpressionEvaluator;
   private readonly onceSeen = globalOnceSeen;
+  private readonly onStoryEnd?: RunnerOptions["onStoryEnd"];
+  private storyEnded = false;
   private readonly nodeGroupOnceSeen = globalNodeGroupOnceSeen;
   private readonly visitCounts: Record<string, number> = {};
 
@@ -95,6 +98,7 @@ export class YarnRunner {
       ...(opts.functions ?? {}),
     } as Record<string, (...args: unknown[]) => unknown>;
     this.handleCommand = opts.handleCommand;
+    this.onStoryEnd = opts.onStoryEnd;
     this.evaluator = new ExpressionEvaluator(this.variables, this.functions, this.program.enums);
     this.commandHandler = opts.commandHandler ?? new CommandHandler(this.variables);
     this.nodeTitle = opts.startAt;
@@ -589,6 +593,14 @@ export class YarnRunner {
   private emit(res: RuntimeResult) {
     this.currentResult = res;
     this.history.push(res);
+    if (res.isDialogueEnd && !this.storyEnded && this.callStack.length === 0) {
+      this.storyEnded = true;
+      if (this.onStoryEnd) {
+        // Create a readonly copy of the variables
+        const variablesCopy = Object.freeze({ ...this.variables });
+        this.onStoryEnd({ storyEnd: true, variables: variablesCopy });
+      }
+    }
     // If we ended a detour node, return to caller after emitting last result
     // Position is restored here, but we wait for next advance() to continue
     if (res.isDialogueEnd && this.callStack.length > 0) {

package/src/tests/custom_functions.test.ts

@@ -0,0 +1,140 @@
+import { test } from "node:test";
+import { strictEqual, ok, match } from "node:assert";
+import { parseYarn, compile } from "../index.js";
+import { YarnRunner } from "../runtime/runner.js";
+
+test("custom functions", () => {
+  const yarnText = `
+title: CustomFuncs
+---
+<<declare $doubled = multiply(2, 3)>>
+<<declare $concatenated = concat("Hello", " World")>>
+<<declare $power = pow(2, 3)>>
+<<declare $conditionalValue = ifThen(true, "yes", "no")>>
+Result: {$doubled}, {$concatenated}, {$power}, {$conditionalValue}
+===
+`;
+
+  const ast = parseYarn(yarnText);
+  const program = compile(ast);
+  const runner = new YarnRunner(program, {
+    startAt: "CustomFuncs",
+    functions: {
+      multiply: (a: unknown, b: unknown) => Number(a) * Number(b),
+      concat: (a: unknown, b: unknown) => String(a) + String(b),
+      pow: (base: unknown, exp: unknown) => Math.pow(Number(base), Number(exp)),
+      ifThen: (cond: unknown, yes: unknown, no: unknown) => Boolean(cond) ? yes : no,
+    },
+  });
+
+  // Need to advance past declare commands and get to the text line
+  for (let i = 0; i < 4; i++) {
+    runner.advance();
+  }
+  strictEqual(runner.currentResult?.type, "text");
+  if (runner.currentResult?.type === "text") {
+    const fullText = (runner.currentResult.speaker ? `${runner.currentResult.speaker}: ` : "") + runner.currentResult.text;
+    strictEqual(fullText, "Result: 6, Hello World, 8, yes");
+  }
+});
+
+test("custom functions with type coercion", () => {
+  const yarnText = `
+title: TypeCoercion
+---
+<<declare $numFromStr = multiply("2", "3")>>
+<<declare $concatNums = concat(123, 456)>>
+<<declare $boolStr = ifThen("true", 1, 0)>>
+Result: {$numFromStr}, {$concatNums}, {$boolStr}
+===
+`;
+
+  const ast = parseYarn(yarnText);
+  const program = compile(ast);
+  const runner = new YarnRunner(program, {
+    startAt: "TypeCoercion",
+    functions: {
+      multiply: (a: unknown, b: unknown) => Number(a) * Number(b),
+      concat: (a: unknown, b: unknown) => String(a) + String(b),
+      ifThen: (cond: unknown, yes: unknown, no: unknown) => Boolean(cond) ? yes : no,
+    },
+  });
+
+  // Need to advance past declare commands and get to the text line
+  for (let i = 0; i < 3; i++) {
+    runner.advance();
+  }
+  strictEqual(runner.currentResult?.type, "text");
+  if (runner.currentResult?.type === "text") {
+    const fullText = (runner.currentResult.speaker ? `${runner.currentResult.speaker}: ` : "") + runner.currentResult.text;
+    strictEqual(fullText, "Result: 6, 123456, 1");
+  }
+});
+
+test("custom functions error handling", () => {
+  const yarnText = `
+title: ErrorHandling
+---
+<<declare $result = safeDivide(10, 0)>>
+Result: {$result}
+===
+`;
+
+  const ast = parseYarn(yarnText);
+  const program = compile(ast);
+  const runner = new YarnRunner(program, {
+    startAt: "ErrorHandling",
+    functions: {
+      safeDivide: (a: unknown, b: unknown) => {
+        const numerator = Number(a);
+        const denominator = Number(b);
+        return denominator === 0 ? "Cannot divide by zero" : numerator / denominator;
+      },
+    },
+  });
+
+  // Advance until we reach a text result (some commands emit immediately)
+  for (let i = 0; i < 10 && runner.currentResult?.type !== "text"; i++) {
+    runner.advance();
+  }
+  strictEqual(runner.currentResult?.type, "text");
+  if (runner.currentResult?.type === "text") {
+    const fullText = (runner.currentResult.speaker ? `${runner.currentResult.speaker}: ` : "") + runner.currentResult.text;
+    strictEqual(fullText, "Result: Cannot divide by zero");
+  }
+});
+
+test("custom functions alongside built-in functions", () => {
+  const yarnText = `
+title: MixedFunctions
+---
+<<declare $random = random()>>
+<<declare $doubled = multiply($random, 2)>>
+<<declare $formatted = format_number($doubled)>>
+Result: {$formatted}
+===
+`;
+
+  const ast = parseYarn(yarnText);
+  const program = compile(ast);
+  const runner = new YarnRunner(program, {
+    startAt: "MixedFunctions",
+    functions: {
+      multiply: (a: unknown, b: unknown) => Number(a) * Number(b),
+      format_number: (n: unknown) => Number(n).toFixed(2),
+    },
+  });
+
+  // Need to advance past declare commands and get to the text line
+  for (let i = 0; i < 3; i++) {
+    runner.advance();
+  }
+  strictEqual(runner.currentResult?.type, "text");
+  if (runner.currentResult?.type === "text") {
+    const fullText = (runner.currentResult.speaker ? `${runner.currentResult.speaker}: ` : "") + runner.currentResult.text;
+    const resultNumber = parseFloat(fullText.replace("Result: ", ""));
+    ok(resultNumber >= 0);
+    ok(resultNumber <= 2);
+    match(fullText, /Result: \d+\.\d{2}/);
+  }
+});

package/src/tests/markup.test.ts

@@ -43,6 +43,23 @@ test("parseMarkup handles self-closing tags", () => {
   );
 });
 
+test("parseMarkup handles br line breaks", () => {
+  const result = parseMarkup("Line one[br]Line two[/br][br/]Line three");
+  strictEqual(result.text, "Line one\nLine two\nLine three");
+
+  const brSegments = result.segments.filter(
+    (segment) => segment.selfClosing && segment.wrappers.some((wrapper) => wrapper.name === "br")
+  );
+
+  strictEqual(brSegments.length, 2);
+  ok(
+    brSegments.every((segment) =>
+      segment.wrappers.some((wrapper) => wrapper.name === "br" && wrapper.type === "default")
+    ),
+    "Expected br wrappers to use default HTML type"
+  );
+});
+
 test("parseMarkup respects nomarkup blocks and escaping", () => {
   const result = parseMarkup(`[nomarkup][b] raw [/b][/nomarkup] and \\[escaped\\]`);
   strictEqual(result.text, "[b] raw [/b] and [escaped]");
@@ -59,4 +76,3 @@ function findSegment(result: MarkupParseResult, target: string) {
     return text === target;
   });
 }
-

package/src/tests/story_end.test.ts

@@ -0,0 +1,42 @@
+import { test } from "node:test";
+import { ok, strictEqual } from "node:assert";
+import { parseYarn, compile, YarnRunner } from "../index.js";
+
+test("onStoryEnd receives variables snapshot", () => {
+  const script = `
+title: Start
+---
+Narrator: Beginning
+<<set $score = 42>>
+Narrator: Done
+===
+`;
+  let payload: { variables: Readonly<Record<string, unknown>>; storyEnd: true } | undefined;
+  const doc = parseYarn(script);
+  const ir = compile(doc);
+  const runner = new YarnRunner(ir, {
+    startAt: "Start",
+    onStoryEnd: (info) => {
+      payload = info;
+    },
+  });
+
+  let result = runner.currentResult;
+  ok(result && result.type === "text");
+
+  runner.advance();
+  result = runner.currentResult;
+  ok(result && result.type === "command");
+
+  runner.advance();
+  result = runner.currentResult;
+  ok(result && result.type === "text");
+
+  runner.advance();
+  result = runner.currentResult;
+  ok(result && result.isDialogueEnd === true);
+
+  strictEqual(payload?.storyEnd, true);
+  const variables = payload?.variables ?? {};
+  strictEqual((variables as Record<string, unknown>)["score"], 42);
+});