react-websocket 2.1.0 → 3.0.0

package/dist/core.js

@@ -0,0 +1,469 @@
+// src/types.ts
+var MessageError = class extends Error {
+  /** The raw `event.data` that failed. */
+  data;
+  /** Schema validation issues, when the message failed `schema`. */
+  issues;
+  constructor(message, data, options) {
+    super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "MessageError";
+    this.data = data;
+    this.issues = options?.issues;
+  }
+};
+
+// src/client.ts
+var OPEN = 1;
+var RECONNECT_DEFAULTS = {
+  maxAttempts: Infinity,
+  minDelay: 1e3,
+  maxDelay: 3e4,
+  factor: 2,
+  jitter: 0.5
+};
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  promise.status = "pending";
+  promise.catch(() => {
+  });
+  const deferred = {
+    promise,
+    settled: false,
+    resolve() {
+      if (deferred.settled) return;
+      deferred.settled = true;
+      promise.status = "fulfilled";
+      promise.value = void 0;
+      resolve();
+    },
+    reject(reason) {
+      if (deferred.settled) return;
+      deferred.settled = true;
+      promise.status = "rejected";
+      promise.reason = reason;
+      reject(reason);
+    }
+  };
+  return deferred;
+}
+function rethrowAsync(error) {
+  queueMicrotask(() => {
+    throw error;
+  });
+}
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+var ON_TEARDOWN = /* @__PURE__ */ Symbol.for("react-websocket.onTeardown");
+function createClient(url, options = {}) {
+  const onTeardown = options[ON_TEARDOWN];
+  const log = options.logger ?? (() => {
+  });
+  const retry = options.reconnect === false ? null : {
+    ...RECONNECT_DEFAULTS,
+    ...typeof options.reconnect === "object" ? options.reconnect : {}
+  };
+  const queueLimit = options.queue === false ? 0 : typeof options.queue === "object" ? Math.max(0, options.queue.limit ?? Infinity) : Infinity;
+  let snapshot = { status: "idle", lastMessage: void 0, attempt: 0 };
+  const storeListeners = /* @__PURE__ */ new Set();
+  const listeners = {
+    open: /* @__PURE__ */ new Set(),
+    message: /* @__PURE__ */ new Set(),
+    close: /* @__PURE__ */ new Set(),
+    error: /* @__PURE__ */ new Set()
+  };
+  let ws = null;
+  let wanted = false;
+  let refs = 0;
+  let pinned = false;
+  let pending = [];
+  let ready = null;
+  let opened = false;
+  let unavailable = null;
+  let startScheduled = false;
+  let inbox = null;
+  let generation = 0;
+  let windowBound = false;
+  let retryTimer;
+  let teardownTimer;
+  let heartbeatTimer;
+  let pongTimer;
+  function set(patch) {
+    snapshot = { ...snapshot, ...patch };
+    for (const listener of [...storeListeners]) listener();
+  }
+  function emit(type, ...args) {
+    for (const listener of [...listeners[type]]) {
+      try {
+        listener(...args);
+      } catch (error) {
+        rethrowAsync(error);
+      }
+    }
+  }
+  function getImpl() {
+    if (options.WebSocket) return options.WebSocket;
+    return typeof window === "undefined" ? void 0 : globalThis.WebSocket;
+  }
+  function rejectReady(reason) {
+    if (!ready || ready.settled) ready = createDeferred();
+    ready.reject(reason);
+  }
+  function retryNow() {
+    if (retryTimer !== void 0) {
+      log("network or visibility change, retrying now");
+      open();
+    }
+  }
+  function onVisibilityChange() {
+    if (document.visibilityState === "visible") retryNow();
+  }
+  function bindWindow() {
+    if (windowBound || typeof window === "undefined") return;
+    windowBound = true;
+    window.addEventListener("online", retryNow);
+    document.addEventListener("visibilitychange", onVisibilityChange);
+  }
+  function unbindWindow() {
+    if (!windowBound) return;
+    windowBound = false;
+    window.removeEventListener("online", retryNow);
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+  }
+  function startHeartbeat(socket) {
+    const heartbeat = options.heartbeat;
+    if (!heartbeat) return;
+    heartbeatTimer = setInterval(() => {
+      socket.send(heartbeat.message ?? "ping");
+      if (heartbeat.timeout && pongTimer === void 0) {
+        pongTimer = setTimeout(() => {
+          log("heartbeat timeout");
+          detach(socket, false);
+          socket.close(4e3, "heartbeat timeout");
+          handleClose({ code: 4e3, reason: "heartbeat timeout", wasClean: false });
+        }, heartbeat.timeout);
+      }
+    }, heartbeat.interval);
+  }
+  function stopHeartbeat() {
+    clearInterval(heartbeatTimer);
+    clearTimeout(pongTimer);
+    heartbeatTimer = pongTimer = void 0;
+  }
+  function detach(socket, reportClose) {
+    if (ws === socket) ws = null;
+    socket.onopen = socket.onmessage = socket.onerror = null;
+    socket.onclose = reportClose ? (event) => emit("close", { code: event.code, reason: event.reason, wasClean: event.wasClean }) : null;
+  }
+  function backoff(attempt) {
+    const { minDelay, maxDelay, factor, jitter } = retry;
+    const base = Math.min(maxDelay, minDelay * factor ** (attempt - 1));
+    return Math.round(base * (1 - jitter * Math.random()));
+  }
+  function open() {
+    clearTimeout(retryTimer);
+    retryTimer = void 0;
+    const Impl = getImpl();
+    if (!Impl) return;
+    const id = ++generation;
+    set({ status: snapshot.attempt === 0 ? "connecting" : "reconnecting" });
+    let target;
+    try {
+      target = typeof url === "string" ? url : url();
+    } catch (error) {
+      urlFailed(error);
+      return;
+    }
+    if (typeof target === "string") {
+      start(Impl, target);
+      return;
+    }
+    Promise.resolve(target).then(
+      (resolved) => {
+        if (id === generation && wanted) start(Impl, resolved);
+      },
+      (error) => {
+        if (id === generation && wanted) urlFailed(error);
+      }
+    );
+  }
+  function urlFailed(error) {
+    const reason = error instanceof Error ? error : new Error(String(error));
+    log("url() failed", reason);
+    emit("error", reason);
+    retryOrFail({ code: 1006, reason: "url() failed", wasClean: false }, reason);
+  }
+  function start(Impl, target) {
+    let socket;
+    try {
+      socket = new Impl(target, options.protocols);
+    } catch (error) {
+      emit("error", error);
+      fail(error);
+      return;
+    }
+    if (options.binaryType) socket.binaryType = options.binaryType;
+    ws = socket;
+    log("connecting", target);
+    socket.onopen = (event) => {
+      log("open");
+      opened = true;
+      set({ status: "open", attempt: 0 });
+      startHeartbeat(socket);
+      ready?.resolve();
+      emit("open", event);
+      if (ws !== socket) return;
+      const queued = pending;
+      pending = [];
+      for (const data of queued) socket.send(data);
+    };
+    socket.onmessage = (event) => receive(event, socket);
+    socket.onerror = (event) => emit("error", event);
+    socket.onclose = (event) => {
+      detach(socket, false);
+      handleClose({ code: event.code, reason: event.reason, wasClean: event.wasClean });
+    };
+  }
+  function handleClose(info) {
+    stopHeartbeat();
+    log("closed", info);
+    retryOrFail(info);
+    emit("close", info);
+  }
+  function retryOrFail(info, error) {
+    if (wanted && retry && snapshot.attempt < retry.maxAttempts && (retry.shouldReconnect?.(info) ?? true)) {
+      const attempt = snapshot.attempt + 1;
+      const delay = backoff(attempt);
+      set({ status: "reconnecting", attempt });
+      log(`reconnecting in ${delay}ms (attempt ${attempt})`);
+      retryTimer = setTimeout(open, delay);
+    } else {
+      fail(
+        error ?? new Error(`WebSocket closed (code ${info.code}${info.reason ? `: ${info.reason}` : ""})`)
+      );
+    }
+  }
+  function fail(reason) {
+    wanted = false;
+    opened = false;
+    unbindWindow();
+    pending = [];
+    set({ status: "closed" });
+    rejectReady(reason);
+  }
+  function receive(event, socket) {
+    clearTimeout(pongTimer);
+    pongTimer = void 0;
+    if (options.heartbeat?.pong !== void 0 && event.data === options.heartbeat.pong) return;
+    const run = () => decode(event, socket);
+    if (inbox) {
+      const next = inbox.then(run).then(() => {
+        if (inbox === next) inbox = null;
+      });
+      inbox = next;
+      return;
+    }
+    const result = run();
+    if (result) {
+      const next = result.then(() => {
+        if (inbox === next) inbox = null;
+      });
+      inbox = next;
+    }
+  }
+  function decode(event, socket) {
+    let value;
+    try {
+      value = options.parse ? options.parse(event.data) : options.json ? JSON.parse(event.data) : event.data;
+    } catch (cause) {
+      emit("error", new MessageError("Failed to parse message", event.data, { cause }));
+      return;
+    }
+    const schema = options.schema;
+    if (!schema) return deliver(value, event, socket);
+    let result;
+    try {
+      result = schema["~standard"].validate(value);
+    } catch (cause) {
+      emit("error", new MessageError("Schema validation threw", event.data, { cause }));
+      return;
+    }
+    if (isThenable(result)) {
+      return Promise.resolve(result).then(
+        (r) => validated(r, event, socket),
+        (cause) => emit("error", new MessageError("Schema validation threw", event.data, { cause }))
+      );
+    }
+    validated(result, event, socket);
+  }
+  function validated(result, event, socket) {
+    if (result.issues) {
+      emit(
+        "error",
+        new MessageError("Message failed schema validation", event.data, { issues: result.issues })
+      );
+    } else {
+      deliver(result.value, event, socket);
+    }
+  }
+  function deliver(message, event, socket) {
+    if (ws !== socket) return;
+    set({ lastMessage: message });
+    emit("message", message, event);
+  }
+  function send(message) {
+    const data = options.serialize ? options.serialize(message) : options.json ? JSON.stringify(message) : message;
+    if (ws && ws.readyState === OPEN) {
+      ws.send(data);
+      return true;
+    }
+    if (queueLimit === 0) {
+      log("dropped message: socket is not open");
+      return false;
+    }
+    if (!getImpl()) {
+      log("dropped message: no WebSocket implementation available");
+      return false;
+    }
+    pending.push(data);
+    if (pending.length > queueLimit) {
+      pending.shift();
+      log(`dropped oldest queued message: queue limit (${queueLimit}) reached`);
+    }
+    return false;
+  }
+  function begin() {
+    wanted = true;
+    if (snapshot.status === "idle" || snapshot.status === "closed") {
+      opened = false;
+      if (ready?.settled) ready = null;
+    }
+    snapshot = { ...snapshot, attempt: 0 };
+    bindWindow();
+    open();
+  }
+  function ensureConnecting() {
+    if (wanted || !getImpl()) return;
+    begin();
+  }
+  function connect() {
+    pinned = true;
+    ensureConnecting();
+  }
+  function stop(code, reason) {
+    wanted = false;
+    generation++;
+    clearTimeout(retryTimer);
+    retryTimer = void 0;
+    stopHeartbeat();
+    unbindWindow();
+    pending = [];
+    if (ws) {
+      const socket = ws;
+      detach(socket, true);
+      socket.close(code, reason);
+    }
+  }
+  function close(code = 1e3, reason) {
+    pinned = false;
+    opened = false;
+    stop(code, reason);
+    set({ status: "closed", attempt: 0 });
+    rejectReady(new Error("WebSocket was closed"));
+  }
+  function reconnect() {
+    if (!getImpl()) return;
+    clearTimeout(retryTimer);
+    retryTimer = void 0;
+    stopHeartbeat();
+    if (ws) {
+      const socket = ws;
+      detach(socket, true);
+      socket.close(1e3, "reconnect");
+    }
+    begin();
+  }
+  function teardown() {
+    if (refs > 0 || pinned) return;
+    if (ready && !ready.settled) return;
+    stop();
+    ready = null;
+    opened = false;
+    set({ status: "idle", attempt: 0 });
+    onTeardown?.();
+  }
+  function acquire() {
+    refs++;
+    clearTimeout(teardownTimer);
+    if (snapshot.status === "idle") ensureConnecting();
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      if (--refs > 0) return;
+      clearTimeout(teardownTimer);
+      teardownTimer = setTimeout(teardown, 0);
+    };
+  }
+  return {
+    url,
+    get ready() {
+      if (!getImpl()) {
+        if (!unavailable) {
+          unavailable = createDeferred();
+          unavailable.reject(
+            new Error("react-websocket: no WebSocket available here (server render?)")
+          );
+        }
+        return unavailable.promise;
+      }
+      if (snapshot.status === "idle" && !startScheduled) {
+        startScheduled = true;
+        queueMicrotask(() => {
+          startScheduled = false;
+          if (snapshot.status === "idle") ensureConnecting();
+        });
+      }
+      if (!ready) {
+        ready = createDeferred();
+        if (opened) ready.resolve();
+      }
+      return ready.promise;
+    },
+    get socket() {
+      return ws;
+    },
+    subscribe(listener) {
+      storeListeners.add(listener);
+      return () => {
+        storeListeners.delete(listener);
+      };
+    },
+    getSnapshot: () => snapshot,
+    on(type, listener) {
+      const entry = ((...args) => listener(...args));
+      listeners[type].add(entry);
+      return () => {
+        listeners[type].delete(entry);
+      };
+    },
+    send,
+    connect,
+    close,
+    reconnect,
+    acquire
+  };
+}
+function createWebSocket(url, options) {
+  return createClient(url, options);
+}
+export {
+  MessageError,
+  createWebSocket
+};
+//# sourceMappingURL=core.js.map

