@broadcastingplatforms/sdk 0.0.0-dev.9cfcfc6

package/dist/realtime.mjs

@@ -0,0 +1,1021 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/errors.ts
+var SDKError = class extends Error {
+  /**
+   * Construct an SDKError. Signature is compatible with Error.
+   * You can pass in a message or an options object, as with the Error constructor.
+   * Additional fields (code, etc) may be added via the second argument.
+   */
+  constructor(message, details = {}) {
+    const resolvedMessage = message ?? (typeof details.message === "string" ? details.message : "Unknown error");
+    super(resolvedMessage);
+    /**
+     * Canonical SDK error code.
+     */
+    __publicField(this, "code");
+    /**
+     * HTTP status code if available.
+     */
+    __publicField(this, "statusCode");
+    /**
+     * End-user safe message.
+     */
+    __publicField(this, "userMessage");
+    /**
+     * Optional request metadata (null when unavailable).
+     */
+    __publicField(this, "request");
+    /**
+     * Optional response metadata (null when unavailable).
+     */
+    __publicField(this, "response");
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (details && typeof details === "object") {
+      for (const [key, value] of Object.entries(details)) {
+        if (!["name", "message", "stack"].includes(key)) {
+          this[key] = value;
+        }
+      }
+    }
+    this.name = "SDKError";
+    this.code = details.code ?? "unknown_error";
+    this.statusCode = typeof details.statusCode === "number" ? details.statusCode : void 0;
+    this.userMessage = typeof details.userMessage === "string" ? details.userMessage : this.message;
+    this.request = details.request ?? null;
+    this.response = details.response ?? null;
+  }
+  /**
+   * Serialize the error into a plain object, preserving extra fields.
+   */
+  toJSON() {
+    const extras = { ...this };
+    delete extras.code;
+    delete extras.statusCode;
+    delete extras.message;
+    delete extras.userMessage;
+    delete extras.request;
+    delete extras.response;
+    delete extras.form;
+    delete extras.cause;
+    return {
+      ...extras,
+      code: this.code,
+      statusCode: this.statusCode,
+      message: this.message,
+      userMessage: this.userMessage,
+      request: this.request,
+      response: this.response
+    };
+  }
+};
+var STATUS_CODE_DEFAULTS = {
+  401: {
+    code: "authentication_required",
+    message: "Authentication required",
+    userMessage: "Please log in to continue. Your session may have expired."
+  },
+  403: {
+    code: "permission_denied",
+    message: "Permission denied",
+    userMessage: "You do not have permission to perform this action."
+  },
+  404: {
+    code: "not_found",
+    message: "Resource not found",
+    userMessage: "The requested resource was not found."
+  },
+  422: {
+    code: "validation_failed",
+    message: "Validation failed",
+    userMessage: "The provided information is invalid. Please check your input and try again."
+  },
+  429: {
+    code: "rate_limited",
+    message: "Rate limit exceeded",
+    userMessage: "Too many requests. Please wait a moment and try again."
+  },
+  500: {
+    code: "server_error",
+    message: "Internal server error",
+    userMessage: "Something went wrong on our end. Please try again later."
+  }
+};
+var DEFAULT_ERROR = {
+  code: "unknown_error",
+  userMessage: "An unexpected error occurred. Please try again."
+};
+function createSdkError(message, details = {}) {
+  const statusCode = details.response?.status;
+  const statusValues = statusCode && STATUS_CODE_DEFAULTS[statusCode] ? STATUS_CODE_DEFAULTS[statusCode] : DEFAULT_ERROR;
+  const enrichedDetails = {
+    ...details,
+    statusCode,
+    code: details.code ?? statusValues.code,
+    userMessage: details.userMessage ?? statusValues.userMessage,
+    request: details.request ?? null,
+    response: details.response ?? null
+  };
+  return new SDKError(message, enrichedDetails);
+}
+
+// src/realtime.ts
+var resolvePusher = () => {
+  const injected = globalThis.__SDK_Pusher;
+  if (injected) {
+    return injected;
+  }
+  const globalPusher = globalThis.Pusher;
+  if (globalPusher) {
+    return globalPusher;
+  }
+  if (typeof __require === "function") {
+    try {
+      const module = __require("pusher-js");
+      return module.default ?? module;
+    } catch {
+    }
+  }
+  const dynamicImport = import("pusher-js");
+  return dynamicImport.then((module) => {
+    const resolvedModule = module;
+    return resolvedModule.default ?? module;
+  }).catch(() => {
+    throw createSdkError(
+      "Pusher constructor not found. Provide globalThis.__SDK_Pusher/globalThis.Pusher, or ensure pusher-js is resolvable from a CJS context (ESM runtimes must inject the global constructor)."
+    );
+  });
+};
+var isPromise = (value) => Boolean(value && typeof value.then === "function");
+var normalizeAuthEndpoint = (baseUrl, authEndpoint) => {
+  if (authEndpoint) {
+    return authEndpoint;
+  }
+  if (!baseUrl) {
+    return "/api/broadcasting/auth";
+  }
+  const trimmed = baseUrl.replace(/\/+$/, "");
+  if (trimmed.endsWith("/api")) {
+    return `${trimmed}/broadcasting/auth`;
+  }
+  return `${trimmed}/api/broadcasting/auth`;
+};
+var normalizePresenceMembers = (members) => {
+  if (!members) {
+    return [];
+  }
+  if (Array.isArray(members)) {
+    return members;
+  }
+  const memberRecord = members.members;
+  if (memberRecord && typeof memberRecord === "object") {
+    return Object.values(memberRecord);
+  }
+  if (typeof members === "object") {
+    return Object.values(members);
+  }
+  return [];
+};
+var createPresenceBindings = () => ({
+  here: /* @__PURE__ */ new Map(),
+  joining: /* @__PURE__ */ new Map(),
+  leaving: /* @__PURE__ */ new Map()
+});
+var NoopRealtimeChannel = class {
+  listen() {
+  }
+  stopListening() {
+  }
+  /**
+   * Register a no-op presence callback.
+   * @returns Unsubscribe function.
+   */
+  here(_callback) {
+    return () => void 0;
+  }
+  /**
+   * Register a no-op presence callback.
+   * @returns Unsubscribe function.
+   */
+  joining(_callback) {
+    return () => void 0;
+  }
+  /**
+   * Register a no-op presence callback.
+   * @returns Unsubscribe function.
+   */
+  leaving(_callback) {
+    return () => void 0;
+  }
+};
+var NoopRealtimeTransport = class {
+  constructor() {
+    /**
+     * Raw realtime provider instance.
+     */
+    __publicField(this, "pusher", null);
+  }
+  /**
+   * Subscribe to a public channel.
+   */
+  channel() {
+    return new NoopRealtimeChannel();
+  }
+  /**
+   * Subscribe to a private channel.
+   */
+  "private"() {
+    return new NoopRealtimeChannel();
+  }
+  /**
+   * Subscribe to a presence channel.
+   */
+  join() {
+    return new NoopRealtimeChannel();
+  }
+  /**
+   * Leave a channel.
+   */
+  leave() {
+  }
+  /**
+   * Disconnect the realtime client.
+   */
+  disconnect() {
+  }
+  /**
+   * Update the auth token for realtime subscriptions.
+   */
+  setToken() {
+  }
+  /**
+   * Listen for connection state changes.
+   */
+  onConnectionStateChange(callback) {
+    callback("disconnected");
+    return () => void 0;
+  }
+};
+var PusherRealtimeTransport = class {
+  /**
+   * Create a new Pusher-backed realtime transport.
+   * @param options - Realtime client configuration.
+   */
+  constructor(options) {
+    __publicField(this, "pusher", null);
+    __publicField(this, "options");
+    /**
+     * Resolved Pusher constructor used during initialization.
+     */
+    __publicField(this, "pusherConstructor", null);
+    /**
+     * Initialization promise when awaiting async token resolution.
+     */
+    __publicField(this, "initializationPromise", null);
+    /**
+     * Track whether disconnect was invoked before initialization finished.
+     */
+    __publicField(this, "isDisconnected", false);
+    __publicField(this, "subscriptions", /* @__PURE__ */ new Map());
+    __publicField(this, "connectionListeners", /* @__PURE__ */ new Set());
+    /**
+     * Mutable auth header map shared with the Pusher instance.
+     */
+    __publicField(this, "authHeaders", {});
+    __publicField(this, "token", null);
+    __publicField(this, "currentState", "connecting");
+    /**
+     * Track whether connection listeners are currently being notified.
+     */
+    __publicField(this, "isNotifyingState", false);
+    /**
+     * Queue connection state transitions to preserve delivery order.
+     */
+    __publicField(this, "pendingStates", []);
+    this.options = options;
+    const pendingResolutions = [];
+    const pusherResolution = resolvePusher();
+    if (isPromise(pusherResolution)) {
+      pendingResolutions.push(
+        pusherResolution.then((constructor) => {
+          this.pusherConstructor = constructor;
+        })
+      );
+    } else {
+      this.pusherConstructor = pusherResolution;
+    }
+    const tokenResolution = this.resolveTokenFromOptions();
+    if (isPromise(tokenResolution)) {
+      pendingResolutions.push(tokenResolution);
+    }
+    if (pendingResolutions.length > 0) {
+      this.initializationPromise = Promise.all(pendingResolutions).then(() => {
+        if (this.isDisconnected) {
+          this.initializationPromise = null;
+          return;
+        }
+        this.initialize();
+      }).catch((error) => {
+        this.handleInitializationFailure(error);
+      });
+      return;
+    }
+    this.initialize();
+  }
+  /**
+   * Subscribe to a public channel.
+   */
+  channel(name) {
+    return this.subscribe(name, "public");
+  }
+  /**
+   * Subscribe to a private channel.
+   */
+  "private"(name) {
+    return this.subscribe(name, "private");
+  }
+  /**
+   * Subscribe to a presence channel.
+   */
+  join(name) {
+    return this.subscribe(name, "presence");
+  }
+  /**
+   * Leave a channel.
+   */
+  leave(name) {
+    const subscription = this.subscriptions.get(name) ?? this.subscriptions.get(this.getChannelName(name, "presence")) ?? this.subscriptions.get(this.getChannelName(name, "private"));
+    if (!subscription) {
+      return;
+    }
+    if (!this.pusher) {
+      this.subscriptions.delete(subscription.channelName);
+      return;
+    }
+    this.pusher.unsubscribe(subscription.channelName);
+    this.subscriptions.delete(subscription.channelName);
+  }
+  /**
+   * Disconnect the realtime client.
+   */
+  disconnect() {
+    this.isDisconnected = true;
+    if (!this.pusher) {
+      this.subscriptions.clear();
+      this.handleConnectionState("disconnected");
+      return;
+    }
+    this.pusher.disconnect();
+    this.pusher = null;
+    this.subscriptions.clear();
+    this.handleConnectionState("disconnected");
+  }
+  /**
+   * Update the auth token for realtime subscriptions.
+   */
+  setToken(token) {
+    this.applyToken(token);
+  }
+  /**
+   * Listen for connection state changes.
+   */
+  onConnectionStateChange(callback) {
+    this.connectionListeners.add(callback);
+    callback(this.currentState);
+    return () => {
+      this.connectionListeners.delete(callback);
+    };
+  }
+  /**
+   * Record initialization failures without throwing unhandled rejections.
+   * @param error - Initialization failure.
+   */
+  handleInitializationFailure(error) {
+    void error;
+    this.initializationPromise = null;
+    this.pusher = null;
+    this.handleConnectionState("failed");
+  }
+  initialize() {
+    if (!this.pusherConstructor) {
+      throw createSdkError(
+        "Pusher constructor not found. Provide globalThis.__SDK_Pusher/globalThis.Pusher, or ensure pusher-js is resolvable from a CJS context (ESM runtimes must inject the global constructor)."
+      );
+    }
+    const authEndpoint = normalizeAuthEndpoint(
+      this.options.baseUrl,
+      this.options.authEndpoint
+    );
+    this.pusher = new this.pusherConstructor(this.options.appKey, {
+      wsHost: this.options.wsHost,
+      wsPort: this.options.wsPort ?? 443,
+      wssPort: this.options.wssPort ?? 443,
+      forceTLS: this.options.forceTLS ?? true,
+      enabledTransports: this.options.enabledTransports ?? ["ws", "wss"],
+      cluster: this.options.cluster ?? "",
+      authEndpoint,
+      auth: {
+        headers: this.authHeaders
+      }
+    });
+    this.pusher.connection.bind("state_change", (states) => {
+      this.handleConnectionState(states.current);
+    });
+    this.handleConnectionState(this.pusher.connection.state);
+    this.initializationPromise = null;
+    this.flushPendingSubscriptions(this.pusher);
+  }
+  /**
+   * Subscribe any queued channels after initialization completes.
+   * @param pusher - Initialized Pusher client instance.
+   */
+  flushPendingSubscriptions(pusher) {
+    for (const subscription of this.subscriptions.values()) {
+      if (!subscription.pending) {
+        continue;
+      }
+      const channel = pusher.subscribe(
+        subscription.channelName
+      );
+      subscription.channel = channel;
+      subscription.pending = false;
+      this.bindListeners(subscription);
+      this.rebindPresenceCallbacks(subscription);
+    }
+  }
+  /**
+   * Resolve an initial token from the options provider if available.
+   * @returns A promise when async token resolution is in progress.
+   * @throws {SDKError} When token resolution fails.
+   */
+  resolveTokenFromOptions() {
+    if (!this.options.getToken) {
+      return;
+    }
+    try {
+      const result = this.options.getToken();
+      if (isPromise(result)) {
+        return result.then((token) => {
+          this.applyToken(token);
+        }).catch((error) => {
+          throw this.normalizeTokenError(error, "Failed to resolve auth token.");
+        });
+      }
+      this.applyToken(result ?? null);
+    } catch (error) {
+      throw this.normalizeTokenError(error, "Failed to resolve auth token.");
+    }
+  }
+  /**
+   * Normalize token resolution errors into SDKError instances.
+   * @param error - Error to normalize.
+   * @param fallbackMessage - Fallback error message.
+   * @returns Normalized SDKError instance.
+   */
+  normalizeTokenError(error, fallbackMessage) {
+    if (error instanceof SDKError) {
+      return error;
+    }
+    const message = error instanceof Error ? error.message : fallbackMessage;
+    return createSdkError(message);
+  }
+  /**
+   * Apply a new auth token to the client configuration.
+   * Refresh auth subscriptions whenever the token changes.
+   */
+  applyToken(token) {
+    if (token === this.token) {
+      return;
+    }
+    this.token = token;
+    this.syncAuthHeaders();
+    if (!this.pusher) {
+      return;
+    }
+    this.refreshAuthSubscriptions();
+  }
+  /**
+   * Sync the auth header map with the current token.
+   */
+  syncAuthHeaders() {
+    if (this.token) {
+      this.authHeaders.Authorization = `Bearer ${this.token}`;
+      return;
+    }
+    delete this.authHeaders.Authorization;
+  }
+  /**
+   * Normalize and broadcast realtime connection state changes.
+   */
+  handleConnectionState(state) {
+    const mapped = this.mapConnectionState(state);
+    if (mapped === this.currentState) {
+      return;
+    }
+    this.currentState = mapped;
+    this.pendingStates.push(mapped);
+    if (this.isNotifyingState) {
+      return;
+    }
+    this.isNotifyingState = true;
+    let firstError = null;
+    try {
+      while (this.pendingStates.length) {
+        const nextState = this.pendingStates.shift();
+        if (!nextState) {
+          continue;
+        }
+        const listeners = Array.from(this.connectionListeners);
+        for (const listener of listeners) {
+          try {
+            listener(nextState);
+          } catch (error) {
+            if (!firstError) {
+              firstError = error;
+            }
+          }
+        }
+      }
+    } finally {
+      this.isNotifyingState = false;
+    }
+    if (firstError) {
+      throw firstError;
+    }
+  }
+  mapConnectionState(state) {
+    switch (state) {
+      case "initialized":
+      case "connecting":
+        return "connecting";
+      case "connected":
+        return "connected";
+      case "disconnected":
+        return "disconnected";
+      case "unavailable":
+        return "unavailable";
+      case "failed":
+        return "failed";
+      default:
+        return "disconnected";
+    }
+  }
+  subscribe(name, type) {
+    if (this.isDisconnected) {
+      return new NoopRealtimeChannel();
+    }
+    const channelName = this.getChannelName(name, type);
+    const existing = this.subscriptions.get(channelName);
+    if (existing) {
+      return this.createChannelWrapper(existing);
+    }
+    if (!this.pusher) {
+      if (this.initializationPromise) {
+        const subscription2 = this.createPendingSubscription(
+          name,
+          channelName,
+          type
+        );
+        this.subscriptions.set(channelName, subscription2);
+        return this.createChannelWrapper(subscription2);
+      }
+      return new NoopRealtimeChannel();
+    }
+    const channel = this.pusher.subscribe(channelName);
+    const subscription = {
+      name,
+      channelName,
+      type,
+      channel,
+      listeners: /* @__PURE__ */ new Map(),
+      presence: {
+        here: /* @__PURE__ */ new Set(),
+        joining: /* @__PURE__ */ new Set(),
+        leaving: /* @__PURE__ */ new Set()
+      },
+      presenceBindings: createPresenceBindings()
+    };
+    this.subscriptions.set(channelName, subscription);
+    return this.createChannelWrapper(subscription);
+  }
+  /**
+   * Create a placeholder channel while initialization is pending.
+   */
+  createPendingChannel(type) {
+    const channel = {
+      bind: () => void 0,
+      unbind: () => void 0,
+      unbind_all: () => void 0
+    };
+    if (type === "presence") {
+      return {
+        ...channel,
+        members: void 0
+      };
+    }
+    return channel;
+  }
+  /**
+   * Create a subscription record before the Pusher client is ready.
+   */
+  createPendingSubscription(name, channelName, type) {
+    return {
+      name,
+      channelName,
+      type,
+      channel: this.createPendingChannel(type),
+      listeners: /* @__PURE__ */ new Map(),
+      presence: {
+        here: /* @__PURE__ */ new Set(),
+        joining: /* @__PURE__ */ new Set(),
+        leaving: /* @__PURE__ */ new Set()
+      },
+      presenceBindings: createPresenceBindings(),
+      pending: true
+    };
+  }
+  /**
+   * Bind non-presence event listeners to the current channel.
+   * @param subscription - Target subscription record.
+   */
+  bindListeners(subscription) {
+    const channel = subscription.channel;
+    for (const [event, callbacks] of subscription.listeners.entries()) {
+      for (const callback of callbacks) {
+        channel.bind(event, callback);
+      }
+    }
+  }
+  /**
+   * Rebind presence callbacks to the current channel instance.
+   * @param subscription - Target subscription record.
+   * @param options - Optional rebinding configuration.
+   * @param options.emitHere - When true, emit the current member list immediately.
+   */
+  rebindPresenceCallbacks(subscription, options = {}) {
+    if (subscription.type !== "presence") {
+      return;
+    }
+    const emitHere = options.emitHere ?? true;
+    subscription.presenceBindings = createPresenceBindings();
+    for (const callback of subscription.presence.here) {
+      this.bindPresenceListener(subscription, "here", callback);
+    }
+    for (const callback of subscription.presence.joining) {
+      this.bindPresenceListener(subscription, "joining", callback);
+    }
+    for (const callback of subscription.presence.leaving) {
+      this.bindPresenceListener(subscription, "leaving", callback);
+    }
+    const presenceChannel = subscription.channel;
+    const members = normalizePresenceMembers(presenceChannel.members);
+    if (emitHere && members.length) {
+      for (const callback of subscription.presence.here) {
+        callback(members);
+      }
+    }
+  }
+  /**
+   * Bind a presence listener for the current subscription channel.
+   */
+  bindPresenceListener(subscription, type, callback) {
+    const presenceChannel = subscription.channel;
+    if (type === "here") {
+      const bindings2 = subscription.presenceBindings.here;
+      const hereCallback = callback;
+      if (bindings2.has(hereCallback)) {
+        return;
+      }
+      const handler2 = (members) => hereCallback(normalizePresenceMembers(members));
+      presenceChannel.bind("pusher:subscription_succeeded", handler2);
+      bindings2.set(hereCallback, handler2);
+      return;
+    }
+    if (type === "joining") {
+      const bindings2 = subscription.presenceBindings.joining;
+      const joiningCallback = callback;
+      if (bindings2.has(joiningCallback)) {
+        return;
+      }
+      const handler2 = (payload) => joiningCallback(payload);
+      presenceChannel.bind("pusher:member_added", handler2);
+      bindings2.set(joiningCallback, handler2);
+      return;
+    }
+    const bindings = subscription.presenceBindings.leaving;
+    const leavingCallback = callback;
+    if (bindings.has(leavingCallback)) {
+      return;
+    }
+    const handler = (payload) => leavingCallback(payload);
+    presenceChannel.bind("pusher:member_removed", handler);
+    bindings.set(leavingCallback, handler);
+  }
+  /**
+   * Remove a presence listener for the current subscription channel.
+   */
+  removePresenceListener(subscription, type, callback) {
+    if (subscription.type !== "presence") {
+      return;
+    }
+    const presenceChannel = subscription.channel;
+    if (type === "here") {
+      const hereCallback = callback;
+      subscription.presence.here.delete(hereCallback);
+      const bindings2 = subscription.presenceBindings.here;
+      const handler2 = bindings2.get(hereCallback);
+      if (handler2) {
+        presenceChannel.unbind(
+          "pusher:subscription_succeeded",
+          handler2
+        );
+        bindings2.delete(hereCallback);
+      }
+      return;
+    }
+    if (type === "joining") {
+      const joiningCallback = callback;
+      subscription.presence.joining.delete(joiningCallback);
+      const bindings2 = subscription.presenceBindings.joining;
+      const handler2 = bindings2.get(joiningCallback);
+      if (handler2) {
+        presenceChannel.unbind(
+          "pusher:member_added",
+          handler2
+        );
+        bindings2.delete(joiningCallback);
+      }
+      return;
+    }
+    const leavingCallback = callback;
+    subscription.presence.leaving.delete(leavingCallback);
+    const bindings = subscription.presenceBindings.leaving;
+    const handler = bindings.get(leavingCallback);
+    if (handler) {
+      presenceChannel.unbind(
+        "pusher:member_removed",
+        handler
+      );
+      bindings.delete(leavingCallback);
+    }
+  }
+  createChannelWrapper(subscription) {
+    if (subscription.type === "presence") {
+      return this.createPresenceChannelWrapper(subscription);
+    }
+    return this.createBaseChannelWrapper(subscription);
+  }
+  createBaseChannelWrapper(subscription) {
+    return {
+      listen: (event, callback) => {
+        this.addListener(subscription, event, callback);
+      },
+      stopListening: (event, callback) => {
+        this.removeListener(subscription, event, callback);
+      }
+    };
+  }
+  /**
+   * Create a presence channel wrapper with unsubscribe support.
+   */
+  createPresenceChannelWrapper(subscription) {
+    const channel = this.createBaseChannelWrapper(subscription);
+    return {
+      ...channel,
+      here: (callback) => {
+        subscription.presence.here.add(callback);
+        this.bindPresenceListener(subscription, "here", callback);
+        const presenceChannel = subscription.channel;
+        const members = normalizePresenceMembers(presenceChannel.members);
+        if (members.length) {
+          callback(members);
+        }
+        return () => {
+          this.removePresenceListener(subscription, "here", callback);
+        };
+      },
+      joining: (callback) => {
+        subscription.presence.joining.add(callback);
+        this.bindPresenceListener(subscription, "joining", callback);
+        return () => {
+          this.removePresenceListener(subscription, "joining", callback);
+        };
+      },
+      leaving: (callback) => {
+        subscription.presence.leaving.add(callback);
+        this.bindPresenceListener(subscription, "leaving", callback);
+        return () => {
+          this.removePresenceListener(subscription, "leaving", callback);
+        };
+      }
+    };
+  }
+  /**
+   * Refresh private and presence subscriptions after auth changes.
+   */
+  refreshAuthSubscriptions() {
+    if (!this.pusher) {
+      return;
+    }
+    for (const subscription of this.subscriptions.values()) {
+      if (subscription.type === "public") {
+        continue;
+      }
+      this.pusher.unsubscribe(subscription.channelName);
+      if (!this.token) {
+        subscription.channel.unbind_all();
+        subscription.channel = this.createPendingChannel(subscription.type);
+        subscription.presenceBindings = createPresenceBindings();
+        continue;
+      }
+      const channel = this.pusher.subscribe(
+        subscription.channelName
+      );
+      subscription.channel = channel;
+      this.bindListeners(subscription);
+      this.rebindPresenceCallbacks(subscription);
+    }
+  }
+  /**
+   * Register a listener for a realtime event.
+   * @param subscription - Target subscription record.
+   * @param event - Realtime event name (leading dot is optional).
+   * @param callback - Event handler callback.
+   */
+  addListener(subscription, event, callback) {
+    const normalizedEvent = event.startsWith(".") ? event.slice(1) : event;
+    let callbacks = subscription.listeners.get(normalizedEvent);
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Set();
+      subscription.listeners.set(normalizedEvent, callbacks);
+    }
+    if (callbacks.has(callback)) {
+      return;
+    }
+    callbacks.add(callback);
+    subscription.channel.bind(
+      normalizedEvent,
+      callback
+    );
+  }
+  /**
+   * Remove listeners for a realtime event.
+   * @param subscription - Target subscription record.
+   * @param event - Realtime event name to stop listening for.
+   * @param callback - Specific handler to remove if provided.
+   */
+  removeListener(subscription, event, callback) {
+    if (!event) {
+      subscription.listeners.clear();
+      subscription.channel.unbind_all();
+      this.rebindPresenceCallbacks(subscription, { emitHere: false });
+      return;
+    }
+    const normalizedEvent = event.startsWith(".") ? event.slice(1) : event;
+    if (!subscription.listeners.has(normalizedEvent)) {
+      return;
+    }
+    if (callback) {
+      subscription.listeners.get(normalizedEvent)?.delete(callback);
+      subscription.channel.unbind(
+        normalizedEvent,
+        callback
+      );
+      if (subscription.listeners.get(normalizedEvent)?.size === 0) {
+        subscription.listeners.delete(normalizedEvent);
+      }
+      return;
+    }
+    subscription.listeners.delete(normalizedEvent);
+    subscription.channel.unbind(normalizedEvent);
+  }
+  getChannelName(name, type) {
+    switch (type) {
+      case "private":
+        return name.startsWith("private-") ? name : `private-${name}`;
+      case "presence":
+        return name.startsWith("presence-") ? name : `presence-${name}`;
+      default:
+        return name;
+    }
+  }
+};
+var RealtimeNamespace = class {
+  /**
+   * Create a new realtime namespace client.
+   * @param transport - Transport implementation for realtime operations.
+   */
+  constructor(transport) {
+    __publicField(this, "chat");
+    __publicField(this, "transport");
+    this.transport = transport;
+    this.chat = this.createChatNamespace();
+  }
+  /**
+   * Raw Pusher client instance for advanced usage.
+   */
+  get pusher() {
+    return this.transport.pusher;
+  }
+  /**
+   * Subscribe to a public channel.
+   */
+  channel(name) {
+    return this.transport.channel(name);
+  }
+  /**
+   * Subscribe to a private channel.
+   */
+  "private"(name) {
+    return this.transport.private(name);
+  }
+  /**
+   * Subscribe to a presence channel.
+   */
+  join(name) {
+    return this.transport.join(name);
+  }
+  /**
+   * Leave a channel.
+   */
+  leave(name) {
+    this.transport.leave(name);
+  }
+  /**
+   * Disconnect the realtime client.
+   */
+  disconnect() {
+    this.transport.disconnect();
+  }
+  /**
+   * Update the auth token for realtime subscriptions.
+   */
+  setToken(token) {
+    this.transport.setToken(token);
+  }
+  /**
+   * Listen for connection state changes.
+   */
+  onConnectionStateChange(callback) {
+    return this.transport.onConnectionStateChange(callback);
+  }
+  /**
+   * Create the chat realtime helpers.
+   */
+  createChatNamespace() {
+    return {
+      joinRoom: (channelId) => {
+        const channelName = this.toChatRoom(channelId);
+        return this.join(channelName);
+      },
+      leaveRoom: (channelId) => {
+        this.leave(this.toChatRoom(channelId));
+      },
+      onMessage: (channelId, callback) => this.attachChatListener(channelId, ".SendPublicChatMessage", callback),
+      onMessageUpdated: (channelId, callback) => this.attachChatListener(channelId, ".chat.message.updated", callback),
+      onMessageDeleted: (channelId, callback) => this.attachChatListener(channelId, ".chat.message.deleted", callback)
+    };
+  }
+  /**
+   * Attach a chat listener to the channel room.
+   */
+  attachChatListener(channelId, event, callback) {
+    const channel = this.join(this.toChatRoom(channelId));
+    channel.listen(event, callback);
+    return () => {
+      channel.stopListening(event, callback);
+    };
+  }
+  /**
+   * Build the chat room name for a channel id.
+   */
+  toChatRoom(channelId) {
+    return `chat-public.${String(channelId)}`;
+  }
+};
+var createRealtimeClient = (options) => {
+  if (!options) {
+    return new RealtimeNamespace(new NoopRealtimeTransport());
+  }
+  try {
+    return new RealtimeNamespace(new PusherRealtimeTransport(options));
+  } catch (error) {
+    if (error instanceof SDKError) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : "Unknown realtime error";
+    throw createSdkError(`Failed to initialize realtime client: ${message}`);
+  }
+};
+export {
+  createRealtimeClient
+};
+//# sourceMappingURL=realtime.mjs.map