cross-tab-worker-databus 0.20.71 → 0.20.85

package/dist/centrifuge.js

@@ -1,54 +1,119 @@
 import {
   CrossTabDataBus,
+  assertHeartbeatInterval,
+  assertStructuredCloneable,
   parseDataBusPublication,
+  publicationMetadata,
   selectWorkerBackend
-} from "./chunk-D2SIT473.js";
+} from "./chunk-PW63EWIK.js";
+import {
+  CENTRIFUGE_INPUT_TYPE,
+  CENTRIFUGE_OUTPUT_TYPE,
+  DEFAULT_STORAGE_PREFIX,
+  WORKER_BACKEND,
+  WORKER_MODE,
+  WORKER_STATUS
+} from "./chunk-TZ7ZP7YD.js";
 
 // src/centrifuge-session.ts
 import { Centrifuge } from "centrifuge";
+
+// 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);
@@ -111,25 +176,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) {
@@ -141,7 +237,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) {
@@ -152,24 +248,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/centrifuge-protocol.ts
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -184,6 +266,7 @@ var CentrifugeWorkerTransport = class {
   heartbeatIntervalMs;
   workerFactory;
   sharedWorkerFactory;
+  credentialProvider;
   backend = null;
   worker = null;
   sharedWorker = null;
@@ -201,12 +284,13 @@ var CentrifugeWorkerTransport = class {
     return this.backend ?? "uninitialized";
   }
   constructor(options = {}) {
-    this.workerMode = options.workerMode ?? "dedicated";
+    this.workerMode = options.workerMode ?? WORKER_MODE.DEDICATED;
     this.transferable = options.transferable ?? false;
     this.heartbeatIntervalMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
     assertHeartbeatInterval(this.heartbeatIntervalMs);
     this.workerFactory = options.workerFactory;
     this.sharedWorkerFactory = options.sharedWorkerFactory;
+    this.credentialProvider = options.credentialProvider;
   }
   /**
    * Start the transport: select a backend, initialise the Worker (or local
@@ -217,29 +301,29 @@ var CentrifugeWorkerTransport = class {
     assertStructuredCloneable(config.options ?? {});
     this.handlers = handlers;
     const backend = selectWorkerBackend(this.workerMode, {
-      worker: this.workerFactory !== void 0,
-      sharedWorker: this.sharedWorkerFactory !== void 0
+      worker: this.workerFactory !== void 0 || typeof Worker !== "undefined",
+      sharedWorker: this.sharedWorkerFactory !== void 0 || typeof SharedWorker !== "undefined"
     });
     const input = this.buildInitInput(config);
-    if (backend === "shared") {
+    if (backend === WORKER_BACKEND.SHARED) {
       this.startSharedWorker(input);
-      this.backend = "shared";
+      this.backend = WORKER_BACKEND.SHARED;
       return;
     }
-    if (backend === "dedicated") {
+    if (backend === WORKER_BACKEND.DEDICATED) {
       this.startDedicatedWorker(input);
-      this.backend = "dedicated";
+      this.backend = WORKER_BACKEND.DEDICATED;
       return;
     }
     this.localSession = new CentrifugeSession({ post: this.handleSessionOutput });
     this.localSession.handle(input);
-    this.backend = "local";
+    this.backend = WORKER_BACKEND.LOCAL;
   }
   subscribe(topic) {
-    this.post({ type: "SUBSCRIBE", topic });
+    this.post({ type: CENTRIFUGE_INPUT_TYPE.SUBSCRIBE, topic });
   }
   unsubscribe(topic) {
-    this.post({ type: "UNSUBSCRIBE", topic });
+    this.post({ type: CENTRIFUGE_INPUT_TYPE.UNSUBSCRIBE, topic });
   }
   /**
    * Publish data to `topic`. Binary data (ArrayBuffer) is sent via Transferable
@@ -247,10 +331,10 @@ var CentrifugeWorkerTransport = class {
    */
   publish(topic, data, options) {
     if (this.transferable && data instanceof ArrayBuffer) {
-      this.post({ type: "PUBLISH_BIN", topic, data, ...publicationMetadata(options) }, [data]);
+      this.post({ type: CENTRIFUGE_INPUT_TYPE.PUBLISH_BIN, topic, data, ...publicationMetadata(options?.messageId, options?.timestamp) }, [data]);
       return;
     }
-    this.post({ type: "PUBLISH", topic, data, ...publicationMetadata(options) });
+    this.post({ type: CENTRIFUGE_INPUT_TYPE.PUBLISH, topic, data, ...publicationMetadata(options?.messageId, options?.timestamp) });
   }
   /**
    * Gracefully stop the transport: send STOP, clean up event listeners, and
@@ -259,7 +343,7 @@ var CentrifugeWorkerTransport = class {
   stop() {
     if (!this.backend) return;
     this.generation++;
-    this.post({ type: "STOP" });
+    this.post({ type: CENTRIFUGE_INPUT_TYPE.STOP });
     this.clearHeartbeat();
     if (this.worker) {
       this.worker.removeEventListener("message", this.handleMessage);
@@ -278,10 +362,11 @@ var CentrifugeWorkerTransport = class {
    * default-resolution logic kicks in for the common case. */
   buildInitInput(config) {
     return {
-      type: "INIT",
+      type: CENTRIFUGE_INPUT_TYPE.INIT,
       url: config.url,
       config: config.options ?? {},
       ...this.transferable ? { transferable: true } : {},
+      ...this.credentialProvider ? { tokenBridge: true } : {},
       ...this.heartbeatIntervalMs !== DEFAULT_HEARTBEAT_INTERVAL_MS ? { heartbeatIntervalMs: this.heartbeatIntervalMs } : {}
     };
   }
@@ -320,10 +405,34 @@ var CentrifugeWorkerTransport = class {
    * Shared by the Worker message listener, the SharedWorker port listener,
    * and the local-session sink — all three feed into this single dispatcher. */
   handleOutput(message) {
-    if (message.type === "STATUS") this.handlers?.onStatus(message.status);
-    if (message.type === "MESSAGE") this.handlers?.onMessage({ topic: message.topic, data: message.data, ...publicationMetadata(message) });
-    if (message.type === "MESSAGE_BIN") this.handlers?.onMessage({ topic: message.topic, data: message.data, ...publicationMetadata(message) });
-    if (message.type === "ERROR") this.handlers?.onError(deserializeWorkerError(message.error));
+    if (message.type === CENTRIFUGE_OUTPUT_TYPE.STATUS) this.handlers?.onStatus(message.status);
+    if (message.type === CENTRIFUGE_OUTPUT_TYPE.MESSAGE) this.handlers?.onMessage({ topic: message.topic, data: message.data, ...publicationMetadata(message.messageId, message.timestamp) });
+    if (message.type === CENTRIFUGE_OUTPUT_TYPE.MESSAGE_BIN) this.handlers?.onMessage({ topic: message.topic, data: message.data, ...publicationMetadata(message.messageId, message.timestamp) });
+    if (message.type === CENTRIFUGE_OUTPUT_TYPE.ERROR) this.handlers?.onError(deserializeWorkerError(message.error));
+    if (message.type === CENTRIFUGE_OUTPUT_TYPE.TOKEN_REQUEST) this.resolveTokenRequest(message.requestId, message.kind, message.channel);
+  }
+  /** Resolve a Worker credential request from the main thread: call the
+   * credentialProvider, then post the fresh token (or a serialized failure)
+   * back to the session that issued the request. */
+  resolveTokenRequest(requestId, kind, channel) {
+    const provider = this.credentialProvider;
+    const value = kind === "channelToken" && provider?.getChannelToken ? provider.getChannelToken(channel ?? "") : provider?.getToken?.();
+    Promise.resolve(value).then(
+      (token) => {
+        if (typeof token !== "string" || token.length === 0) {
+          this.post({
+            type: CENTRIFUGE_INPUT_TYPE.TOKEN_ERROR,
+            requestId,
+            error: serializeError(new Error(`The credential provider returned no ${kind}.`))
+          });
+          return;
+        }
+        this.post({ type: CENTRIFUGE_INPUT_TYPE.TOKEN_RESPONSE, requestId, token });
+      },
+      (error) => {
+        this.post({ type: CENTRIFUGE_INPUT_TYPE.TOKEN_ERROR, requestId, error: serializeError(error) });
+      }
+    );
   }
   /** Handle a Worker-level failure (crash, message decode error). Discards the
    * dead backend so a later start()/reopen can rebuild from scratch, and
@@ -339,7 +448,7 @@ var CentrifugeWorkerTransport = class {
     this.clearHeartbeat();
     this.resetBackend();
     this.handlers?.onError(new Error(message));
-    this.handlers?.onStatus("error");
+    this.handlers?.onStatus(WORKER_STATUS.ERROR);
   }
   /** Remove every listener attached to the current SharedWorker and its port. */
   detachSharedWorkerListeners() {
@@ -352,7 +461,7 @@ var CentrifugeWorkerTransport = class {
     if (this.heartbeatHandle !== null) return;
     if (this.heartbeatIntervalMs === Infinity) return;
     this.heartbeatHandle = setInterval(() => {
-      this.post({ type: "PING" });
+      this.post({ type: CENTRIFUGE_INPUT_TYPE.PING });
     }, this.heartbeatIntervalMs);
   }
   clearHeartbeat() {
@@ -403,6 +512,7 @@ function createCentrifugeDataBus(options) {
   const {
     clusterKey,
     connection,
+    credentialProvider,
     heartbeatIntervalMs,
     sharedWorkerFactory,
     transferable,
@@ -420,7 +530,8 @@ function createCentrifugeDataBus(options) {
       ...sharedWorkerFactory ? { sharedWorkerFactory } : {},
       ...transferable === void 0 ? {} : { transferable },
       ...workerMode ? { workerMode } : {},
-      ...heartbeatIntervalMs === void 0 ? {} : { heartbeatIntervalMs }
+      ...heartbeatIntervalMs === void 0 ? {} : { heartbeatIntervalMs },
+      ...credentialProvider ? { credentialProvider } : {}
     })
   });
 }
@@ -437,7 +548,7 @@ function createDefaultWorker() {
     );
   }
   return new Worker(workerUrl, {
-    name: "cross-tab-worker-databus",
+    name: DEFAULT_STORAGE_PREFIX,
     type: "module"
   });
 }
@@ -454,45 +565,14 @@ function createDefaultSharedWorker() {
     );
   }
   return new SharedWorker(workerUrl, {
-    name: "cross-tab-worker-databus-shared",
+    name: `${DEFAULT_STORAGE_PREFIX}-shared`,
     type: "module"
   });
 }
-function assertHeartbeatInterval(value) {
-  if (value === Infinity) return;
-  if (typeof value === "number" && Number.isFinite(value) && value > 0) return;
-  throw new TypeError(
-    `Centrifuge heartbeatIntervalMs must be a positive number or Infinity, got ${String(value)}.`
-  );
-}
-function assertStructuredCloneable(value) {
-  if (typeof structuredClone !== "function") return;
-  try {
-    structuredClone(value);
-  } catch (error) {
-    throw new TypeError(
-      "Centrifuge Worker configuration and published data must be structured-cloneable.",
-      { cause: error }
-    );
-  }
-}
 function postToPortLike(target, message, transfer) {
   if (transfer) target.postMessage(message, transfer);
   else target.postMessage(message);
 }
-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;
-}
-function publicationMetadata(metadata) {
-  return {
-    ...metadata?.messageId === void 0 ? {} : { messageId: metadata.messageId },
-    ...metadata?.timestamp === void 0 ? {} : { timestamp: metadata.timestamp }
-  };
-}
 export {
   CentrifugeWorkerTransport,
   createCentrifugeDataBus