@rohal12/spindle 0.51.3 → 0.52.0

package/src/saves/storage.ts

@@ -4,7 +4,13 @@ import type { SaveRecord, PlaythroughRecord, StorageBackend } from './types';
 // Memory backend
 // ---------------------------------------------------------------------------
 
+/**
+ * In-memory storage. Like the other backends it stores copies: records and
+ * values go in and come out cloned, so changing a record after storing it,
+ * or one that was read, changes nothing stored.
+ */
 export function createMemoryBackend(): StorageBackend {
+  const copy = <T>(value: T): T => structuredClone(value);
   const saves = new Map<string, SaveRecord>();
   const playthroughs = new Map<string, PlaythroughRecord>();
   const meta = new Map<string, unknown>();
@@ -13,11 +19,12 @@ export function createMemoryBackend(): StorageBackend {
     type: 'memory',
 
     async putSave(record: SaveRecord): Promise<void> {
-      saves.set(record.meta.id, record);
+      saves.set(record.meta.id, copy(record));
     },
 
     async getSave(id: string): Promise<SaveRecord | undefined> {
-      return saves.get(id);
+      const record = saves.get(id);
+      return record && copy(record);
     },
 
     async deleteSave(id: string): Promise<void> {
@@ -25,7 +32,7 @@ export function createMemoryBackend(): StorageBackend {
     },
 
     async getSavesByIfid(ifid: string): Promise<SaveRecord[]> {
-      return [...saves.values()].filter((s) => s.meta.ifid === ifid);
+      return [...saves.values()].filter((s) => s.meta.ifid === ifid).map(copy);
     },
 
     async deleteSavesByIfid(ifid: string): Promise<void> {
@@ -48,11 +55,13 @@ export function createMemoryBackend(): StorageBackend {
     },
 
     async putPlaythrough(record: PlaythroughRecord): Promise<void> {
-      playthroughs.set(record.id, record);
+      playthroughs.set(record.id, copy(record));
     },
 
     async getPlaythroughsByIfid(ifid: string): Promise<PlaythroughRecord[]> {
-      return [...playthroughs.values()].filter((p) => p.ifid === ifid);
+      return [...playthroughs.values()]
+        .filter((p) => p.ifid === ifid)
+        .map(copy);
     },
 
     async deletePlaythroughsByIfid(ifid: string): Promise<void> {
@@ -67,11 +76,11 @@ export function createMemoryBackend(): StorageBackend {
     },
 
     async getMeta<T = unknown>(key: string): Promise<T | undefined> {
-      return meta.get(key) as T | undefined;
+      return copy(meta.get(key)) as T | undefined;
     },
 
     async setMeta(key: string, value: unknown): Promise<void> {
-      meta.set(key, value);
+      meta.set(key, copy(value));
     },
 
     async deleteMeta(key: string): Promise<void> {
@@ -154,6 +163,14 @@ export function createLocalStorageBackend(): StorageBackend {
 
     async putSave(record: SaveRecord): Promise<void> {
       const id = record.meta.id;
+      // A save rewritten under another playthrough (an overwrite after a
+      // restart) leaves its old playthrough's index
+      const previous = lsGet<SaveRecord>(`${LS_SAVE_PREFIX}${id}`);
+      if (previous && previous.meta.playthroughId !== record.meta.playthroughId)
+        lsIndexRemove(
+          `${LS_IDX_SAVES_PT_PREFIX}${previous.meta.playthroughId}`,
+          id,
+        );
       lsSet(`${LS_SAVE_PREFIX}${id}`, record);
       lsIndexAdd(`${LS_IDX_SAVES_PREFIX}${record.meta.ifid}`, id);
       lsIndexAdd(`${LS_IDX_SAVES_PT_PREFIX}${record.meta.playthroughId}`, id);

package/src/saves/types.ts

@@ -1,4 +1,5 @@
 import type { PRNGSnapshot } from '../prng';
+import { isDeserializable } from '../class-registry';
 
 /** History moment as persisted in saves (full variable snapshots). */
 export interface SaveHistoryMoment {
@@ -25,6 +26,11 @@ export interface SaveMeta {
   createdAt: string;
   updatedAt: string;
   title: string;
+  /**
+   * True once the player has named the save (renameSave). Overwriting the
+   * save keeps such a title; a generated one is generated anew.
+   */
+  userTitle?: boolean;
   passage: string;
   custom: Record<string, unknown>;
   estimatedBytes?: number;
@@ -97,11 +103,16 @@ function isOptionalPRNGSnapshot(value: unknown): boolean {
   );
 }
 
+/** A variable container whose values deserialize() can restore. */
+function isSerializedVariables(value: unknown): boolean {
+  return isRecord(value) && isDeserializable(value);
+}
+
 function isSaveHistoryMoment(value: unknown): value is SaveHistoryMoment {
   return (
     isRecord(value) &&
     typeof value.passage === 'string' &&
-    isRecord(value.variables) &&
+    isSerializedVariables(value.variables) &&
     typeof value.timestamp === 'number' &&
     isOptionalPRNGSnapshot(value.prng)
   );
@@ -109,18 +120,21 @@ function isSaveHistoryMoment(value: unknown): value is SaveHistoryMoment {
 
 /**
  * Full check of a payload from outside the running story (an imported save):
- * every history moment is well formed, and `historyIndex` is an integer that
- * points at a moment of the payload's passage. Anything that passes can be
- * stored and later loaded.
+ * every history moment is well formed, `historyIndex` is an integer that
+ * points at a moment of the payload's passage, and the encoded values (Map,
+ * Set, Date, RegExp, class instances) in the live variables and every
+ * moment's variables have the shape deserialize() expects. Anything that
+ * passes can be stored and later loaded.
  */
 function isImportablePayload(value: unknown): value is SavePayload {
   if (!isRecord(value)) return false;
   if (typeof value.passage !== 'string') return false;
-  if (!isRecord(value.variables)) return false;
+  if (!isSerializedVariables(value.variables)) return false;
 
   const { history, historyIndex } = value;
   if (!Array.isArray(history) || history.length === 0) return false;
-  if (!history.every(isSaveHistoryMoment)) return false;
+  // Array.from: every() skips the holes of a sparse array
+  if (!Array.from(history).every(isSaveHistoryMoment)) return false;
   if (
     typeof historyIndex !== 'number' ||
     !Number.isInteger(historyIndex) ||