@rlanz/socket 0.0.1-5 → 0.0.1-7

package/build/chunk-QNOOQXYY.js

@@ -0,0 +1,899 @@
+import {
+  BindableChannelPattern
+} from "./chunk-6PJ4ALJD.js";
+
+// src/client/callback.ts
+function reportClientError(error) {
+  try {
+    const reportError = globalThis.reportError;
+    if (typeof reportError === "function") {
+      reportError(error);
+    } else {
+      console.error(error);
+    }
+  } catch {
+  }
+}
+function callClientHandler(handler, data) {
+  try {
+    const result = Reflect.apply(handler, void 0, [data]);
+    if (result && typeof result.then === "function") {
+      void Promise.resolve(result).catch(reportClientError);
+    }
+  } catch (error) {
+    reportClientError(error);
+  }
+}
+
+// src/client/presence_snapshot.ts
+var ClientPresenceSnapshot = class _ClientPresenceSnapshot {
+  count;
+  users;
+  #usersById;
+  constructor(users) {
+    this.users = Object.freeze(users.map((user) => Object.freeze({ ...user })));
+    this.count = this.users.length;
+    this.#usersById = new Map(this.users.map((user) => [user.id, user]));
+  }
+  /**
+   * Validate one transport snapshot for the expected channel.
+   */
+  static fromTransport(value, expectedChannel) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return null;
+    }
+    const data = value;
+    if (data.channel !== expectedChannel || !Array.isArray(data.users) || !Number.isInteger(data.count) || data.count !== data.users.length) {
+      return null;
+    }
+    const users = [];
+    const userIds = /* @__PURE__ */ new Set();
+    for (const candidate of data.users) {
+      if (!candidate || typeof candidate !== "object" || Array.isArray(candidate) || typeof candidate.id !== "string" || typeof candidate.joinedAt !== "string" || userIds.has(candidate.id)) {
+        return null;
+      }
+      userIds.add(candidate.id);
+      users.push(candidate);
+    }
+    return new _ClientPresenceSnapshot(users);
+  }
+  /**
+   * Return users that joined or left since the previous snapshot.
+   */
+  diff(previous) {
+    if (!previous) {
+      return { joining: this.users, leaving: [] };
+    }
+    return {
+      joining: this.users.filter((user) => !previous.#usersById.has(user.id)),
+      leaving: previous.users.filter((user) => !this.#usersById.has(user.id))
+    };
+  }
+};
+
+// src/client/channel.ts
+var CLIENT_EVENT_PREFIX = "client:";
+var Channel = class {
+  /**
+   * 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;
+  /**
+   * 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 = ClientPresenceSnapshot.fromTransport(
+          response.data?.presenceData,
+          this.name
+        );
+        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 = ClientPresenceSnapshot.fromTransport(data, this.name);
+      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;
+    if (this.#hereHandler) {
+      callClientHandler(this.#hereHandler, [...data.users]);
+    }
+  }
+  /**
+   * Handles a presence update.
+   *
+   * previous IDs     current IDs
+   *     |                |
+   *     +-- diff in -----+--> joining / leaving callbacks
+   */
+  #handlePresenceUpdate(data) {
+    const { joining, leaving } = data.diff(this.#presence);
+    this.#presence = data;
+    for (const user of joining) {
+      if (this.#joiningHandler) {
+        callClientHandler(this.#joiningHandler, user);
+      }
+    }
+    for (const user of leaving) {
+      if (this.#leavingHandler) {
+        callClientHandler(this.#leavingHandler, user);
+      }
+    }
+    if (this.#hereHandler) {
+      callClientHandler(this.#hereHandler, [...data.users]);
+    }
+  }
+  #resetConnectionState() {
+    this.#active = false;
+    this.#presence = null;
+  }
+  #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 resolveChannel = /* @__PURE__ */ Symbol("resolveChannel");
+function buildChannelName(pattern, parameters = {}) {
+  const bindablePattern = BindableChannelPattern.parse(pattern);
+  if (!bindablePattern) {
+    throw new Error(`Unsupported generated channel pattern: ${pattern}`);
+  }
+  return bindablePattern.bind(parameters);
+}
+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(...args) {
+    const [pattern, parameters] = args;
+    const name = args.length > 1 ? buildChannelName(pattern, parameters) : pattern;
+    return this[resolveChannel](name);
+  }
+  /** Resolves a channel for framework adapters after their public type checks. @internal */
+  [resolveChannel](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);
+      }
+    }
+  }
+};
+
+export {
+  callClientHandler,
+  resolveChannel,
+  buildChannelName,
+  Socket
+};
+//# sourceMappingURL=chunk-QNOOQXYY.js.map