@rlanz/socket 0.0.1-0

package/build/src/client/index.js

@@ -0,0 +1,671 @@
+// src/client/channel.ts
+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();
+  /**
+   * 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;
+  constructor(name, transport) {
+    this.name = name;
+    this.#transport = transport;
+  }
+  /**
+   * Whether the channel should stay subscribed.
+   */
+  get subscribed() {
+    return this.#subscribed;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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);
+    return this;
+  }
+  /**
+   * Removes an event listener.
+   */
+  stopListening(event, handler) {
+    if (handler) {
+      this.#eventHandlers.get(event)?.delete(handler);
+    } else {
+      this.#eventHandlers.delete(event);
+    }
+    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;
+    if (this.#pendingSubscribe) {
+      return this.#pendingSubscribe.promise;
+    }
+    if (this.#active) {
+      return this;
+    }
+    const timeout = options.timeout ?? 5e3;
+    if (!this.#listenersAttached) {
+      this.#setupSocketListeners();
+    }
+    const token = ++this.#subscribeToken;
+    let resolvePromise;
+    let rejectPromise;
+    const promise = new Promise((resolve2, reject2) => {
+      resolvePromise = resolve2;
+      rejectPromise = reject2;
+    });
+    this.#pendingSubscribe = {
+      promise,
+      resolve: resolvePromise,
+      reject: rejectPromise,
+      token
+    };
+    const { resolve, reject } = this.#pendingSubscribe;
+    const timer = setTimeout(() => {
+      if (token !== this.#subscribeToken) return;
+      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 = 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"));
+    });
+    return promise;
+  }
+  /**
+   * Unsubscribes from the channel.
+   */
+  async unsubscribe(options = {}) {
+    if (!this.#subscribed && !this.#active) return;
+    this.#subscribed = false;
+    this.#subscribeToken++;
+    if (this.#pendingSubscribe) {
+      this.#pendingSubscribe.reject(new Error(`Unsubscribed from channel: ${this.name}`));
+      this.#pendingSubscribe = null;
+    }
+    return 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();
+      });
+    });
+  }
+  /**
+   * Sends an event to the server.
+   */
+  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;
+  }
+  /**
+   * 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`);
+    }
+    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) => {
+      if (!data || typeof data !== "object") return;
+      this.#handlePresenceUpdate(data);
+    };
+    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) => 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));
+    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));
+    for (const user of data.users) {
+      if (!previousIds.has(user.id)) {
+        this.#joiningHandler?.(user);
+      }
+    }
+    if (this.#presence) {
+      for (const user of this.#presence.users) {
+        if (!currentIds.has(user.id)) {
+          this.#leavingHandler?.(user);
+        }
+      }
+    }
+    this.#presence = data;
+    this.#presentUserIds = currentIds;
+    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;
+  }
+  /**
+   * Performs terminal cleanup after the user leaves or the socket is disposed.
+   */
+  #cleanupTerminal() {
+    this.#subscribed = false;
+    this.#resetConnectionState();
+    this.#detachTransportListeners();
+    this.#clearUserCallbacks();
+  }
+};
+
+// 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");
+    const connectPromise = new Promise((resolve, reject) => {
+      const ws = this.#createWebSocket(this.#buildUrl());
+      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 = () => {
+        settled = true;
+        cleanup();
+        this.#reconnectAttempts = 0;
+        this.#setState("connected");
+        this.#emitLocal("connect");
+        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) => this.#handleIncoming(event.data));
+      ws.addEventListener("close", handleClose);
+    });
+    this.#connectPromise = connectPromise;
+    return connectPromise;
+  }
+  disconnect() {
+    this.#manualDisconnect = true;
+    if (this.#reconnectTimer) {
+      clearTimeout(this.#reconnectTimer);
+      this.#reconnectTimer = null;
+    }
+    this.#cancelConnect?.(new Error("Socket disconnected"));
+    this.#reconnectAttempts = 0;
+    this.#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) {
+    if (this.#ws?.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    this.#ws.send(JSON.stringify(message));
+  }
+  sendRequest(message, timeout = 5e3) {
+    if (this.#ws?.readyState !== WebSocket.OPEN) {
+      return Promise.reject(new Error("Socket is not connected"));
+    }
+    const id = String(++this.#requestId);
+    const payload = { id, ...message };
+    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));
+    });
+  }
+  #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);
+      return message && typeof message === "object" ? message : 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.#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(() => this.#handleClose());
+    }, 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) => handler(data));
+  }
+  #setState(state) {
+    if (this.#state === state) {
+      return;
+    }
+    this.#state = state;
+    this.#stateHandlers.forEach((handler) => handler(state));
+  }
+};
+
+// src/client/socket.ts
+var Socket = class {
+  #channels = /* @__PURE__ */ new Map();
+  #url;
+  #path;
+  #auth;
+  #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.#auth = options.auth;
+    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;
+  }
+  get id() {
+    return void 0;
+  }
+  connect() {
+    return this.#session.connect();
+  }
+  disconnect() {
+    for (const channel of this.#channels.values()) {
+      channel.unsubscribe().catch(() => {
+      });
+    }
+    this.#channels.clear();
+    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();
+      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");
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.pathname = this.#path;
+    if (this.#auth) {
+      url.searchParams.set("auth", JSON.stringify(this.#auth));
+    }
+    return url.toString();
+  }
+  async #resubscribeChannels() {
+    for (const channel of this.#channels.values()) {
+      if (channel.subscribed && !channel.active) {
+        await channel.subscribe().catch(console.error);
+      }
+    }
+  }
+};
+export {
+  Channel,
+  Socket
+};
+//# sourceMappingURL=index.js.map