react-websocket 2.2.0 → 3.1.0

package/dist/core.cjs

@@ -0,0 +1,594 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core.ts
+var core_exports = {};
+__export(core_exports, {
+  MessageError: () => MessageError,
+  createWebSocket: () => createWebSocket,
+  createWebSocketState: () => createWebSocketState,
+  createWebSocketTopics: () => createWebSocketTopics
+});
+module.exports = __toCommonJS(core_exports);
+
+// 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);
+}
+
+// src/state.ts
+function createWebSocketState(client, options) {
+  const { initialState, reduce } = options;
+  let state = initialState;
+  const listeners = /* @__PURE__ */ new Set();
+  function setState(update) {
+    const next = typeof update === "function" ? update(state) : update;
+    if (Object.is(next, state)) return;
+    state = next;
+    for (const listener of [...listeners]) listener();
+  }
+  const off = client.on("message", (message) => setState((current) => reduce(current, message)));
+  return {
+    client,
+    initialState,
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    setState,
+    reset: () => setState(initialState),
+    dispose: off
+  };
+}
+
+// src/topics.ts
+function createWebSocketTopics(client, options) {
+  const counts = /* @__PURE__ */ new Map();
+  const pendingRemoval = /* @__PURE__ */ new Map();
+  let sentOn = null;
+  let sent = /* @__PURE__ */ new Set();
+  function isOpen() {
+    return client.getSnapshot().status === "open" && client.socket !== null;
+  }
+  function subscribe(topic) {
+    if (!isOpen()) return;
+    if (client.socket !== sentOn) {
+      sentOn = client.socket;
+      sent = /* @__PURE__ */ new Set();
+    }
+    if (sent.has(topic)) return;
+    sent.add(topic);
+    client.send(options.subscribe(topic));
+  }
+  function unsubscribe(topic) {
+    if (!isOpen() || client.socket !== sentOn || !sent.delete(topic)) return;
+    if (options.unsubscribe) client.send(options.unsubscribe(topic));
+  }
+  const off = client.on("open", () => {
+    sentOn = client.socket;
+    sent = /* @__PURE__ */ new Set();
+    for (const topic of counts.keys()) subscribe(topic);
+  });
+  return {
+    client,
+    acquire(topic) {
+      const releaseConnection = client.acquire();
+      clearTimeout(pendingRemoval.get(topic));
+      pendingRemoval.delete(topic);
+      counts.set(topic, (counts.get(topic) ?? 0) + 1);
+      subscribe(topic);
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        const remaining = (counts.get(topic) ?? 1) - 1;
+        if (remaining > 0) {
+          counts.set(topic, remaining);
+        } else {
+          counts.delete(topic);
+          pendingRemoval.set(
+            topic,
+            setTimeout(() => {
+              pendingRemoval.delete(topic);
+              if (!counts.has(topic)) unsubscribe(topic);
+            }, 0)
+          );
+        }
+        releaseConnection();
+      };
+    },
+    active: () => [...counts.keys()],
+    dispose() {
+      off();
+      for (const timer of pendingRemoval.values()) clearTimeout(timer);
+      pendingRemoval.clear();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MessageError,
+  createWebSocket,
+  createWebSocketState,
+  createWebSocketTopics
+});
+//# sourceMappingURL=core.cjs.map