听书音频缓存，进度缓存

src/lib/book-tts-cache.client.ts

@@ -0,0 +1,162 @@
+'use client';
+
+const DB_NAME = 'moontv_book_tts';
+const STORE_NAME = 'audio_chunks';
+const DB_VERSION = 1;
+const DEFAULT_CACHE_LIMIT = 150 * 1024 * 1024;
+
+export interface CachedBookTtsChunk {
+  cacheKey: string;
+  sourceId: string;
+  bookId: string;
+  chapterHref: string;
+  chunkIndex: number;
+  textHash: string;
+  voice: string;
+  rate: string;
+  pitch: string;
+  volume: string;
+  textPreview: string;
+  mimeType: string;
+  audioBlob: Blob;
+  size: number;
+  duration?: number;
+  createdAt: number;
+  lastAccessAt: number;
+}
+
+function openDatabase(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        const store = db.createObjectStore(STORE_NAME, { keyPath: 'cacheKey' });
+        store.createIndex('lastAccessAt', 'lastAccessAt', { unique: false });
+        store.createIndex('book', ['sourceId', 'bookId'], { unique: false });
+        store.createIndex('chapter', ['sourceId', 'bookId', 'chapterHref'], { unique: false });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error || new Error('打开听书缓存失败'));
+  });
+}
+
+async function sha256(input: string): Promise<string> {
+  const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(input));
+  return Array.from(new Uint8Array(digest))
+    .map((item) => item.toString(16).padStart(2, '0'))
+    .join('');
+}
+
+export async function buildBookTtsCacheKey(input: {
+  sourceId: string;
+  bookId: string;
+  chapterHref: string;
+  chunkIndex: number;
+  text: string;
+  voice: string;
+  rate: string;
+  pitch: string;
+  volume: string;
+}): Promise<{ cacheKey: string; textHash: string }> {
+  const textHash = await sha256(input.text);
+  const raw = JSON.stringify({
+    sourceId: input.sourceId,
+    bookId: input.bookId,
+    chapterHref: input.chapterHref,
+    chunkIndex: input.chunkIndex,
+    voice: input.voice,
+    rate: input.rate,
+    pitch: input.pitch,
+    volume: input.volume,
+    textHash,
+  });
+  return {
+    cacheKey: `bookTts:${await sha256(raw)}`,
+    textHash,
+  };
+}
+
+export async function getCachedBookTtsChunk(cacheKey: string): Promise<CachedBookTtsChunk | null> {
+  const db = await openDatabase();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, 'readonly');
+    const request = tx.objectStore(STORE_NAME).get(cacheKey);
+    request.onsuccess = () => {
+      db.close();
+      resolve((request.result as CachedBookTtsChunk | undefined) || null);
+    };
+    request.onerror = () => {
+      db.close();
+      reject(request.error || new Error('读取听书缓存失败'));
+    };
+  });
+}
+
+export async function putCachedBookTtsChunk(record: CachedBookTtsChunk): Promise<void> {
+  const db = await openDatabase();
+  await new Promise<void>((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, 'readwrite');
+    tx.objectStore(STORE_NAME).put(record);
+    tx.oncomplete = () => {
+      db.close();
+      resolve();
+    };
+    tx.onerror = () => {
+      db.close();
+      reject(tx.error || new Error('写入听书缓存失败'));
+    };
+  });
+}
+
+export async function touchCachedBookTtsChunk(cacheKey: string): Promise<void> {
+  const current = await getCachedBookTtsChunk(cacheKey);
+  if (!current) return;
+  await putCachedBookTtsChunk({ ...current, lastAccessAt: Date.now() });
+}
+
+export async function listCachedBookTtsChunks(): Promise<CachedBookTtsChunk[]> {
+  const db = await openDatabase();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, 'readonly');
+    const request = tx.objectStore(STORE_NAME).getAll();
+    request.onsuccess = () => {
+      db.close();
+      resolve((request.result as CachedBookTtsChunk[]) || []);
+    };
+    request.onerror = () => {
+      db.close();
+      reject(request.error || new Error('读取听书缓存列表失败'));
+    };
+  });
+}
+
+export async function deleteCachedBookTtsChunk(cacheKey: string): Promise<void> {
+  const db = await openDatabase();
+  await new Promise<void>((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, 'readwrite');
+    tx.objectStore(STORE_NAME).delete(cacheKey);
+    tx.oncomplete = () => {
+      db.close();
+      resolve();
+    };
+    tx.onerror = () => {
+      db.close();
+      reject(tx.error || new Error('删除听书缓存失败'));
+    };
+  });
+}
+
+export async function enforceBookTtsCacheLimit(limit = DEFAULT_CACHE_LIMIT): Promise<void> {
+  const items = await listCachedBookTtsChunks();
+  const total = items.reduce((sum, item) => sum + item.size, 0);
+  if (total <= limit) return;
+  let current = total;
+  const sorted = [...items].sort((a, b) => a.lastAccessAt - b.lastAccessAt);
+  for (const item of sorted) {
+    if (current <= limit) break;
+    await deleteCachedBookTtsChunk(item.cacheKey);
+    current -= item.size;
+  }
+}

src/lib/book.types.ts

@@ -149,6 +149,7 @@ export interface BookTtsProgress {
   chapterTitle?: string;
   chunkIndex: number;
   charOffset: number;
+  currentTimeSec?: number;
   voice: string;
   rate: string;
   pitch: string;