| import { TranslationCache } from './types'; |
|
|
| const DB_NAME = 'TranslationCache'; |
| const DB_VERSION = 1; |
| const STORE_NAME = 'translations'; |
|
|
| interface CacheEntry { |
| key: string; |
| translation: string; |
| timestamp: number; |
| provider: string; |
| sourceLang: string; |
| targetLang: string; |
| originalText: string; |
| } |
|
|
| const memoryCache: TranslationCache = {}; |
| const memoryTimestamps: Record<string, number> = {}; |
|
|
| const openDatabase = (): Promise<IDBDatabase> => { |
| return new Promise((resolve, reject) => { |
| if (!window.indexedDB) { |
| console.warn('IndexedDB not supported. Using in-memory cache only.'); |
| reject(new Error('IndexedDB not supported')); |
| return; |
| } |
|
|
| const request = indexedDB.open(DB_NAME, DB_VERSION); |
|
|
| request.onerror = (event) => { |
| console.error('IndexedDB error:', event); |
| reject(new Error('Could not open IndexedDB')); |
| }; |
|
|
| request.onsuccess = (event) => { |
| const db = (event.target as IDBOpenDBRequest).result; |
| resolve(db); |
| }; |
|
|
| request.onupgradeneeded = (event) => { |
| const db = (event.target as IDBOpenDBRequest).result; |
|
|
| if (!db.objectStoreNames.contains(STORE_NAME)) { |
| const store = db.createObjectStore(STORE_NAME, { keyPath: 'key' }); |
| store.createIndex('provider', 'provider', { unique: false }); |
| store.createIndex('timestamp', 'timestamp', { unique: false }); |
| } |
| }; |
| }); |
| }; |
|
|
| export const loadCacheFromDB = async ( |
| options: { |
| maxAge?: number; |
| maxEntries?: number; |
| onlyLoadProviders?: string[]; |
| onlyLoadLanguages?: { source?: string[]; target?: string[] }; |
| } = {}, |
| ): Promise<void> => { |
| try { |
| const db = await openDatabase(); |
| const transaction = db.transaction(STORE_NAME, 'readonly'); |
| const store = transaction.objectStore(STORE_NAME); |
|
|
| let request: IDBRequest; |
| if (options.onlyLoadProviders && options.onlyLoadProviders.length > 0) { |
| const providerPromises = options.onlyLoadProviders.map((provider) => { |
| return new Promise<CacheEntry[]>((resolve) => { |
| const providerIndex = store.index('provider'); |
| const request = providerIndex.getAll(provider); |
|
|
| request.onsuccess = () => { |
| resolve(request.result); |
| }; |
|
|
| request.onerror = () => { |
| resolve([]); |
| }; |
| }); |
| }); |
|
|
| const allEntries = (await Promise.all(providerPromises)).flat(); |
| processLoadedEntries(allEntries, options); |
| } else { |
| request = store.getAll(); |
|
|
| request.onsuccess = () => { |
| const entries = request.result as CacheEntry[]; |
| processLoadedEntries(entries, options); |
| }; |
|
|
| request.onerror = (event) => { |
| console.error('Error loading cache from IndexedDB:', event); |
| }; |
| } |
|
|
| transaction.oncomplete = () => { |
| db.close(); |
| }; |
| } catch (error) { |
| console.error('Failed to load cache from IndexedDB:', error); |
| } |
| }; |
|
|
| const processLoadedEntries = ( |
| entries: CacheEntry[], |
| options: { |
| maxAge?: number; |
| maxEntries?: number; |
| onlyLoadLanguages?: { source?: string[]; target?: string[] }; |
| }, |
| ): void => { |
| let filteredEntries = entries; |
|
|
| if (options.maxAge) { |
| const cutoff = Date.now() - options.maxAge; |
| filteredEntries = filteredEntries.filter((entry) => entry.timestamp >= cutoff); |
| } |
|
|
| if (options.onlyLoadLanguages) { |
| if (options.onlyLoadLanguages.source && options.onlyLoadLanguages.source.length > 0) { |
| filteredEntries = filteredEntries.filter((entry) => |
| options.onlyLoadLanguages!.source!.includes(entry.sourceLang), |
| ); |
| } |
|
|
| if (options.onlyLoadLanguages.target && options.onlyLoadLanguages.target.length > 0) { |
| filteredEntries = filteredEntries.filter((entry) => |
| options.onlyLoadLanguages!.target!.includes(entry.targetLang), |
| ); |
| } |
| } |
|
|
| if (options.maxEntries && filteredEntries.length > options.maxEntries) { |
| filteredEntries.sort((a, b) => b.timestamp - a.timestamp); |
| filteredEntries = filteredEntries.slice(0, options.maxEntries); |
| } |
|
|
| filteredEntries.forEach((entry) => { |
| memoryCache[entry.key] = entry.translation; |
| memoryTimestamps[entry.key] = entry.timestamp; |
| }); |
|
|
| |
| }; |
|
|
| export const getCacheKey = ( |
| text: string, |
| sourceLang: string, |
| targetLang: string, |
| provider: string, |
| ): string => { |
| return `${provider}:${sourceLang}:${targetLang}:${text}`; |
| }; |
|
|
| export const getFromCache = async ( |
| text: string, |
| sourceLang: string, |
| targetLang: string, |
| provider: string, |
| ): Promise<string | null> => { |
| if (!text?.trim()) return null; |
|
|
| const key = getCacheKey(text, sourceLang, targetLang, provider); |
|
|
| if (memoryCache[key]) { |
| return memoryCache[key]; |
| } |
|
|
| try { |
| const db = await openDatabase(); |
| const transaction = db.transaction(STORE_NAME, 'readonly'); |
| const store = transaction.objectStore(STORE_NAME); |
| const request = store.get(key); |
|
|
| return new Promise((resolve) => { |
| request.onsuccess = () => { |
| const entry = request.result as CacheEntry; |
| if (entry) { |
| memoryCache[key] = entry.translation; |
| memoryTimestamps[key] = entry.timestamp; |
| resolve(entry.translation); |
| } else { |
| resolve(null); |
| } |
| }; |
|
|
| request.onerror = () => { |
| resolve(null); |
| }; |
|
|
| transaction.oncomplete = () => { |
| db.close(); |
| }; |
| }); |
| } catch (error) { |
| console.error('Error accessing IndexedDB:', error); |
| return null; |
| } |
| }; |
|
|
| export const storeInCache = async ( |
| text: string, |
| translation: string, |
| sourceLang: string, |
| targetLang: string, |
| provider: string, |
| ): Promise<void> => { |
| if (!text?.trim() || !translation) return; |
|
|
| const key = getCacheKey(text, sourceLang, targetLang, provider); |
| const timestamp = Date.now(); |
|
|
| memoryCache[key] = translation; |
| memoryTimestamps[key] = timestamp; |
|
|
| try { |
| const db = await openDatabase(); |
| const transaction = db.transaction(STORE_NAME, 'readwrite'); |
| const store = transaction.objectStore(STORE_NAME); |
|
|
| const entry: CacheEntry = { |
| key, |
| translation, |
| timestamp, |
| provider, |
| sourceLang, |
| targetLang, |
| originalText: text, |
| }; |
|
|
| store.put(entry); |
|
|
| return new Promise((resolve, reject) => { |
| transaction.oncomplete = () => { |
| db.close(); |
| resolve(); |
| }; |
|
|
| transaction.onerror = (event) => { |
| console.error('Error storing in IndexedDB:', event); |
| reject(new Error('Failed to store in IndexedDB')); |
| }; |
| }); |
| } catch (error) { |
| console.error('Error accessing IndexedDB:', error); |
| } |
| }; |
|
|
| export interface CacheFilterOptions { |
| provider?: string; |
| maxAge?: number; |
| } |
|
|
| export const clearCache = async (filter?: CacheFilterOptions): Promise<number> => { |
| let deletedCount = 0; |
|
|
| if (!filter) { |
| const count = Object.keys(memoryCache).length; |
| Object.keys(memoryCache).forEach((key) => { |
| delete memoryCache[key]; |
| delete memoryTimestamps[key]; |
| }); |
| deletedCount = count; |
| } else { |
| const keysToDelete: string[] = []; |
|
|
| Object.keys(memoryCache).forEach((key) => { |
| let shouldDelete = true; |
|
|
| if (filter.provider) { |
| const parts = key.split(':'); |
| const provider = parts[0]; |
|
|
| if (filter.provider && provider !== filter.provider) { |
| shouldDelete = false; |
| } |
| } |
|
|
| if (shouldDelete && filter.maxAge && memoryTimestamps[key]) { |
| const timestamp = memoryTimestamps[key]; |
| if (Date.now() - timestamp < filter.maxAge) { |
| shouldDelete = false; |
| } |
| } |
|
|
| if (shouldDelete) { |
| keysToDelete.push(key); |
| } |
| }); |
|
|
| keysToDelete.forEach((key) => { |
| delete memoryCache[key]; |
| delete memoryTimestamps[key]; |
| }); |
|
|
| deletedCount = keysToDelete.length; |
| } |
|
|
| try { |
| const db = await openDatabase(); |
| const transaction = db.transaction(STORE_NAME, 'readwrite'); |
| const store = transaction.objectStore(STORE_NAME); |
|
|
| if (!filter) { |
| store.clear(); |
| } else { |
| const request = store.getAll(); |
|
|
| request.onsuccess = () => { |
| const entries = request.result as CacheEntry[]; |
| const filteredEntries = entries.filter((entry) => { |
| if (filter.provider && entry.provider !== filter.provider) { |
| return false; |
| } |
|
|
| if (filter.maxAge && Date.now() - entry.timestamp >= filter.maxAge) { |
| return true; |
| } |
|
|
| return true; |
| }); |
|
|
| filteredEntries.forEach((entry) => { |
| store.delete(entry.key); |
| }); |
| }; |
| } |
|
|
| return new Promise((resolve) => { |
| transaction.oncomplete = () => { |
| db.close(); |
| resolve(deletedCount); |
| }; |
|
|
| transaction.onerror = () => { |
| db.close(); |
| resolve(deletedCount); |
| }; |
| }); |
| } catch (error) { |
| console.error('Error clearing IndexedDB cache:', error); |
| return deletedCount; |
| } |
| }; |
|
|
| export const getCacheStats = async ( |
| includeDB: boolean = false, |
| ): Promise<{ |
| memoryCacheEntries: number; |
| memoryCacheSizeInBytes: number; |
| dbCacheEntries?: number; |
| dbCacheSizeInBytes?: number; |
| totalEntries?: number; |
| totalSizeInBytes?: number; |
| }> => { |
| const memoryCacheEntries = Object.keys(memoryCache).length; |
|
|
| let memoryCacheSizeInBytes = 0; |
| for (const key in memoryCache) { |
| memoryCacheSizeInBytes += key.length; |
|
|
| const value = memoryCache[key] || ''; |
| memoryCacheSizeInBytes += value.length; |
| } |
|
|
| if (!includeDB) { |
| return { memoryCacheEntries, memoryCacheSizeInBytes }; |
| } |
|
|
| try { |
| const db = await openDatabase(); |
| const transaction = db.transaction(STORE_NAME, 'readonly'); |
| const store = transaction.objectStore(STORE_NAME); |
| const countRequest = store.count(); |
|
|
| return new Promise((resolve) => { |
| countRequest.onsuccess = () => { |
| const dbCacheEntries = countRequest.result; |
|
|
| const getAllRequest = store.getAll(); |
|
|
| getAllRequest.onsuccess = () => { |
| const entries = getAllRequest.result as CacheEntry[]; |
|
|
| let dbCacheSizeInBytes = 0; |
| entries.forEach((entry) => { |
| const entryString = JSON.stringify(entry); |
| dbCacheSizeInBytes += entryString.length; |
| }); |
|
|
| const totalEntries = |
| memoryCacheEntries + dbCacheEntries - Math.min(memoryCacheEntries, dbCacheEntries); |
|
|
| const totalSizeInBytes = memoryCacheSizeInBytes + dbCacheSizeInBytes; |
|
|
| resolve({ |
| memoryCacheEntries, |
| memoryCacheSizeInBytes, |
| dbCacheEntries, |
| dbCacheSizeInBytes, |
| totalEntries, |
| totalSizeInBytes, |
| }); |
| }; |
| }; |
|
|
| transaction.oncomplete = () => { |
| db.close(); |
| }; |
|
|
| transaction.onerror = () => { |
| db.close(); |
| resolve({ |
| memoryCacheEntries, |
| memoryCacheSizeInBytes, |
| }); |
| }; |
| }); |
| } catch (error) { |
| console.error('Error getting IndexedDB stats:', error); |
| return { memoryCacheEntries, memoryCacheSizeInBytes }; |
| } |
| }; |
|
|
| export const pruneCache = async ( |
| options: { |
| maxAge?: number; |
| maxEntries?: number; |
| maxSizeInBytes?: number; |
| dryRun?: boolean; |
| } = {}, |
| ): Promise<number> => { |
| const { maxAge, maxEntries, maxSizeInBytes, dryRun = false } = options; |
|
|
| if (!maxAge && !maxEntries && !maxSizeInBytes) { |
| return 0; |
| } |
|
|
| try { |
| const db = await openDatabase(); |
| const transaction = db.transaction(STORE_NAME, dryRun ? 'readonly' : 'readwrite'); |
| const store = transaction.objectStore(STORE_NAME); |
| const getAllRequest = store.getAll(); |
|
|
| return new Promise((resolve) => { |
| getAllRequest.onsuccess = () => { |
| const entries = getAllRequest.result as CacheEntry[]; |
| const entriesToPrune: CacheEntry[] = []; |
|
|
| if (maxAge) { |
| const cutoffTime = Date.now() - maxAge; |
| const agedEntries = entries.filter((entry) => entry.timestamp < cutoffTime); |
| entriesToPrune.push(...agedEntries); |
| } |
|
|
| if (maxEntries && entries.length > maxEntries) { |
| const sortedEntries = [...entries].sort((a, b) => a.timestamp - b.timestamp); |
| const excessEntries = sortedEntries.slice(0, entries.length - maxEntries); |
|
|
| const prunedKeys = new Set(entriesToPrune.map((e) => e.key)); |
| excessEntries.forEach((entry) => { |
| if (!prunedKeys.has(entry.key)) { |
| entriesToPrune.push(entry); |
| } |
| }); |
| } |
|
|
| if (maxSizeInBytes) { |
| let currentSize = 0; |
| entries.forEach((entry) => { |
| const entryString = JSON.stringify(entry); |
| currentSize += entryString.length; |
| }); |
|
|
| if (currentSize > maxSizeInBytes) { |
| const remainingEntries = entries |
| .filter((entry) => !entriesToPrune.some((e) => e.key === entry.key)) |
| .sort((a, b) => a.timestamp - b.timestamp); |
|
|
| let sizeToRemove = currentSize - maxSizeInBytes; |
| const prunedKeys = new Set(entriesToPrune.map((e) => e.key)); |
|
|
| for (const entry of remainingEntries) { |
| if (sizeToRemove <= 0) break; |
|
|
| if (!prunedKeys.has(entry.key)) { |
| const entryString = JSON.stringify(entry); |
| const entrySize = entryString.length * 2; |
|
|
| entriesToPrune.push(entry); |
| prunedKeys.add(entry.key); |
| sizeToRemove -= entrySize; |
| } |
| } |
| } |
| } |
|
|
| const pruneCount = entriesToPrune.length; |
|
|
| if (!dryRun && pruneCount > 0) { |
| entriesToPrune.forEach((entry) => { |
| store.delete(entry.key); |
|
|
| delete memoryCache[entry.key]; |
| delete memoryTimestamps[entry.key]; |
| }); |
| } |
|
|
| resolve(pruneCount); |
| }; |
|
|
| getAllRequest.onerror = () => { |
| resolve(0); |
| }; |
|
|
| transaction.oncomplete = () => { |
| db.close(); |
| }; |
| }); |
| } catch (error) { |
| console.error('Error pruning cache:', error); |
| return 0; |
| } |
| }; |
|
|
| export const initCache = async ( |
| options: { |
| preload?: boolean; |
| preloadOptions?: { |
| maxAge?: number; |
| maxEntries?: number; |
| onlyLoadProviders?: string[]; |
| onlyLoadLanguages?: { source?: string[]; target?: string[] }; |
| }; |
| autoPrune?: boolean; |
| pruneInterval?: number; |
| pruneOptions?: { |
| maxAge?: number; |
| maxEntries?: number; |
| maxSizeInBytes?: number; |
| }; |
| } = {}, |
| ): Promise<() => void> => { |
| const { |
| preload = true, |
| preloadOptions = { |
| maxAge: 30 * 24 * 60 * 60 * 1000, |
| maxEntries: 10000, |
| }, |
| autoPrune = true, |
| pruneInterval = 60 * 60 * 1000, |
| pruneOptions = { |
| maxAge: 90 * 24 * 60 * 60 * 1000, |
| maxEntries: 100000, |
| maxSizeInBytes: 10 * 1024 * 1024, |
| }, |
| } = options; |
|
|
| if (preload) { |
| await loadCacheFromDB(preloadOptions); |
| } |
|
|
| let intervalId: number | null = null; |
|
|
| if (autoPrune) { |
| await pruneCache(pruneOptions); |
|
|
| intervalId = window.setInterval(async () => { |
| await pruneCache(pruneOptions); |
| }, pruneInterval); |
| } |
|
|
| return () => { |
| if (intervalId !== null) { |
| clearInterval(intervalId); |
| } |
| }; |
| }; |
|
|
| let cleanupFunction: (() => void) | null = null; |
|
|
| if (typeof window !== 'undefined') { |
| initCache().then((cleanup) => { |
| cleanupFunction = cleanup; |
| }); |
|
|
| window.addEventListener('beforeunload', () => { |
| if (cleanupFunction) { |
| cleanupFunction(); |
| } |
| }); |
| } |
|
|
