react-realtime-hooks 1.4.0 → 1.4.1

package/dist/index.js

@@ -803,9 +803,95 @@ var resolveUrlProvider = (url) => {
   const resolved = typeof url === "function" ? url() : url;
   return normalizeResolvedUrl(resolved ?? null);
 };
+var createInitialState3 = () => ({
+  manualClose: false,
+  manualOpen: false,
+  pendingCloseAction: null,
+  reconnectSuppressed: false,
+  skipNextCloseReconnect: false,
+  terminalError: null
+});
+var useWebSocketController = () => {
+  const ref = useRef(null);
+  if (ref.current === null) {
+    ref.current = createInitialState3();
+  }
+  const state = ref.current;
+  const controllerRef = useRef(null);
+  if (controllerRef.current === null) {
+    controllerRef.current = {
+      clearReconnectSuppression: () => {
+        state.reconnectSuppressed = false;
+      },
+      consumePendingCloseAction: () => {
+        const action = state.pendingCloseAction;
+        state.pendingCloseAction = null;
+        return action;
+      },
+      consumeSkipNextCloseReconnect: () => {
+        const skip = state.skipNextCloseReconnect;
+        state.skipNextCloseReconnect = false;
+        return skip;
+      },
+      hasManualCloseRequested: () => state.manualClose,
+      hasManualOpenRequested: () => state.manualOpen,
+      isReconnectSuppressed: () => state.reconnectSuppressed,
+      noteEffectInitiatedClose: () => {
+        state.reconnectSuppressed = true;
+      },
+      noteHeartbeatActiveSocketClose: (input) => {
+        state.manualOpen = false;
+        state.terminalError = input.reconnectTrigger === null ? input.error : null;
+        state.pendingCloseAction = input;
+        state.skipNextCloseReconnect = true;
+        state.reconnectSuppressed = true;
+      },
+      noteHeartbeatNoActiveSocket: ({ shouldReconnect, error }) => {
+        state.manualOpen = false;
+        state.terminalError = shouldReconnect ? null : error;
+      },
+      noteParseError: (error) => {
+        state.terminalError = error;
+        state.manualOpen = false;
+        state.skipNextCloseReconnect = true;
+        state.reconnectSuppressed = true;
+      },
+      noteSocketOpened: () => {
+        state.manualClose = false;
+        state.manualOpen = false;
+        state.reconnectSuppressed = false;
+        state.terminalError = null;
+      },
+      noteUserCloseRequested: () => {
+        state.manualClose = true;
+        state.manualOpen = false;
+        state.reconnectSuppressed = true;
+        state.terminalError = null;
+      },
+      noteUserOpenRequested: () => {
+        state.manualClose = false;
+        state.manualOpen = true;
+        state.reconnectSuppressed = false;
+        state.terminalError = null;
+      },
+      noteUserReconnectClosed: () => {
+        state.reconnectSuppressed = false;
+      },
+      noteUserReconnectRequested: () => {
+        state.manualClose = false;
+        state.manualOpen = true;
+        state.skipNextCloseReconnect = true;
+        state.reconnectSuppressed = true;
+        state.terminalError = null;
+      },
+      peekTerminalError: () => state.terminalError
+    };
+  }
+  return controllerRef.current;
+};
 
 // src/hooks/useWebSocket.ts
