cross-tab-worker-databus 0.20.71 → 0.20.86

package/dist/centrifuge.worker.js

@@ -5003,50 +5003,140 @@ function parseDataBusPublication(value, fallbackTopic) {
   };
 }
 
+// src/utils/constants.ts
+var WORKER_STATUS = {
+  CONNECTING: "connecting",
+  CONNECTED: "connected",
+  DISCONNECTED: "disconnected",
+  ERROR: "error"
+};
+var DEFAULT_STORAGE_PREFIX = "cross-tab-worker-databus";
+var STORAGE_CHANNEL_PREFIX = `${DEFAULT_STORAGE_PREFIX}:channel:`;
+var TAB_ID_STORAGE_KEY = `${DEFAULT_STORAGE_PREFIX}:tab-id`;
+var CENTRIFUGE_INPUT_TYPE = {
+  INIT: "INIT",
+  SUBSCRIBE: "SUBSCRIBE",
+  UNSUBSCRIBE: "UNSUBSCRIBE",
+  PUBLISH: "PUBLISH",
+  PUBLISH_BIN: "PUBLISH_BIN",
+  PING: "PING",
+  STOP: "STOP",
+  TOKEN_RESPONSE: "TOKEN_RESPONSE",
+  TOKEN_ERROR: "TOKEN_ERROR"
+};
+var CENTRIFUGE_OUTPUT_TYPE = {
+  STATUS: "STATUS",
+  MESSAGE: "MESSAGE",
+  MESSAGE_BIN: "MESSAGE_BIN",
+  ERROR: "ERROR",
+  TOKEN_REQUEST: "TOKEN_REQUEST"
+};
+
+// src/utils/metadata.ts
+function publicationMetadata(messageId, timestamp) {
+  if (messageId === void 0 && timestamp === void 0) return void 0;
+  return {
+    ...messageId === void 0 ? {} : { messageId },
+    ...timestamp === void 0 ? {} : { timestamp }
+  };
+}
+
+// src/utils/error-utils.ts
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      ...error.stack ? { stack: error.stack } : {}
+    };
+  }
+  const context = error === void 0 ? void 0 : error;
+  return {
+    name: "CentrifugeError",
+    message: typeof error === "string" ? error : "Centrifuge worker operation failed.",
+    ...context === void 0 || !isStructuredCloneable(context) ? {} : { context }
+  };
+}
+function isStructuredCloneable(value) {
+  if (typeof structuredClone !== "function") return true;
+  try {
+    structuredClone(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deserializeWorkerError(error) {
+  const result = new Error(error.message);
+  result.name = error.name;
+  if (error.stack) result.stack = error.stack;
+  if (error.context !== void 0) Object.assign(result, { context: error.context });
+  return result;
+}
+
 // src/centrifuge-session.ts
 var CentrifugeSession = class {
   constructor(sink) {
     this.sink = sink;
   }
+  sink;
   client = null;
   subscriptions = /* @__PURE__ */ new Map();
   transferable = false;
+  tokenBridge = false;
+  nextRequestId = 1;
+  pendingTokenRequests = /* @__PURE__ */ new Map();
   /** Dispatch an incoming Worker message to the matching operation.
    * Unknown message types are ignored rather than thrown, so a future protocol
    * extension adding a new variant cannot crash an older session. */
   handle(message) {
     switch (message.type) {
-      case "INIT":
-        this.initialize(message.url, message.config, message.transferable === true);
+      case CENTRIFUGE_INPUT_TYPE.INIT:
+        this.initialize(message.url, message.config, message.transferable === true, message.tokenBridge === true);
         return;
-      case "SUBSCRIBE":
+      case CENTRIFUGE_INPUT_TYPE.SUBSCRIBE:
         this.subscribe(message.topic);
         return;
-      case "UNSUBSCRIBE":
+      case CENTRIFUGE_INPUT_TYPE.UNSUBSCRIBE:
         this.unsubscribe(message.topic);
         return;
-      case "PUBLISH":
-      case "PUBLISH_BIN":
+      case CENTRIFUGE_INPUT_TYPE.PUBLISH:
+      case CENTRIFUGE_INPUT_TYPE.PUBLISH_BIN:
         this.publish(message.topic, message.data, message.messageId, message.timestamp);
         return;
-      case "STOP":
+      case CENTRIFUGE_INPUT_TYPE.STOP:
         this.stop();
         return;
+      case CENTRIFUGE_INPUT_TYPE.TOKEN_RESPONSE:
+        this.resolveToken(message.requestId, message.token);
+        return;
+      case CENTRIFUGE_INPUT_TYPE.TOKEN_ERROR:
+        this.rejectToken(message.requestId, deserializeWorkerError(message.error));
+        return;
       default:
         return;
     }
   }
   /** Create the Centrifuge client, wire up lifecycle listeners, and connect. */
-  initialize(url, config, transferable) {
+  initialize(url, config, transferable, tokenBridge) {
     if (this.client) return;
     this.transferable = transferable;
-    const client = new Centrifuge(url, config);
+    this.tokenBridge = tokenBridge;
+    const clientOptions = tokenBridge ? {
+      ...config,
+      // Route credential fetches back to the main thread, where the
+      // application's credentialProvider lives (config must stay
+      // structured-cloneable, so functions cannot cross the boundary).
+      getToken: () => this.requestToken("token"),
+      getChannelToken: (channel) => this.requestToken("channelToken", channel)
+    } : config;
+    const client = new Centrifuge(url, clientOptions);
     this.client = client;
     client.on("state", (context) => {
-      this.post({ type: "STATUS", status: normalizeStatus(context.newState) });
+      this.post({ type: CENTRIFUGE_OUTPUT_TYPE.STATUS, status: normalizeStatus(context.newState) });
     });
-    client.on("connected", () => this.post({ type: "STATUS", status: "connected" }));
-    client.on("disconnected", () => this.post({ type: "STATUS", status: "disconnected" }));
+    client.on("connected", () => this.post({ type: CENTRIFUGE_OUTPUT_TYPE.STATUS, status: WORKER_STATUS.CONNECTED }));
+    client.on("disconnected", () => this.post({ type: CENTRIFUGE_OUTPUT_TYPE.STATUS, status: WORKER_STATUS.DISCONNECTED }));
     client.on("error", (context) => this.postError(context));
     client.on("publication", (context) => {
       const topic = context.channel || getPayloadTopic(context.data);
@@ -5109,25 +5199,56 @@ var CentrifugeSession = class {
   postPublication(topic, data) {
     if (!topic) return;
     if (this.transferable && data instanceof ArrayBuffer) {
-      this.post({ type: "MESSAGE_BIN", topic, data }, [data]);
+      this.post({ type: CENTRIFUGE_OUTPUT_TYPE.MESSAGE_BIN, topic, data }, [data]);
       return;
     }
     const publication = parseDataBusPublication(data, topic);
     if (!publication) return;
     this.post({
-      type: "MESSAGE",
+      type: CENTRIFUGE_OUTPUT_TYPE.MESSAGE,
       topic: publication.topic,
       data: publication.data,
-      ...publication.messageId === void 0 ? {} : { messageId: publication.messageId },
-      ...publication.timestamp === void 0 ? {} : { timestamp: publication.timestamp }
+      ...publicationMetadata(publication.messageId, publication.timestamp)
     });
   }
   /** Disconnect the client and clear all subscriptions. */
   stop() {
+    for (const [, pending] of this.pendingTokenRequests) {
+      pending.reject(new Error("Centrifuge session stopped before the credential was resolved."));
+    }
+    this.pendingTokenRequests.clear();
     this.client?.disconnect();
     this.subscriptions.clear();
     this.client = null;
-    this.post({ type: "STATUS", status: "disconnected" });
+    this.post({ type: CENTRIFUGE_OUTPUT_TYPE.STATUS, status: WORKER_STATUS.DISCONNECTED });
+  }
+  /** Issue a credential request to the main thread and await the response.
+   * Used as Centrifuge's `getToken` / `getChannelToken` when token bridging is
+   * enabled; resolved or rejected by a matching TOKEN_RESPONSE / TOKEN_ERROR. */
+  requestToken(kind, channel) {
+    const requestId = this.nextRequestId;
+    this.nextRequestId += 1;
+    return new Promise((resolve, reject) => {
+      this.pendingTokenRequests.set(requestId, { resolve, reject });
+      this.post({
+        type: CENTRIFUGE_OUTPUT_TYPE.TOKEN_REQUEST,
+        requestId,
+        kind,
+        ...channel === void 0 ? {} : { channel }
+      });
+    });
+  }
+  resolveToken(requestId, token) {
+    const pending = this.pendingTokenRequests.get(requestId);
+    if (!pending) return;
+    this.pendingTokenRequests.delete(requestId);
+    pending.resolve(token);
+  }
+  rejectToken(requestId, error) {
+    const pending = this.pendingTokenRequests.get(requestId);
+    if (!pending) return;
+    this.pendingTokenRequests.delete(requestId);
+    pending.reject(error);
   }
   /** Forward a message to the sink (the transport layer). */
   post(message, transfer) {
@@ -5139,7 +5260,7 @@ var CentrifugeSession = class {
    * Fatal errors are distinguished by the client eventually emitting
    * `disconnected` without a subsequent `connected`. */
   postError(error) {
-    this.post({ type: "ERROR", error: serializeError(error) });
+    this.post({ type: CENTRIFUGE_OUTPUT_TYPE.ERROR, error: serializeError(error) });
   }
 };
 function getPayloadTopic(data) {
@@ -5150,24 +5271,10 @@ function getPayloadTopic(data) {
   const topic = nested ?? payload.channel;
   return typeof topic === "string" ? topic : "";
 }
-var LIVE_STATES = /* @__PURE__ */ new Set(["connecting", "connected"]);
+var LIVE_STATES = /* @__PURE__ */ new Set([WORKER_STATUS.CONNECTING, WORKER_STATUS.CONNECTED]);
 function normalizeStatus(status) {
   return LIVE_STATES.has(status) ? status : "disconnected";
 }
-function serializeError(error) {
-  if (error instanceof Error) {
-    return {
-      name: error.name,
-      message: error.message,
-      ...error.stack ? { stack: error.stack } : {}
-    };
-  }
-  return {
-    name: "CentrifugeError",
-    message: typeof error === "string" ? error : "Centrifuge worker operation failed.",
-    ...error === void 0 ? {} : { context: error }
-  };
-}
 
 // src/workers/centrifuge.worker.ts
 var workerScope = self;