react-realtime-hooks 1.4.0 → 1.4.2

package/README.md

@@ -38,6 +38,7 @@ Real apps need:
 - Discriminated connection snapshots: `idle`, `connecting`, `open`, `reconnecting`, `closing`, `closed`, `error`.
 - First-class TypeScript support with generic message types and custom parsers/serializers.
 - SSR-safe by default. No browser-only globals are touched during server render.
+- Strict Mode safe. Works correctly under React 18+ `<StrictMode>` and Next.js dev double-mount — see [Strict Mode Safety](#strict-mode-safety).
 - Zero runtime dependencies beyond React.
 - Manual controls stay available when you need them: `open()`, `close()`, `reconnect()`, `send()`.
 
@@ -655,6 +656,19 @@ That keeps the gate predictable when multiple blockers apply at once.
 - No transport polyfills are bundled. Provide your own runtime support where needed.
 - Browser-native transport constraints still apply: auth, proxy, CORS, and network policy are outside the hook's control.
 
+## Strict Mode Safety
+
+All hooks are safe to use under React 18+ `<React.StrictMode>` and the Next.js App Router's dev mode, both of which intentionally mount → unmount → mount each component on first render to surface effect-cleanup bugs.
+
+Concretely:
+
+- `useWebSocket` and `useEventSource` defer the actual `new WebSocket(...)` / `new EventSource(...)` call by a microtask. If the component unmounts before that microtask runs (the Strict Mode discard mount), no transport is ever created. If the mount survives, exactly one transport is created — never two.
+- All effects in the library tear down their timers, listeners, and transports synchronously in the cleanup function. There is no "zombie" `setInterval`, no orphaned `addEventListener`, no leaked `WebSocket` left in `CONNECTING` after a discarded mount.
+- Latest-state refs are committed via `useInsertionEffect`, not by writing to `ref.current` during render. A discarded render never leaves the ref out of sync with the committed tree.
+- The library's own test suite runs every hook test inside `<React.StrictMode>` by default, so any regression that only shows up under double-mount is caught in CI.
+
+If you observe a Strict Mode regression — e.g. two simultaneous WebSocket connections, an `EventSource` that survives a closed component, or a heartbeat that keeps firing after unmount — please open an issue with a minimal repro. That class of bug is supposed to be impossible by construction, and we treat it as a correctness defect.
+
 ## Testing And Quality
 
 The package includes behavior tests for:

package/dist/index.cjs

@@ -466,7 +466,9 @@ var useReconnect = (options = {}) => {
     () => createInitialState(normalizedOptions.enabled)
   );
   const stateRef = react.useRef(state);
-  stateRef.current = state;
+  react.useInsertionEffect(() => {
+    stateRef.current = state;
+  });
   const commitState = (next) => {
     const resolved = typeof next === "function" ? next(stateRef.current) : next;
     stateRef.current = resolved;
@@ -599,7 +601,9 @@ var useHeartbeat = (options) => {
     () => createInitialState2(enabled && startOnMount)
   );
   const stateRef = react.useRef(state);
-  stateRef.current = state;
+  react.useInsertionEffect(() => {
+    stateRef.current = state;
+  });
   const commitState = (next) => {
     const resolved = typeof next === "function" ? next(stateRef.current) : next;
     stateRef.current = resolved;
@@ -805,9 +809,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 = react.useRef(null);
+  if (ref.current === null) {
+    ref.current = createInitialState3();
+  }
+  const state = ref.current;
+  const controllerRef = react.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,
@@ -850,18 +940,15 @@ var useWebSocket = (options) => {
   const activeSocketEpochRef = react.useRef(null);
   const closingSocketEpochRef = react.useRef(null);
   const nextSocketEpochRef = react.useRef(0);
-  const manualCloseRef = react.useRef(false);
-  const manualOpenRef = react.useRef(false);
-  const skipCloseReconnectRef = react.useRef(false);
-  const suppressReconnectRef = react.useRef(false);
-  const pendingCloseActionRef = react.useRef(null);
-  const terminalErrorRef = react.useRef(null);
+  const controller = useWebSocketController();
   const [openNonce, setOpenNonce] = react.useState(0);
   const [state, setState] = react.useState(
-    () => createInitialState3(connect ? "connecting" : "idle")
+    () => createInitialState4(connect ? "connecting" : "idle")
   );
   const stateRef = react.useRef(state);
-  stateRef.current = state;
+  react.useInsertionEffect(() => {
+    stateRef.current = state;
+  });
   const reconnectEnabled = options.reconnect !== false && supported && resolvedUrl !== null;
   const reconnect = useReconnect(
     options.reconnect === false ? { enabled: false } : {
@@ -978,10 +1065,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(),
@@ -993,12 +1079,10 @@ var useWebSocket = (options) => {
         }
         return;
       }
-      pendingCloseActionRef.current = {
+      controller.noteHeartbeatActiveSocketClose({
         error,
         reconnectTrigger: shouldReconnect ? reconnectTrigger : null
-      };
-      skipCloseReconnectRef.current = true;
-      suppressReconnectRef.current = true;
+      });
       closeSocket({ trackClose: true });
     }
   );
@@ -1013,10 +1097,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) => ({
@@ -1043,10 +1124,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);
@@ -1090,13 +1168,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(),
@@ -1111,7 +1187,7 @@ var useWebSocket = (options) => {
       return;
     }
     if (terminalError !== null) {
-      suppressReconnectRef.current = false;
+      controller.clearReconnectSuppression();
       commitState((current) => ({
         ...current,
         lastChangedAt: Date.now(),
@@ -1122,7 +1198,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(),
@@ -1133,33 +1209,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) => ({
@@ -1201,22 +1267,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) {
@@ -1283,6 +1349,7 @@ var useWebSocket = (options) => {
     closeSocket,
     commitState,
     connect,
+    controller,
     handleClose,
     handleError,
     handleMessage,
@@ -1297,11 +1364,10 @@ var useWebSocket = (options) => {
     supported
   ]);
   react.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) {
@@ -1310,7 +1376,7 @@ var useWebSocket = (options) => {
     if (isSocketActive(socket2)) {
       socket2.close();
     }
-  }, []);
+  }, [controller]);
   const stopHeartbeat = heartbeat.stop;
   react.useEffect(() => {
     if (state.status !== "open") {
@@ -1415,7 +1481,7 @@ var useWebSocket = (options) => {
     socket
   };
 };
-var createInitialState4 = (status = "idle") => ({
+var createInitialState5 = (status = "idle") => ({
   lastChangedAt: null,
   lastError: null,
   lastEventName: null,
@@ -1452,10 +1518,12 @@ var useEventSource = (options) => {
   const terminalErrorRef = react.useRef(null);
   const [openNonce, setOpenNonce] = react.useState(0);
   const [state, setState] = react.useState(
-    () => createInitialState4(connect ? "connecting" : "idle")
+    () => createInitialState5(connect ? "connecting" : "idle")
   );
   const stateRef = react.useRef(state);
-  stateRef.current = state;
+  react.useInsertionEffect(() => {
+    stateRef.current = state;
+  });
   const reconnectEnabled = options.reconnect !== false && supported && resolvedUrl !== null;
   const reconnect = useReconnect(
     options.reconnect === false ? { enabled: false } : {