269 lines
6.5 KiB
TypeScript
269 lines
6.5 KiB
TypeScript
const DB_NAME = "otunes-cache"
|
|
const DB_VERSION = 1
|
|
const STORE_NAME = "entries"
|
|
const WRITE_DELAY_MS = 250
|
|
/** Keys are `<prefix>:<rest>`; prefixes without a limit are never evicted. */
|
|
const MAX_ENTRIES_BY_PREFIX: Record<string, number> = {
|
|
q: 400,
|
|
song: 5000,
|
|
}
|
|
|
|
type Entry = { value: unknown; touchedAt: number }
|
|
|
|
const memory = new Map<string, Entry>()
|
|
const prefixCounts = new Map<string, number>()
|
|
const listeners = new Map<string, Set<() => void>>()
|
|
const loadListeners = new Set<() => void>()
|
|
const pendingWrites = new Map<string, Entry | null>()
|
|
let flushTimer: ReturnType<typeof setTimeout> | null = null
|
|
let dbPromise: Promise<IDBDatabase | null> | null = null
|
|
let loadPromise: Promise<void> | null = null
|
|
let loaded = false
|
|
|
|
function requestToPromise<T>(request: IDBRequest<T>) {
|
|
return new Promise<T>((resolve, reject) => {
|
|
request.onsuccess = () => resolve(request.result)
|
|
request.onerror = () => reject(request.error)
|
|
})
|
|
}
|
|
|
|
function transactionDone(transaction: IDBTransaction) {
|
|
return new Promise<void>((resolve, reject) => {
|
|
transaction.oncomplete = () => resolve()
|
|
transaction.onabort = () => reject(transaction.error)
|
|
transaction.onerror = () => reject(transaction.error)
|
|
})
|
|
}
|
|
|
|
function openDb() {
|
|
if (dbPromise) {
|
|
return dbPromise
|
|
}
|
|
|
|
dbPromise = new Promise<IDBDatabase | null>((resolve) => {
|
|
if (typeof indexedDB === "undefined") {
|
|
resolve(null)
|
|
return
|
|
}
|
|
|
|
try {
|
|
const request = indexedDB.open(DB_NAME, DB_VERSION)
|
|
request.onupgradeneeded = () => {
|
|
if (!request.result.objectStoreNames.contains(STORE_NAME)) {
|
|
request.result.createObjectStore(STORE_NAME)
|
|
}
|
|
}
|
|
request.onsuccess = () => resolve(request.result)
|
|
request.onerror = () => resolve(null)
|
|
request.onblocked = () => resolve(null)
|
|
} catch {
|
|
resolve(null)
|
|
}
|
|
})
|
|
|
|
return dbPromise
|
|
}
|
|
|
|
function notify(key: string) {
|
|
for (const listener of listeners.get(key) ?? []) {
|
|
listener()
|
|
}
|
|
}
|
|
|
|
function notifyAll() {
|
|
for (const key of listeners.keys()) {
|
|
notify(key)
|
|
}
|
|
for (const listener of loadListeners) {
|
|
listener()
|
|
}
|
|
}
|
|
|
|
async function flushWrites() {
|
|
flushTimer = null
|
|
if (pendingWrites.size === 0) {
|
|
return
|
|
}
|
|
|
|
const writes = [...pendingWrites]
|
|
pendingWrites.clear()
|
|
|
|
const db = await openDb()
|
|
if (!db) {
|
|
return
|
|
}
|
|
|
|
try {
|
|
const transaction = db.transaction(STORE_NAME, "readwrite")
|
|
const store = transaction.objectStore(STORE_NAME)
|
|
for (const [key, entry] of writes) {
|
|
if (entry === null) {
|
|
store.delete(key)
|
|
} else {
|
|
store.put(entry, key)
|
|
}
|
|
}
|
|
await transactionDone(transaction)
|
|
} catch {
|
|
// Persisting is best-effort; the in-memory copy stays authoritative.
|
|
}
|
|
}
|
|
|
|
function scheduleWrite(key: string, entry: Entry | null) {
|
|
pendingWrites.set(key, entry)
|
|
if (flushTimer === null) {
|
|
flushTimer = setTimeout(() => void flushWrites(), WRITE_DELAY_MS)
|
|
}
|
|
}
|
|
|
|
function entryPrefix(key: string) {
|
|
const index = key.indexOf(":")
|
|
return index === -1 ? key : key.slice(0, index)
|
|
}
|
|
|
|
function evictOldEntries(prefix: string, force = false) {
|
|
const limit = MAX_ENTRIES_BY_PREFIX[prefix]
|
|
const count = prefixCounts.get(prefix) ?? 0
|
|
if (limit === undefined || count <= (force ? limit : limit * 1.25)) {
|
|
return
|
|
}
|
|
|
|
const oldest = [...memory.entries()]
|
|
.filter(([key]) => entryPrefix(key) === prefix)
|
|
.sort(([, a], [, b]) => a.touchedAt - b.touchedAt)
|
|
.slice(0, count - limit)
|
|
|
|
for (const [key] of oldest) {
|
|
removeFromMemory(key)
|
|
scheduleWrite(key, null)
|
|
}
|
|
}
|
|
|
|
function setInMemory(key: string, entry: Entry) {
|
|
if (!memory.has(key)) {
|
|
const prefix = entryPrefix(key)
|
|
prefixCounts.set(prefix, (prefixCounts.get(prefix) ?? 0) + 1)
|
|
}
|
|
memory.set(key, entry)
|
|
}
|
|
|
|
function removeFromMemory(key: string) {
|
|
if (memory.delete(key)) {
|
|
const prefix = entryPrefix(key)
|
|
prefixCounts.set(prefix, (prefixCounts.get(prefix) ?? 1) - 1)
|
|
}
|
|
}
|
|
|
|
/** Writes pending entries now instead of after the batching delay. */
|
|
export function flushPersistentCache() {
|
|
if (flushTimer !== null) {
|
|
clearTimeout(flushTimer)
|
|
}
|
|
void flushWrites()
|
|
}
|
|
|
|
export function loadPersistentCache() {
|
|
if (loadPromise) {
|
|
return loadPromise
|
|
}
|
|
|
|
loadPromise = (async () => {
|
|
const db = await openDb()
|
|
if (db) {
|
|
try {
|
|
const transaction = db.transaction(STORE_NAME, "readonly")
|
|
const store = transaction.objectStore(STORE_NAME)
|
|
const [keys, values] = await Promise.all([
|
|
requestToPromise(store.getAllKeys()),
|
|
requestToPromise(store.getAll() as IDBRequest<Entry[]>),
|
|
])
|
|
keys.forEach((key, index) => {
|
|
const entry = values[index]
|
|
if (typeof key === "string" && entry && !memory.has(key)) {
|
|
setInMemory(key, entry)
|
|
}
|
|
})
|
|
for (const prefix of Object.keys(MAX_ENTRIES_BY_PREFIX)) {
|
|
evictOldEntries(prefix, true)
|
|
}
|
|
} catch {
|
|
// Treat an unreadable cache as empty.
|
|
}
|
|
}
|
|
|
|
loaded = true
|
|
notifyAll()
|
|
})()
|
|
|
|
return loadPromise
|
|
}
|
|
|
|
export function isPersistentCacheLoaded() {
|
|
return loaded
|
|
}
|
|
|
|
export function readCache<T>(key: string): T | undefined {
|
|
return memory.get(key)?.value as T | undefined
|
|
}
|
|
|
|
export function writeCache(
|
|
key: string,
|
|
value: unknown,
|
|
options: { notify?: boolean } = {}
|
|
) {
|
|
const entry = { value, touchedAt: Date.now() }
|
|
setInMemory(key, entry)
|
|
scheduleWrite(key, entry)
|
|
evictOldEntries(entryPrefix(key))
|
|
if (options.notify) {
|
|
notify(key)
|
|
}
|
|
}
|
|
|
|
export async function clearPersistentCache() {
|
|
memory.clear()
|
|
prefixCounts.clear()
|
|
pendingWrites.clear()
|
|
if (flushTimer !== null) {
|
|
clearTimeout(flushTimer)
|
|
flushTimer = null
|
|
}
|
|
notifyAll()
|
|
|
|
const db = await openDb()
|
|
if (!db) {
|
|
return
|
|
}
|
|
|
|
try {
|
|
const transaction = db.transaction(STORE_NAME, "readwrite")
|
|
transaction.objectStore(STORE_NAME).clear()
|
|
await transactionDone(transaction)
|
|
} catch {
|
|
// Ignore; stale entries are scoped per user and evicted over time.
|
|
}
|
|
}
|
|
|
|
export function subscribeCache(key: string, listener: () => void) {
|
|
let keyListeners = listeners.get(key)
|
|
if (!keyListeners) {
|
|
keyListeners = new Set()
|
|
listeners.set(key, keyListeners)
|
|
}
|
|
keyListeners.add(listener)
|
|
|
|
return () => {
|
|
keyListeners.delete(listener)
|
|
if (keyListeners.size === 0) {
|
|
listeners.delete(key)
|
|
}
|
|
}
|
|
}
|
|
|
|
export function subscribeCacheLoaded(listener: () => void) {
|
|
loadListeners.add(listener)
|
|
return () => {
|
|
loadListeners.delete(listener)
|
|
}
|
|
}
|