cross-tab-worker-databus 0.4.0 → 0.5.0

package/dist/cjs/index.cjs

@@ -25,6 +25,7 @@ __export(src_exports, {
   WebSocketTransport: () => WebSocketTransport,
   WorkerClusterRuntime: () => WorkerClusterRuntime,
   createBrowserEnvironment: () => createBrowserEnvironment,
+  createIndexedDbReplayPersistence: () => createIndexedDbReplayPersistence,
   createOpaqueKey: () => createOpaqueKey,
   createWebSocketDataBus: () => createWebSocketDataBus,
   getOrCreateTabId: () => getOrCreateTabId,
@@ -1225,6 +1226,8 @@ var CrossTabDataBus = class _CrossTabDataBus {
   // replay is enabled — buffering is opt-in and must cost nothing otherwise.
   replayBuffers;
   replayMaxPerTopic;
+  replayPersistence;
+  replayHydration;
   initialConfig;
   hasInitialConfig;
   trace;
@@ -1264,6 +1267,8 @@ var CrossTabDataBus = class _CrossTabDataBus {
     }
     this.replayMaxPerTopic = replay?.maxPerTopic ?? DEFAULT_REPLAY_MAX_PER_TOPIC;
     this.replayBuffers = replay ? /* @__PURE__ */ new Map() : null;
+    this.replayPersistence = replay?.persistence ?? null;
+    this.replayHydration = this.hydrateReplay();
     const { autoStart, initialConfig, trace, transport, ...clusterOptions } = options;
     this.transport = transport;
     this.initialConfig = initialConfig;
@@ -1432,7 +1437,13 @@ var CrossTabDataBus = class _CrossTabDataBus {
         typeof options.replay === "number" ? Math.floor(options.replay) : this.replayMaxPerTopic,
         this.replayMaxPerTopic
       );
-      this.deliverReplay(topic, limit, handler);
+      if (this.replayPersistence) {
+        void this.replayHydration.then(() => {
+          if (this.topicHandlers.get(topic)?.has(handler)) this.deliverReplay(topic, limit, handler);
+        });
+      } else {
+        this.deliverReplay(topic, limit, handler);
+      }
     }
     return () => this.unsubscribe(topic, handler);
   }
@@ -1556,6 +1567,27 @@ var CrossTabDataBus = class _CrossTabDataBus {
     }
     buffer.push(message);
     if (buffer.length > this.replayMaxPerTopic) buffer.shift();
+    if (this.replayPersistence) {
+      void this.replayPersistence.append(message).catch((error) => this.reportError(error));
+    }
+  }
+  async hydrateReplay() {
+    if (!this.replayBuffers || !this.replayPersistence) {
+      return;
+    }
+    try {
+      for (const message of await this.replayPersistence.load()) {
+        let buffer = this.replayBuffers.get(message.topic);
+        if (!buffer) {
+          buffer = [];
+          this.replayBuffers.set(message.topic, buffer);
+        }
+        buffer.push(message);
+        if (buffer.length > this.replayMaxPerTopic) buffer.shift();
+      }
+    } catch (error) {
+      this.reportError(error);
+    }
   }
   /** Deliver buffered history to a newly-registered handler. For an exact
    * topic this is that topic's ring; for a wildcard subscription every
@@ -1750,6 +1782,54 @@ function formatRouteTrace(route) {
   return `${route.topicKey}@${route.workerId}|confirmed=${route.confirmedAt !== void 0}`;
 }
 
+// src/core/replay-persistence.ts
+function createIndexedDbReplayPersistence(options) {
+  const indexedDb = globalThis.indexedDB;
+  if (!indexedDb) throw new Error("IndexedDB is unavailable in this environment.");
+  const dbName = options.dbName ?? "cross-tab-worker-databus";
+  const storeName = "replay";
+  const maxPerTopic = options.maxPerTopic;
+  if (!Number.isSafeInteger(maxPerTopic) || maxPerTopic <= 0) {
+    throw new TypeError(`maxPerTopic must be a positive safe integer, got ${String(maxPerTopic)}.`);
+  }
+  let dbPromise = null;
+  const open = () => {
+    if (dbPromise) return dbPromise;
+    dbPromise = new Promise((resolve, reject) => {
+      const request = indexedDb.open(dbName, 1);
+      request.onupgradeneeded = () => request.result.createObjectStore(storeName, { keyPath: "topic" });
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error ?? new Error("Failed to open replay database."));
+    });
+    return dbPromise;
+  };
+  return {
+    async load() {
+      const db = await open();
+      return new Promise((resolve, reject) => {
+        const request = db.transaction(storeName, "readonly").objectStore(storeName).getAll();
+        request.onsuccess = () => resolve(request.result.flatMap((record) => record.messages));
+        request.onerror = () => reject(request.error ?? new Error("Failed to load replay history."));
+      });
+    },
+    async append(message) {
+      const db = await open();
+      await new Promise((resolve, reject) => {
+        const transaction = db.transaction(storeName, "readwrite");
+        const store = transaction.objectStore(storeName);
+        const request = store.get(message.topic);
+        request.onsuccess = () => {
+          const messages = (request.result?.messages ?? []).concat(message).slice(-maxPerTopic);
+          store.put({ topic: message.topic, messages });
+        };
+        request.onerror = () => reject(request.error ?? new Error("Failed to read replay history."));
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error ?? new Error("Failed to persist replay history."));
+      });
+    }
+  };
+}
+
 // src/websocket.ts
 var WS_OPEN = 1;
 var WebSocketTransport = class {