@rohal12/spindle 0.52.0 → 0.52.2

package/src/store.ts

@@ -46,15 +46,17 @@ import {
   clearAllData as smClearAllData,
   deletePlaythroughData as smDeletePlaythroughData,
 } from './saves/save-manager';
-import { deepClone, serialize } from './class-registry';
+import { deepClone, deepEqual, serialize } from './class-registry';
 import {
   snapshotPRNG,
   restorePRNG,
   resetPRNG,
+  withoutDraws,
   type PRNGSnapshot,
 } from './prng';
 import { errorMessage } from './utils/error-message';
 import {
+  isMergeable,
   routeStoreUpdate,
   runWithCommittedMutations,
 } from './execute-mutation';
@@ -64,6 +66,7 @@ import {
   isNamespace,
   type Namespace,
 } from './utils/namespace';
+import { createCounts, type Counts } from './utils/counts';
 
 enablePatches();
 // Story state holds Map and Set values: Immer must be able to draft them
@@ -531,13 +534,14 @@ function loadedEntryMoment(
 }
 
 /**
- * Copy the variables that changed between `before` and `after` (the live
- * variables around the `beforesave` hooks) into the payload's snapshot of the
- * saved moment. A load restores that snapshot, the state on entering the
- * passage, and runs the passage again, so data a hook adds to a save would
- * otherwise be lost on load (#227). Only the payload's copy changes: the live
- * history keeps the recorded snapshot (#159). Store updates are immutable, so
- * a value a hook did not touch keeps its identity.
+ * Write the changes between `before` and `after` (the live variables around
+ * the `beforesave` hooks) into the payload's snapshot of the saved moment. A
+ * load restores that snapshot, the state on entering the passage, and runs
+ * the passage again, so data a hook adds to a save would otherwise be lost
+ * on load (#227). Only the property paths the hooks changed are written: a
+ * whole variable would bring along what the passage did to the rest of it,
+ * which the passage then does again on load (#232). Only the payload's copy
+ * changes: the live history keeps the recorded snapshot (#159).
  */
 function keepHookWrites(
   payload: SavePayload,
@@ -546,15 +550,100 @@ function keepHookWrites(
 ): void {
   const moment = payload.history[payload.historyIndex];
   if (!moment) return;
-  const has = (vars: Record<string, unknown>, key: string) =>
-    Object.prototype.hasOwnProperty.call(vars, key);
-  for (const key of new Set([...Object.keys(before), ...Object.keys(after)])) {
-    if (!has(after, key)) {
-      delete moment.variables[key];
-    } else if (!has(before, key) || after[key] !== before[key]) {
-      moment.variables[key] = deepClone(after[key]);
+  mergeHookWrites(moment.variables, before, after, new Set());
+}
+
+const hasOwn = (obj: object, key: string): boolean =>
+  Object.prototype.hasOwnProperty.call(obj, key);
+
+/**
+ * Whether changes between `a` and `b` merge key by key: both are arrays,
+ * or both are objects of one class (see isMergeable).
+ */
+function mergeable(a: unknown, b: unknown): boolean {
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b);
+  }
+  return (
+    isMergeable(a) &&
+    isMergeable(b) &&
+    Object.getPrototypeOf(a) === Object.getPrototypeOf(b)
+  );
+}
+
+/**
+ * Apply the hooks' change of a value, from `before` to `after`, to the
+ * snapshot's copy of it, `target[key]`. Store updates are immutable, so a
+ * value no hook touched keeps its identity; one rebuilt with equal content
+ * (mutation code commits whole values) is no change either. Where `target`
+ * lacks the key or holds another kind of value (the passage created or
+ * replaced it), the hooks' whole value is written.
+ */
+function mergeHookWrite(
+  target: Record<string, unknown>,
+  key: string,
+  before: unknown,
+  after: unknown,
+  ancestors: Set<object>,
+): void {
+  if (Object.is(before, after)) return;
+  if (
+    mergeable(before, after) &&
+    hasOwn(target, key) &&
+    mergeable(after, target[key]) &&
+    // Stop at cycles: deepEqual() and deepClone() handle them
+    !ancestors.has(after as object)
+  ) {
+    mergeHookWrites(
+      target[key] as Record<string, unknown>,
+      before as Record<string, unknown>,
+      after as Record<string, unknown>,
+      ancestors,
+    );
+  } else if (!deepEqual(before, after)) {
+    target[key] = deepClone(after);
+  }
+}
+
+/**
+ * Apply the changes between `before` and `after`, two objects or two arrays
+ * (see mergeable()), to the snapshot's `target`. Array elements merge by
+ * index. Elements the hooks removed from an array's end are removed from
+ * the snapshot's array at the same indices, and elements they added are
+ * appended to it: where the passage resized the array, its indices do not
+ * line up with the snapshot's, and the passage resizes it again on load.
+ */
+function mergeHookWrites(
+  target: Record<string, unknown>,
+  before: Record<string, unknown>,
+  after: Record<string, unknown>,
+  ancestors: Set<object>,
+): void {
+  ancestors.add(after);
+  if (Array.isArray(target)) {
+    const b = before as unknown as unknown[];
+    const a = after as unknown as unknown[];
+    const shared = Math.min(b.length, a.length, target.length);
+    for (let i = 0; i < shared; i++) {
+      mergeHookWrite(target, String(i), b[i], a[i], ancestors);
+    }
+    if (a.length < b.length) {
+      target.length = Math.min(target.length, a.length);
+    }
+    for (let i = b.length; i < a.length; i++) target.push(deepClone(a[i]));
+  } else {
+    for (const key of Object.keys(before)) {
+      if (!hasOwn(after, key)) delete target[key];
+    }
+    for (const key of Object.keys(after)) {
+      if (hasOwn(before, key)) {
+        mergeHookWrite(target, key, before[key], after[key], ancestors);
+      } else {
+        target[key] = deepClone(after[key]);
+      }
     }
   }
+  ancestors.delete(after);
 }
 
 /** Restore or reset PRNG from a history moment's snapshot. */
@@ -594,8 +683,8 @@ export interface StoryState {
   temporary: Record<string, unknown>;
   history: HistoryMoment[];
   historyIndex: number;
-  visitCounts: Record<string, number>;
-  renderCounts: Record<string, number>;
+  visitCounts: Counts;
+  renderCounts: Counts;
   knownSaves: Record<string, true>;
   /**
    * The playthrough the running game is in: its saves are grouped under it.
@@ -801,8 +890,8 @@ export const useStoryStore = create<StoryState>()(
     temporary: createNamespace(),
     history: [],
     historyIndex: -1,
-    visitCounts: {},
-    renderCounts: {},
+    visitCounts: createCounts(),
+    renderCounts: createCounts(),
     knownSaves: {},
     playthroughId: '',
     maxHistory: 40,
@@ -870,8 +959,8 @@ export const useStoryStore = create<StoryState>()(
           },
         ];
         state.historyIndex = 0;
-        state.visitCounts = { [startPassage.name]: 1 };
-        state.renderCounts = { [startPassage.name]: 1 };
+        state.visitCounts = createCounts(null, startPassage.name);
+        state.renderCounts = createCounts(null, startPassage.name);
       });
 
       // Update lastNavigationVars to the Immer-produced reference
@@ -955,10 +1044,8 @@ export const useStoryStore = create<StoryState>()(
         state.historyIndex = state.history.length - 1;
         // Trim oldest entries if over the limit
         trimHistory(state);
-        state.visitCounts[passageName] =
-          (state.visitCounts[passageName] ?? 0) + 1;
-        state.renderCounts[passageName] =
-          (state.renderCounts[passageName] ?? 0) + 1;
+        state.visitCounts = createCounts(state.visitCounts, passageName);
+        state.renderCounts = createCounts(state.renderCounts, passageName);
       });
 
       // Watchers react to the completed transition (visit counts, cleared
@@ -1094,8 +1181,7 @@ export const useStoryStore = create<StoryState>()(
 
     trackRender: (passageName: string) => {
       set((state) => {
-        state.renderCounts[passageName] =
-          (state.renderCounts[passageName] ?? 0) + 1;
+        state.renderCounts = createCounts(state.renderCounts, passageName);
       });
     },
 
@@ -1144,8 +1230,8 @@ export const useStoryStore = create<StoryState>()(
           },
         ];
         state.historyIndex = 0;
-        state.visitCounts = { [startPassage.name]: 1 };
-        state.renderCounts = { [startPassage.name]: 1 };
+        state.visitCounts = createCounts(null, startPassage.name);
+        state.renderCounts = createCounts(null, startPassage.name);
         if (!keepDeferred) {
           state.renderDeferred = false;
         }
@@ -1492,8 +1578,8 @@ export const useStoryStore = create<StoryState>()(
         );
         // A save made under a higher limit keeps no more than the limit
         trimHistory(state);
-        state.visitCounts = payload.visitCounts ?? {};
-        state.renderCounts = payload.renderCounts ?? {};
+        state.visitCounts = createCounts(payload.visitCounts);
+        state.renderCounts = createCounts(payload.renderCounts);
         state.temporary = createNamespace();
         state.transient = createNamespace(deepClone(get().transientDefaults));
       });
@@ -1517,7 +1603,8 @@ export const useStoryStore = create<StoryState>()(
       // Write the loaded game to the session so a refresh restores it
       persistSession(get);
 
-      emit('afterload', slot);
+      // Draws made by the handlers would shift the passage's replayed rolls
+      withoutDraws(() => emit('afterload', slot));
     },
 
     getHistoryVariables: (index: number): Record<string, unknown> => {

package/src/story-api.ts

@@ -24,6 +24,7 @@ import { registerClass } from './class-registry';
 import { frozenCopy, getActiveMutationScope } from './execute-mutation';
 import { getByPath, setByPath } from './utils/object-path';
 import { checkVariableName } from './utils/namespace';
+import { countOf } from './utils/counts';
 import { defineMacro } from './define-macro';
 import type { MacroDefinition } from './define-macro';
 import { getMacroRegistry as _getMacroRegistry } from './registry';
@@ -358,7 +359,7 @@ function createStoryAPI(): StoryAPI {
 
     visited(name?: string): number {
       const state = useStoryStore.getState();
-      return state.visitCounts[name ?? state.currentPassage] ?? 0;
+      return countOf(state.visitCounts, name ?? state.currentPassage);
     },
 
     hasVisited(name?: string): boolean {
@@ -367,17 +368,17 @@ function createStoryAPI(): StoryAPI {
 
     hasVisitedAny(...names: string[]): boolean {
       const { visitCounts } = useStoryStore.getState();
-      return names.some((n) => (visitCounts[n] ?? 0) > 0);
+      return names.some((n) => countOf(visitCounts, n) > 0);
     },
 
     hasVisitedAll(...names: string[]): boolean {
       const { visitCounts } = useStoryStore.getState();
-      return names.every((n) => (visitCounts[n] ?? 0) > 0);
+      return names.every((n) => countOf(visitCounts, n) > 0);
     },
 
     rendered(name?: string): number {
       const state = useStoryStore.getState();
-      return state.renderCounts[name ?? state.currentPassage] ?? 0;
+      return countOf(state.renderCounts, name ?? state.currentPassage);
     },
 
     hasRendered(name?: string): boolean {
@@ -386,12 +387,12 @@ function createStoryAPI(): StoryAPI {
 
     hasRenderedAny(...names: string[]): boolean {
       const { renderCounts } = useStoryStore.getState();
-      return names.some((n) => (renderCounts[n] ?? 0) > 0);
+      return names.some((n) => countOf(renderCounts, n) > 0);
     },
 
     hasRenderedAll(...names: string[]): boolean {
       const { renderCounts } = useStoryStore.getState();
-      return names.every((n) => (renderCounts[n] ?? 0) > 0);
+      return names.every((n) => countOf(renderCounts, n) > 0);
     },
 
     currentPassage(): Passage | undefined {

package/src/triggers.ts

@@ -19,7 +19,6 @@ export interface QueuedDialog {
 }
 
 interface Trigger {
-  id: number;
   name?: string;
   condition: string;
   callback?: () => void;
@@ -30,7 +29,6 @@ interface Trigger {
   macroKey?: string;
 }
 
-let nextId = 0;
 let triggers: Trigger[] = [];
 let checking = false;
 
@@ -67,13 +65,11 @@ function registerTrigger(
   callbackOrOptions: (() => void) | WatchOptions,
   macroKey?: string,
 ): () => void {
-  const id = nextId++;
   const isCallback = typeof callbackOrOptions === 'function';
   const options = isCallback ? undefined : callbackOrOptions;
   const callback = isCallback ? callbackOrOptions : undefined;
 
   const trigger: Trigger = {
-    id,
     name: options?.name,
     condition,
     callback,
@@ -86,8 +82,10 @@ function registerTrigger(
   triggers.push(trigger);
   triggers.sort((a, b) => b.priority - a.priority);
 
+  // By identity: an unsubscribe kept across a restart (resetTriggers) must
+  // not remove a watcher added since
   return () => {
-    triggers = triggers.filter((t) => t.id !== id);
+    triggers = triggers.filter((t) => t !== trigger);
   };
 }
 
@@ -177,7 +175,7 @@ function runCheckLoop(): void {
         anyFired = true;
 
         if (trigger.options?.once) {
-          triggers = triggers.filter((t) => t.id !== trigger.id);
+          triggers = triggers.filter((t) => t !== trigger);
         }
 
         fireTrigger(trigger);
@@ -267,7 +265,6 @@ export function reinitTriggerState(): void {
 export function resetTriggers(): void {
   triggers = [];
   dialogQueue = [];
-  nextId = 0;
   dialogHostCallbacks?.closeAll();
 }
 

package/src/utils/counts.ts

@@ -0,0 +1,45 @@
+/**
+ * Passage counters: the visit and render counts of the story state, keyed
+ * by passage name.
+ *
+ * A passage may have any name, including `constructor`, `toString` or
+ * `__proto__`, so the counters only ever read their own entries: a passage
+ * that was never counted counts 0, never an Object.prototype member. The
+ * store keeps them without a prototype, so writing the count of a passage
+ * named `__proto__` stores an entry instead of replacing the prototype.
+ * Counters from outside the store (a loaded save) go through
+ * createCounts(), which keeps only their own entries that are counts.
+ */
+
+export type Counts = Record<string, number>;
+
+const isCount = (value: unknown): value is number =>
+  typeof value === 'number' && Number.isInteger(value) && value >= 0;
+
+/** The count of `name` in `counts`: its own entry, or 0. */
+export function countOf(
+  counts: object | null | undefined,
+  name: string,
+): number {
+  if (!counts || !Object.prototype.hasOwnProperty.call(counts, name)) return 0;
+  const value = (counts as Record<string, unknown>)[name];
+  return isCount(value) ? value : 0;
+}
+
+/**
+ * Counters with no prototype holding the own entries of `source` that are
+ * counts, with `name` (if given) counted once more. Immer copies the
+ * counters on every write anyway, so counting into a fresh copy costs no
+ * more than counting in place.
+ */
+export function createCounts(source?: object | null, name?: string): Counts {
+  const counts = Object.create(null) as Counts;
+  if (source) {
+    for (const key of Object.keys(source)) {
+      const value = (source as Record<string, unknown>)[key];
+      if (isCount(value)) counts[key] = value;
+    }
+  }
+  if (name !== undefined) counts[name] = countOf(source, name) + 1;
+  return counts;
+}