package/dist/core.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/client.ts"],"sourcesContent":["/**\n * Where to connect: a URL, or a function that returns one (sync or async).\n *\n * A function is called before **every** connection attempt, including reconnects,\n * so it can put a fresh auth token in the URL. If it throws or rejects, that counts\n * as a failed attempt and is retried with backoff.\n *\n * @example\n * ```ts\n * createWebSocket(async () => `wss://api.example.com/live?token=${await getToken()}`);\n * ```\n */\nexport type UrlSource = string | (() => string | Promise<string>);\n\n/**\n * Connection state.\n *\n * - `idle`: not connected and not trying to be. Nobody is using the client yet, or everyone stopped.\n * - `connecting`: the first attempt is in progress.\n * - `open`: connected. `send()` goes out immediately.\n * - `reconnecting`: the connection dropped (or an attempt failed) and a retry is scheduled or in progress.\n * - `closed`: stopped for good, by `close()` or after giving up on reconnecting.\n *   It stays closed until `connect()` or `reconnect()` is called, or every hook unmounts.\n */\nexport type Status = 'idle' | 'connecting' | 'open' | 'reconnecting' | 'closed';\n\n/** The client's state as seen by React. A new object is created on every change. */\nexport interface Snapshot<In> {\n  /** Connection state. */\n  readonly status: Status;\n  /** Most recent message (after `parse`/`json` and `schema`), kept across reconnects. */\n  readonly lastMessage: In | undefined;\n  /** Consecutive failed attempts since the last successful open. `0` while open. */\n  readonly attempt: number;\n}\n\n/** Details of a closed connection, from the browser's `CloseEvent`. */\nexport interface CloseInfo {\n  /** Close code: `1000` is a normal close, `1006` an abnormal one (e.g. network loss), `4000`–`4999` are yours. */\n  readonly code: number;\n  /** Close reason sent by the side that closed the connection. Often empty. */\n  readonly reason: string;\n  /** Whether the closing handshake completed. */\n  readonly wasClean: boolean;\n}\n\n/** Anything `WebSocket.prototype.send` accepts: a string, `Blob`, `ArrayBuffer` or typed array. */\nexport type SendData = Parameters<WebSocket['send']>[0];\n\n/** Reconnect timing. Delay before attempt `n` = `min(maxDelay, minDelay * factor ** (n - 1))`, minus jitter. */\nexport interface ReconnectOptions {\n  /**\n   * Maximum consecutive reconnect attempts. When the last one fails too, the client\n   * gives up: the status becomes `closed` and `ready` rejects. `0` never retries.\n   * @default Infinity\n   */\n  maxAttempts?: number;\n  /**\n   * Delay before the first retry, in ms.\n   * @default 1000\n   */\n  minDelay?: number;\n  /**\n   * Upper bound for the delay, in ms.\n   * @default 30000\n   */\n  maxDelay?: number;\n  /**\n   * Backoff multiplier applied per attempt.\n   * @default 2\n   */\n  factor?: number;\n  /**\n   * Randomly shave up to this fraction (0–1) off each delay, so that many clients\n   * dropped at once don't all reconnect at the same moment.\n   * @default 0.5\n   */\n  jitter?: number;\n  /**\n   * Called on every unexpected close. Return `false` to stop reconnecting.\n   *\n   * @example\n   * ```ts\n   * // Don't retry when the server rejects our credentials.\n   * shouldReconnect: close => close.code !== 4001\n   * ```\n   * @default () => true\n   */\n  shouldReconnect?: (close: CloseInfo) => boolean;\n}\n\n/** Application-level keep-alive. Useful behind proxies that drop idle connections. */\nexport interface HeartbeatOptions {\n  /** Send `message` every `interval` ms while open. */\n  interval: number;\n  /**\n   * Sent as-is (it is not passed through `serialize` or `json`).\n   * @default 'ping'\n   */\n  message?: string;\n  /** Incoming data equal to this string is swallowed instead of being delivered as a message. */\n  pong?: string;\n  /**\n   * If nothing at all arrives within this many ms after a ping, the connection is\n   * treated as dead: it closes with code `4000` and reconnects.\n   */\n  timeout?: number;\n}\n\n/** Bounds for the send queue. */\nexport interface QueueOptions {\n  /**\n   * Maximum number of messages held while not connected. When full, the oldest\n   * message is dropped.\n   * @default Infinity\n   */\n  limit?: number;\n}\n\n/**\n * The minimal [Standard Schema v1](https://standardschema.dev) interface, implemented\n * by zod (3.24+), valibot (1.0+), arktype (2.0+) and others. You don't need to\n * import this; pass your schema object directly.\n */\nexport interface StandardSchemaV1<Input = unknown, Output = Input> {\n  readonly '~standard': {\n    readonly version: 1;\n    readonly vendor: string;\n    readonly validate: (\n      value: unknown\n    ) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;\n    readonly types?: { readonly input: Input; readonly output: Output } | undefined;\n  };\n}\n\n/** The result of a Standard Schema `validate` call. */\nexport type StandardSchemaResult<Output> =\n  | { readonly value: Output; readonly issues?: undefined }\n  | { readonly issues: ReadonlyArray<{ readonly message: string }> };\n\n/**\n * Connection options, shared by `createWebSocket(url, options)` and `useWebSocket(url, options)`.\n *\n * @typeParam In - Type of incoming messages (after `parse`/`json`/`schema`).\n * @typeParam Out - Type accepted by `send()`.\n */\nexport interface WebSocketOptions<In = unknown, Out = unknown> {\n  /** Sub-protocol(s) passed to the `WebSocket` constructor. */\n  protocols?: string | string[];\n  /**\n   * How binary messages are exposed.\n   * @default 'blob'\n   */\n  binaryType?: BinaryType;\n  /**\n   * `JSON.parse` incoming and `JSON.stringify` outgoing messages. Messages that fail\n   * to parse are reported to `onError` as a {@link MessageError} and not delivered.\n   * @default false\n   */\n  json?: boolean;\n  /**\n   * Custom decoder for incoming `event.data`. Takes precedence over `json`.\n   * Throwing reports a {@link MessageError} and drops the message.\n   */\n  parse?: (data: unknown) => unknown;\n  /** Custom encoder for outgoing messages. Takes precedence over `json`. */\n  serialize?: (message: Out) => SendData;\n  /**\n   * Validate incoming messages (after parsing) with any Standard Schema library.\n   * Invalid messages are reported to `onError` as a {@link MessageError} and not delivered.\n   * The message type `In` is inferred from it.\n   *\n   * @example\n   * ```ts\n   * createWebSocket(url, { json: true, schema: z.object({ price: z.number() }) });\n   * ```\n   */\n  schema?: StandardSchemaV1<unknown, In>;\n  /**\n   * Reconnect with exponential backoff after an unexpected close. `false` disables it.\n   * @default true\n   */\n  reconnect?: boolean | ReconnectOptions;\n  /** Send a ping on an interval and, optionally, reconnect when the server goes quiet. */\n  heartbeat?: HeartbeatOptions;\n  /**\n   * Buffer `send()` calls made while not connected and send them, in order, on open\n   * (right after `open` listeners run).\n   * `false` drops them instead. `{ limit }` caps the buffer, dropping the oldest.\n   * The queue is cleared by `close()` or when the client gives up.\n   * @default true\n   */\n  queue?: boolean | QueueOptions;\n  /**\n   * Receives debug messages about connection attempts, retries and dropped messages.\n   * @example\n   * ```ts\n   * logger: console.debug\n   * ```\n   */\n  logger?: (message: string, ...details: unknown[]) => void;\n  /**\n   * `WebSocket` implementation to use, e.g. a mock in tests or the `ws` package in Node.\n   * When omitted, the global `WebSocket` is used in browsers. During a server render\n   * (no `window`), nothing connects unless an implementation is passed.\n   */\n  WebSocket?: typeof WebSocket;\n}\n\n/**\n * Reported via the `error` event (and `onError`) when an incoming message can't be\n * decoded by `parse`/`json` or fails `schema` validation. The message is not delivered.\n *\n * @example\n * ```ts\n * onError(error) {\n *   if (error instanceof MessageError) report(error.data, error.issues);\n * }\n * ```\n */\nexport class MessageError extends Error {\n  /** The raw `event.data` that failed. */\n  readonly data: unknown;\n  /** Schema validation issues, when the message failed `schema`. */\n  readonly issues: ReadonlyArray<{ readonly message: string }> | undefined;\n\n  constructor(\n    message: string,\n    data: unknown,\n    options?: { cause?: unknown; issues?: ReadonlyArray<{ readonly message: string }> }\n  ) {\n    super(message, options?.cause === undefined ? undefined : { cause: options.cause });\n    this.name = 'MessageError';\n    this.data = data;\n    this.issues = options?.issues;\n  }\n}\n\n/** Events emitted by a client. Subscribe with `client.on(type, listener)` or `useWebSocketEvent`. */\nexport interface EventMap<In> {\n  /**\n   * The socket opened (initially or after a reconnect). Listeners run before queued\n   * messages are sent, so a handshake sent from here goes out first.\n   */\n  open: (event: Event) => void;\n  /** A message arrived and passed `parse` and `schema`. */\n  message: (message: In, event: MessageEvent) => void;\n  /** A socket closed, whether it will be retried or not. */\n  close: (close: CloseInfo) => void;\n  /**\n   * A socket error `Event`, a {@link MessageError} for an undecodable or invalid message,\n   * or the `Error` thrown by the `WebSocket` constructor or a `url` function.\n   */\n  error: (error: Event | MessageError | Error) => void;\n}\n\n/**\n * A WebSocket connection that reconnects, queues, decodes and can be shared.\n * Create one with `createWebSocket()`.\n *\n * The connection is reference-counted: it opens when the first hook mounts (or\n * `ready` is read) and closes one tick after the last hook unmounts. Calling\n * `connect()` keeps it open regardless, until `close()`.\n *\n * @typeParam In - Type of incoming messages.\n * @typeParam Out - Type accepted by `send()`.\n */\nexport interface WebSocketClient<In = unknown, Out = unknown> {\n  /** The URL (or URL function) the client was created with. */\n  readonly url: UrlSource;\n  /**\n   * A promise that resolves once the socket has opened. Reading it starts an idle client.\n   *\n   * It stays resolved through automatic reconnects, so `use(client.ready)` shows a\n   * Suspense fallback only for the first connection, never on a network blip; use\n   * `status` to show reconnects. It rejects when the client gives up reconnecting, when\n   * `close()` is called, and during a server render. After that, `connect()` or\n   * `reconnect()` make it a new pending promise.\n   *\n   * It is safe to pass to React 19's `use()`: the same promise is returned until its state\n   * changes, and it carries `status`/`value`/`reason` so `use()` doesn't suspend when it is\n   * already settled.\n   */\n  readonly ready: Promise<void>;\n  /** The current underlying `WebSocket`, if any. An escape hatch; prefer the client's methods. */\n  readonly socket: WebSocket | null;\n  /** Subscribe to snapshot changes. Compatible with `useSyncExternalStore`. Returns an unsubscribe function. */\n  subscribe(listener: () => void): () => void;\n  /** The current {@link Snapshot}. Returns the same object until something changes. */\n  getSnapshot(): Snapshot<In>;\n  /**\n   * Listen to an event. Returns an unsubscribe function. Listener errors are re-thrown\n   * asynchronously, so one failing listener doesn't break the others.\n   */\n  on<K extends keyof EventMap<In>>(type: K, listener: EventMap<In>[K]): () => void;\n  /**\n   * Send a message (encoded with `serialize`/`json` if configured). If the socket isn't\n   * open, the message is queued and sent on open (see the `queue` option).\n   * @returns `true` if it was sent immediately, `false` if it was queued or dropped.\n   */\n  send(message: Out): boolean;\n  /**\n   * Start connecting, and keep the connection open even when no hook is using the\n   * client, until `close()` is called. Does nothing if already connecting or open.\n   */\n  connect(): void;\n  /**\n   * Close the connection and stop reconnecting. The status becomes `closed` and the\n   * send queue is cleared. Mounted hooks stay mounted; call `connect()` or `reconnect()`\n   * to start again.\n   * @param code - Close code. @default 1000\n   */\n  close(code?: number, reason?: string): void;\n  /**\n   * Drop the current socket (if any) and connect again immediately, resetting the\n   * backoff. Also restarts a `closed` client.\n   */\n  reconnect(): void;\n  /**\n   * Hold the connection open until the returned function is called. This is what the\n   * hooks use; call it yourself to integrate with non-React code.\n   * @returns A release function (safe to call more than once).\n   */\n  acquire(): () => void;\n}\n","import {\n  MessageError,\n  type CloseInfo,\n  type EventMap,\n  type ReconnectOptions,\n  type SendData,\n  type Snapshot,\n  type StandardSchemaResult,\n  type UrlSource,\n  type WebSocketClient,\n  type WebSocketOptions\n} from './types';\n\nconst OPEN = 1;\n\nconst RECONNECT_DEFAULTS = {\n  maxAttempts: Infinity,\n  minDelay: 1000,\n  maxDelay: 30_000,\n  factor: 2,\n  jitter: 0.5\n} satisfies ReconnectOptions;\n\ntype Timer = ReturnType<typeof setTimeout> | undefined;\n\n// React's `use()` reads `status`/`value`/`reason` off a thenable to skip suspending\n// when it is already settled.\ntype TrackedPromise = Promise<void> & {\n  status: 'pending' | 'fulfilled' | 'rejected';\n  value?: void;\n  reason?: unknown;\n};\n\ninterface Deferred {\n  readonly promise: TrackedPromise;\n  settled: boolean;\n  resolve(): void;\n  reject(reason: unknown): void;\n}\n\nfunction createDeferred(): Deferred {\n  let resolve!: () => void;\n  let reject!: (reason: unknown) => void;\n  const promise = new Promise<void>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  }) as TrackedPromise;\n  promise.status = 'pending';\n  // Nobody may be awaiting `ready`; don't surface that as an unhandled rejection.\n  promise.catch(() => {});\n  const deferred: Deferred = {\n    promise,\n    settled: false,\n    resolve() {\n      if (deferred.settled) return;\n      deferred.settled = true;\n      promise.status = 'fulfilled';\n      promise.value = undefined;\n      resolve();\n    },\n    reject(reason) {\n      if (deferred.settled) return;\n      deferred.settled = true;\n      promise.status = 'rejected';\n      promise.reason = reason;\n      reject(reason);\n    }\n  };\n  return deferred;\n}\n\nfunction rethrowAsync(error: unknown) {\n  queueMicrotask(() => {\n    throw error;\n  });\n}\n\nfunction isThenable<T>(value: unknown): value is PromiseLike<T> {\n  return typeof (value as PromiseLike<T> | null)?.then === 'function';\n}\n\n/**\n * @internal Option key for a callback run when the client tears down, which lets the hooks'\n * URL registry forget clients nobody holds anymore. A registered symbol rather than an export,\n * because the hooks entry imports the client from the `core` entry at runtime.\n */\nconst ON_TEARDOWN = Symbol.for('react-websocket.onTeardown');\n\nfunction createClient<In = unknown, Out = unknown>(\n  url: UrlSource,\n  options: WebSocketOptions<In, Out> & { [ON_TEARDOWN]?: () => void } = {}\n): WebSocketClient<In, Out> {\n  const onTeardown = options[ON_TEARDOWN];\n  const log = options.logger ?? (() => {});\n  const retry =\n    options.reconnect === false\n      ? null\n      : {\n          ...RECONNECT_DEFAULTS,\n          ...(typeof options.reconnect === 'object' ? options.reconnect : {})\n        };\n  const queueLimit =\n    options.queue === false\n      ? 0\n      : typeof options.queue === 'object'\n        ? Math.max(0, options.queue.limit ?? Infinity)\n        : Infinity;\n\n  let snapshot: Snapshot<In> = { status: 'idle', lastMessage: undefined, attempt: 0 };\n  const storeListeners = new Set<() => void>();\n  const listeners: { [K in keyof EventMap<In>]: Set<EventMap<In>[K]> } = {\n    open: new Set(),\n    message: new Set(),\n    close: new Set(),\n    error: new Set()\n  };\n\n  let ws: WebSocket | null = null;\n  let wanted = false;\n  let refs = 0;\n  // Set by a public `connect()`: stay connected after the last hook releases, until `close()`.\n  let pinned = false;\n  let pending: SendData[] = [];\n  let ready: Deferred | null = null;\n  // Opened at least once since the client was last started. `ready` stays resolved through\n  // automatic reconnects so `use(client.ready)` doesn't swap content for a fallback on every blip.\n  let opened = false;\n  let unavailable: Deferred | null = null;\n  let startScheduled = false;\n  let inbox: Promise<void> | null = null;\n  // Bumped per connection attempt so a slow `url()` can't resurrect a cancelled one.\n  let generation = 0;\n  let windowBound = false;\n  let retryTimer: Timer;\n  let teardownTimer: Timer;\n  let heartbeatTimer: ReturnType<typeof setInterval> | undefined;\n  let pongTimer: Timer;\n\n  function set(patch: Partial<Snapshot<In>>) {\n    snapshot = { ...snapshot, ...patch };\n    for (const listener of [...storeListeners]) listener();\n  }\n\n  function emit<K extends keyof EventMap<In>>(type: K, ...args: Parameters<EventMap<In>[K]>) {\n    for (const listener of [...listeners[type]]) {\n      try {\n        (listener as (...a: Parameters<EventMap<In>[K]>) => void)(...args);\n      } catch (error) {\n        rethrowAsync(error);\n      }\n    }\n  }\n\n  function getImpl(): typeof WebSocket | undefined {\n    if (options.WebSocket) return options.WebSocket;\n    // Node has a global WebSocket too; don't connect from a server render.\n    return typeof window === 'undefined' ? undefined : globalThis.WebSocket;\n  }\n\n  function rejectReady(reason: unknown) {\n    if (!ready || ready.settled) ready = createDeferred();\n    ready.reject(reason);\n  }\n\n  function retryNow() {\n    if (retryTimer !== undefined) {\n      log('network or visibility change, retrying now');\n      open();\n    }\n  }\n\n  function onVisibilityChange() {\n    if (document.visibilityState === 'visible') retryNow();\n  }\n\n  function bindWindow() {\n    if (windowBound || typeof window === 'undefined') return;\n    windowBound = true;\n    window.addEventListener('online', retryNow);\n    document.addEventListener('visibilitychange', onVisibilityChange);\n  }\n\n  function unbindWindow() {\n    if (!windowBound) return;\n    windowBound = false;\n    window.removeEventListener('online', retryNow);\n    document.removeEventListener('visibilitychange', onVisibilityChange);\n  }\n\n  function startHeartbeat(socket: WebSocket) {\n    const heartbeat = options.heartbeat;\n    if (!heartbeat) return;\n    heartbeatTimer = setInterval(() => {\n      socket.send(heartbeat.message ?? 'ping');\n      if (heartbeat.timeout && pongTimer === undefined) {\n        pongTimer = setTimeout(() => {\n          log('heartbeat timeout');\n          // The close handshake may never finish on a dead link, so don't wait for it.\n          detach(socket, false);\n          socket.close(4000, 'heartbeat timeout');\n          handleClose({ code: 4000, reason: 'heartbeat timeout', wasClean: false });\n        }, heartbeat.timeout);\n      }\n    }, heartbeat.interval);\n  }\n\n  function stopHeartbeat() {\n    clearInterval(heartbeatTimer);\n    clearTimeout(pongTimer);\n    heartbeatTimer = pongTimer = undefined;\n  }\n\n  /** Stop tracking `socket`. Its eventual close event is still reported unless `reportClose` is false. */\n  function detach(socket: WebSocket, reportClose: boolean) {\n    if (ws === socket) ws = null;\n    socket.onopen = socket.onmessage = socket.onerror = null;\n    socket.onclose = reportClose\n      ? event => emit('close', { code: event.code, reason: event.reason, wasClean: event.wasClean })\n      : null;\n  }\n\n  function backoff(attempt: number) {\n    const { minDelay, maxDelay, factor, jitter } = retry!;\n    const base = Math.min(maxDelay, minDelay * factor ** (attempt - 1));\n    return Math.round(base * (1 - jitter * Math.random()));\n  }\n\n  function open() {\n    clearTimeout(retryTimer);\n    retryTimer = undefined;\n    const Impl = getImpl();\n    if (!Impl) return;\n    const id = ++generation;\n    set({ status: snapshot.attempt === 0 ? 'connecting' : 'reconnecting' });\n\n    let target: string | Promise<string>;\n    try {\n      target = typeof url === 'string' ? url : url();\n    } catch (error) {\n      urlFailed(error);\n      return;\n    }\n    if (typeof target === 'string') {\n      start(Impl, target);\n      return;\n    }\n    Promise.resolve(target).then(\n      resolved => {\n        if (id === generation && wanted) start(Impl, resolved);\n      },\n      error => {\n        if (id === generation && wanted) urlFailed(error);\n      }\n    );\n  }\n\n  /** `url()` threw or rejected (e.g. a token refresh failed): count it as a failed attempt. */\n  function urlFailed(error: unknown) {\n    const reason = error instanceof Error ? error : new Error(String(error));\n    log('url() failed', reason);\n    emit('error', reason);\n    retryOrFail({ code: 1006, reason: 'url() failed', wasClean: false }, reason);\n  }\n\n  function start(Impl: typeof WebSocket, target: string) {\n    let socket: WebSocket;\n    try {\n      socket = new Impl(target, options.protocols);\n    } catch (error) {\n      // e.g. an invalid URL; retrying won't help.\n      emit('error', error as Error);\n      fail(error);\n      return;\n    }\n    if (options.binaryType) socket.binaryType = options.binaryType;\n    ws = socket;\n    log('connecting', target);\n\n    socket.onopen = event => {\n      log('open');\n      opened = true;\n      set({ status: 'open', attempt: 0 });\n      startHeartbeat(socket);\n      ready?.resolve();\n      // `open` listeners go first, so a handshake sent from `onOpen` (e.g. auth) precedes\n      // whatever was queued while disconnected.\n      emit('open', event);\n      if (ws !== socket) return; // a listener closed or replaced it\n      const queued = pending;\n      pending = [];\n      for (const data of queued) socket.send(data);\n    };\n    socket.onmessage = event => receive(event, socket);\n    socket.onerror = event => emit('error', event);\n    socket.onclose = event => {\n      detach(socket, false);\n      handleClose({ code: event.code, reason: event.reason, wasClean: event.wasClean });\n    };\n  }\n\n  function handleClose(info: CloseInfo) {\n    stopHeartbeat();\n    log('closed', info);\n    retryOrFail(info);\n    emit('close', info);\n  }\n\n  function retryOrFail(info: CloseInfo, error?: Error) {\n    if (\n      wanted &&\n      retry &&\n      snapshot.attempt < retry.maxAttempts &&\n      (retry.shouldReconnect?.(info) ?? true)\n    ) {\n      const attempt = snapshot.attempt + 1;\n      const delay = backoff(attempt);\n      set({ status: 'reconnecting', attempt });\n      log(`reconnecting in ${delay}ms (attempt ${attempt})`);\n      retryTimer = setTimeout(open, delay);\n    } else {\n      fail(\n        error ??\n          new Error(`WebSocket closed (code ${info.code}${info.reason ? `: ${info.reason}` : ''})`)\n      );\n    }\n  }\n\n  function fail(reason: unknown) {\n    wanted = false;\n    opened = false;\n    unbindWindow();\n    pending = [];\n    set({ status: 'closed' });\n    rejectReady(reason);\n  }\n\n  function receive(event: MessageEvent, socket: WebSocket) {\n    clearTimeout(pongTimer);\n    pongTimer = undefined;\n    if (options.heartbeat?.pong !== undefined && event.data === options.heartbeat.pong) return;\n\n    // Async schema validation must not reorder messages.\n    const run = () => decode(event, socket);\n    if (inbox) {\n      const next: Promise<void> = inbox.then(run).then(() => {\n        if (inbox === next) inbox = null;\n      });\n      inbox = next;\n      return;\n    }\n    const result = run();\n    if (result) {\n      const next: Promise<void> = result.then(() => {\n        if (inbox === next) inbox = null;\n      });\n      inbox = next;\n    }\n  }\n\n  function decode(event: MessageEvent, socket: WebSocket): void | Promise<void> {\n    let value: unknown;\n    try {\n      value = options.parse\n        ? options.parse(event.data)\n        : options.json\n          ? JSON.parse(event.data as string)\n          : event.data;\n    } catch (cause) {\n      emit('error', new MessageError('Failed to parse message', event.data, { cause }));\n      return;\n    }\n\n    const schema = options.schema;\n    if (!schema) return deliver(value as In, event, socket);\n\n    let result: ReturnType<(typeof schema)['~standard']['validate']>;\n    try {\n      result = schema['~standard'].validate(value);\n    } catch (cause) {\n      emit('error', new MessageError('Schema validation threw', event.data, { cause }));\n      return;\n    }\n    if (isThenable<StandardSchemaResult<In>>(result)) {\n      return Promise.resolve(result).then(\n        r => validated(r, event, socket),\n        cause => emit('error', new MessageError('Schema validation threw', event.data, { cause }))\n      );\n    }\n    validated(result, event, socket);\n  }\n\n  function validated(result: StandardSchemaResult<In>, event: MessageEvent, socket: WebSocket) {\n    if (result.issues) {\n      emit(\n        'error',\n        new MessageError('Message failed schema validation', event.data, { issues: result.issues })\n      );\n    } else {\n      deliver(result.value, event, socket);\n    }\n  }\n\n  function deliver(message: In, event: MessageEvent, socket: WebSocket) {\n    if (ws !== socket) return; // closed or replaced while validating\n    set({ lastMessage: message });\n    emit('message', message, event);\n  }\n\n  function send(message: Out): boolean {\n    const data = options.serialize\n      ? options.serialize(message)\n      : options.json\n        ? JSON.stringify(message)\n        : (message as SendData);\n    if (ws && ws.readyState === OPEN) {\n      ws.send(data);\n      return true;\n    }\n    if (queueLimit === 0) {\n      log('dropped message: socket is not open');\n      return false;\n    }\n    if (!getImpl()) {\n      // e.g. during a server render: this client can never connect, so don't hold on to it.\n      log('dropped message: no WebSocket implementation available');\n      return false;\n    }\n    pending.push(data);\n    if (pending.length > queueLimit) {\n      pending.shift();\n      log(`dropped oldest queued message: queue limit (${queueLimit}) reached`);\n    }\n    return false;\n  }\n\n  function begin() {\n    wanted = true;\n    // Starting over after `close()` or giving up: wait for a new connection.\n    if (snapshot.status === 'idle' || snapshot.status === 'closed') {\n      opened = false;\n      if (ready?.settled) ready = null;\n    }\n    snapshot = { ...snapshot, attempt: 0 }; // open() notifies\n    bindWindow();\n    open();\n  }\n\n  /** Start connecting unless already wanted. Used by holders (`acquire`, `ready`). */\n  function ensureConnecting() {\n    if (wanted || !getImpl()) return;\n    begin();\n  }\n\n  function connect() {\n    pinned = true;\n    ensureConnecting();\n  }\n\n  function stop(code?: number, reason?: string) {\n    wanted = false;\n    generation++;\n    clearTimeout(retryTimer);\n    retryTimer = undefined;\n    stopHeartbeat();\n    unbindWindow();\n    pending = [];\n    if (ws) {\n      const socket = ws;\n      detach(socket, true);\n      socket.close(code, reason);\n    }\n  }\n\n  function close(code = 1000, reason?: string) {\n    pinned = false;\n    opened = false;\n    stop(code, reason);\n    set({ status: 'closed', attempt: 0 });\n    rejectReady(new Error('WebSocket was closed'));\n  }\n\n  function reconnect() {\n    if (!getImpl()) return;\n    clearTimeout(retryTimer);\n    retryTimer = undefined;\n    stopHeartbeat();\n    if (ws) {\n      const socket = ws;\n      detach(socket, true);\n      socket.close(1000, 'reconnect');\n    }\n    begin();\n  }\n\n  function teardown() {\n    if (refs > 0 || pinned) return;\n    // Someone may be suspended on `ready`; let the attempt finish.\n    if (ready && !ready.settled) return;\n    stop();\n    ready = null;\n    opened = false;\n    set({ status: 'idle', attempt: 0 });\n    onTeardown?.();\n  }\n\n  function acquire() {\n    refs++;\n    clearTimeout(teardownTimer);\n    if (snapshot.status === 'idle') ensureConnecting();\n    let released = false;\n    return () => {\n      if (released) return;\n      released = true;\n      if (--refs > 0) return;\n      // Deferred so StrictMode's unmount/remount and route transitions don't churn the socket.\n      clearTimeout(teardownTimer);\n      teardownTimer = setTimeout(teardown, 0);\n    };\n  }\n\n  return {\n    url,\n    get ready() {\n      if (!getImpl()) {\n        if (!unavailable) {\n          unavailable = createDeferred();\n          unavailable.reject(\n            new Error('react-websocket: no WebSocket available here (server render?)')\n          );\n        }\n        return unavailable.promise;\n      }\n      if (snapshot.status === 'idle' && !startScheduled) {\n        // `ready` is read during render; start outside of it.\n        startScheduled = true;\n        queueMicrotask(() => {\n          startScheduled = false;\n          if (snapshot.status === 'idle') ensureConnecting();\n        });\n      }\n      if (!ready) {\n        ready = createDeferred();\n        if (opened) ready.resolve();\n      }\n      return ready.promise;\n    },\n    get socket() {\n      return ws;\n    },\n    subscribe(listener) {\n      storeListeners.add(listener);\n      return () => {\n        storeListeners.delete(listener);\n      };\n    },\n    getSnapshot: () => snapshot,\n    on(type, listener) {\n      // Wrap so the same function can be subscribed twice and unsubscribed independently.\n      const entry = ((...args: unknown[]) =>\n        (listener as (...a: unknown[]) => void)(...args)) as typeof listener;\n      listeners[type].add(entry);\n      return () => {\n        listeners[type].delete(entry);\n      };\n    },\n    send,\n    connect,\n    close,\n    reconnect,\n    acquire\n  };\n}\n\n/**\n * Create a WebSocket client, usually at module level, to share across components.\n *\n * Nothing connects until a hook uses it, `ready` is read, or `connect()` is called.\n * It closes one tick after the last hook unmounts, unless `connect()` was called.\n *\n * @param url - A URL, or a function (sync or async) called before every connection\n *   attempt, e.g. to put a fresh auth token in the URL on each reconnect.\n * @typeParam In - Type of incoming messages. Inferred from `options.schema` if given.\n * @typeParam Out - Type accepted by `send()`.\n *\n * @example\n * ```ts\n * type ChatIn = { user: string; text: string };\n * type ChatOut = { text: string };\n *\n * export const chat = createWebSocket<ChatIn, ChatOut>('wss://api.example.com/chat', { json: true });\n * ```\n */\nexport function createWebSocket<In = unknown, Out = unknown>(\n  url: UrlSource,\n  options?: WebSocketOptions<In, Out>\n): WebSocketClient<In, Out> {\n  return createClient(url, options);\n}\n"],"mappings":"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","names":[]}

