Function createPersistenceQueue

src/renderer/src/stores/persistenceQueue.ts:65–177

(
  persistFn: (key: TKey, data: TData) => Promise<void>,
  options: QueueOptions<TData> = {}
)

}

export function createPersistenceQueue<TKey extends string, TData>(
  persistFn: (key: TKey, data: TData) => Promise<void>,
  options: QueueOptions<TData> = {}
): PersistenceQueue<TKey, TData> {
  const {
    debounceMs = 300,
    maxDelayMs = 2000,
    maxRetries = 3,
    initialRetryDelay = 1000,
    mergePending
  } = options

  const pending = new Map<TKey, WriteTask<TData>>()
  const timers = new Map<TKey, ReturnType<typeof setTimeout>>()
  const firstQueueTime = new Map<TKey, number>()
  const writing = new Map<TKey, Promise<void>>()

  function enqueue(key: TKey, data: TData): void {
    const now = Date.now()
    const current = pending.get(key)
    const mergedData = current && mergePending ? mergePending(current.data, data) : data
    pending.set(key, { data: mergedData, timestamp: current?.timestamp ?? now })

    if (!firstQueueTime.has(key)) {
      firstQueueTime.set(key, now)
    }

    const existingTimer = timers.get(key)
    if (existingTimer) {
      clearTimeout(existingTimer)
    }

    const firstTime = firstQueueTime.get(key) ?? now
    const elapsed = now - firstTime

    if (elapsed >= maxDelayMs) {
      void flush(key)
    } else {
      const delay = Math.min(debounceMs, maxDelayMs - elapsed)
      const timer = setTimeout(() => {
        void flush(key)
      }, delay)
      timers.set(key, timer)
    }
  }

  async function flush(key: TKey): Promise<void> {
    const timer = timers.get(key)
    if (timer) {
      clearTimeout(timer)
      timers.delete(key)
    }

    const inflight = writing.get(key)
    if (inflight) {
      await inflight
    }