@rohal12/spindle 0.1.0

package/src/saves/idb.ts

@@ -0,0 +1,165 @@
+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);
+  }
+}

package/src/saves/save-manager.ts

@@ -0,0 +1,317 @@
+import type {
+  SavePayload,
+  SaveMeta,
+  SaveRecord,
+  PlaythroughRecord,
+  SaveExport,
+} from './types';
+import {
+  putSave,
+  getSave,
+  deleteSave as idbDeleteSave,
+  getSavesByIfid,
+  putPlaythrough,
+  getPlaythroughsByIfid,
+  getMeta,
+  setMeta,
+} from './idb';
+
+type TitleGenerator = (payload: SavePayload) => string;
+
+let titleGenerator: TitleGenerator | null = null;
+let saveTitlePassageContent: string | null = null;
+let initialized = false;
+
+// --- Title Generation ---
+
+export function setTitleGenerator(fn: TitleGenerator): void {
+  titleGenerator = fn;
+}
+
+export function setSaveTitlePassage(content: string): void {
+  saveTitlePassageContent = content;
+}
+
+function generateTitle(payload: SavePayload): string {
+  // SaveTitle passage takes precedence
+  if (saveTitlePassageContent) {
+    try {
+      const fn = new Function(
+        'passage',
+        'variables',
+        saveTitlePassageContent,
+      ) as (passage: string, variables: Record<string, unknown>) => string;
+      const result = fn(payload.passage, payload.variables);
+      if (typeof result === 'string' && result.trim()) return result.trim();
+    } catch {
+      // fall through to other generators
+    }
+  }
+
+  if (titleGenerator) {
+    try {
+      const result = titleGenerator(payload);
+      if (typeof result === 'string' && result.trim()) return result.trim();
+    } catch {
+      // fall through to default
+    }
+  }
+
+  // Default: passage name + timestamp
+  const now = new Date();
+  const time = now.toLocaleTimeString(undefined, {
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+  return `${payload.passage} - ${time}`;
+}
+
+// --- Init ---
+
+export async function initSaveSystem(): Promise<void> {
+  if (initialized) return;
+  initialized = true;
+}
+
+// --- Playthroughs ---
+
+export async function startNewPlaythrough(ifid: string): Promise<string> {
+  const existing = await getPlaythroughsByIfid(ifid);
+  const num = existing.length + 1;
+
+  const id = crypto.randomUUID();
+  const record: PlaythroughRecord = {
+    id,
+    ifid,
+    createdAt: new Date().toISOString(),
+    label: `Playthrough ${num}`,
+  };
+
+  await putPlaythrough(record);
+  await setMeta(`currentPlaythroughId.${ifid}`, id);
+  return id;
+}
+
+export async function getCurrentPlaythroughId(
+  ifid: string,
+): Promise<string | undefined> {
+  return getMeta<string>(`currentPlaythroughId.${ifid}`);
+}
+
+// --- Save CRUD ---
+
+export async function createSave(
+  ifid: string,
+  playthroughId: string,
+  payload: SavePayload,
+  custom: Record<string, unknown> = {},
+): Promise<SaveRecord> {
+  const now = new Date().toISOString();
+  const meta: SaveMeta = {
+    id: crypto.randomUUID(),
+    ifid,
+    playthroughId,
+    createdAt: now,
+    updatedAt: now,
+    title: generateTitle(payload),
+    passage: payload.passage,
+    custom,
+  };
+
+  const record: SaveRecord = { meta, payload: structuredClone(payload) };
+  await putSave(record);
+  return record;
+}
+
+export async function overwriteSave(
+  saveId: string,
+  payload: SavePayload,
+): Promise<SaveRecord | undefined> {
+  const existing = await getSave(saveId);
+  if (!existing) return undefined;
+
+  existing.meta.updatedAt = new Date().toISOString();
+  existing.meta.passage = payload.passage;
+  existing.payload = structuredClone(payload);
+  await putSave(existing);
+  return existing;
+}
+
+export async function loadSave(
+  saveId: string,
+): Promise<SavePayload | undefined> {
+  const record = await getSave(saveId);
+  return record?.payload;
+}
+
+export async function deleteSaveById(saveId: string): Promise<void> {
+  await idbDeleteSave(saveId);
+}
+
+export async function renameSave(
+  saveId: string,
+  newTitle: string,
+): Promise<void> {
+  const record = await getSave(saveId);
+  if (!record) return;
+  record.meta.title = newTitle;
+  record.meta.updatedAt = new Date().toISOString();
+  await putSave(record);
+}
+
+// --- Grouped Retrieval ---
+
+export interface PlaythroughGroup {
+  playthrough: PlaythroughRecord;
+  saves: SaveRecord[];
+}
+
+export async function getSavesGrouped(
+  ifid: string,
+): Promise<PlaythroughGroup[]> {
+  const [allSaves, allPlaythroughs] = await Promise.all([
+    getSavesByIfid(ifid),
+    getPlaythroughsByIfid(ifid),
+  ]);
+
+  const ptMap = new Map<string, PlaythroughRecord>();
+  for (const pt of allPlaythroughs) ptMap.set(pt.id, pt);
+
+  const groups = new Map<string, SaveRecord[]>();
+  for (const save of allSaves) {
+    const pid = save.meta.playthroughId;
+    if (!groups.has(pid)) groups.set(pid, []);
+    groups.get(pid)!.push(save);
+  }
+
+  // Sort saves within each group newest-first
+  for (const saves of groups.values()) {
+    saves.sort(
+      (a, b) =>
+        new Date(b.meta.updatedAt).getTime() -
+        new Date(a.meta.updatedAt).getTime(),
+    );
+  }
+
+  // Build result sorted by playthrough creation newest-first
+  const result: PlaythroughGroup[] = [];
+  const sortedPts = [...ptMap.values()].sort(
+    (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
+  );
+
+  for (const pt of sortedPts) {
+    const saves = groups.get(pt.id) ?? [];
+    result.push({ playthrough: pt, saves });
+  }
+
+  // Include any orphaned saves (playthrough record missing)
+  for (const [pid, saves] of groups) {
+    if (!ptMap.has(pid)) {
+      result.push({
+        playthrough: {
+          id: pid,
+          ifid,
+          createdAt: saves[0]?.meta.createdAt ?? new Date().toISOString(),
+          label: 'Unknown Playthrough',
+        },
+        saves,
+      });
+    }
+  }
+
+  return result;
+}
+
+// --- Quick Save ---
+
+const AUTOSAVE_KEY_PREFIX = 'autosave.';
+
+export async function quickSave(
+  ifid: string,
+  playthroughId: string,
+  payload: SavePayload,
+): Promise<SaveRecord> {
+  const metaKey = `${AUTOSAVE_KEY_PREFIX}${ifid}`;
+  const existingId = await getMeta<string>(metaKey);
+
+  if (existingId) {
+    const updated = await overwriteSave(existingId, payload);
+    if (updated) return updated;
+  }
+
+  // Create new autosave
+  const record = await createSave(ifid, playthroughId, payload, {
+    isAutosave: true,
+  });
+  await setMeta(metaKey, record.meta.id);
+  return record;
+}
+
+export async function hasQuickSave(ifid: string): Promise<boolean> {
+  const metaKey = `${AUTOSAVE_KEY_PREFIX}${ifid}`;
+  const existingId = await getMeta<string>(metaKey);
+  if (!existingId) return false;
+  const record = await getSave(existingId);
+  return record !== undefined;
+}
+
+export async function loadQuickSave(
+  ifid: string,
+): Promise<SavePayload | undefined> {
+  const metaKey = `${AUTOSAVE_KEY_PREFIX}${ifid}`;
+  const existingId = await getMeta<string>(metaKey);
+  if (!existingId) return undefined;
+  return loadSave(existingId);
+}
+
+// --- Export / Import ---
+
+export async function exportSave(
+  saveId: string,
+): Promise<SaveExport | undefined> {
+  const record = await getSave(saveId);
+  if (!record) return undefined;
+
+  return {
+    version: 1,
+    ifid: record.meta.ifid,
+    exportedAt: new Date().toISOString(),
+    save: record,
+  };
+}
+
+export async function importSave(
+  data: SaveExport,
+  ifid: string,
+): Promise<SaveRecord> {
+  if (data.version !== 1) {
+    throw new Error(`Unsupported save version: ${data.version}`);
+  }
+  if (data.ifid !== ifid) {
+    throw new Error(
+      `Save is from a different story (expected IFID ${ifid}, got ${data.ifid})`,
+    );
+  }
+
+  // Re-assign a new ID to avoid collisions
+  const record = structuredClone(data.save);
+  record.meta.id = crypto.randomUUID();
+  record.meta.updatedAt = new Date().toISOString();
+
+  // Ensure the playthrough exists
+  const playthroughs = await getPlaythroughsByIfid(ifid);
+  const ptExists = playthroughs.some((p) => p.id === record.meta.playthroughId);
+  if (!ptExists) {
+    // Create an "Imported" playthrough
+    const pt: PlaythroughRecord = {
+      id: record.meta.playthroughId,
+      ifid,
+      createdAt: record.meta.createdAt,
+      label: 'Imported',
+    };
+    await putPlaythrough(pt);
+  }
+
+  await putSave(record);
+  return record;
+}

package/src/saves/types.ts

@@ -0,0 +1,40 @@
+import type { HistoryMoment } from '../store';
+
+export interface SavePayload {
+  passage: string;
+  variables: Record<string, unknown>;
+  history: HistoryMoment[];
+  historyIndex: number;
+  visitCounts?: Record<string, number>;
+  renderCounts?: Record<string, number>;
+}
+
+export interface SaveMeta {
+  id: string;
+  ifid: string;
+  playthroughId: string;
+  createdAt: string;
+  updatedAt: string;
+  title: string;
+  passage: string;
+  custom: Record<string, unknown>;
+}
+
+export interface SaveRecord {
+  meta: SaveMeta;
+  payload: SavePayload;
+}
+
+export interface PlaythroughRecord {
+  id: string;
+  ifid: string;
+  createdAt: string;
+  label: string;
+}
+
+export interface SaveExport {
+  version: 1;
+  ifid: string;
+  exportedAt: string;
+  save: SaveRecord;
+}

package/src/settings.ts

@@ -0,0 +1,96 @@
+import { useStoryStore } from './store';
+
+export interface ToggleConfig {
+  label: string;
+  default: boolean;
+}
+
+export interface ListConfig {
+  label: string;
+  options: string[];
+  default: string;
+}
+
+export interface RangeConfig {
+  label: string;
+  min: number;
+  max: number;
+  step: number;
+  default: number;
+}
+
+export type SettingDef =
+  | { type: 'toggle'; config: ToggleConfig }
+  | { type: 'list'; config: ListConfig }
+  | { type: 'range'; config: RangeConfig };
+
+const definitions = new Map<string, SettingDef>();
+let values: Record<string, unknown> = {};
+
+function storageKey(): string {
+  const storyData = useStoryStore.getState().storyData;
+  const ifid = storyData?.ifid || 'unknown';
+  return `spindle.${ifid}.settings`;
+}
+
+function persist(): void {
+  localStorage.setItem(storageKey(), JSON.stringify(values));
+}
+
+function loadFromStorage(): void {
+  try {
+    const raw = localStorage.getItem(storageKey());
+    if (raw) {
+      values = { ...values, ...JSON.parse(raw) };
+    }
+  } catch {
+    // ignore corrupted data
+  }
+}
+
+export const settings = {
+  addToggle(name: string, config: ToggleConfig): void {
+    definitions.set(name, { type: 'toggle', config });
+    if (!(name in values)) {
+      values[name] = config.default;
+    }
+    loadFromStorage();
+  },
+
+  addList(name: string, config: ListConfig): void {
+    definitions.set(name, { type: 'list', config });
+    if (!(name in values)) {
+      values[name] = config.default;
+    }
+    loadFromStorage();
+  },
+
+  addRange(name: string, config: RangeConfig): void {
+    definitions.set(name, { type: 'range', config });
+    if (!(name in values)) {
+      values[name] = config.default;
+    }
+    loadFromStorage();
+  },
+
+  get(name: string): unknown {
+    return values[name];
+  },
+
+  set(name: string, value: unknown): void {
+    values[name] = value;
+    persist();
+  },
+
+  getAll(): Record<string, unknown> {
+    return { ...values };
+  },
+
+  getDefinitions(): Map<string, SettingDef> {
+    return definitions;
+  },
+
+  hasAny(): boolean {
+    return definitions.size > 0;
+  },
+};