@rohal12/spindle 0.59.0 → 0.59.1

package/src/story-variables.ts

@@ -11,7 +11,6 @@ import {
 } from './js-lexer';
 import {
   argPieces,
-  holdsCode,
   parseOrError,
   withParseCache,
   type ParametersOf,
@@ -53,7 +52,6 @@ function declarationRegex(sigil: string): RegExp {
 const VAR_PATH_RE = /\$(\w+(?:\.\w+)*)/y;
 /** Quoted first argument of an input macro naming a story variable. */
 const QUOTED_VAR_ARG_RE = /^["']\$(\w+(?:\.\w+)*)["']?$/;
-const FOR_LOCAL_RE = /\{for\s+@(\w+)(?:\s*,\s*@(\w+))?\s+of\b/g;
 
 const VALID_VAR_TYPES = new Set<string>(['number', 'string', 'boolean']);
 
@@ -131,22 +129,6 @@ export function parseStoryVariables(
   return schema;
 }
 
-/**
- * Extract for-loop local variable names from passage content.
- * `{for @item of ...}` → "item"
- * `{for @index, @item of ...}` → "index", "item"
- */
-function extractForLocals(content: string): Set<string> {
-  const locals = new Set<string>();
-  let match: RegExpExecArray | null;
-  FOR_LOCAL_RE.lastIndex = 0;
-  while ((match = FOR_LOCAL_RE.exec(content)) !== null) {
-    locals.add(match[1]!);
-    if (match[2]) locals.add(match[2]!);
-  }
-  return locals;
-}
-
 /**
  * Validate a single variable reference path (e.g. "player.health") against
  * the schema. Returns an error message or null if valid.
@@ -154,7 +136,6 @@ function extractForLocals(content: string): Set<string> {
 function validateRef(
   ref: string,
   schema: Map<string, VariableSchema>,
-  forLocals: Set<string>,
 ): string | null {
   const parts = ref.split('.');
   const rootName = parts[0]!;
@@ -162,9 +143,6 @@ function validateRef(
   const nameError = variableNameError(rootName, '$' + rootName);
   if (nameError) return nameError;
 
-  // Skip for-loop locals
-  if (forLocals.has(rootName)) return null;
-
   const rootSchema = schema.get(rootName);
   if (!rootSchema) {
     return `Undeclared variable: $${ref}`;
@@ -252,8 +230,9 @@ function scanInterpolations(
  * Report `$var` references in JavaScript code, lexed as the expression
  * engine lexes it (`lexJs`): references in code, but none inside string or
  * regex literals or comments, nor property names (`a.$b`, `{ $b: 1 }`).
- * The text of string and template literals is scanned for the markup that
- * labels evaluate (`{$…}`); the `${…}` parts of template literals are code.
+ * The text of string and template literals is not scanned: a string in code
+ * is literal text unless a macro argument that holds markup is read as such
+ * (see scanArgs); the `${…}` parts of template literals are code.
  */
 function scanCode(
   code: string,
@@ -270,7 +249,6 @@ function scanCode(
     VAR_PATH_RE.lastIndex = ref.start;
     onRef(VAR_PATH_RE.exec(code)![1]!);
   }
-  for (const text of parsed.strings) scanInterpolations(text, onRef);
 }
 
 /** `scanCode` for code acorn can't parse: lexed leniently. */
@@ -279,8 +257,6 @@ function scanCodeLeniently(
   onRef: RefCallback,
   goal: JsGoal,
 ): void {
-  /** Open template literals: their text so far, null in an interpolation. */
-  const templates: { nesting: number; text: string | null }[] = [];
   lexJs(
     code,
     {
@@ -289,32 +265,11 @@ function scanCodeLeniently(
         VAR_PATH_RE.lastIndex = index;
         onRef(VAR_PATH_RE.exec(code)![1]!);
       },
-      literal(text, _index, nesting) {
-        const template = templates[templates.length - 1];
-        if (template?.nesting === nesting) {
-          if (template.text === null) {
-            // The `}` ending an interpolation: back to the template's text
-            template.text = '';
-          } else if (text === '`' || text === '${') {
-            scanInterpolations(template.text, onRef);
-            if (text === '`') templates.pop();
-            else template.text = null;
-          } else {
-            template.text += text;
-          }
-        } else if (text === '`') {
-          templates.push({ nesting, text: '' });
-        } else if (text[0] === '"' || text[0] === "'") {
-          const { closed } = scanStringLiteral(text, 0);
-          scanInterpolations(text.slice(1, closed ? -1 : undefined), onRef);
-        }
-        // Regex literals and comments hold no references
-      },
+      // Strings, regex literals and comments hold no references
+      literal() {},
     },
     goal,
   );
-  // An unterminated template literal's text
-  for (const t of templates) if (t.text) scanInterpolations(t.text, onRef);
 }
 
 /**
@@ -341,22 +296,29 @@ function collectPassageRefs(
 }
 
 /**
- * Report the references in the code that a macro's quoted arguments hold
- * (see ParameterDef.holds), the condition and `run` action of `{watch}`:
- * the argument scan sees only the strings. Only the macros that declare
- * code in a string have their arguments read.
+ * Report the references in the arguments of a macro by what its parameters
+ * say each holds (see ParameterDef.holds): code is scanned as code and
+ * markup as markup, but literal text (a placeholder, a passage name) holds
+ * none. A macro without declared parameters, or arguments that do not
+ * parse, are scanned as code.
  */
-function scanStringCode(
+function scanArgs(
   token: Extract<Token, { type: 'macro' }>,
   params: readonly ParameterDef[] | undefined,
   onRef: RefCallback,
 ): void {
-  if (!params || !token.rawArgs || !holdsCode(params)) return;
-  for (const piece of argPieces(token.rawArgs, 0, params, token.name, '')) {
-    if (piece.kind === 'code' && piece.inString) {
-      scanCode(piece.code, onRef, piece.goal);
+  if (!token.rawArgs) return;
+  if (params) {
+    const pieces = [...argPieces(token.rawArgs, 0, params, token.name, '')];
+    if (!pieces.some((piece) => piece.kind === 'argument-error')) {
+      for (const piece of pieces) {
+        if (piece.kind === 'code') scanCode(piece.code, onRef, piece.goal);
+        else if (piece.kind === 'text') scanInterpolations(piece.text, onRef);
+      }
+      return;
     }
   }
+  scanCode(token.rawArgs, onRef);
 }
 
 /** Report the `$var` references in the tokens of `content`. */
@@ -379,13 +341,14 @@ function collectTokenRefs(
         else scanInterpolations(value, onRef, storeVarMacros);
       }
     } else if (token.type === 'macro' && !token.isClose) {
-      scanCode(token.rawArgs, onRef);
-      scanStringCode(token, parametersOf(token.name), onRef);
+      scanArgs(token, parametersOf(token.name), onRef);
 
       if (storeVarMacros.has(token.name.toLowerCase())) {
         const first = token.rawArgs.trim().split(/\s+/)[0] ?? '';
         const quoted = QUOTED_VAR_ARG_RE.exec(first);
         if (quoted) onRef(quoted[1]!);
+        // Unquoted, the variable is an argument of no declared role
+        else if (!/^["'`]/.test(first)) scanCode(first, onRef);
       }
 
       if (token.name === 'do') {
@@ -430,12 +393,11 @@ export function validatePassages(
     // Don't validate the declarations or the SaveTitle code themselves
     if (NOT_MARKUP.has(name)) continue;
 
-    const forLocals = extractForLocals(passage.content);
     collectPassageRefs(
       passage.content,
       storeVarSet,
       (ref) => {
-        const error = validateRef(ref, schema, forLocals);
+        const error = validateRef(ref, schema);
         if (error) {
           errors.push(`Passage "${name}": ${error}`);
         }

package/src/structural.ts

@@ -36,6 +36,12 @@ export interface DeepCloneOptions {
    * plain object, which would lose their prototype and identity.
    */
   keepUnregistered?: boolean;
+  /**
+   * The copies made so far, by original. Values copied with one map share
+   * their references: an object met again, in the same value or another,
+   * is the copy already made. The map is filled as values are copied.
+   */
+  seen?: Map<object, object>;
 }
 
 type TypedArrayCtor = new (
@@ -45,7 +51,7 @@ type TypedArrayCtor = new (
 ) => ArrayBufferView;
 
 export function deepClone<T>(value: T, options: DeepCloneOptions = {}): T {
-  const seen = new Map<object, object>();
+  const seen = options.seen ?? new Map<object, object>();
 
   /** Record `copy` as the copy of `obj` before its contents are copied. */
   const keep = <C extends object>(obj: object, copy: C): C => {
@@ -53,11 +59,20 @@ export function deepClone<T>(value: T, options: DeepCloneOptions = {}): T {
     return copy;
   };
 
-  /** Copy the own (enumerable) keys of `obj` into `copy`. */
+  /**
+   * Copy the own (enumerable) keys of `obj` into `copy`, symbol keys too: a
+   * save refuses them, which a copy must not hide.
+   */
   function copyKeys(obj: object, copy: object): object {
     for (const key of Object.keys(obj)) {
       setOwn(copy, key, clone((obj as Record<string, unknown>)[key]));
     }
+    for (const sym of Object.getOwnPropertySymbols(obj)) {
+      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) continue;
+      (copy as Record<symbol, unknown>)[sym] = clone(
+        (obj as Record<symbol, unknown>)[sym],
+      );
+    }
     return copy;
   }
 
@@ -195,20 +210,25 @@ function loosePairs(): Pairs {
 /**
  * Pairs that also require the same reference structure: each object of one
  * value pairs with exactly one of the other, so shared references and
- * cycles are shared at the same places.
+ * cycles are shared at the same places. `ab` and `ba` hold the pairs (and
+ * may hold some already); those made are listed in `added`.
  */
-function strictPairs(): Pairs {
-  const ab = new Map<object, object>();
-  const ba = new Map<object, object>();
-  const pairs: Pairs = (a, b) => {
+function strictPairs(
+  ab = new Map<object, object>(),
+  ba = new Map<object, object>(),
+): Pairs & { added: [object, object][] } {
+  const added: [object, object][] = [];
+  const pairs = ((a, b) => {
     const known = ab.get(a);
     if (known !== undefined) return known === b;
     if (ba.has(b)) return false;
     ab.set(a, b);
     ba.set(b, a);
+    added.push([a, b]);
     return undefined;
-  };
+  }) as Pairs & { added: [object, object][] };
   pairs.strict = true;
+  pairs.added = added;
   return pairs;
 }
 
@@ -225,28 +245,55 @@ export function deepEqualStrict(a: unknown, b: unknown): boolean {
  * `prev` at the same place replaced by `prev`'s: the history moments of a
  * save then share what did not change between them, which a save stores
  * once. Containers on the way to a change are copied; neither value is
- * changed. Shared references and cycles within `curr` stay so.
+ * changed. The result has the reference structure of `curr`: what `curr`
+ * shares or cycles through stays so, and what it does not share stays
+ * apart, whichever parts are reused.
  */
 export function shareEqual<T>(prev: unknown, curr: T): T {
-  const done = new Map<object, unknown>();
-  function share(p: unknown, c: unknown): unknown {
-    if (p === c || !isObjectValue(c) || !isObjectValue(p)) return c;
-    if (done.has(c)) return done.get(c);
-    if (deepEqualStrict(p, c)) {
-      done.set(c, p);
-      return p;
+  if (!isObjectValue(prev) || !isObjectValue(curr)) return curr;
+  /** The object of the result standing for each object of `curr` met. */
+  const done = new Map<object, object>();
+  /** The object of `curr` each object of `prev` in the result stands for. */
+  const used = new Map<object, object>();
+
+  /** `value` for the result: copied, as far as it is not met already. */
+  const fresh = <V>(value: V): V =>
+    isObjectValue(value)
+      ? deepClone(value, { keepUnregistered: true, seen: done })
+      : value;
+
+  /**
+   * Whether `p` and `c` are equal and so can stand for each other, which
+   * needs each object in them to stand for one object only, in the whole
+   * result. Then every pair of objects they hold is placed in the result.
+   */
+  function reuse(p: object, c: object): boolean {
+    const pairs = strictPairs(used, done);
+    if (equal(p, c, pairs)) return true;
+    for (const [a, b] of pairs.added) {
+      used.delete(a);
+      done.delete(b);
     }
+    return false;
+  }
+
+  function share(p: unknown, c: unknown): unknown {
+    if (!isObjectValue(c)) return c;
+    const placed = done.get(c);
+    if (placed !== undefined) return placed;
+    if (!isObjectValue(p)) return fresh(c);
+    if (reuse(p, c)) return p;
     if (c instanceof Map && p instanceof Map) {
       const out = new Map();
       done.set(c, out);
-      for (const [k, v] of c) out.set(k, p.has(k) ? share(p.get(k), v) : v);
+      for (const [k, v] of c) out.set(fresh(k), share(p.get(k), v));
       return out;
     }
     if (Array.isArray(c) && Array.isArray(p)) {
       const out = new Array(c.length) as unknown[];
       done.set(c, out);
       for (let i = 0; i < c.length; i++) {
-        if (i in c) out[i] = i < p.length ? share(p[i], c[i]) : c[i];
+        if (i in c) out[i] = share(p[i], c[i]);
       }
       return out;
     }
@@ -255,12 +302,11 @@ export function shareEqual<T>(prev: unknown, curr: T): T {
       done.set(c, out);
       const cr = c as Record<string, unknown>;
       for (const key of Object.keys(cr)) {
-        setOwn(out, key, hasOwn(p, key) ? share(p[key], cr[key]) : cr[key]);
+        setOwn(out, key, share(hasOwn(p, key) ? p[key] : undefined, cr[key]));
       }
       return out;
     }
-    done.set(c, c);
-    return c;
+    return fresh(c);
   }
   return share(prev, curr) as T;
 }