@iam4x/reconnecting-websocket 1.3.0 → 1.4.1

package/dist/index.d.ts

@@ -34,6 +34,7 @@ export declare class ReconnectingWebSocket {
     constructor(url: string, options?: ReconnectOptions);
     connect(): void;
     emit(event: EventType, payload: any): void;
+    private runWithFinalizer;
     scheduleReconnect(): void;
     startHealthCheck(): void;
     stopHealthCheck(): void;

package/dist/index.js

@@ -82,18 +82,21 @@ export class ReconnectingWebSocket {
         this.openFn = (event) => {
             // Only process if event is from the current socket
             if (event.target === currentWs && this.ws === currentWs) {
+                const isReconnect = this.wasConnected;
                 this.clearTimers();
                 this.retryCount = 0;
-                this.emit("open", event);
-                // Emit reconnect event if this was a reconnection after a disconnection
-                if (this.wasConnected) {
-                    this.emit("reconnect", event);
-                }
                 this.wasConnected = true;
                 this.startHealthCheck();
                 this.startInactivityTimer();
-                // Flush any queued messages now that socket is open
-                this.flushMessageQueue();
+                this.runWithFinalizer(() => {
+                    this.emit("open", event);
+                    if (isReconnect) {
+                        this.emit("reconnect", event);
+                    }
+                }, () => {
+                    // Flush queued messages even if a listener throws during open/reconnect.
+                    this.flushMessageQueue();
+                });
             }
         };
         this.msgFn = (event) => {
@@ -106,12 +109,16 @@ export class ReconnectingWebSocket {
         this.closeFn = (event) => {
             // Only process if event is from the current socket
             if (event.target === currentWs && this.ws === currentWs) {
+                const shouldReconnect = !this.forcedClose;
                 this.stopHealthCheck();
                 this.stopInactivityTimer();
-                this.emit("close", { code: event.code, reason: event.reason });
-                if (!this.forcedClose) {
-                    this.scheduleReconnect();
-                }
+                this.runWithFinalizer(() => {
+                    this.emit("close", { code: event.code, reason: event.reason });
+                }, () => {
+                    if (shouldReconnect) {
+                        this.scheduleReconnect();
+                    }
+                });
             }
         };
         this.errorFn = (event) => {
@@ -131,6 +138,33 @@ export class ReconnectingWebSocket {
             listener(payload);
         }
     }
+    runWithFinalizer(action, finalizer) {
+        let didThrow = false;
+        let thrown;
+        try {
+            action();
+        }
+        catch (error) {
+            didThrow = true;
+            thrown = error;
+        }
+        finally {
+            if (finalizer) {
+                try {
+                    finalizer();
+                }
+                catch (error) {
+                    if (!didThrow) {
+                        didThrow = true;
+                        thrown = error;
+                    }
+                }
+            }
+        }
+        if (didThrow) {
+            throw thrown;
+        }
+    }
     scheduleReconnect() {
         // Clear any existing reconnect timeout first to prevent multiple reconnects
         if (this.reconnectTimeout) {
@@ -180,9 +214,34 @@ export class ReconnectingWebSocket {
             if (this.forcedClose) {
                 return;
             }
-            // Trigger reconnection due to inactivity
+            const shouldReconnect = !this.forcedClose;
+            // Proactively trigger reconnection due to inactivity
+            // Don't rely on the close event as it may never fire on a stalled connection
             if (this.ws) {
+                // Stop health check to prevent it from also triggering reconnection
+                this.stopHealthCheck();
+                // Remove event listeners to prevent any late events from interfering
+                if (this.openFn)
+                    this.ws.removeEventListener("open", this.openFn);
+                if (this.msgFn)
+                    this.ws.removeEventListener("message", this.msgFn);
+                if (this.closeFn)
+                    this.ws.removeEventListener("close", this.closeFn);
+                if (this.errorFn)
+                    this.ws.removeEventListener("error", this.errorFn);
+                // Try to close the socket (may hang on stalled connections, but we don't wait)
                 this.ws.close();
+                // Clear the socket reference
+                this.ws = undefined;
+                this.runWithFinalizer(() => {
+                    // Emit close event to listeners with a special code indicating inactivity timeout.
+                    this.emit("close", { code: 4000, reason: "Inactivity timeout" });
+                }, () => {
+                    if (shouldReconnect) {
+                        // Schedule reconnection directly without waiting for close event.
+                        this.scheduleReconnect();
+                    }
+                });
             }
         }, this.options.watchingInactivityTimeout);
     }

package/package.json

@@ -3,7 +3,7 @@
   "module": "src/index.ts",
   "type": "module",
   "license": "MIT",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "private": false,
   "types": "./dist/index.d.ts",
   "exports": {