@rohal12/spindle 0.35.0 → 0.36.0

package/src/story-api.ts

@@ -1,8 +1,21 @@
 import { useStoryStore } from './store';
 import type { Passage } from './parser';
 import { settings } from './settings';
-import type { SavePayload, SaveInfo } from './saves/types';
-import { setTitleGenerator } from './saves/save-manager';
+import type {
+  SavePayload,
+  SaveInfo,
+  StorageInfo,
+  StorageQuota,
+} from './saves/types';
+import {
+  setTitleGenerator,
+  getStorageInfo as _getStorageInfo,
+  clearGameData as _clearGameData,
+  clearAllData as _clearAllData,
+  deletePlaythroughData,
+  populateKnownSaves,
+} from './saves/save-manager';
+import { getBackendType } from './saves/storage';
 import { registerClass } from './class-registry';
 import { defineMacro } from './define-macro';
 import type { MacroDefinition } from './define-macro';
@@ -76,6 +89,14 @@ export interface StoryAPI {
   readonly saves: {
     setTitleGenerator(fn: (payload: SavePayload) => string): void;
   };
+  readonly storage: {
+    getInfo(): Promise<StorageInfo>;
+    getQuota(): Promise<StorageQuota>;
+    clearGameData(): Promise<void>;
+    clearAllData(): Promise<void>;
+    deletePlaythrough(playthroughId: string): Promise<void>;
+    readonly backend: 'indexeddb' | 'localstorage' | 'memory';
+  };
   getActions(): StoryAction[];
   performAction(id: string, value?: unknown): void;
   on(event: 'navigate', callback: NavigateCallback): () => void;
@@ -246,6 +267,68 @@ function createStoryAPI(): StoryAPI {
       },
     },
 
+    storage: {
+      async getInfo(): Promise<StorageInfo> {
+        const ifid = useStoryStore.getState().storyData?.ifid;
+        if (!ifid)
+          return {
+            saveCount: 0,
+            playthroughCount: 0,
+            totalBytes: 0,
+            backend: getBackendType(),
+          };
+        return _getStorageInfo(ifid);
+      },
+
+      async getQuota(): Promise<StorageQuota> {
+        if (typeof navigator !== 'undefined' && navigator.storage?.estimate) {
+          try {
+            const est = await navigator.storage.estimate();
+            return {
+              usage: est.usage ?? 0,
+              quota: est.quota ?? 0,
+              estimateSupported: true,
+            };
+          } catch {
+            // fall through
+          }
+        }
+        return { usage: 0, quota: 0, estimateSupported: false };
+      },
+
+      async clearGameData(): Promise<void> {
+        const ifid = useStoryStore.getState().storyData?.ifid;
+        if (!ifid) return;
+        await _clearGameData(ifid);
+        useStoryStore.setState((state) => {
+          state.knownSaves = {};
+        });
+        useStoryStore.getState().restart();
+      },
+
+      async clearAllData(): Promise<void> {
+        await _clearAllData();
+        useStoryStore.setState((state) => {
+          state.knownSaves = {};
+        });
+        useStoryStore.getState().restart();
+      },
+
+      async deletePlaythrough(playthroughId: string): Promise<void> {
+        const { storyData } = useStoryStore.getState();
+        if (!storyData) return;
+        await deletePlaythroughData(storyData.ifid, playthroughId);
+        const known = await populateKnownSaves(storyData.ifid);
+        useStoryStore.setState((state) => {
+          state.knownSaves = known;
+        });
+      },
+
+      get backend() {
+        return getBackendType();
+      },
+    },
+
     getActions(): StoryAction[] {
       return getActions();
     },

package/src/saves/idb.ts

