@rohal12/spindle 0.59.0 → 0.59.2

package/dist/pkg/story-variables.js

@@ -10040,7 +10040,7 @@ function unset(param) {
 	return param.type === "options" ? {} : void 0;
 }
 var WORD_RE = /\w+/y;
-var DIGITS_RE = /\d+/y;
+var NUMBER_RE = /[-+]?(?:\d+\.?\d*|\.\d+)/y;
 var WORD_OR_PUNCT_RE = /\S+/y;
 /** Match the sticky regex `re` at `pos`, returning the matched text. */
 function matchAt(re, src, pos) {
@@ -10049,7 +10049,8 @@ function matchAt(re, src, pos) {
 }
 /**
 * Read keyword options (`goto "X" priority 5 once`). A keyword takes the
-* quoted string (with or without whitespace before it) or digit run after
+* quoted string (with or without whitespace before it) or number (signed,
+* fractional) after
 * it as its value; keywords that aren't declared, and their values, are
 * skipped. A keyword of a `string` parameter must be followed by a quoted
 * string.
@@ -10068,7 +10069,7 @@ function readOptions(params, src, { at, spans }) {
 		let j = i;
 		while (j < src.length && isWhitespace(src[j])) j++;
 		const quoted = readQuoted(src, j);
-		const digits = quoted || j === i ? null : matchAt(DIGITS_RE, src, j);
+		const digits = quoted || j === i ? null : matchAt(NUMBER_RE, src, j);
 		if (quoted) {
 			val = quoted.value;
 			i = quoted.end;
@@ -10392,15 +10393,22 @@ function* codeAndText(src, tokens, parametersOf) {
 	const closeOf = (t, name) => tokens.findIndex((c, k) => k > t && c.type === "macro" && c.isClose && c.name.toLowerCase() === name);
 	for (let t = 0; t < tokens.length; t++) {
 		const token = tokens[t];
-		if (token.type === "link") yield {
-			kind: "passage",
-			name: token.target,
-			offset: token.targetStart,
-			length: token.targetEnd - token.targetStart,
-			macro: "link",
-			label: src.slice(token.start, token.end)
-		};
-		else if (token.type === "expression") yield {
+		if (token.type === "link") {
+			yield {
+				kind: "passage",
+				name: token.target,
+				offset: token.targetStart,
+				length: token.targetEnd - token.targetStart,
+				macro: "link",
+				label: src.slice(token.start, token.end)
+			};
+			if (token.display.includes("{")) yield {
+				kind: "text",
+				text: token.display,
+				offset: locate(src, token.display, token.start),
+				where: "In the label of a link: "
+			};
+		} else if (token.type === "expression") yield {
 			kind: "code",
 			code: token.expression,
 			offset: token.end - 1 - token.expression.length,
@@ -10566,7 +10574,7 @@ function* argPieces(args, offset, params, macro, label) {
 			};
 		}
 	}
-	yield* visit(params, values);
+	yield* [...visit(params, values)].sort((a, b) => a.offset - b.offset);
 }
 /**
 * Index of `part` in `text` from `from` on, else anywhere, else `from`: the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rohal12/spindle",
-  "version": "0.59.0",
+  "version": "0.59.2",
   "type": "module",
   "description": "A Preact-based story format for Twine 2.",
   "license": "Unlicense",

package/src/automation/runner.ts

@@ -8,6 +8,7 @@ import type {
 import type { StoryAPI } from '../story-api';
 import type { StoryAction } from '../action-registry';
 import { errorMessage } from '../utils/error-message';
+import { deepEqual } from '../structural';
 
 export interface RunOptions {
   onStep?: (stepIndex: number, step: AutomationStep) => void;
@@ -88,7 +89,7 @@ async function executeStep(
     if (assert.variables) {
       for (const [key, expected] of Object.entries(assert.variables)) {
         const actual = story.get(key);
-        if (actual !== expected) {
+        if (!deepEqual(actual, expected)) {
           errors.push({
             step: index,
             message: `Variable "${key}": expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`,

package/src/code-check.ts

@@ -249,6 +249,15 @@ export function* codeAndText(
         macro: 'link',
         label: src.slice(token.start, token.end),
       };
+      // The label is markup too (the link renders as `{link}`)
+      if (token.display.includes('{')) {
+        yield {
+          kind: 'text',
+          text: token.display,
+          offset: locate(src, token.display, token.start),
+          where: 'In the label of a link: ',
+        };
+      }
     } else if (token.type === 'expression') {
       yield {
         kind: 'code',
@@ -435,7 +444,8 @@ export function* argPieces(
       }
     }
   }
-  yield* visit(params, values);
+  // Options are visited in metadata order, which is not the order written
+  yield* [...visit(params, values)].sort((a, b) => a.offset - b.offset);
 }
 
 /**

package/src/components/PassageDialog.tsx

@@ -5,6 +5,7 @@ import { renderNodes, NobrContext } from '../markup/render';
 import { useStoryFields } from '../hooks/use-story-fields';
 import { emitFromRender } from '../event-emitter';
 import { useModalFocus } from '../hooks/use-modal-focus';
+import { registerOpenDialog } from '../triggers';
 import { errorMessage } from '../utils/error-message';
 
 export const DialogCloseContext = createContext<(() => void) | null>(null);
@@ -70,6 +71,9 @@ export function PassageDialog({
   // Declared before the dialogrender effect so handlers can move focus.
   useModalFocus(panelRef, '.dialog-body', dismissible, stableOnClose);
 
+  // Be on the stack of displayed dialogs the Story dialog API works on.
+  useLayoutEffect(() => registerOpenDialog(stableOnClose), [stableOnClose]);
+
   // Signal that the dialog's DOM is committed (once per open).
   useLayoutEffect(() => {
     if (panelRef.current) {

package/src/components/macros/MacroLink.tsx

@@ -16,7 +16,8 @@ defineMacro({
     { name: 'passage', type: 'passage' },
   ],
   render({ children = [] }, ctx) {
-    const display = ctx.args.text ?? '';
+    // The label is markup: resolved once, for the element and its action
+    const display = ctx.resolve?.(ctx.args.text ?? '') ?? '';
     let passage: string | null = null;
     // Boxed: anything can be thrown, including null and other falsy values
     let failure: { error: unknown } | undefined;

package/src/components/macros/Meter.tsx

@@ -44,7 +44,11 @@ defineMacro({
   ],
   render(_props, ctx) {
     try {
-      const { currentExpr, maxExpr, labelMode } = meterArgs(ctx.args);
+      const { currentExpr, maxExpr, labelMode } = meterArgs({
+        ...ctx.args,
+        // The label is markup: resolved before reading none, % or a unit
+        label: ctx.resolve?.(ctx.args.label),
+      });
       const current = Number(ctx.evaluate!(currentExpr));
       const max = Number(ctx.evaluate!(maxExpr));
       const pct =

package/src/components/macros/Type.tsx

@@ -15,12 +15,14 @@ defineMacro({
     const visibleCharsRef = useRef(0);
     visibleCharsRef.current = visibleChars;
 
+    // Measure after every render: reactive content can become nonempty (or
+    // change length) after mounting. Setting an equal count is a no-op.
     useEffect(() => {
       if (containerRef.current) {
         const text = containerRef.current.textContent || '';
         setTotalChars(text.length);
       }
-    }, []);
+    });
 
     // Typewriter interval
     useEffect(() => {

package/src/components/macros/macro-args.ts

@@ -108,7 +108,7 @@ function unset(param: ParameterDef): unknown {
 }
 
 const WORD_RE = /\w+/y;
-const DIGITS_RE = /\d+/y;
+const NUMBER_RE = /[-+]?(?:\d+\.?\d*|\.\d+)/y;
 const WORD_OR_PUNCT_RE = /\S+/y;
 
 /** Match the sticky regex `re` at `pos`, returning the matched text. */
@@ -119,7 +119,8 @@ function matchAt(re: RegExp, src: string, pos: number): string | null {
 
 /**
  * Read keyword options (`goto "X" priority 5 once`). A keyword takes the
- * quoted string (with or without whitespace before it) or digit run after
+ * quoted string (with or without whitespace before it) or number (signed,
+ * fractional) after
  * it as its value; keywords that aren't declared, and their values, are
  * skipped. A keyword of a `string` parameter must be followed by a quoted
  * string.
@@ -141,13 +142,13 @@ function readOptions(
     i += key.length;
 
     // A value is a quoted string, which may follow the keyword directly
-    // (`goto"Hall"`: a quote can't be part of one), or a digit run after
+    // (`goto"Hall"`: a quote can't be part of one), or a number after
     // whitespace.
     let val: string | undefined;
     let j = i;
     while (j < src.length && isWhitespace(src[j]!)) j++;
     const quoted = readQuoted(src, j);
-    const digits = quoted || j === i ? null : matchAt(DIGITS_RE, src, j);
+    const digits = quoted || j === i ? null : matchAt(NUMBER_RE, src, j);
     if (quoted) {
       val = quoted.value;
       i = quoted.end;

package/src/execute-mutation.ts

@@ -10,13 +10,18 @@ import { useStoryStore } from './store';
 import type { StoryState, VariableNamespaces } from './store';
 import { execute } from './expression';
 import {
+  aliasChanges,
   applyChange,
   deepClone,
   deepEqual,
   diffPaths,
+  existingObjects,
   isApplied,
   isMergeable,
+  locateObjects,
   mergeKeys,
+  pathKey,
+  underChange,
   type PathChange,
 } from './structural';
 import { getByPath } from './utils/object-path';
@@ -71,6 +76,39 @@ export function readState(): StoryState {
 const cloneValue = <T>(value: T): T =>
   deepClone(value, { keepUnregistered: true });
 
+/** Copies values for one target, so what they share they share there too. */
+type Cloner = <T>(value: T) => T;
+
+/**
+ * A cloner of values written into `target`. The references among the values
+ * it copies are kept (`$b = $a` writes one array twice: the two paths get
+ * one copy), and, given where the objects of the source are (see
+ * locateObjects), an object that is one the target holds already is that
+ * one, not a copy: `$a.self = $a` refers to the root of `a` in the store.
+ */
+function clonerFor(
+  target: Record<string, unknown>,
+  paths?: ReadonlyMap<object, string[]>,
+): Cloner {
+  const seen = paths ? existingObjects(paths, target) : new Map();
+  return (value) => deepClone(value, { keepUnregistered: true, seen });
+}
+
+/** One cloner per target copy, made when first used. */
+const clonersFor = (
+  paths?: (target: Record<string, unknown>) => ReadonlyMap<object, string[]>,
+) => {
+  const made = new Map<object, Cloner>();
+  return (target: Record<string, unknown>): Cloner => {
+    let cloner = made.get(target);
+    if (!cloner) {
+      cloner = clonerFor(target, paths?.(target));
+      made.set(target, cloner);
+    }
+    return cloner;
+  };
+};
+
 /**
  * A frozen copy of a value read from a working copy, matching what reads
  * from the (frozen) store return: writing to it fails instead of changing
@@ -94,6 +132,7 @@ function mirror(
   ns: NamespaceName,
   change: PathChange,
   scopes: readonly MutationScope[] = activeScopes,
+  cloner: (target: Record<string, unknown>) => Cloner = clonerOf,
 ): void {
   const root = change.path[0]!;
   for (const scope of scopes) {
@@ -103,7 +142,7 @@ function mirror(
           copy,
           change.deleted
             ? change
-            : { ...change, value: cloneValue(change.value) },
+            : { ...change, value: cloner(copy)(change.value) },
         );
       } catch {
         const stored = draft[ns][root];
@@ -119,6 +158,9 @@ function mirror(
   }
 }
 
+/** A cloner of a copy of its own (no references shared with others). */
+const clonerOf = (target: Record<string, unknown>): Cloner => clonerFor(target);
+
 const NAMESPACE_KEYS: ReadonlySet<string> = new Set(NAMESPACES);
 
 /**
@@ -244,10 +286,19 @@ export function routeStoreUpdate<S extends VariableNamespaces>(
       own.length ? writtenPaths(view[ns], next[ns], own) : [],
     ] as const;
   });
-  const owned = (change: PathChange): PathChange =>
-    change.deleted ? change : { ...change, value: cloneValue(change.value) };
+  // Each target takes its own copies, which share what the written values do
+  const cloners = clonersFor();
+  const owned = (
+    change: PathChange,
+    target: Record<string, unknown>,
+  ): PathChange =>
+    change.deleted
+      ? change
+      : { ...change, value: cloners(target)(change.value) };
   for (const [ns, list] of changes) {
-    for (const change of list) applyChange(inner.work[ns], owned(change));
+    for (const change of list) {
+      applyChange(inner.work[ns], owned(change, inner.work[ns]));
+    }
   }
 
   return (draft) => {
@@ -266,7 +317,7 @@ export function routeStoreUpdate<S extends VariableNamespaces>(
       for (const change of list) {
         const root = change.path[0]!;
         try {
-          applyChange(namespaces[ns], owned(change));
+          applyChange(namespaces[ns], owned(change, namespaces[ns]));
         } catch {
           if (hasOwn(inner.work[ns], root)) {
             namespaces[ns][root] = cloneValue(inner.work[ns][root]);
@@ -274,7 +325,7 @@ export function routeStoreUpdate<S extends VariableNamespaces>(
             delete namespaces[ns][root];
           }
         }
-        mirror(namespaces, ns, change);
+        mirror(namespaces, ns, change, activeScopes, cloners);
       }
     }
   };
@@ -312,7 +363,7 @@ function commitScopes(commits: readonly Commit[]): void {
     scope,
     keepRunning,
     changes: NAMESPACES.map(
-      (ns) => [ns, diffPaths(scope.base[ns], scope.work[ns])] as const,
+      (ns) => [ns, changesOf(scope.base[ns], scope.work[ns])] as const,
     ),
   }));
   const changed = all.filter(({ changes }) =>
@@ -336,35 +387,84 @@ function commitScopes(commits: readonly Commit[]): void {
   }
 
   function commitRecipe(draft: VariableNamespaces): void {
-    all.forEach(({ scope, keepRunning, changes }, i) => {
-      const own = <T>(value: T): T => (keepRunning ? cloneValue(value) : value);
+    all.forEach(({ scope, changes }, i) => {
+      // The copies the store and the enclosing mutations take are their own,
+      // and keep the references of the values written (one object written
+      // at two paths is one object there) and to the objects they hold
+      // already (see clonerFor). The code's working copy stays its own.
+      const paths = new Map(
+        changes.map(([ns, list]) => [ns, locateObjects(scope.work[ns], list)]),
+      );
+      const own = new Map(
+        changes.map(([ns]) => [ns, clonerFor(draft[ns], paths.get(ns))]),
+      );
+      const enclosing = all.slice(0, i).map((c) => c.scope);
+      const enclosingCloners = new Map(
+        changes.map(([ns]) => [ns, clonersFor(() => paths.get(ns)!)]),
+      );
       for (const [ns, list] of changes) {
         const replaced = new Set<string>();
         for (const change of list) {
           const root = change.path[0]!;
-          // A changed path already holding the value keeps its reference
-          if (replaced.has(root) || isApplied(draft[ns], change)) continue;
+          if (replaced.has(root)) continue;
           try {
-            applyChange(
-              draft[ns],
-              change.deleted ? change : { ...change, value: own(change.value) },
-            );
+            if (change.deleted) {
+              if (!isApplied(draft[ns], change)) applyChange(draft[ns], change);
+              continue;
+            }
+            // A changed path already holding the value keeps its reference;
+            // an alias change is one of reference only: it holds when the
+            // very object is there.
+            const value = change.alias ? own.get(ns)!(change.value) : undefined;
+            if (
+              change.alias
+                ? Object.is(getByPath(draft[ns], change.path), value)
+                : isApplied(draft[ns], change)
+            ) {
+              continue;
+            }
+            applyChange(draft[ns], {
+              ...change,
+              value: change.alias ? value : own.get(ns)!(change.value),
+            });
           } catch {
             // An intermediate object the code wrote into is gone from the
             // store: the code's view of the whole root wins.
-            draft[ns][root] = own(scope.work[ns][root]);
+            draft[ns][root] = own.get(ns)!(scope.work[ns][root]);
             replaced.add(root);
           }
         }
         // Hand the changes to the mutations this one runs inside, before
         // watchers fired by this update run.
-        const enclosing = all.slice(0, i).map((c) => c.scope);
-        for (const change of list) mirror(draft, ns, change, enclosing);
+        for (const change of list) {
+          mirror(draft, ns, change, enclosing, enclosingCloners.get(ns)!);
+        }
       }
     });
   }
 }
 
+/**
+ * The changes of the code to a namespace: its property paths that differ
+ * (see diffPaths), and those that hold equal content but another object
+ * than they did (see aliasChanges), those first.
+ */
+function changesOf(
+  base: Record<string, unknown>,
+  work: Record<string, unknown>,
+): PathChange[] {
+  const written = diffPaths(base, work);
+  const keys = new Set(written.map((c) => pathKey(c.path)));
+  const aliases: PathChange[] = [];
+  for (const change of aliasChanges(base, work)) {
+    // Written whole by a change at it or above it
+    if (underChange(change.path, keys)) continue;
+    keys.add(pathKey(change.path));
+    aliases.push(change);
+  }
+  return [...aliases, ...written];
+}
+
 /** Every running mutation, to commit with its code going on. */
 const running = (): Commit[] =>
   activeScopes.map((scope) => ({ scope, keepRunning: true }));

package/src/saves/save-manager.ts

@@ -7,6 +7,7 @@ import type {
   SaveExport,
   StorageInfo,
 } from './types';
+import { randomUUID } from '../utils/uuid';
 import { checkSaveExport, estimatePayloadBytes } from './types';
 import {
   decodePayload,
@@ -130,7 +131,7 @@ export const startNewPlaythrough = queued(startNewPlaythroughNow);
 
 async function startNewPlaythroughNow(
   ifid: string,
-  id: string = crypto.randomUUID(),
+  id: string = randomUUID(),
 ): Promise<string> {
   const backend = await getBackend();
   const num = await nextPlaythroughNumber(ifid);
@@ -296,7 +297,7 @@ async function createSaveNow(
 ): Promise<SaveRecord> {
   const now = new Date().toISOString();
   const meta: SaveMeta = {
-    id: crypto.randomUUID(),
+    id: randomUUID(),
     ifid,
     playthroughId,
     createdAt: now,
@@ -774,7 +775,7 @@ async function prepareImport(data: unknown, ifid: string): Promise<SaveRecord> {
 
   // Re-assign a new ID to avoid collisions
   const record = deepClone(data.save);
-  record.meta.id = crypto.randomUUID();
+  record.meta.id = randomUUID();
   record.meta.updatedAt = new Date().toISOString();
   // The save now belongs to this story: it is listed, loaded and cleared
   // with it, whatever its own metadata says

package/src/saves/storage.ts

@@ -289,7 +289,16 @@ function createIDBBackend(): StorageBackend {
         }
       };
 
-      req.onsuccess = () => resolve(req.result);
+      req.onsuccess = () => {
+        const db = req.result;
+        // Let another tab delete or upgrade the database: close at once and
+        // reopen on the next use.
+        db.onversionchange = () => {
+          db.close();
+          dbPromise = null;
+        };
+        resolve(db);
+      };
       req.onerror = () => reject(req.error);
     });
 
@@ -315,7 +324,20 @@ function createIDBBackend(): StorageBackend {
       make: (store: IDBObjectStore) => IDBRequest<R>,
     ): Promise<R> => {
       const db = await openDB();
-      return idbReq(make(db.transaction(name, mode).objectStore(name)));
+      const tx = db.transaction(name, mode);
+      const result = idbReq(make(tx.objectStore(name)));
+      // A request can succeed and its transaction still roll back, so a
+      // write is done only when the transaction completes.
+      if (mode === 'readonly') return result;
+      const committed = new Promise<void>((resolve, reject) => {
+        tx.oncomplete = () => resolve();
+        tx.onabort = () =>
+          reject(
+            tx.error ?? new DOMException('Transaction aborted', 'AbortError'),
+          );
+      });
+      const [value] = await Promise.all([result, committed]);
+      return value;
     };
 
     return {
@@ -348,6 +370,12 @@ function createIDBBackend(): StorageBackend {
       const req = indexedDB.deleteDatabase(IDB_DB_NAME);
       req.onsuccess = () => resolve();
       req.onerror = () => reject(req.error);
+      req.onblocked = () =>
+        reject(
+          new Error(
+            'Cannot clear the saved data: another tab or window of this site still has it open. Close the other tabs and try again.',
+          ),
+        );
     });
   });
 }

package/src/store.ts

@@ -1,4 +1,5 @@
 import { create } from './preact-store';
+import { randomUUID } from './utils/uuid';
 import { immer } from 'zustand/middleware/immer';
 import type { StateCreator } from 'zustand/vanilla';
 import {
@@ -120,7 +121,10 @@ let lastNavigationVars: Namespace = createNamespace();
  * object) or deleted. A recorded value is a deep copy, so that changing a
  * live value in place (a class instance is not frozen) cannot change
  * history; instances of unregistered classes are kept, as the store keeps
- * them (a save then refuses them).
+ * them (a save then refuses them). The copies are made together, so what
+ * variables share (an object, a cycle) stays shared in them, and a variable
+ * left as it is that shares with a replaced one is recorded again, to share
+ * with its copy.
  */
 function computeVarPatches(
   prev: Record<string, unknown>,
@@ -132,13 +136,32 @@ function computeVarPatches(
     // whose inherited `constructor` is no variable
     if (!hasOwn(curr, key)) forward.push({ key, deleted: true });
   }
+  const seen = new Map<object, object>();
+  const record = (key: string) =>
+    forward.push({
+      key,
+      deleted: false,
+      value: deepClone(curr[key], { keepUnregistered: true, seen }),
+    });
+  const unchanged: string[] = [];
   for (const key of Object.keys(curr)) {
-    if (!hasOwn(prev, key) || !Object.is(prev[key], curr[key])) {
-      forward.push({
-        key,
-        deleted: false,
-        value: deepClone(curr[key], { keepUnregistered: true }),
-      });
+    if (!hasOwn(prev, key) || !Object.is(prev[key], curr[key])) record(key);
+    else if (typeof curr[key] === 'object' && curr[key] !== null) {
+      unchanged.push(key);
+    }
+  }
+  // Probe an unchanged variable with a copy of its own: it shares with a
+  // recorded one if the copy meets an object already copied
+  for (let found = seen.size > 0; found; ) {
+    found = false;
+    for (const key of unchanged) {
+      const probe = new Map<object, object>();
+      deepClone(curr[key], { keepUnregistered: true, seen: probe });
+      if (![...probe.keys()].some((object) => seen.has(object))) continue;
+      record(key);
+      unchanged.splice(unchanged.indexOf(key), 1);
+      found = true;
+      break;
     }
   }
   return { forward };
@@ -573,7 +596,7 @@ function switchToPlaythrough(id: string, stored: Promise<unknown>): void {
 
 /** Move the running game to a new playthrough at once (see restart). */
 function switchToNewPlaythrough(ifid: string): void {
-  const id = crypto.randomUUID();
+  const id = randomUUID();
   const stored = startNewPlaythrough(ifid, id).catch((err) => {
     console.error('spindle: failed to start new playthrough', err);
   });
@@ -1462,7 +1485,7 @@ export const useStoryStore = create<StoryState>()(
       const ifid = storyData.ifid;
       const current = knownPlaythroughId();
       const established = playthroughSetup;
-      const replacementId = crypto.randomUUID();
+      const replacementId = randomUUID();
       const deletion = smDeletePlaythroughData(ifid, playthroughId, {
         current: current || established,
         id: replacementId,