@rlanz/socket 0.0.1-6 → 0.0.1-8

package/build/src/client/index.js

@@ -1,842 +1,9 @@
 import {
-  callClientHandler,
-  reportClientError
-} from "../../chunk-SFAY2ZA4.js";
-
-// src/client/channel.ts
-var CLIENT_EVENT_PREFIX = "client:";
-var Channel = class _Channel {
-  static #parsePresenceData(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      return null;
-    }
-    const data = value;
-    if (typeof data.channel !== "string" || !Array.isArray(data.users) || !data.users.every(
-      (user) => user !== null && typeof user === "object" && typeof user.id === "string" && typeof user.joinedAt === "string"
-    )) {
-      return null;
-    }
-    const usersById = /* @__PURE__ */ new Map();
-    for (const user of data.users) {
-      if (!usersById.has(user.id)) {
-        usersById.set(user.id, user);
-      }
-    }
-    const users = [...usersById.values()];
-    return { ...data, channel: data.channel, users, count: users.length };
-  }
-  /**
-   * Channel name.
-   */
-  name;
-  /**
-   * Socket client transport.
-   */
-  #transport;
-  /**
-   * Whether the channel should stay subscribed.
-   */
-  #subscribed = false;
-  #active = false;
-  /**
-   * Event handlers grouped by event type.
-   */
-  #eventHandlers = /* @__PURE__ */ new Map();
-  #managedEventHandlers = /* @__PURE__ */ new Map();
-  /**
-   * Current presence data.
-   */
-  #presence = null;
-  /**
-   * Present user IDs used to detect join and leave events.
-   */
-  #presentUserIds = /* @__PURE__ */ new Set();
-  /**
-   * Handler registered through .here().
-   */
-  #hereHandler = null;
-  /**
-   * Handler registered through .joining().
-   */
-  #joiningHandler = null;
-  /**
-   * Handler registered through .leaving().
-   */
-  #leavingHandler = null;
-  /**
-   * Internal transport handlers to clean up on unsubscribe.
-   */
-  #boundPresenceHandler = null;
-  #boundEventHandler = null;
-  #boundDisconnectHandler = null;
-  #listenersAttached = false;
-  #pendingSubscribe = null;
-  #subscribeToken = 0;
-  #managedSubscriptions = 0;
-  #pendingUnsubscribe = null;
-  constructor(name, transport) {
-    this.name = name;
-    this.#transport = transport;
-  }
-  /**
-   * Whether the channel should stay subscribed.
-   */
-  get subscribed() {
-    return this.#subscribed || this.#managedSubscriptions > 0;
-  }
-  /** Whether a framework lifecycle currently owns this channel. @internal */
-  get $managed() {
-    return this.#managedSubscriptions > 0;
-  }
-  /**
-   * Whether the channel is active on the server.
-   */
-  get active() {
-    return this.#active;
-  }
-  /**
-   * List of present users.
-   */
-  get users() {
-    return this.#presence?.users ?? [];
-  }
-  /**
-   * Number of present users.
-   */
-  get count() {
-    return this.#presence?.count ?? 0;
-  }
-  /**
-   * Registers a handler called with the present users.
-   * Called immediately on subscribe and after each presence change.
-   */
-  here(handler) {
-    this.#hereHandler = handler;
-    return this;
-  }
-  /**
-   * Registers a handler called when a user joins.
-   */
-  joining(handler) {
-    this.#joiningHandler = handler;
-    return this;
-  }
-  /**
-   * Registers a handler called when a user leaves.
-   */
-  leaving(handler) {
-    this.#leavingHandler = handler;
-    return this;
-  }
-  listen(event, handler) {
-    const handlers = this.#eventHandlers.get(event) ?? /* @__PURE__ */ new Set();
-    handlers.add(handler);
-    this.#eventHandlers.set(event, handlers);
-    return this;
-  }
-  stopListening(event, handler) {
-    if (handler) {
-      this.#eventHandlers.get(event)?.delete(handler);
-    } else {
-      this.#eventHandlers.delete(event);
-    }
-    return this;
-  }
-  /** Registers a lifecycle-owned event handler. @internal */
-  $listen(event, handler) {
-    const handlers = this.#managedEventHandlers.get(event) ?? /* @__PURE__ */ new Set();
-    handlers.add(handler);
-    this.#managedEventHandlers.set(event, handlers);
-  }
-  /** Removes a lifecycle-owned event handler. @internal */
-  $stopListening(event, handler) {
-    const handlers = this.#managedEventHandlers.get(event);
-    handlers?.delete(handler);
-    if (handlers?.size === 0) this.#managedEventHandlers.delete(event);
-  }
-  /**
-   * Listens for a client event whispered by another channel member.
-   */
-  listenForWhisper(event, handler) {
-    const handlers = this.#eventHandlers.get(`${CLIENT_EVENT_PREFIX}${event}`) ?? /* @__PURE__ */ new Set();
-    handlers.add(handler);
-    this.#eventHandlers.set(`${CLIENT_EVENT_PREFIX}${event}`, handlers);
-    return this;
-  }
-  /**
-   * Removes a whispered client event listener.
-   */
-  stopListeningForWhisper(event, handler) {
-    const name = `${CLIENT_EVENT_PREFIX}${event}`;
-    if (handler) this.#eventHandlers.get(name)?.delete(handler);
-    else this.#eventHandlers.delete(name);
-    return this;
-  }
-  /**
-   * Subscribes to the channel.
-   *
-   * client listeners -> subscribe ack -> active channel
-   *        |                 |                 |
-   *        v                 v                 v
-   *     events ready     presence sync      send/listen
-   */
-  async subscribe(options = {}) {
-    this.#subscribed = true;
-    return this.#ensureSubscribed(options);
-  }
-  /** Acquires subscription intent without overriding a direct consumer. @internal */
-  $acquire(options = {}) {
-    this.#managedSubscriptions++;
-    const ready = this.#transport.connected ? this.#ensureSubscribed(options) : Promise.resolve(this);
-    let released = false;
-    return {
-      ready,
-      release: () => {
-        if (released) return this.#pendingUnsubscribe ?? Promise.resolve();
-        released = true;
-        this.#managedSubscriptions--;
-        return this.#unsubscribeIfUnused();
-      }
-    };
-  }
-  /** Restores desired subscriptions after the transport reconnects. @internal */
-  $resubscribe(options = {}) {
-    return this.#ensureSubscribed(options);
-  }
-  async #ensureSubscribed(options) {
-    if (this.#pendingUnsubscribe) {
-      await this.#pendingUnsubscribe;
-    }
-    if (!this.subscribed) return this;
-    if (this.#pendingSubscribe) {
-      await this.#pendingSubscribe.promise;
-      return this;
-    }
-    if (this.#active) {
-      return this;
-    }
-    const timeout = options.timeout ?? 5e3;
-    if (!this.#listenersAttached) {
-      this.#setupSocketListeners();
-    }
-    const token = ++this.#subscribeToken;
-    const deferred = Promise.withResolvers();
-    this.#pendingSubscribe = {
-      promise: deferred.promise,
-      resolve: deferred.resolve,
-      reject: deferred.reject,
-      token
-    };
-    const { resolve, reject } = this.#pendingSubscribe;
-    const timer = setTimeout(() => {
-      if (token !== this.#subscribeToken) return;
-      this.#subscribeToken++;
-      this.#pendingSubscribe = null;
-      this.#resetConnectionState();
-      reject(new Error(`Subscribe timeout for channel: ${this.name}`));
-    }, timeout);
-    this.#transport.sendRequest({ type: "subscribe", channel: this.name }, timeout).then((response) => {
-      if (token !== this.#subscribeToken) return;
-      clearTimeout(timer);
-      this.#pendingSubscribe = null;
-      if (response.ok) {
-        this.#active = true;
-        const presenceData = _Channel.#parsePresenceData(
-          response.data?.presenceData ?? response.presenceData
-        );
-        if (presenceData) {
-          this.#handleInitialPresence(presenceData);
-        }
-        resolve(this);
-      } else {
-        this.#resetConnectionState();
-        reject(new Error(response.error ?? "Subscribe failed"));
-      }
-    }).catch((error) => {
-      if (token !== this.#subscribeToken) return;
-      clearTimeout(timer);
-      this.#pendingSubscribe = null;
-      this.#resetConnectionState();
-      reject(error instanceof Error ? error : new Error("Subscribe failed"));
-    });
-    await deferred.promise;
-    return this;
-  }
-  /**
-   * Unsubscribes from the channel.
-   */
-  async unsubscribe(options = {}) {
-    this.#subscribed = false;
-    this.#clearUserCallbacks();
-    return this.#unsubscribeIfUnused(options);
-  }
-  #unsubscribeIfUnused(options = {}) {
-    if (this.subscribed) return Promise.resolve();
-    if (this.#pendingUnsubscribe) return this.#pendingUnsubscribe;
-    const hadPendingSubscribe = this.#pendingSubscribe !== null;
-    this.#subscribeToken++;
-    if (this.#pendingSubscribe) {
-      this.#pendingSubscribe.reject(new Error(`Unsubscribed from channel: ${this.name}`));
-      this.#pendingSubscribe = null;
-    }
-    if (!hadPendingSubscribe && !this.#active) {
-      this.#cleanupTerminal();
-      return Promise.resolve();
-    }
-    this.#active = false;
-    const pending = new Promise((resolve) => {
-      const timeout = options.timeout ?? 5e3;
-      const timer = setTimeout(() => {
-        resolve();
-      }, timeout);
-      this.#transport.sendRequest({ type: "unsubscribe", channel: this.name }, timeout).then(() => {
-        clearTimeout(timer);
-        resolve();
-      }).catch(() => {
-        clearTimeout(timer);
-        resolve();
-      });
-    });
-    this.#pendingUnsubscribe = pending;
-    void pending.finally(() => {
-      if (this.#pendingUnsubscribe !== pending) return;
-      this.#pendingUnsubscribe = null;
-      this.#resetConnectionState();
-      this.#detachTransportListeners();
-      if (!this.subscribed) this.#clearCallbacks();
-    });
-    return pending;
-  }
-  send(event, data) {
-    if (!this.#active) {
-      console.warn(`Cannot send to channel ${this.name}: not subscribed`);
-      return this;
-    }
-    const payload = {
-      channel: this.name,
-      event,
-      data
-    };
-    this.#transport.send({ type: "message", ...payload });
-    return this;
-  }
-  /**
-   * Relays a client event to other members of this channel.
-   */
-  whisper(event, data) {
-    if (!this.#active) {
-      console.warn(`Cannot whisper to channel ${this.name}: not subscribed`);
-      return this;
-    }
-    const payload = {
-      channel: this.name,
-      event,
-      data
-    };
-    this.#transport.send({ type: "whisper", ...payload });
-    return this;
-  }
-  async sendWithAck(event, data) {
-    if (!this.#active) {
-      throw new Error(`Cannot send to channel ${this.name}: not subscribed`);
-    }
-    const payload = {
-      channel: this.name,
-      event,
-      data
-    };
-    const response = await this.#transport.sendRequest({
-      type: "message",
-      ...payload
-    });
-    if (!response?.ok) {
-      throw new Error(response?.error ?? `Channel handler failed: ${event}`);
-    }
-    return response.data;
-  }
-  /**
-   * Configures transport listeners.
-   */
-  #setupSocketListeners() {
-    this.#boundPresenceHandler = (data) => {
-      const presenceData = _Channel.#parsePresenceData(data);
-      if (!presenceData) return;
-      this.#handlePresenceUpdate(presenceData);
-    };
-    this.#transport.on(`channel:${this.name}:presence:update`, this.#boundPresenceHandler);
-    this.#boundEventHandler = (data) => {
-      if (!data || typeof data !== "object") return;
-      const payload = data;
-      if (!payload.event) return;
-      const handlers = this.#eventHandlers.get(payload.event);
-      handlers?.forEach((handler) => callClientHandler(handler, payload.data));
-      const managedHandlers = this.#managedEventHandlers.get(payload.event);
-      managedHandlers?.forEach((handler) => callClientHandler(handler, payload.data));
-    };
-    this.#transport.on(`channel:${this.name}:event`, this.#boundEventHandler);
-    this.#boundDisconnectHandler = () => {
-      this.#resetConnectionState();
-    };
-    this.#transport.on("disconnect", this.#boundDisconnectHandler);
-    this.#listenersAttached = true;
-  }
-  /**
-   * Handles the initial presence snapshot.
-   */
-  #handleInitialPresence(data) {
-    this.#presence = data;
-    this.#presentUserIds = new Set(data.users.map((u) => u.id));
-    if (this.#hereHandler) {
-      callClientHandler(this.#hereHandler, data.users);
-    }
-  }
-  /**
-   * Handles a presence update.
-   *
-   * previous IDs     current IDs
-   *     |                |
-   *     +-- diff in -----+--> joining / leaving callbacks
-   */
-  #handlePresenceUpdate(data) {
-    const previousIds = this.#presentUserIds;
-    const currentIds = new Set(data.users.map((u) => u.id));
-    const joiningUsers = data.users.filter((user) => !previousIds.has(user.id));
-    const leavingUsers = (this.#presence?.users ?? []).filter((user) => !currentIds.has(user.id));
-    this.#presence = data;
-    this.#presentUserIds = currentIds;
-    for (const user of joiningUsers) {
-      if (this.#joiningHandler) {
-        callClientHandler(this.#joiningHandler, user);
-      }
-    }
-    for (const user of leavingUsers) {
-      if (this.#leavingHandler) {
-        callClientHandler(this.#leavingHandler, user);
-      }
-    }
-    if (this.#hereHandler) {
-      callClientHandler(this.#hereHandler, data.users);
-    }
-  }
-  #resetConnectionState() {
-    this.#active = false;
-    this.#presence = null;
-    this.#presentUserIds.clear();
-  }
-  #detachTransportListeners() {
-    if (this.#boundPresenceHandler) {
-      this.#transport.off(`channel:${this.name}:presence:update`, this.#boundPresenceHandler);
-      this.#boundPresenceHandler = null;
-    }
-    if (this.#boundEventHandler) {
-      this.#transport.off(`channel:${this.name}:event`, this.#boundEventHandler);
-      this.#boundEventHandler = null;
-    }
-    if (this.#boundDisconnectHandler) {
-      this.#transport.off("disconnect", this.#boundDisconnectHandler);
-      this.#boundDisconnectHandler = null;
-    }
-    this.#listenersAttached = false;
-  }
-  #clearUserCallbacks() {
-    this.#eventHandlers.clear();
-    this.#hereHandler = null;
-    this.#joiningHandler = null;
-    this.#leavingHandler = null;
-  }
-  #clearCallbacks() {
-    this.#clearUserCallbacks();
-    this.#managedEventHandlers.clear();
-  }
-  /**
-   * Performs terminal cleanup after the user leaves or the socket is disposed.
-   */
-  #cleanupTerminal() {
-    this.#resetConnectionState();
-    this.#detachTransportListeners();
-    this.#clearCallbacks();
-  }
-};
-
-// src/client/socket_session.ts
-var ClientSocketSession = class {
-  #ws = null;
-  #state = "disconnected";
-  #connectPromise = null;
-  #cancelConnect = null;
-  #stateHandlers = /* @__PURE__ */ new Set();
-  #eventHandlers = /* @__PURE__ */ new Map();
-  #pendingRequests = /* @__PURE__ */ new Map();
-  #requestId = 0;
-  #reconnectAttempts = 0;
-  #reconnectTimer = null;
-  #manualDisconnect = false;
-  #buildUrl;
-  #createWebSocket;
-  #autoReconnect;
-  #reconnectDelay;
-  #reconnectMaxDelay;
-  #onConnected;
-  constructor(options) {
-    this.#buildUrl = options.buildUrl;
-    this.#createWebSocket = options.createWebSocket ?? ((url) => new WebSocket(url));
-    this.#autoReconnect = options.autoReconnect ?? true;
-    this.#reconnectDelay = Math.max(0, options.reconnectDelay ?? 250);
-    this.#reconnectMaxDelay = Math.max(this.#reconnectDelay, options.reconnectMaxDelay ?? 5e3);
-    this.#onConnected = options.onConnected;
-  }
-  get state() {
-    return this.#state;
-  }
-  get connected() {
-    return this.#state === "connected";
-  }
-  connect() {
-    if (this.#state === "connected") {
-      return Promise.resolve();
-    }
-    if (this.#connectPromise) {
-      return this.#connectPromise;
-    }
-    this.#manualDisconnect = false;
-    this.#setState("connecting");
-    let setupFailed = false;
-    const connectPromise = new Promise((resolve, reject) => {
-      let ws;
-      try {
-        ws = this.#createWebSocket(this.#buildUrl());
-      } catch (error) {
-        setupFailed = true;
-        reject(error);
-        return;
-      }
-      this.#ws = ws;
-      let settled = false;
-      const cleanup = () => {
-        ws.removeEventListener("open", handleOpen);
-        ws.removeEventListener("error", handleError);
-        if (this.#connectPromise === connectPromise) {
-          this.#connectPromise = null;
-        }
-        if (this.#cancelConnect === cancelConnect) {
-          this.#cancelConnect = null;
-        }
-      };
-      const cancelConnect = (error) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        cleanup();
-        reject(error);
-      };
-      const handleOpen = () => {
-        if (settled || this.#ws !== ws) {
-          return;
-        }
-        this.#setState("connected");
-        if (settled || this.#ws !== ws || !this.connected) {
-          return;
-        }
-        settled = true;
-        cleanup();
-        this.#reconnectAttempts = 0;
-        this.#emitLocal("connect");
-        if (this.#onConnected) {
-          this.#callHandler(this.#onConnected);
-        }
-        resolve();
-      };
-      const handleError = () => {
-        cancelConnect(new Error("WebSocket connection failed"));
-        if (this.#ws === ws) {
-          this.#setState("disconnected");
-        }
-      };
-      const handleClose = () => {
-        cancelConnect(new Error("WebSocket connection failed"));
-        if (this.#ws === ws) {
-          this.#handleClose();
-        }
-      };
-      this.#cancelConnect = cancelConnect;
-      ws.addEventListener("open", handleOpen);
-      ws.addEventListener("error", handleError);
-      ws.addEventListener("message", (event) => {
-        if (this.#ws === ws) {
-          this.#handleIncoming(event.data);
-        }
-      });
-      ws.addEventListener("close", handleClose);
-    });
-    this.#connectPromise = connectPromise;
-    if (setupFailed) {
-      this.#connectPromise = null;
-      this.#setState("disconnected");
-    }
-    return connectPromise;
-  }
-  disconnect() {
-    this.#manualDisconnect = true;
-    if (this.#reconnectTimer) {
-      clearTimeout(this.#reconnectTimer);
-      this.#reconnectTimer = null;
-    }
-    this.#cancelConnect?.(new Error("Socket disconnected"));
-    this.#reconnectAttempts = 0;
-    const ws = this.#ws;
-    const shouldEmitDisconnect = this.#state !== "disconnected";
-    this.#ws = null;
-    this.#setState("disconnected");
-    if (shouldEmitDisconnect) {
-      this.#emitLocal("disconnect");
-    }
-    ws?.close();
-    this.#rejectPending(new Error("Socket disconnected"));
-  }
-  onStateChange(handler) {
-    this.#stateHandlers.add(handler);
-    return () => {
-      this.#stateHandlers.delete(handler);
-    };
-  }
-  on(event, handler) {
-    if (!this.#eventHandlers.has(event)) {
-      this.#eventHandlers.set(event, /* @__PURE__ */ new Set());
-    }
-    this.#eventHandlers.get(event).add(handler);
-    return () => {
-      this.off(event, handler);
-    };
-  }
-  off(event, handler) {
-    this.#eventHandlers.get(event)?.delete(handler);
-  }
-  send(message) {
-    const ws = this.#ws;
-    if (ws?.readyState !== WebSocket.OPEN) {
-      return;
-    }
-    ws.send(JSON.stringify(message));
-  }
-  sendRequest(message, timeout = 5e3) {
-    const ws = this.#ws;
-    if (ws?.readyState !== WebSocket.OPEN) {
-      return Promise.reject(new Error("Socket is not connected"));
-    }
-    const id = String(++this.#requestId);
-    const payload = { ...message, id };
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.#pendingRequests.delete(id);
-        reject(new Error("Socket request timed out"));
-      }, timeout);
-      this.#pendingRequests.set(id, {
-        resolve,
-        reject,
-        timer
-      });
-      ws.send(JSON.stringify(payload));
-    });
-  }
-  #handleIncoming(raw) {
-    const message = this.#parseMessage(raw);
-    if (!message) {
-      return;
-    }
-    if (message.type === "ack") {
-      this.#resolveAck(message);
-      return;
-    }
-    if (message.type === "event") {
-      if (message.channel) {
-        if (message.event === "presence:update") {
-          this.#emitLocal(`channel:${message.channel}:presence:update`, message.data);
-          return;
-        }
-        this.#emitLocal(`channel:${message.channel}:event`, {
-          event: message.event,
-          data: message.data
-        });
-        return;
-      }
-      this.#emitLocal(message.event, message.data);
-    }
-  }
-  #parseMessage(raw) {
-    try {
-      const data = typeof raw === "string" ? raw : String(raw);
-      const message = JSON.parse(data);
-      if (!message || typeof message !== "object" || Array.isArray(message)) {
-        return null;
-      }
-      if (message.type === "ack" && typeof message.id === "string" && typeof message.ok === "boolean" && (message.error === void 0 || typeof message.error === "string")) {
-        return message;
-      }
-      if (message.type === "event" && typeof message.event === "string" && (message.channel === void 0 || typeof message.channel === "string")) {
-        return message;
-      }
-      return null;
-    } catch {
-      return null;
-    }
-  }
-  #resolveAck(message) {
-    if (!message.id) {
-      return;
-    }
-    const pending = this.#pendingRequests.get(message.id);
-    if (!pending) {
-      return;
-    }
-    clearTimeout(pending.timer);
-    this.#pendingRequests.delete(message.id);
-    if (message.ok) {
-      pending.resolve({ ok: true, data: message.data });
-    } else {
-      pending.resolve({ ok: false, error: message.error });
-    }
-  }
-  #handleClose() {
-    const shouldEmitDisconnect = this.#state !== "disconnected";
-    this.#ws = null;
-    this.#setState("disconnected");
-    if (shouldEmitDisconnect) {
-      this.#emitLocal("disconnect");
-    }
-    this.#rejectPending(new Error("Socket disconnected"));
-    this.#scheduleReconnect();
-  }
-  #scheduleReconnect() {
-    if (this.#manualDisconnect || !this.#autoReconnect || this.#reconnectTimer) {
-      return;
-    }
-    const delay = Math.min(
-      this.#reconnectDelay * 2 ** this.#reconnectAttempts,
-      this.#reconnectMaxDelay
-    );
-    this.#reconnectAttempts += 1;
-    this.#reconnectTimer = setTimeout(() => {
-      this.#reconnectTimer = null;
-      this.connect().catch(() => {
-        if (this.#state === "disconnected") {
-          this.#scheduleReconnect();
-        }
-      });
-    }, delay);
-  }
-  #rejectPending(error) {
-    for (const [id, pending] of this.#pendingRequests) {
-      clearTimeout(pending.timer);
-      pending.reject(error);
-      this.#pendingRequests.delete(id);
-    }
-  }
-  #emitLocal(event, data) {
-    this.#eventHandlers.get(event)?.forEach((handler) => this.#callHandler(handler, data));
-  }
-  #setState(state) {
-    if (this.#state === state) {
-      return;
-    }
-    this.#state = state;
-    this.#stateHandlers.forEach((handler) => this.#callHandler(handler, state));
-  }
-  #callHandler(handler, data) {
-    callClientHandler(handler, data);
-  }
-};
-
-// src/client/socket.ts
-var Socket = class {
-  #channels = /* @__PURE__ */ new Map();
-  #url;
-  #path;
-  #session;
-  constructor(options = {}) {
-    const browserWindow = globalThis;
-    const browserOrigin = typeof globalThis === "object" && browserWindow.window?.location?.origin ? browserWindow.window.location.origin : "";
-    this.#url = options.url ?? browserOrigin;
-    this.#path = options.path ?? "/socket";
-    this.#session = new ClientSocketSession({
-      buildUrl: () => this.#buildUrl(),
-      autoReconnect: options.autoReconnect,
-      reconnectDelay: options.reconnectDelay,
-      reconnectMaxDelay: options.reconnectMaxDelay,
-      onConnected: () => {
-        void this.#resubscribeChannels();
-      }
-    });
-  }
-  get state() {
-    return this.#session.state;
-  }
-  get connected() {
-    return this.#session.connected;
-  }
-  connect() {
-    return this.#session.connect();
-  }
-  disconnect() {
-    for (const channel of this.#channels.values()) {
-      channel.unsubscribe().catch(() => {
-      });
-    }
-    this.#session.disconnect();
-  }
-  channel(name) {
-    if (!this.#channels.has(name)) {
-      this.#channels.set(name, new Channel(name, this));
-    }
-    return this.#channels.get(name);
-  }
-  async leave(name) {
-    const channel = this.#channels.get(name);
-    if (channel) {
-      await channel.unsubscribe();
-      if (this.#channels.get(name) === channel && !channel.subscribed) {
-        this.#channels.delete(name);
-      }
-    }
-  }
-  onStateChange(handler) {
-    return this.#session.onStateChange(handler);
-  }
-  on(event, handler) {
-    return this.#session.on(event, handler);
-  }
-  off(event, handler) {
-    this.#session.off(event, handler);
-  }
-  send(message) {
-    this.#session.send(message);
-  }
-  sendRequest(message, timeout = 5e3) {
-    return this.#session.sendRequest(message, timeout);
-  }
-  #buildUrl() {
-    const browserGlobal = globalThis;
-    const url = new URL(this.#url || browserGlobal.location?.origin || "http://localhost");
-    if (url.protocol === "http:") {
-      url.protocol = "ws:";
-    } else if (url.protocol === "https:") {
-      url.protocol = "wss:";
-    } else if (url.protocol !== "ws:" && url.protocol !== "wss:") {
-      throw new Error(`Unsupported socket URL protocol: ${url.protocol}`);
-    }
-    url.pathname = this.#path;
-    return url.toString();
-  }
-  async #resubscribeChannels() {
-    for (const channel of this.#channels.values()) {
-      if (channel.subscribed && !channel.active) {
-        await channel.$resubscribe().catch(reportClientError);
-      }
-    }
-  }
-};
+  Socket
+} from "../../chunk-QNOOQXYY.js";
+import "../../chunk-6PJ4ALJD.js";
+import "../../chunk-E6ILCRL3.js";
 export {
-  Channel,
   Socket
 };
 //# sourceMappingURL=index.js.map