@iam4x/reconnecting-websocket 1.4.0 → 1.4.2

package/dist/index.d.ts

@@ -33,7 +33,11 @@ export declare class ReconnectingWebSocket {
     get bufferedAmount(): number;
     constructor(url: string, options?: ReconnectOptions);
     connect(): void;
+    private getSocketState;
+    private removeSocketListeners;
+    private forceReconnectForSocket;
     emit(event: EventType, payload: any): void;
+    private runWithFinalizer;
     scheduleReconnect(): void;
     startHealthCheck(): void;
     stopHealthCheck(): void;

package/dist/index.js

@@ -25,7 +25,7 @@ export class ReconnectingWebSocket {
     // Queue for messages sent when socket is not open
     messageQueue = [];
     get readyState() {
-        return this.ws?.readyState ?? WebSocket.CLOSED;
+        return this.ws?.readyState ?? this.getSocketState("CLOSED");
     }
     get bufferedAmount() {
         return this.ws?.bufferedAmount ?? 0;
@@ -48,52 +48,54 @@ export class ReconnectingWebSocket {
         // This ensures that manual reconnections (via connect()) can auto-reconnect
         this.forcedClose = false;
         // Remove event listeners from old socket
-        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);
+        if (this.ws) {
+            this.removeSocketListeners(this.ws);
+        }
         // Close old socket if still connecting or open
-        if (this.ws?.readyState === WebSocket.CONNECTING ||
-            this.ws?.readyState === WebSocket.OPEN) {
+        if (this.ws?.readyState === this.getSocketState("CONNECTING") ||
+            this.ws?.readyState === this.getSocketState("OPEN")) {
             this.ws?.close();
         }
         // Clear any pending timers (this also removes abort listener from old controller)
         this.clearTimers();
+        // Create new socket
+        this.ws = new this.options.WebSocketConstructor(this.options.url);
+        const currentWs = this.ws;
         // Create new abort controller
         this.abortController = new AbortController();
         this.abortHandler = () => {
-            if (this.ws?.readyState === WebSocket.CONNECTING) {
-                this.ws.close();
+            if (this.ws === currentWs &&
+                currentWs.readyState === this.getSocketState("CONNECTING")) {
+                this.forceReconnectForSocket(currentWs, {
+                    code: 1006,
+                    reason: "Connection timeout",
+                });
             }
         };
         this.abortController.signal.addEventListener("abort", this.abortHandler);
-        // Create new socket
-        this.ws = new this.options.WebSocketConstructor(this.options.url);
         this.connectTimeout = setTimeout(() => {
             this.abortController?.abort();
         }, this.options.connectionTimeout);
         // Create and store new event handlers
         // Capture the new socket reference to check against in handlers
-        const currentWs = this.ws;
         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 +108,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) => {
@@ -126,11 +132,75 @@ export class ReconnectingWebSocket {
         currentWs.addEventListener("close", this.closeFn);
         currentWs.addEventListener("error", this.errorFn);
     }
+    getSocketState(state) {
+        const fallbackStates = {
+            CONNECTING: 0,
+            OPEN: 1,
+            CLOSED: 3,
+        };
+        const WebSocketConstructor = this.options
+            .WebSocketConstructor;
+        return WebSocketConstructor[state] ?? fallbackStates[state];
+    }
+    removeSocketListeners(socket) {
+        if (this.openFn)
+            socket.removeEventListener("open", this.openFn);
+        if (this.msgFn)
+            socket.removeEventListener("message", this.msgFn);
+        if (this.closeFn)
+            socket.removeEventListener("close", this.closeFn);
+        if (this.errorFn)
+            socket.removeEventListener("error", this.errorFn);
+    }
+    forceReconnectForSocket(socket, closePayload) {
+        const shouldReconnect = !this.forcedClose;
+        this.stopHealthCheck();
+        this.stopInactivityTimer();
+        this.removeSocketListeners(socket);
+        socket.close();
+        if (this.ws === socket) {
+            this.ws = undefined;
+        }
+        this.runWithFinalizer(() => {
+            this.emit("close", closePayload);
+        }, () => {
+            if (shouldReconnect) {
+                this.scheduleReconnect();
+            }
+        });
+    }
     emit(event, payload) {
         for (const listener of this.listeners[event]) {
             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) {
@@ -147,15 +217,20 @@ export class ReconnectingWebSocket {
         if (this.options.healthCheckInterval <= 0) {
             return;
         }
+        const currentWs = this.ws;
+        if (!currentWs) {
+            return;
+        }
         this.healthCheckInterval = setInterval(() => {
             // Only check if we're not forcing a close and we expect to be connected
-            if (this.forcedClose) {
+            if (this.forcedClose || this.ws !== currentWs) {
                 return;
             }
             // If we've been connected before and the socket is not OPEN, trigger reconnection
-            if (this.wasConnected && this.readyState !== WebSocket.OPEN) {
+            if (this.wasConnected &&
+                currentWs.readyState !== this.getSocketState("OPEN")) {
                 // Clear the existing socket reference since it's in a bad state
-                if (this.ws) {
+                if (this.ws === currentWs) {
                     // Don't emit close event since we didn't receive one - this is a silent failure
                     this.ws = undefined;
                 }
@@ -175,34 +250,21 @@ export class ReconnectingWebSocket {
         if (this.options.watchingInactivityTimeout <= 0) {
             return;
         }
+        const currentWs = this.ws;
+        if (!currentWs) {
+            return;
+        }
         this.inactivityTimeout = setTimeout(() => {
             // Only trigger if we're not forcing a close and we expect to be connected
-            if (this.forcedClose) {
+            if (this.forcedClose || this.ws !== currentWs) {
                 return;
             }
             // 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;
-                // Emit close event to listeners with a special code indicating inactivity timeout
-                this.emit("close", { code: 4000, reason: "Inactivity timeout" });
-                // Schedule reconnection directly without waiting for close event
-                this.scheduleReconnect();
-            }
+            this.forceReconnectForSocket(currentWs, {
+                code: 4000,
+                reason: "Inactivity timeout",
+            });
         }, this.options.watchingInactivityTimeout);
     }
     stopInactivityTimer() {
@@ -243,7 +305,10 @@ export class ReconnectingWebSocket {
         this.listeners[event] = this.listeners[event].filter((l) => l !== listener);
     }
     send(...args) {
-        if (this.ws?.readyState === WebSocket.OPEN) {
+        if (this.forcedClose) {
+            return;
+        }
+        if (this.ws?.readyState === this.getSocketState("OPEN")) {
             this.ws.send(...args);
         }
         else {
@@ -252,7 +317,7 @@ export class ReconnectingWebSocket {
     }
     flushMessageQueue() {
         while (this.messageQueue.length > 0 &&
-            this.ws?.readyState === WebSocket.OPEN) {
+            this.ws?.readyState === this.getSocketState("OPEN")) {
             const args = this.messageQueue.shift();
             this.ws.send(...args);
         }
@@ -264,14 +329,7 @@ export class ReconnectingWebSocket {
         this.messageQueue = [];
         if (this.ws) {
             // Remove event listeners before closing to prevent memory leaks
-            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);
+            this.removeSocketListeners(this.ws);
             this.ws.close(...args);
             this.ws = undefined;
         }

package/package.json

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