@rohal12/spindle 0.51.2 → 0.51.4

package/src/components/macros/WidgetInvocation.tsx

@@ -9,12 +9,14 @@ import {
   LocalsValuesContext,
   LocalsUpdateContext,
   NobrContext,
+  InlineContext,
   WidgetChildrenContext,
   renderNodes,
 } from '../../markup/render';
 import { useMergedLocals } from '../../hooks/use-merged-locals';
 import { evaluate } from '../../expression';
 import type { ASTNode } from '../../markup/ast';
+import { isWhitespace, splitTopLevel } from './arg-utils';
 
 interface WidgetInvocationProps {
   body: ASTNode[];
@@ -53,55 +55,13 @@ function isStandaloneValue(token: string): boolean {
 }
 
 /**
- * Try to split a raw string on whitespace at depth 0 (respecting quotes,
- * parentheses, brackets, and braces). Each resulting token must pass
- * `isStandaloneValue()` or the split is rejected and `null` is returned.
+ * Try to split a raw string on whitespace at depth 0 (respecting strings,
+ * template literals, parentheses, brackets, and braces). Each resulting token
+ * must pass `isStandaloneValue()` or the split is rejected and `null` is
+ * returned.
  */
 function trySplitOnWhitespace(raw: string): string[] | null {
-  const args: string[] = [];
-  let current = '';
-  let depth = 0;
-  let inString: string | null = null;
-
-  for (let i = 0; i < raw.length; i++) {
-    const ch = raw[i]!;
-
-    if (inString) {
-      current += ch;
-      if (ch === inString && raw[i - 1] !== '\\') inString = null;
-      continue;
-    }
-
-    if (ch === '"' || ch === "'" || ch === '`') {
-      inString = ch;
-      current += ch;
-      continue;
-    }
-
-    if (ch === '(' || ch === '[' || ch === '{') {
-      depth++;
-      current += ch;
-      continue;
-    }
-
-    if (ch === ')' || ch === ']' || ch === '}') {
-      depth--;
-      current += ch;
-      continue;
-    }
-
-    if (/\s/.test(ch) && depth === 0) {
-      if (current) {
-        args.push(current);
-        current = '';
-      }
-      continue;
-    }
-
-    current += ch;
-  }
-
-  if (current) args.push(current);
+  const args = splitTopLevel(raw, isWhitespace).filter(Boolean);
 
   // Need 2+ tokens
   if (args.length < 2) return null;
@@ -120,51 +80,9 @@ function trySplitOnWhitespace(raw: string): string[] | null {
  * string literals separated by whitespace (e.g. `"Label" "target"`).
  */
 export function splitArgs(raw: string): string[] {
-  const args: string[] = [];
-  let current = '';
-  let depth = 0;
-  let inString: string | null = null;
-  let hasComma = false;
-
-  for (let i = 0; i < raw.length; i++) {
-    const ch = raw[i]!;
-
-    if (inString) {
-      current += ch;
-      if (ch === inString && raw[i - 1] !== '\\') inString = null;
-      continue;
-    }
-
-    if (ch === '"' || ch === "'" || ch === '`') {
-      inString = ch;
-      current += ch;
-      continue;
-    }
-
-    if (ch === '(' || ch === '[' || ch === '{') {
-      depth++;
-      current += ch;
-      continue;
-    }
-
-    if (ch === ')' || ch === ']' || ch === '}') {
-      depth--;
-      current += ch;
-      continue;
-    }
-
-    if (ch === ',' && depth === 0) {
-      hasComma = true;
-      args.push(current.trim());
-      current = '';
-      continue;
-    }
-
-    current += ch;
-  }
-
-  const last = current.trim();
-  if (last) args.push(last);
+  const args = splitTopLevel(raw, (ch) => ch === ',').map((a) => a.trim());
+  const hasComma = args.length > 1;
+  if (args[args.length - 1] === '') args.pop();
 
   // If no commas were found and we got a single expression, try splitting
   // on whitespace at depth 0 (e.g. "Label" "target", $var "text", $x $y).
@@ -186,6 +104,7 @@ function WidgetBody({
   ownKeys: Record<string, unknown>;
 }) {
   const nobr = useContext(NobrContext);
+  const inline = useContext(InlineContext);
   const [localMutations, setLocalMutations] = useState<Record<string, unknown>>(
     {},
   );
@@ -211,7 +130,7 @@ function WidgetBody({
   return (
     <LocalsUpdateContext.Provider value={updater}>
       <LocalsValuesContext.Provider value={localState}>
-        {renderNodes(body, { nobr, locals: localState })}
+        {renderNodes(body, { nobr, inline, locals: localState })}
       </LocalsValuesContext.Provider>
     </LocalsUpdateContext.Provider>
   );
@@ -225,6 +144,7 @@ export function WidgetInvocation({
 }: WidgetInvocationProps) {
   const parentValues = useContext(LocalsValuesContext);
   const nobr = useContext(NobrContext);
+  const inline = useContext(InlineContext);
   const [mergedVars, mergedTemps, mergedLocals, mergedTrans] =
     useMergedLocals();
 
@@ -235,7 +155,7 @@ export function WidgetInvocation({
   if (params.length === 0) {
     return (
       <WidgetChildrenContext.Provider value={childrenValue}>
-        {renderNodes(body, { nobr, locals: parentValues })}
+        {renderNodes(body, { nobr, inline, locals: parentValues })}
       </WidgetChildrenContext.Provider>
     );
   }

package/src/components/macros/arg-utils.ts

@@ -0,0 +1,120 @@
+/**
+ * Shared helpers for macros that split or read their raw argument text by
+ * hand. Their lexical model is the expression lexer's (`js-lexer.ts`):
+ * string, template and regex literals and comments are opaque (a backslash
+ * inside a literal escapes the character after it, and `${…}` parts of a
+ * template are code), `/` opens a regex only where an operand is expected,
+ * and `(`/`[`/`{` nest.
+ */
+import { lexJs, lexTemplate, scanStringLiteral } from '../../js-lexer';
+
+/** True for a whitespace character. */
+export function isWhitespace(ch: string): boolean {
+  return /\s/.test(ch);
+}
+
+function isOpener(ch: string): boolean {
+  return ch === '(' || ch === '[' || ch === '{';
+}
+
+function isCloser(ch: string): boolean {
+  return ch === ')' || ch === ']' || ch === '}';
+}
+
+/**
+ * Given the index of an opening quote (`"`, `'` or a backtick), return the
+ * index just past its closing quote, or `src.length` if it is unterminated.
+ * A backslash escapes the character after it, so a quote preceded by an even
+ * run of backslashes still closes the string and one preceded by an odd run
+ * does not. Inside a template literal, `${…}` interpolations are lexed as
+ * code, so quotes, backticks, braces and regexes inside them do not end it.
+ */
+export function skipString(src: string, start: number): number {
+  return src[start] === '`'
+    ? lexTemplate(src, start)
+    : scanStringLiteral(src, start).end;
+}
+
+/**
+ * Undo the escapes allowed in a literal quoted macro argument: `\"`, `\'`
+ * and `\\` become `"`, `'` and `\`. Other backslash sequences (`\n`, `\d`)
+ * are kept as written, so code and regex text inside the string survive.
+ */
+export function unescapeQuoted(body: string): string {
+  return body.replace(/\\(["'\\])/g, '$1');
+}
+
+/**
+ * Read the `"…"` or `'…'` string whose opening quote is at `start`.
+ * Returns its unescaped value and the index just past the closing quote, or
+ * `null` if there is no such quote at `start` or the string is unterminated.
+ */
+export function readQuoted(
+  src: string,
+  start: number,
+): { value: string; end: number } | null {
+  const quote = src[start];
+  if (quote !== '"' && quote !== "'") return null;
+  const { end, closed } = scanStringLiteral(src, start);
+  if (!closed) return null;
+  return { value: unescapeQuoted(src.slice(start + 1, end - 1)), end };
+}
+
+/**
+ * The unescaped value of `src` when it is exactly one `"…"` or `'…'` string
+ * (as with `readQuoted`), otherwise `null`.
+ */
+export function readWholeQuoted(src: string): string | null {
+  const quoted = readQuoted(src, 0);
+  return quoted && quoted.end === src.length ? quoted.value : null;
+}
+
+/**
+ * Strip an optional quote from each end of an unquoted-or-loosely-quoted
+ * argument (`"Red`, `Red'`), leaving at least one character. This is the
+ * lenient fallback for labels that are not one well-formed quoted string.
+ */
+export function stripLooseQuotes(src: string): string {
+  return /^["']?(.+?)["']?$/.exec(src)?.[1] ?? src;
+}
+
+/**
+ * Indices of the characters in `src` that satisfy `isSeparator` and sit at
+ * depth 0: in code outside string, template and regex literals and comments,
+ * and outside `()`, `[]` and `{}` pairs.
+ */
+export function topLevelIndices(
+  src: string,
+  isSeparator: (ch: string) => boolean,
+): number[] {
+  const indices: number[] = [];
+  let depth = 0;
+  lexJs(src, {
+    code(ch, i, nesting) {
+      if (nesting > 0) return; // inside a template interpolation
+      if (isOpener(ch)) depth++;
+      else if (isCloser(ch)) depth--;
+      else if (depth === 0 && isSeparator(ch)) indices.push(i);
+    },
+  });
+  return indices;
+}
+
+/**
+ * Split `src` at every depth-0 separator (see `topLevelIndices`). Segments
+ * are returned as written, untrimmed, and empty segments are kept, so
+ * `n` separators always give `n + 1` segments.
+ */
+export function splitTopLevel(
+  src: string,
+  isSeparator: (ch: string) => boolean,
+): string[] {
+  const segments: string[] = [];
+  let from = 0;
+  for (const i of topLevelIndices(src, isSeparator)) {
+    segments.push(src.slice(from, i));
+    from = i + 1;
+  }
+  segments.push(src.slice(from));
+  return segments;
+}

package/src/components/macros/option-utils.ts

@@ -1,17 +1,20 @@
 import type { ASTNode } from '../../markup/ast';
+import { readWholeQuoted } from './arg-utils';
 
 export function parseVarArgs(rawArgs: string): {
   varName: string;
   placeholder: string;
 } {
-  const match = rawArgs.match(
-    /^\s*(["']?\$[\w.]+["']?)\s*(?:["'](.*)["'])?\s*$/,
-  );
+  const match = rawArgs.match(/^\s*(["']?\$[\w.]+["']?)\s*(["'].*["'])?\s*$/);
   if (!match) {
     return { varName: rawArgs.trim(), placeholder: '' };
   }
   const varName = match[1]!.replace(/["']/g, '');
-  const placeholder = match[2] || '';
+  // A quoted placeholder accepts \" \' and \\ escapes.
+  const quoted = match[2];
+  const placeholder = quoted
+    ? (readWholeQuoted(quoted) ?? quoted.slice(1, -1))
+    : '';
   return { varName, placeholder };
 }
 
@@ -24,7 +27,8 @@ export function extractOptions(children: ASTNode[]): string[] {
     if (node.type === 'macro' && node.name === 'option') {
       const raw = node.rawArgs.trim();
       // Strip surrounding quotes so {option "Long Sword"} gives "Long Sword"
-      const stripped = raw.replace(/^(["'])(.+)\1$/, '$2');
+      const stripped =
+        readWholeQuoted(raw) ?? raw.replace(/^(["'])(.+)\1$/, '$2');
       options.push(stripped);
     }
   }

package/src/define-macro.ts

@@ -15,6 +15,7 @@ import {
   LocalsUpdateContext,
   LocalsValuesContext,
   NobrContext,
+  InlineContext,
   renderNodes as _renderNodes,
   renderInlineNodes,
 } from './markup/render';
@@ -22,6 +23,7 @@ import type { ASTNode } from './markup/ast';
 import { executeMutation } from './execute-mutation';
 import { evaluate } from './expression';
 import { useStoryStore } from './store';
+import { getByPath, setByPath } from './utils/object-path';
 import { useAction } from './hooks/use-action';
 import type { UseActionOptions } from './hooks/use-action';
 import { collectText } from './utils/extract-text';
@@ -101,33 +103,6 @@ const sharedHooks = {
   useContext,
 };
 
-/** Traverse a dot-path on an object, returning the nested value. */
-function getByPath(obj: Record<string, unknown>, segments: string[]): unknown {
-  let current: unknown = obj;
-  for (const seg of segments) {
-    if (current == null || typeof current !== 'object') return undefined;
-    current = (current as Record<string, unknown>)[seg];
-  }
-  return current;
-}
-
-/** Set a nested value by dot-path segments on an (Immer draft) object. */
-function setByPath(
-  obj: Record<string, unknown>,
-  segments: string[],
-  value: unknown,
-): void {
-  let target: Record<string, unknown> = obj;
-  for (let i = 0; i < segments.length - 1; i++) {
-    const seg = segments[i]!;
-    if (target[seg] == null || typeof target[seg] !== 'object') {
-      target[seg] = {};
-    }
-    target = target[seg] as Record<string, unknown>;
-  }
-  target[segments[segments.length - 1]!] = value;
-}
-
 export function defineMacro(
   config: MacroDefinition,
   source: 'builtin' | 'user' = 'builtin',
@@ -146,11 +121,17 @@ export function defineMacro(
     // Always-on: cssClass + mutation
     const { update, getValues } = useContext(LocalsUpdateContext);
     const nobr = useContext(NobrContext);
+    const inline = useContext(InlineContext);
     const localsValues = useContext(LocalsValuesContext);
     const renderNodes = (
       nodes: ASTNode[],
-      options?: { nobr?: boolean; locals?: Record<string, unknown> },
-    ) => _renderNodes(nodes, { nobr, locals: localsValues, ...options });
+      options?: {
+        nobr?: boolean;
+        locals?: Record<string, unknown>;
+        inline?: boolean;
+      },
+    ) =>
+      _renderNodes(nodes, { nobr, inline, locals: localsValues, ...options });
     const ctx: MacroContext = {
       collectText,
       sourceLocation: currentSourceLocation,
@@ -202,11 +183,9 @@ export function defineMacro(
         getByPath(useStoryStore.getState().variables, segments);
       ctx.setValue = (value: unknown) => {
         useStoryStore.setState((state) => {
-          setByPath(
-            state.variables as Record<string, unknown>,
-            segments,
-            value,
-          );
+          setByPath(state.variables, segments, value, {
+            createMissing: true,
+          });
         });
       };
     }