@rlanz/socket 0.0.1-4 → 0.0.1-6

package/build/src/client/index.js

@@ -1,6 +1,30 @@
+import {
+  callClientHandler,
+  reportClientError
+} from "../../chunk-SFAY2ZA4.js";
+
 // src/client/channel.ts
 var CLIENT_EVENT_PREFIX = "client:";
-var Channel = class {
+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.
    */
@@ -18,6 +42,7 @@ var Channel = class {
    * Event handlers grouped by event type.
    */
   #eventHandlers = /* @__PURE__ */ new Map();
+  #managedEventHandlers = /* @__PURE__ */ new Map();
   /**
    * Current presence data.
    */
@@ -47,6 +72,8 @@ var Channel = class {
   #listenersAttached = false;
   #pendingSubscribe = null;
   #subscribeToken = 0;
+  #managedSubscriptions = 0;
+  #pendingUnsubscribe = null;
   constructor(name, transport) {
     this.name = name;
     this.#transport = transport;
@@ -55,7 +82,11 @@ var Channel = class {
    * Whether the channel should stay subscribed.
    */
   get subscribed() {
-    return this.#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.
@@ -97,19 +128,12 @@ var Channel = class {
     this.#leavingHandler = handler;
     return this;
   }
-  /**
-   * Listens for an event on this channel.
-   */
   listen(event, handler) {
-    if (!this.#eventHandlers.has(event)) {
-      this.#eventHandlers.set(event, /* @__PURE__ */ new Set());
-    }
-    this.#eventHandlers.get(event).add(handler);
+    const handlers = this.#eventHandlers.get(event) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.#eventHandlers.set(event, handlers);
     return this;
   }
-  /**
-   * Removes an event listener.
-   */
   stopListening(event, handler) {
     if (handler) {
       this.#eventHandlers.get(event)?.delete(handler);
@@ -118,17 +142,35 @@ var Channel = class {
     }
     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) {
-    return this.listen(`${CLIENT_EVENT_PREFIX}${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) {
-    return this.stopListening(`${CLIENT_EVENT_PREFIX}${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.
@@ -140,8 +182,35 @@ var Channel = class {
    */
   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) {
-      return this.#pendingSubscribe.promise;
+      await this.#pendingSubscribe.promise;
+      return this;
     }
     if (this.#active) {
       return this;
@@ -151,21 +220,17 @@ var Channel = class {
       this.#setupSocketListeners();
     }
     const token = ++this.#subscribeToken;
-    let resolvePromise;
-    let rejectPromise;
-    const promise = new Promise((resolve2, reject2) => {
-      resolvePromise = resolve2;
-      rejectPromise = reject2;
-    });
+    const deferred = Promise.withResolvers();
     this.#pendingSubscribe = {
-      promise,
-      resolve: resolvePromise,
-      reject: rejectPromise,
+      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}`));
@@ -176,7 +241,9 @@ var Channel = class {
       this.#pendingSubscribe = null;
       if (response.ok) {
         this.#active = true;
-        const presenceData = response.data?.presenceData ?? response.presenceData;
+        const presenceData = _Channel.#parsePresenceData(
+          response.data?.presenceData ?? response.presenceData
+        );
         if (presenceData) {
           this.#handleInitialPresence(presenceData);
         }
@@ -192,39 +259,54 @@ var Channel = class {
       this.#resetConnectionState();
       reject(error instanceof Error ? error : new Error("Subscribe failed"));
     });
-    return promise;
+    await deferred.promise;
+    return this;
   }
   /**
    * Unsubscribes from the channel.
    */
   async unsubscribe(options = {}) {
-    if (!this.#subscribed && !this.#active) return;
     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;
     }
-    return new Promise((resolve) => {
+    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(() => {
-        this.#cleanupTerminal();
         resolve();
       }, timeout);
       this.#transport.sendRequest({ type: "unsubscribe", channel: this.name }, timeout).then(() => {
         clearTimeout(timer);
-        this.#cleanupTerminal();
         resolve();
       }).catch(() => {
         clearTimeout(timer);
-        this.#cleanupTerminal();
         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;
   }
-  /**
-   * Sends an event to the server.
-   */
   send(event, data) {
     if (!this.#active) {
       console.warn(`Cannot send to channel ${this.name}: not subscribed`);
@@ -254,9 +336,6 @@ var Channel = class {
     this.#transport.send({ type: "whisper", ...payload });
     return this;
   }
-  /**
-   * Sends an event and waits for a response.
-   */
   async sendWithAck(event, data) {
     if (!this.#active) {
       throw new Error(`Cannot send to channel ${this.name}: not subscribed`);
@@ -280,8 +359,9 @@ var Channel = class {
    */
   #setupSocketListeners() {
     this.#boundPresenceHandler = (data) => {
-      if (!data || typeof data !== "object") return;
-      this.#handlePresenceUpdate(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) => {
@@ -289,7 +369,9 @@ var Channel = class {
       const payload = data;
       if (!payload.event) return;
       const handlers = this.#eventHandlers.get(payload.event);
-      handlers?.forEach((handler) => handler(payload.data));
+      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 = () => {
@@ -304,7 +386,9 @@ var Channel = class {
   #handleInitialPresence(data) {
     this.#presence = data;
     this.#presentUserIds = new Set(data.users.map((u) => u.id));
-    this.#hereHandler?.(data.users);
+    if (this.#hereHandler) {
+      callClientHandler(this.#hereHandler, data.users);
+    }
   }
   /**
    * Handles a presence update.
@@ -316,21 +400,23 @@ var Channel = class {
   #handlePresenceUpdate(data) {
     const previousIds = this.#presentUserIds;
     const currentIds = new Set(data.users.map((u) => u.id));
-    for (const user of data.users) {
-      if (!previousIds.has(user.id)) {
-        this.#joiningHandler?.(user);
+    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);
       }
     }
-    if (this.#presence) {
-      for (const user of this.#presence.users) {
-        if (!currentIds.has(user.id)) {
-          this.#leavingHandler?.(user);
-        }
+    for (const user of leavingUsers) {
+      if (this.#leavingHandler) {
+        callClientHandler(this.#leavingHandler, user);
       }
     }
-    this.#presence = data;
-    this.#presentUserIds = currentIds;
-    this.#hereHandler?.(data.users);
+    if (this.#hereHandler) {
+      callClientHandler(this.#hereHandler, data.users);
+    }
   }
   #resetConnectionState() {
     this.#active = false;
@@ -358,14 +444,17 @@ var Channel = class {
     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.#subscribed = false;
     this.#resetConnectionState();
     this.#detachTransportListeners();
-    this.#clearUserCallbacks();
+    this.#clearCallbacks();
   }
 };
 
@@ -411,8 +500,16 @@ var ClientSocketSession = class {
     }
     this.#manualDisconnect = false;
     this.#setState("connecting");
+    let setupFailed = false;
     const connectPromise = new Promise((resolve, reject) => {
-      const ws = this.#createWebSocket(this.#buildUrl());
+      let ws;
+      try {
+        ws = this.#createWebSocket(this.#buildUrl());
+      } catch (error) {
+        setupFailed = true;
+        reject(error);
+        return;
+      }
       this.#ws = ws;
       let settled = false;
       const cleanup = () => {
@@ -434,12 +531,20 @@ var ClientSocketSession = class {
         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.#setState("connected");
         this.#emitLocal("connect");
-        this.#onConnected?.();
+        if (this.#onConnected) {
+          this.#callHandler(this.#onConnected);
+        }
         resolve();
       };
       const handleError = () => {
@@ -457,10 +562,18 @@ var ClientSocketSession = class {
       this.#cancelConnect = cancelConnect;
       ws.addEventListener("open", handleOpen);
       ws.addEventListener("error", handleError);
-      ws.addEventListener("message", (event) => this.#handleIncoming(event.data));
+      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() {
@@ -471,7 +584,14 @@ var ClientSocketSession = class {
     }
     this.#cancelConnect?.(new Error("Socket disconnected"));
     this.#reconnectAttempts = 0;
-    this.#ws?.close();
+    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) {
@@ -493,24 +613,30 @@ var ClientSocketSession = class {
     this.#eventHandlers.get(event)?.delete(handler);
   }
   send(message) {
-    if (this.#ws?.readyState !== WebSocket.OPEN) {
+    const ws = this.#ws;
+    if (ws?.readyState !== WebSocket.OPEN) {
       return;
     }
-    this.#ws.send(JSON.stringify(message));
+    ws.send(JSON.stringify(message));
   }
   sendRequest(message, timeout = 5e3) {
-    if (this.#ws?.readyState !== WebSocket.OPEN) {
+    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 = { id, ...message };
+    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 });
-      this.#ws.send(JSON.stringify(payload));
+      this.#pendingRequests.set(id, {
+        resolve,
+        reject,
+        timer
+      });
+      ws.send(JSON.stringify(payload));
     });
   }
   #handleIncoming(raw) {
@@ -541,7 +667,16 @@ var ClientSocketSession = class {
     try {
       const data = typeof raw === "string" ? raw : String(raw);
       const message = JSON.parse(data);
-      return message && typeof message === "object" ? message : null;
+      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;
     }
@@ -564,6 +699,7 @@ var ClientSocketSession = class {
   }
   #handleClose() {
     const shouldEmitDisconnect = this.#state !== "disconnected";
+    this.#ws = null;
     this.#setState("disconnected");
     if (shouldEmitDisconnect) {
       this.#emitLocal("disconnect");
@@ -582,7 +718,11 @@ var ClientSocketSession = class {
     this.#reconnectAttempts += 1;
     this.#reconnectTimer = setTimeout(() => {
       this.#reconnectTimer = null;
-      this.connect().catch(() => this.#handleClose());
+      this.connect().catch(() => {
+        if (this.#state === "disconnected") {
+          this.#scheduleReconnect();
+        }
+      });
     }, delay);
   }
   #rejectPending(error) {
@@ -593,14 +733,17 @@ var ClientSocketSession = class {
     }
   }
   #emitLocal(event, data) {
-    this.#eventHandlers.get(event)?.forEach((handler) => handler(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) => handler(state));
+    this.#stateHandlers.forEach((handler) => this.#callHandler(handler, state));
+  }
+  #callHandler(handler, data) {
+    callClientHandler(handler, data);
   }
 };
 
@@ -631,9 +774,6 @@ var Socket = class {
   get connected() {
     return this.#session.connected;
   }
-  get id() {
-    return void 0;
-  }
   connect() {
     return this.#session.connect();
   }
@@ -642,7 +782,6 @@ var Socket = class {
       channel.unsubscribe().catch(() => {
       });
     }
-    this.#channels.clear();
     this.#session.disconnect();
   }
   channel(name) {
@@ -655,7 +794,9 @@ var Socket = class {
     const channel = this.#channels.get(name);
     if (channel) {
       await channel.unsubscribe();
-      this.#channels.delete(name);
+      if (this.#channels.get(name) === channel && !channel.subscribed) {
+        this.#channels.delete(name);
+      }
     }
   }
   onStateChange(handler) {
@@ -676,14 +817,20 @@ var Socket = class {
   #buildUrl() {
     const browserGlobal = globalThis;
     const url = new URL(this.#url || browserGlobal.location?.origin || "http://localhost");
-    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    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.subscribe().catch(console.error);
+        await channel.$resubscribe().catch(reportClientError);
       }
     }
   }