@iam4x/reconnecting-websocket 1.0.1 → 1.2.0

package/dist/index.d.ts

@@ -6,6 +6,7 @@ interface ReconnectOptions {
     connectionTimeout?: number;
     backoffFactor?: number;
     WebSocketConstructor?: typeof WebSocket;
+    healthCheckInterval?: number;
 }
 export declare class ReconnectingWebSocket {
     options: Required<ReconnectOptions & {
@@ -15,20 +16,30 @@ export declare class ReconnectingWebSocket {
     abortController?: AbortController;
     connectTimeout?: ReturnType<typeof setTimeout>;
     reconnectTimeout?: ReturnType<typeof setTimeout>;
+    healthCheckInterval?: ReturnType<typeof setInterval>;
     retryCount: number;
     forcedClose: boolean;
     wasConnected: boolean;
+    private openFn?;
+    private msgFn?;
+    private closeFn?;
+    private errorFn?;
+    private abortHandler?;
     listeners: Record<EventType, Listener[]>;
+    private messageQueue;
     get readyState(): number;
     get bufferedAmount(): number;
     constructor(url: string, options?: ReconnectOptions);
     connect(): void;
     emit(event: EventType, payload: any): void;
     scheduleReconnect(): void;
+    startHealthCheck(): void;
+    stopHealthCheck(): void;
     clearTimers(): void;
     addEventListener(event: EventType, listener: Listener): void;
     removeEventListener(event: EventType, listener: Listener): void;
     send(...args: Parameters<WebSocket["send"]>): void;
+    private flushMessageQueue;
     close(...args: Parameters<WebSocket["close"]>): void;
 }
 export {};

package/dist/index.js

@@ -4,9 +4,16 @@ export class ReconnectingWebSocket {
     abortController;
     connectTimeout;
     reconnectTimeout;
+    healthCheckInterval;
     retryCount = 0;
     forcedClose = false;
     wasConnected = false;
+    // Store event handlers so we can remove them when cleaning up
+    openFn;
+    msgFn;
+    closeFn;
+    errorFn;
+    abortHandler;
     listeners = {
         open: [],
         message: [],
@@ -14,6 +21,8 @@ export class ReconnectingWebSocket {
         reconnect: [],
         error: [],
     };
+    // Queue for messages sent when socket is not open
+    messageQueue = [];
     get readyState() {
         return this.ws?.readyState ?? WebSocket.CLOSED;
     }
@@ -28,43 +37,89 @@ export class ReconnectingWebSocket {
             connectionTimeout: options.connectionTimeout ?? 10_000,
             backoffFactor: options.backoffFactor ?? 2,
             WebSocketConstructor: options.WebSocketConstructor ?? WebSocket,
+            healthCheckInterval: options.healthCheckInterval ?? 30_000,
         };
         this.connect();
     }
     connect() {
+        // Reset forcedClose flag to allow reconnection for new connection attempts
+        // 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);
+        // Close old socket if still connecting or open
+        if (this.ws?.readyState === WebSocket.CONNECTING ||
+            this.ws?.readyState === WebSocket.OPEN) {
+            this.ws?.close();
+        }
+        // Clear any pending timers (this also removes abort listener from old controller)
+        this.clearTimers();
+        // Create new abort controller
         this.abortController = new AbortController();
-        this.abortController.signal.addEventListener("abort", () => {
+        this.abortHandler = () => {
             if (this.ws?.readyState === WebSocket.CONNECTING) {
                 this.ws.close();
             }
-        });
+        };
+        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);
-        this.ws.addEventListener("open", (event) => {
-            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);
+        // 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) {
+                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();
+                // Flush any queued messages now that socket is open
+                this.flushMessageQueue();
             }
-            this.wasConnected = true;
-        });
-        this.ws.addEventListener("message", (event) => {
-            this.emit("message", event);
-        });
-        this.ws.addEventListener("close", (event) => {
-            this.emit("close", { code: event.code, reason: event.reason });
-            if (!this.forcedClose) {
-                this.scheduleReconnect();
+        };
+        this.msgFn = (event) => {
+            // Only process if event is from the current socket
+            if (event.target === currentWs && this.ws === currentWs) {
+                this.emit("message", event);
+            }
+        };
+        this.closeFn = (event) => {
+            // Only process if event is from the current socket
+            if (event.target === currentWs && this.ws === currentWs) {
+                this.stopHealthCheck();
+                this.emit("close", { code: event.code, reason: event.reason });
+                if (!this.forcedClose) {
+                    this.scheduleReconnect();
+                }
             }
-        });
-        this.ws.addEventListener("error", (event) => {
-            this.emit("error", event);
-            // Error will typically cause connection to close, triggering reconnect
-        });
+        };
+        this.errorFn = (event) => {
+            // Only process if event is from the current socket
+            if (event.target === currentWs && this.ws === currentWs) {
+                this.emit("error", event);
+            }
+        };
+        // Add event listeners to new socket
+        currentWs.addEventListener("open", this.openFn);
+        currentWs.addEventListener("message", this.msgFn);
+        currentWs.addEventListener("close", this.closeFn);
+        currentWs.addEventListener("error", this.errorFn);
     }
     emit(event, payload) {
         for (const listener of this.listeners[event]) {
@@ -72,11 +127,44 @@ export class ReconnectingWebSocket {
         }
     }
     scheduleReconnect() {
+        // Clear any existing reconnect timeout first to prevent multiple reconnects
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = undefined;
+        }
         const { retryDelay, backoffFactor, maxRetryDelay } = this.options;
         const delay = Math.min(retryDelay * Math.pow(backoffFactor, this.retryCount), maxRetryDelay);
         this.retryCount += 1;
         this.reconnectTimeout = setTimeout(() => this.connect(), delay);
     }
