@playfast/reform 1.1.1 → 1.2.1

package/src/remote/pendingQueue.ts

@@ -0,0 +1,145 @@
+import { Equal, MutableRef, Option } from 'effect'
+import { inspectable } from '../internal/inspect'
+import type { Scheduler } from '../internal/scheduler'
+import type { Store } from '../internal/store'
+import type { PendingIntent } from './remoteStateTypes'
+
+export interface PendingNode<I> {
+  readonly entry: MutableRef.MutableRef<PendingIntent<I>>
+}
+
+// Duplicate opIds retain every node so indexed updates preserve the old map semantics.
+export interface PendingOpEntry<I> {
+  readonly nodes: Set<PendingNode<I>>
+}
+
+export interface PendingQueue<I> {
+  readonly store: Store<ReadonlyArray<PendingIntent<I>>>
+  readonly revision: () => number
+  readonly fold: <B>(initial: B, combine: (accumulator: B, entry: PendingIntent<I>) => B) => B
+  readonly append: (entry: PendingIntent<I>) => void
+  readonly ack: (opId: string) => void
+  readonly settle: (opId: string) => void
+}
+
+export const makePendingQueue = <I>(scheduler: Scheduler): PendingQueue<I> => {
+  // Set insertion order preserves dispatch/apply order while allowing O(1) updates.
+  const ordered = new Set<PendingNode<I>>()
+  const byOpId = new Map<string, PendingOpEntry<I>>()
+  const listeners = new Set<() => void>()
+  const revision = MutableRef.make(0)
+  const initial: ReadonlyArray<PendingIntent<I>> = []
+  const snapshot = MutableRef.make<Option.Option<ReadonlyArray<PendingIntent<I>>>>(
+    Option.some(initial),
+  )
+
+  const materialize = (): ReadonlyArray<PendingIntent<I>> => {
+    const cached = MutableRef.get(snapshot)
+    if (Option.isSome(cached)) {
+      return cached.value
+    }
+    const current = Array.from(ordered, (node) => MutableRef.get(node.entry))
+    MutableRef.set(snapshot, Option.some(current))
+    return current
+  }
+
+  const announce = (next: Option.Option<ReadonlyArray<PendingIntent<I>>>): void => {
+    MutableRef.set(snapshot, next)
+    MutableRef.update(revision, (current) => current + 1)
+    scheduler.schedule(listeners)
+  }
+
+  const link = (entry: PendingIntent<I>): void => {
+    const node: PendingNode<I> = {
+      entry: MutableRef.make(entry),
+    }
+    ordered.add(node)
+    const indexed = byOpId.get(entry.opId)
+    if (indexed === undefined) {
+      byOpId.set(entry.opId, { nodes: new Set([node]) })
+    } else {
+      indexed.nodes.add(node)
+    }
+  }
+
+  const clear = (): void => {
+    ordered.clear()
+    byOpId.clear()
+  }
+
+  const fold = <B>(initialValue: B, combine: (accumulator: B, entry: PendingIntent<I>) => B): B => {
+    const folded = MutableRef.make(initialValue)
+    ordered.forEach((node) => {
+      MutableRef.update(folded, (accumulator) => combine(accumulator, MutableRef.get(node.entry)))
+    })
+    return MutableRef.get(folded)
+  }
+
+  const append = (entry: PendingIntent<I>): void => {
+    link(entry)
+    announce(Option.none())
+  }
+
+  const ack = (opId: string): void => {
+    const indexed = byOpId.get(opId)
+    if (indexed === undefined) {
+      return
+    }
+    const stillSending = MutableRef.make(false)
+    indexed.nodes.forEach((node) => {
+      if (MutableRef.get(node.entry).status === 'sending') {
+        MutableRef.set(stillSending, true)
+      }
+    })
+    if (!MutableRef.get(stillSending)) {
+      return
+    }
+    // Rebuild every duplicate once one is sending, matching the former array map.
+    indexed.nodes.forEach((node) => {
+      MutableRef.update(node.entry, (entry) => ({ ...entry, status: 'confirmed' as const }))
+    })
+    announce(Option.none())
+  }
+
+  const settle = (opId: string): void => {
+    const indexed = byOpId.get(opId)
+    if (indexed === undefined) {
+      return
+    }
+    indexed.nodes.forEach((node) => {
+      ordered.delete(node)
+    })
+    byOpId.delete(opId)
+    announce(Option.none())
+  }
+
+  const store: Store<ReadonlyArray<PendingIntent<I>>> = {
+    get: materialize,
+    getSnapshot: materialize,
+    getVersion: () => MutableRef.get(revision),
+    set: (next) => {
+      if (Equal.equals(materialize(), next)) {
+        return
+      }
+      clear()
+      next.forEach(link)
+      announce(Option.some(next))
+    },
+    subscribe: (listener) => {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+    ...inspectable(() => ({ _id: 'reform/Store', value: materialize() })),
+  }
+
+  return {
+    store,
+    revision: () => MutableRef.get(revision),
+    fold,
+    append,
+    ack,
+    settle,
+  }
+}