feat: add types and IndexedDB cache manager for Bible reader 2025

Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

lib/cache-manager.ts

@@ -0,0 +1,109 @@
+// IndexedDB cache management
+import { BibleChapter, CacheEntry } from '@/types'
+
+const DB_NAME = 'BibleReaderDB'
+const DB_VERSION = 1
+const STORE_NAME = 'chapters'
+const CACHE_DURATION_MS = 30 * 24 * 60 * 60 * 1000 // 30 days
+const MAX_CACHE_SIZE = 50 // keep last 50 chapters
+
+let db: IDBDatabase | null = null
+
+export async function initDatabase(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION)
+
+    request.onerror = () => reject(request.error)
+    request.onsuccess = () => {
+      db = request.result
+      resolve(db)
+    }
+
+    request.onupgradeneeded = (event) => {
+      const database = (event.target as IDBOpenDBRequest).result
+      if (!database.objectStoreNames.contains(STORE_NAME)) {
+        const store = database.createObjectStore(STORE_NAME, { keyPath: 'chapterId' })
+        store.createIndex('timestamp', 'timestamp', { unique: false })
+      }
+    }
+  })
+}
+
+export async function cacheChapter(chapter: BibleChapter): Promise<void> {
+  if (!db) await initDatabase()
+
+  const entry: CacheEntry = {
+    chapterId: chapter.id,
+    data: chapter,
+    timestamp: Date.now(),
+    expiresAt: Date.now() + CACHE_DURATION_MS
+  }
+
+  return new Promise((resolve, reject) => {
+    const transaction = db!.transaction([STORE_NAME], 'readwrite')
+    const store = transaction.objectStore(STORE_NAME)
+
+    // Delete oldest entries if over limit
+    const countRequest = store.count()
+    countRequest.onsuccess = () => {
+      if (countRequest.result >= MAX_CACHE_SIZE) {
+        const index = store.index('timestamp')
+        const oldestRequest = index.openCursor()
+        oldestRequest.onsuccess = (event) => {
+          const cursor = (event.target as IDBRequest).result
+          if (cursor) {
+            cursor.delete()
+          }
+        }
+      }
+    }
+
+    const request = store.put(entry)
+    request.onerror = () => reject(request.error)
+    request.onsuccess = () => resolve()
+  })
+}
+
+export async function getCachedChapter(chapterId: string): Promise<BibleChapter | null> {
+  if (!db) await initDatabase()
+
+  return new Promise((resolve, reject) => {
+    const transaction = db!.transaction([STORE_NAME], 'readonly')
+    const store = transaction.objectStore(STORE_NAME)
+    const request = store.get(chapterId)
+
+    request.onerror = () => reject(request.error)
+    request.onsuccess = () => {
+      const entry = request.result as CacheEntry | undefined
+      if (entry && entry.expiresAt > Date.now()) {
+        resolve(entry.data)
+      } else {
+        resolve(null)
+      }
+    }
+  })
+}
+
+export async function clearExpiredCache(): Promise<void> {
+  if (!db) await initDatabase()
+
+  return new Promise((resolve, reject) => {
+    const transaction = db!.transaction([STORE_NAME], 'readwrite')
+    const store = transaction.objectStore(STORE_NAME)
+    const index = store.index('timestamp')
+    const range = IDBKeyRange.upperBound(Date.now() - CACHE_DURATION_MS)
+    const request = index.openCursor(range)
+
+    request.onsuccess = (event) => {
+      const cursor = (event.target as IDBRequest).result
+      if (cursor) {
+        cursor.delete()
+        cursor.continue()
+      } else {
+        resolve()
+      }
+    }
+
+    request.onerror = () => reject(request.error)
+  })
+}