@iam4x/reconnecting-websocket 1.4.1 → 1.4.2

package/dist/index.d.ts

@@ -33,6 +33,9 @@ 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;

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,37 +48,36 @@ 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) {
@@ -133,6 +132,43 @@ 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);
@@ -181,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;
                 }
@@ -209,40 +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;
             }
-            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.forceReconnectForSocket(currentWs, {
+                code: 4000,
+                reason: "Inactivity timeout",
+            });
         }, this.options.watchingInactivityTimeout);
     }
     stopInactivityTimer() {
@@ -283,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 {
@@ -292,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);
         }
@@ -304,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.1",
+  "version": "1.4.2",
   "private": false,
   "types": "./dist/index.d.ts",
   "exports": {