+    startHealthCheck() {
+        this.stopHealthCheck();
+        if (this.options.healthCheckInterval <= 0) {
+            return;
+        }
+        this.healthCheckInterval = setInterval(() => {
+            // Only check if we're not forcing a close and we expect to be connected
+            if (this.forcedClose) {
+                return;
+            }
+            // If we've been connected before and the socket is not OPEN, trigger reconnection
+            if (this.wasConnected && this.readyState !== WebSocket.OPEN) {
+                // Clear the existing socket reference since it's in a bad state
+                if (this.ws) {
+                    // Don't emit close event since we didn't receive one - this is a silent failure
+                    this.ws = undefined;
+                }
+                this.stopHealthCheck();
+                this.scheduleReconnect();
+            }
+        }, this.options.healthCheckInterval);
+    }
+    stopHealthCheck() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = undefined;
+        }
+    }
     clearTimers() {
         if (this.connectTimeout) {
             clearTimeout(this.connectTimeout);
@@ -86,9 +174,15 @@ export class ReconnectingWebSocket {
             clearTimeout(this.reconnectTimeout);
             this.reconnectTimeout = undefined;
         }
-        if (this.abortController) {
+        if (this.abortController && this.abortHandler) {
+            this.abortController.signal.removeEventListener("abort", this.abortHandler);
             this.abortController = undefined;
+            this.abortHandler = undefined;
         }
+        else if (this.abortController) {
+            this.abortController = undefined;
+        }
+        this.stopHealthCheck();
     }
     addEventListener(event, listener) {
         this.listeners[event].push(listener);
@@ -97,12 +191,35 @@ export class ReconnectingWebSocket {
         this.listeners[event] = this.listeners[event].filter((l) => l !== listener);
     }
     send(...args) {
-        this.ws?.send(...args);
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(...args);
+        }
+        else {
+            this.messageQueue.push(args);
+        }
+    }
+    flushMessageQueue() {
+        while (this.messageQueue.length > 0 &&
+            this.ws?.readyState === WebSocket.OPEN) {
+            const args = this.messageQueue.shift();
+            this.ws.send(...args);
+        }
     }
     close(...args) {
         this.forcedClose = true;
         this.clearTimers();
+        // Clear the message queue on forced close
+        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.ws.close(...args);
             this.ws = undefined;
         }

package/package.json

@@ -3,7 +3,7 @@
   "module": "src/index.ts",
   "type": "module",
   "license": "MIT",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "private": false,
   "types": "./dist/index.d.ts",
   "exports": {
@@ -24,17 +24,18 @@
     "prepare": "husky"
   },
   "devDependencies": {
-    "@eslint/js": "^9.38.0",
-    "@typescript-eslint/parser": "^8.46.2",
-    "eslint": "^9.38.0",
+    "@eslint/js": "^9.39.1",
+    "@types/bun": "^1.3.3",
+    "@typescript-eslint/parser": "^8.48.1",
+    "eslint": "^9.39.1",
     "eslint-config-prettier": "10.1.1",
     "eslint-import-resolver-typescript": "4.3.1",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-prettier": "^5.5.4",
-    "globals": "^16.4.0",
+    "globals": "^16.5.0",
     "husky": "^9.1.7",
-    "prettier": "^3.6.2",
-    "typescript-eslint": "^8.46.2"
+    "prettier": "^3.7.3",
+    "typescript-eslint": "^8.48.1"
   },
   "peerDependencies": {
     "typescript": "^5.8.3"