package/dist/index.cjs

@@ -0,0 +1,129 @@
+'use client';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  useWebSocket: () => useWebSocket,
+  useWebSocketEvent: () => useWebSocketEvent,
+  useWebSocketStatus: () => useWebSocketStatus
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./core.cjs"), module.exports);
+
+// src/react.ts
+var import_react = require("react");
+var import_core = require("./core.cjs");
+var IDLE = Object.freeze({ status: "idle", lastMessage: void 0, attempt: 0 });
+var idleSnapshot = () => IDLE;
+var idleStatus = () => "idle";
+var noopSubscribe = () => () => {
+};
+var noopSend = () => false;
+var noop = () => {
+};
+var ON_TEARDOWN = /* @__PURE__ */ Symbol.for("react-websocket.onTeardown");
+var registry = /* @__PURE__ */ new Map();
+function sharedClient(url, options) {
+  if (typeof window === "undefined") return (0, import_core.createWebSocket)(url, options);
+  const key = `${url}\0${JSON.stringify(options.protocols ?? null)}`;
+  let client = registry.get(key);
+  if (!client) {
+    const created = (0, import_core.createWebSocket)(url, {
+      ...options,
+      [ON_TEARDOWN]: () => {
+        if (registry.get(key) === created) registry.delete(key);
+      }
+    });
+    registry.set(key, created);
+    client = created;
+  }
+  return client;
+}
+function useLatest(value) {
+  const ref = (0, import_react.useRef)(value);
+  (0, import_react.useInsertionEffect)(() => {
+    ref.current = value;
+  });
+  return ref;
+}
+function useHold(client, enabled) {
+  (0, import_react.useEffect)(() => {
+    if (client && enabled) return client.acquire();
+  }, [client, enabled]);
+}
+function useWebSocket(target, options = {}) {
+  const client = target == null ? null : typeof target === "string" ? sharedClient(target, options) : target;
+  const enabled = options.enabled ?? true;
+  const snapshot = (0, import_react.useSyncExternalStore)(
+    client ? client.subscribe : noopSubscribe,
+    client ? client.getSnapshot : idleSnapshot,
+    idleSnapshot
+  );
+  const handlers = useLatest(options);
+  (0, import_react.useEffect)(() => {
+    if (!client || !enabled) return;
+    const offs = [
+      client.on("open", (event) => handlers.current.onOpen?.(event)),
+      client.on("message", (message, event) => handlers.current.onMessage?.(message, event)),
+      client.on("close", (info) => handlers.current.onClose?.(info)),
+      client.on("error", (error) => handlers.current.onError?.(error))
+    ];
+    return () => offs.forEach((off) => off());
+  }, [client, enabled, handlers]);
+  useHold(client, enabled);
+  return {
+    ...snapshot,
+    send: client ? client.send : noopSend,
+    close: client ? client.close : noop,
+    reconnect: client ? client.reconnect : noop,
+    client
+  };
+}
+function useWebSocketEvent(client, type, listener) {
+  const latest = useLatest(listener);
+  (0, import_react.useEffect)(() => {
+    if (!client) return;
+    const off = client.on(type, ((...args) => latest.current(...args)));
+    const release = client.acquire();
+    return () => {
+      off();
+      release();
+    };
+  }, [client, type, latest]);
+}
+function useWebSocketStatus(client) {
+  const status = (0, import_react.useSyncExternalStore)(
+    client ? client.subscribe : noopSubscribe,
+    client ? () => client.getSnapshot().status : idleStatus,
+    idleStatus
+  );
+  useHold(client ?? null, true);
+  return status;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useWebSocket,
+  useWebSocketEvent,
+  useWebSocketStatus,
+  ...require("./core.cjs")
+});
+//# sourceMappingURL=index.cjs.map