partysocket/dist/chunk-EQIKRCA3.mjs

A better WebSocket that Just Works™

import { ReconnectingWebSocket } from "./chunk-S74YV6PU.mjs";

// src/use-handlers.ts
import { useEffect, useRef } from "react";
var useAttachWebSocketEventHandlers = (socket, options) => {
  const handlersRef = useRef(options);
  handlersRef.current = options;
  useEffect(() => {
    const onOpen = (event) => {
      var _a, _b;
      return (_b = (_a = handlersRef.current) == null ? void 0 : _a.onOpen) ==
        null
        ? void 0
        : _b.call(_a, event);
    };
    const onMessage = (event) => {
      var _a, _b;
      return (_b =
        (_a = handlersRef.current) == null ? void 0 : _a.onMessage) == null
        ? void 0
        : _b.call(_a, event);
    };
    const onClose = (event) => {
      var _a, _b;
      return (_b = (_a = handlersRef.current) == null ? void 0 : _a.onClose) ==
        null
        ? void 0
        : _b.call(_a, event);
    };
    const onError = (event) => {
      var _a, _b;
      return (_b = (_a = handlersRef.current) == null ? void 0 : _a.onError) ==
        null
        ? void 0
        : _b.call(_a, event);
    };
    socket.addEventListener("open", onOpen);
    socket.addEventListener("close", onClose);
    socket.addEventListener("error", onError);
    socket.addEventListener("message", onMessage);
    return () => {
      socket.removeEventListener("open", onOpen);
      socket.removeEventListener("close", onClose);
      socket.removeEventListener("error", onError);
      socket.removeEventListener("message", onMessage);
    };
  }, [socket]);
};

// src/use-socket.ts
import {
  useEffect as useEffect2,
  useMemo,
  useRef as useRef2,
  useState
} from "react";
var getOptionsThatShouldCauseRestartWhenChanged = (options) => [
  options.startClosed,
  options.minUptime,
  options.maxRetries,
  options.connectionTimeout,
  options.maxEnqueuedMessages,
  options.maxReconnectionDelay,
  options.minReconnectionDelay,
  options.reconnectionDelayGrowFactor,
  options.debug
];
function useStableSocket({
  options,
  createSocket,
  createSocketMemoKey: createOptionsMemoKey
}) {
  const shouldReconnect = createOptionsMemoKey(options);
  const socketOptions = useMemo(() => {
    return options;
  }, [shouldReconnect]);
  const [socket, setSocket] = useState(() =>
    // only connect on first mount
    createSocket({ ...socketOptions, startClosed: true })
  );
  const socketInitializedRef = useRef2(null);
  const createSocketRef = useRef2(createSocket);
  createSocketRef.current = createSocket;
  useEffect2(() => {
    if (socketInitializedRef.current === socket) {
      const newSocket = createSocketRef.current({
        ...socketOptions,
        // when reconnecting because of options change, we always reconnect
        // (startClosed only applies to initial mount)
        startClosed: false
      });
      setSocket(newSocket);
    } else {
      if (!socketInitializedRef.current && socketOptions.startClosed !== true) {
        socket.reconnect();
      }
      socketInitializedRef.current = socket;
      return () => {
        socket.close();
      };
    }
  }, [socket, socketOptions]);
  return socket;
}

// src/use-ws.ts
function useWebSocket(url, protocols, options = {}) {
  const socket = useStableSocket({
    options,
    createSocket: (options2) =>
      new ReconnectingWebSocket(url, protocols, options2),
    createSocketMemoKey: (options2) =>
      JSON.stringify([
        // will reconnect if url or protocols are specified as a string.
        // if they are functions, the WebSocket will handle reconnection
        url,
        protocols,
        ...getOptionsThatShouldCauseRestartWhenChanged(options2)
      ])
  });
  useAttachWebSocketEventHandlers(socket, options);
  return socket;
}

export {
  useAttachWebSocketEventHandlers,
  getOptionsThatShouldCauseRestartWhenChanged,
  useStableSocket,
  useWebSocket
};
//# sourceMappingURL=chunk-EQIKRCA3.mjs.map