-var createInitialState3 = (status = "idle") => ({
+var createInitialState4 = (status = "idle") => ({
   bufferedAmount: 0,
   lastChangedAt: null,
   lastCloseEvent: null,
@@ -848,15 +934,10 @@ var useWebSocket = (options) => {
   const activeSocketEpochRef = useRef(null);
   const closingSocketEpochRef = useRef(null);
   const nextSocketEpochRef = useRef(0);
-  const manualCloseRef = useRef(false);
-  const manualOpenRef = useRef(false);
-  const skipCloseReconnectRef = useRef(false);
-  const suppressReconnectRef = useRef(false);
-  const pendingCloseActionRef = useRef(null);
-  const terminalErrorRef = useRef(null);
+  const controller = useWebSocketController();
   const [openNonce, setOpenNonce] = useState(0);
   const [state, setState] = useState(
-    () => createInitialState3(connect ? "connecting" : "idle")
+    () => createInitialState4(connect ? "connecting" : "idle")
   );
   const stateRef = useRef(state);
   stateRef.current = state;
@@ -976,10 +1057,9 @@ var useWebSocket = (options) => {
         return;
       }
       const shouldReconnect = action === "reconnect" && reconnectEnabled && (options.shouldReconnect?.(error) ?? true);
-      manualOpenRef.current = false;
-      terminalErrorRef.current = shouldReconnect ? null : error;
       const socket2 = socketRef.current;
       if (socket2 === null || !isSocketActive(socket2)) {
+        controller.noteHeartbeatNoActiveSocket({ error, shouldReconnect });
         commitState((current) => ({
           ...current,
           lastChangedAt: Date.now(),
@@ -991,12 +1071,10 @@ var useWebSocket = (options) => {
         }
         return;
       }
-      pendingCloseActionRef.current = {
+      controller.noteHeartbeatActiveSocketClose({
         error,
         reconnectTrigger: shouldReconnect ? reconnectTrigger : null
-      };
-      skipCloseReconnectRef.current = true;
-      suppressReconnectRef.current = true;
+      });
       closeSocket({ trackClose: true });
     }
   );
@@ -1011,10 +1089,7 @@ var useWebSocket = (options) => {
     }));
   });
   const handleOpen = useStableCallback((event, socket2) => {
-    manualCloseRef.current = false;
-    manualOpenRef.current = false;
-    suppressReconnectRef.current = false;
-    terminalErrorRef.current = null;
+    controller.noteSocketOpened();
     reconnect.markConnected();
     heartbeat.start();
     commitState((current) => ({
@@ -1041,10 +1116,7 @@ var useWebSocket = (options) => {
         cause: error,
         kind: "parse-error"
       });
-      terminalErrorRef.current = parseError;
-      manualOpenRef.current = false;
-      skipCloseReconnectRef.current = true;
-      suppressReconnectRef.current = true;
+      controller.noteParseError(parseError);
       reconnect.cancel();
       heartbeat.stop();
       options.onError?.(parseError);
@@ -1088,13 +1160,11 @@ var useWebSocket = (options) => {
     }
     heartbeat.stop();
     updateBufferedAmount();
-    const pendingCloseAction = pendingCloseActionRef.current;
-    pendingCloseActionRef.current = null;
-    const terminalError = terminalErrorRef.current;
-    const skipCloseReconnect = skipCloseReconnectRef.current;
-    skipCloseReconnectRef.current = false;
+    const pendingCloseAction = controller.consumePendingCloseAction();
+    const terminalError = controller.peekTerminalError();
+    const skipCloseReconnect = controller.consumeSkipNextCloseReconnect();
     if (pendingCloseAction !== null) {
-      suppressReconnectRef.current = false;
+      controller.clearReconnectSuppression();
       commitState((current) => ({
         ...current,
         lastChangedAt: Date.now(),
@@ -1109,7 +1179,7 @@ var useWebSocket = (options) => {
       return;
     }
     if (terminalError !== null) {
-      suppressReconnectRef.current = false;
+      controller.clearReconnectSuppression();
       commitState((current) => ({
         ...current,
         lastChangedAt: Date.now(),
@@ -1120,7 +1190,7 @@ var useWebSocket = (options) => {
       options.onClose?.(event);
       return;
     }
-    const shouldReconnect = !suppressReconnectRef.current && !skipCloseReconnect && reconnectEnabled && (options.shouldReconnect?.(event) ?? true);
+    const shouldReconnect = !controller.isReconnectSuppressed() && !skipCloseReconnect && reconnectEnabled && (options.shouldReconnect?.(event) ?? true);
     commitState((current) => ({
       ...current,
       lastChangedAt: Date.now(),
@@ -1131,33 +1201,23 @@ var useWebSocket = (options) => {
     if (shouldReconnect) {
       reconnect.schedule("close");
     } else {
-      suppressReconnectRef.current = false;
+      controller.clearReconnectSuppression();
     }
   });
   const open = useStableCallback(() => {
-    manualCloseRef.current = false;
-    manualOpenRef.current = true;
-    suppressReconnectRef.current = false;
-    terminalErrorRef.current = null;
+    controller.noteUserOpenRequested();
     reconnect.cancel();
     setOpenNonce((current) => current + 1);
   });
   const reconnectNow = useStableCallback(() => {
-    manualCloseRef.current = false;
-    manualOpenRef.current = true;
-    skipCloseReconnectRef.current = true;
-    suppressReconnectRef.current = true;
-    terminalErrorRef.current = null;
+    controller.noteUserReconnectRequested();
     heartbeat.stop();
     closeSocket();
-    suppressReconnectRef.current = false;
+    controller.noteUserReconnectClosed();
     reconnect.schedule("manual");
   });
   const close = useStableCallback((code, reason) => {
-    manualCloseRef.current = true;
-    manualOpenRef.current = false;
-    suppressReconnectRef.current = true;
-    terminalErrorRef.current = null;
+    controller.noteUserCloseRequested();
     reconnect.cancel();
     heartbeat.stop();
     commitState((current) => ({
@@ -1199,22 +1259,22 @@ var useWebSocket = (options) => {
       }));
       return;
     }
-    const shouldConnect = terminalErrorRef.current === null && (connect && !manualCloseRef.current || manualOpenRef.current || reconnect.status === "running");
+    const shouldConnect = controller.peekTerminalError() === null && (connect && !controller.hasManualCloseRequested() || controller.hasManualOpenRequested() || reconnect.status === "running");
     const nextSocketKey = `${resolvedUrl}::${protocolsDependency}::${options.binaryType ?? "blob"}`;
     if (!shouldConnect) {
       if (socketRef.current !== null) {
-        suppressReconnectRef.current = true;
+        controller.noteEffectInitiatedClose();
         closeSocket();
       }
       socketKeyRef.current = null;
       commitState((current) => ({
         ...current,
-        status: terminalErrorRef.current !== null ? "error" : manualCloseRef.current ? "closed" : "idle"
+        status: controller.peekTerminalError() !== null ? "error" : controller.hasManualCloseRequested() ? "closed" : "idle"
       }));
       return;
     }
     if (socketRef.current !== null && socketKeyRef.current !== nextSocketKey) {
-      suppressReconnectRef.current = true;
+      controller.noteEffectInitiatedClose();
       closeSocket();
     }
     if (socketRef.current !== null) {
@@ -1281,6 +1341,7 @@ var useWebSocket = (options) => {
     closeSocket,
     commitState,
     connect,
+    controller,
     handleClose,
     handleError,
     handleMessage,
@@ -1295,11 +1356,10 @@ var useWebSocket = (options) => {
     supported
   ]);
   useEffect(() => () => {
-    suppressReconnectRef.current = true;
+    controller.noteEffectInitiatedClose();
     socketKeyRef.current = null;
     activeSocketEpochRef.current = null;
     closingSocketEpochRef.current = null;
-    terminalErrorRef.current = null;
     const socket2 = socketRef.current;
     socketRef.current = null;
     if (socket2 === null) {
@@ -1308,7 +1368,7 @@ var useWebSocket = (options) => {
     if (isSocketActive(socket2)) {
       socket2.close();
     }
-  }, []);
+  }, [controller]);
   const stopHeartbeat = heartbeat.stop;
   useEffect(() => {
     if (state.status !== "open") {
@@ -1413,7 +1473,7 @@ var useWebSocket = (options) => {
     socket
   };
 };
-var createInitialState4 = (status = "idle") => ({
+var createInitialState5 = (status = "idle") => ({
   lastChangedAt: null,
   lastError: null,
   lastEventName: null,
@@ -1450,7 +1510,7 @@ var useEventSource = (options) => {
   const terminalErrorRef = useRef(null);
   const [openNonce, setOpenNonce] = useState(0);
   const [state, setState] = useState(
-    () => createInitialState4(connect ? "connecting" : "idle")
+    () => createInitialState5(connect ? "connecting" : "idle")
   );
   const stateRef = useRef(state);
   stateRef.current = state;