experimental-a2 0.16.1 → 0.17.0

package/src/bootstrap-stream.ts

@@ -0,0 +1,72 @@
+import type { Event } from './store.ts'
+import type { PresencePatch, PresenceSnapshot } from './contract.ts'
+import type { StateSnapshotFrame } from './wire.ts'
+import { createStreamActivity, streamActivities } from './stream-activity.ts'
+import { bufferedEvents, takeBuffered } from './stream-buffer.ts'
+
+type StreamItem = Event | PresencePatch | PresenceSnapshot
+
+export function bootstrapStream(options: {
+  snapshot(): Promise<StateSnapshotFrame>
+  stream(index: number): AsyncIterable<StreamItem>
+}): AsyncIterable<StreamItem | StateSnapshotFrame> {
+  return {
+    [Symbol.asyncIterator]() {
+      let closed = false
+      let index: number | undefined
+      let source: AsyncIterator<StreamItem> | undefined
+      let stopActivity: (() => void) | undefined
+      const abort = new AbortController()
+      const activity = createStreamActivity(() => {
+        if (source) streamActivities.get(source)?.activate()
+      })
+      const iterator: AsyncIterator<StreamItem | StateSnapshotFrame> = {
+        async next() {
+          if (closed) return { done: true, value: undefined }
+          if (index === undefined) {
+            let cancel: (() => void) | undefined
+            const cancelled = new Promise<undefined>((resolve) => {
+              cancel = () => resolve(undefined)
+              abort.signal.addEventListener('abort', cancel, { once: true })
+            })
+            try {
+              const snapshot = await Promise.race([
+                options.snapshot(),
+                cancelled,
+              ])
+              if (closed || snapshot === undefined)
+                return { done: true, value: undefined }
+              index = snapshot.index
+              return { done: false, value: snapshot }
+            } finally {
+              if (cancel) abort.signal.removeEventListener('abort', cancel)
+            }
+          }
+          if (!source) {
+            source = options.stream(index)[Symbol.asyncIterator]()
+            const sourceActivity = streamActivities.get(source)
+            if (sourceActivity) {
+              activity.setIdle(sourceActivity.idle)
+              stopActivity = sourceActivity.subscribe(activity.setIdle)
+            }
+          }
+          const result = await source.next()
+          return closed ? { done: true, value: undefined } : result
+        },
+        async return() {
+          if (closed) return { done: true, value: undefined }
+          closed = true
+          abort.abort()
+          stopActivity?.()
+          await source?.return?.()
+          return { done: true, value: undefined }
+        },
+      }
+      streamActivities.set(iterator, activity)
+      bufferedEvents.set(iterator, () =>
+        closed || !source ? undefined : takeBuffered(source),
+      )
+      return iterator
+    },
+  }
+}

package/src/bounded-cache.ts

@@ -0,0 +1,55 @@
+/**
+ * A least-recently-used map bounded by entry count and total bytes. Callers
+ * give each value's size; a value larger than a quarter of the byte budget
+ * is not stored. Eviction happens only on insert, so an idle cache does no
+ * work and holds no timers.
+ */
+export type BoundedCache<K, V> = {
+  get(key: K): V | undefined
+  set(key: K, value: V, bytes: number): void
+  delete(key: K): void
+  /** Remove every entry whose key matches; a scan, for rare invalidations. */
+  deleteWhere(match: (key: K) => boolean): void
+}
+
+export function boundedCache<K, V>({
+  maxEntries,
+  maxBytes,
+}: {
+  maxEntries: number
+  maxBytes: number
+}): BoundedCache<K, V> {
+  const entries = new Map<K, { value: V; bytes: number }>()
+  let total = 0
+
+  const remove = (key: K): void => {
+    const entry = entries.get(key)
+    if (!entry) return
+    entries.delete(key)
+    total -= entry.bytes
+  }
+
+  return {
+    get(key) {
+      const entry = entries.get(key)
+      if (!entry) return undefined
+      entries.delete(key)
+      entries.set(key, entry)
+      return entry.value
+    },
+    set(key, value, bytes) {
+      remove(key)
+      if (bytes > maxBytes / 4) return
+      entries.set(key, { value, bytes })
+      total += bytes
+      for (const oldest of entries.keys()) {
+        if (entries.size <= maxEntries && total <= maxBytes) break
+        remove(oldest)
+      }
+    },
+    delete: remove,
+    deleteWhere(match) {
+      for (const key of entries.keys()) if (match(key)) remove(key)
+    },
+  }
+}

package/src/client-render-session.ts

@@ -0,0 +1,49 @@
+import type { A2Client, SessionClient, SessionOptions } from './client.ts'
+import type { EventDefs, PresenceDefs } from './contract.ts'
+
+type Factory = (sessionId: string, options: unknown) => unknown
+type ClientReact = {
+  factory: Factory
+  resolveInitial(options: {
+    session: object
+    source: object
+    value: unknown
+  }): void
+}
+const factories = new WeakMap<object, ClientReact>()
+
+export function registerRenderSessionFactory(options: {
+  client: object
+  factory: Factory
+  resolveInitial: ClientReact['resolveInitial']
+}): void {
+  factories.set(options.client, options)
+}
+
+export function resolveInitialForReact(options: {
+  client: object
+  session: object
+  source: object
+  value: unknown
+}): void {
+  factories.get(options.client)?.resolveInitial(options)
+}
+
+export function createRenderSession<
+  D extends EventDefs,
+  S,
+  P extends PresenceDefs,
+>(options: {
+  client: A2Client<D, S, P>
+  sessionId: string
+  settings: SessionOptions<D, S>
+}): SessionClient<D, S, P> {
+  const factory = factories.get(options.client)
+  if (!factory)
+    throw new TypeError('React requires a client returned by createClient')
+  return factory.factory(options.sessionId, options.settings) as SessionClient<
+    D,
+    S,
+    P
+  >
+}