@connexis/react 1.0.3 → 1.0.4

package/dist/index.js

@@ -100,9 +100,9 @@ var useSubscription = (topic, optionsOrHandler, handlerOrUndefined) => {
     return () => {
       active = false;
       if (unsubscribe) {
-        unsubscribe();
-      } else if (unsubPromise) {
-        unsubPromise.then((unsub) => unsub());
+        const fn = unsubscribe;
+        unsubscribe = null;
+        fn();
       }
     };
   }, [client, topic, filterString]);

package/dist/index.mjs

@@ -61,9 +61,9 @@ var useSubscription = (topic, optionsOrHandler, handlerOrUndefined) => {
     return () => {
       active = false;
       if (unsubscribe) {
-        unsubscribe();
-      } else if (unsubPromise) {
-        unsubPromise.then((unsub) => unsub());
+        const fn = unsubscribe;
+        unsubscribe = null;
+        fn();
       }
     };
   }, [client, topic, filterString]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@connexis/react",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "React hooks and provider for @connexis",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/__tests__/react-bindings.test.ts

@@ -149,4 +149,46 @@ describe('@connexis/react Hooks', () => {
     await new Promise((resolve) => setTimeout(resolve, 0));
     expect(mockUnsub).toHaveBeenCalled();
   });
+
+  it('should call unsub EXACTLY ONCE when cleanup runs before Promise resolves (React Strict Mode)', async () => {
+    // In React Strict Mode, effects are invoked twice: mount → cleanup → remount.
+    // The cleanup fires before the subscribe Promise has resolved, so `unsubscribe`
+    // is still null when cleanup runs.  The previous (buggy) implementation
+    // scheduled an extra `.then(unsub => unsub())` in the cleanup path, which —
+    // combined with the already-scheduled `.then(unsub => { if (!active) unsub() })`
+    // in the mount path — caused `unsub` to be called TWICE, double-decrementing
+    // the connection ref-count and silently destroying live connections.
+    const client = new MockClient();
+    vi.mocked(useContext).mockReturnValue(client);
+
+    // Keep the Promise pending until we manually resolve it
+    let resolveUnsub!: (fn: () => Promise<void>) => void;
+    const pendingPromise = new Promise<() => Promise<void>>((res) => {
+      resolveUnsub = res;
+    });
+    client.subscribe.mockReturnValue(pendingPromise);
+
+    const mockUnsub = vi.fn().mockResolvedValue(undefined);
+    let effectCleanup: (() => void) | undefined;
+
+    vi.mocked(useEffect).mockImplementationOnce((effect) => {
+      effectCleanup = effect() as any;
+      return undefined;
+    });
+
+    const refObject = { current: null };
+    vi.mocked(useRef).mockReturnValue(refObject);
+
+    useSubscription('ticks', vi.fn());
+
+    // Simulate Strict Mode: cleanup runs BEFORE the Promise resolves
+    if (effectCleanup) effectCleanup();
+
+    // Now resolve the subscribe Promise
+    resolveUnsub(mockUnsub);
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // unsub must be called exactly once — not twice
+    expect(mockUnsub).toHaveBeenCalledTimes(1);
+  });
 });

package/src/index.ts

@@ -91,6 +91,9 @@ export const useSubscription = <T = any>(
       }
     });
 
+    // When the Promise resolves: if we are still active, store the unsubscribe
+    // handle; otherwise call it immediately (covers the case where cleanup ran
+    // before the Promise resolved, e.g. React Strict Mode double-invocation).
     unsubPromise.then((unsub) => {
       if (!active) {
         unsub();
@@ -102,10 +105,21 @@ export const useSubscription = <T = any>(
     return () => {
       active = false;
       if (unsubscribe) {
-        unsubscribe();
-      } else if (unsubPromise) {
-        unsubPromise.then((unsub) => unsub());
+        // Promise already resolved — call the stored handle directly and clear
+        // the ref so any subsequent accidental call is a no-op.
+        const fn = unsubscribe;
+        unsubscribe = null;
+        fn();
       }
+      // If the Promise has NOT resolved yet (unsubscribe is null), the .then()
+      // handler above will fire with active === false and call unsub() exactly
+      // once.  We must NOT schedule a second .then() here, because that would
+      // result in unsub() being invoked twice:
+      //   1. from the original .then() above  (active === false → unsub())
+      //   2. from the extra .then() below     (always → unsub())
+      // Double-calling unsubDirect decrements the connection ref-count twice
+      // per subscription (22 extra decrements for 11 hooks in Strict Mode),
+      // driving it to 0 and silently destroying the live connection.
     };
   }, [client, topic, filterString]);
 };