@@ -1,165 +0,0 @@
-import type { SaveRecord, PlaythroughRecord } from './types';
-
-const DB_NAME = 'spindle';
-const DB_VERSION = 1;
-
-let dbPromise: Promise<IDBDatabase> | null = null;
-let fallbackStore: {
-  saves: Map<string, SaveRecord>;
-  playthroughs: Map<string, PlaythroughRecord>;
-  meta: Map<string, unknown>;
-} | null = null;
-
-function useFallback() {
-  if (!fallbackStore) {
-    fallbackStore = {
-      saves: new Map(),
-      playthroughs: new Map(),
-      meta: new Map(),
-    };
-  }
-  return fallbackStore;
-}
-
-function openDB(): Promise<IDBDatabase> {
-  if (dbPromise) return dbPromise;
-
-  if (typeof indexedDB === 'undefined') {
-    return Promise.reject(new Error('IndexedDB unavailable'));
-  }
-
-  dbPromise = new Promise((resolve, reject) => {
-    const req = indexedDB.open(DB_NAME, DB_VERSION);
-
-    req.onupgradeneeded = () => {
-      const db = req.result;
-
-      if (!db.objectStoreNames.contains('saves')) {
-        const saves = db.createObjectStore('saves', { keyPath: 'meta.id' });
-        saves.createIndex('ifid', 'meta.ifid', { unique: false });
-        saves.createIndex('playthroughId', 'meta.playthroughId', {
-          unique: false,
-        });
-      }
-
-      if (!db.objectStoreNames.contains('playthroughs')) {
-        const pt = db.createObjectStore('playthroughs', { keyPath: 'id' });
-        pt.createIndex('ifid', 'ifid', { unique: false });
-      }
-
-      if (!db.objectStoreNames.contains('meta')) {
-        db.createObjectStore('meta', { keyPath: 'key' });
-      }
-    };
-
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error);
-  });
-
-  return dbPromise;
-}
-
-function tx(
-  storeName: string,
-  mode: IDBTransactionMode,
-): Promise<IDBObjectStore> {
-  return openDB().then((db) =>
-    db.transaction(storeName, mode).objectStore(storeName),
-  );
-}
-
-function idbRequest<T>(req: IDBRequest<T>): Promise<T> {
-  return new Promise((resolve, reject) => {
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error);
-  });
-}
-
-// --- Saves ---
-
-export async function putSave(record: SaveRecord): Promise<void> {
-  try {
-    const store = await tx('saves', 'readwrite');
-    await idbRequest(store.put(record));
-  } catch {
-    useFallback().saves.set(record.meta.id, record);
-  }
-}
-
-export async function getSave(id: string): Promise<SaveRecord | undefined> {
-  try {
-    const store = await tx('saves', 'readonly');
-    return (await idbRequest(store.get(id))) ?? undefined;
-  } catch {
-    return useFallback().saves.get(id);
-  }
-}
-
-export async function deleteSave(id: string): Promise<void> {
-  try {
-    const store = await tx('saves', 'readwrite');
-    await idbRequest(store.delete(id));
-  } catch {
-    useFallback().saves.delete(id);
-  }
-}
-
-export async function getSavesByIfid(ifid: string): Promise<SaveRecord[]> {
-  try {
-    const store = await tx('saves', 'readonly');
-    const index = store.index('ifid');
-    return (await idbRequest(index.getAll(ifid))) ?? [];
-  } catch {
-    return [...useFallback().saves.values()].filter(
-      (s) => s.meta.ifid === ifid,
-    );
-  }
-}
-
-// --- Playthroughs ---
-
-export async function putPlaythrough(record: PlaythroughRecord): Promise<void> {
-  try {
-    const store = await tx('playthroughs', 'readwrite');
-    await idbRequest(store.put(record));
-  } catch {
-    useFallback().playthroughs.set(record.id, record);
-  }
-}
-
-export async function getPlaythroughsByIfid(
-  ifid: string,
-): Promise<PlaythroughRecord[]> {
-  try {
-    const store = await tx('playthroughs', 'readonly');
-    const index = store.index('ifid');
-    return (await idbRequest(index.getAll(ifid))) ?? [];
-  } catch {
-    return [...useFallback().playthroughs.values()].filter(
-      (p) => p.ifid === ifid,
-    );
-  }
-}
-
-// --- Meta (key-value) ---
-
-export async function getMeta<T = unknown>(
-  key: string,
-): Promise<T | undefined> {
-  try {
-    const store = await tx('meta', 'readonly');
-    const row = await idbRequest(store.get(key));
-    return row ? (row as { key: string; value: T }).value : undefined;
-  } catch {
-    return useFallback().meta.get(key) as T | undefined;
-  }
-}
-
-export async function setMeta(key: string, value: unknown): Promise<void> {
-  try {
-    const store = await tx('meta', 'readwrite');
-    await idbRequest(store.put({ key, value }));
-  } catch {
-    useFallback().meta.set(key, value);
-  }
-}