@iam4x/reconnecting-websocket 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -1 +1,34 @@
+type EventType = "open" | "message" | "close" | "reconnect" | "error";
+type Listener = (payload: any) => void;
+interface ReconnectOptions {
+    retryDelay?: number;
+    maxRetryDelay?: number;
+    connectionTimeout?: number;
+    backoffFactor?: number;
+    WebSocketConstructor?: typeof WebSocket;
+}
+export declare class ReconnectingWebSocket {
+    options: Required<ReconnectOptions & {
+        url: string;
+    }>;
+    ws?: WebSocket;
+    abortController?: AbortController;
+    connectTimeout?: ReturnType<typeof setTimeout>;
+    reconnectTimeout?: ReturnType<typeof setTimeout>;
+    retryCount: number;
+    forcedClose: boolean;
+    wasConnected: boolean;
+    listeners: Record<EventType, Listener[]>;
+    get readyState(): number;
+    get bufferedAmount(): number;
+    constructor(url: string, options?: ReconnectOptions);
+    connect(): void;
+    emit(event: EventType, payload: any): void;
+    scheduleReconnect(): void;
+    clearTimers(): void;
+    addEventListener(event: EventType, listener: Listener): void;
+    removeEventListener(event: EventType, listener: Listener): void;
+    send(...args: Parameters<WebSocket["send"]>): void;
+    close(...args: Parameters<WebSocket["close"]>): void;
+}
 export {};

package/dist/index.js

@@ -1,2 +1,110 @@
-console.log("Hello via Bun!");
-export {};
+export class ReconnectingWebSocket {
+    options;
+    ws;
+    abortController;
+    connectTimeout;
+    reconnectTimeout;
+    retryCount = 0;
+    forcedClose = false;
+    wasConnected = false;
+    listeners = {
+        open: [],
+        message: [],
+        close: [],
+        reconnect: [],
+        error: [],
+    };
+    get readyState() {
+        return this.ws?.readyState ?? WebSocket.CLOSED;
+    }
+    get bufferedAmount() {
+        return this.ws?.bufferedAmount ?? 0;
+    }
+    constructor(url, options = {}) {
+        this.options = {
+            url,
+            retryDelay: options.retryDelay ?? 1000,
+            maxRetryDelay: options.maxRetryDelay ?? 30_000,
+            connectionTimeout: options.connectionTimeout ?? 10_000,
+            backoffFactor: options.backoffFactor ?? 2,
+            WebSocketConstructor: options.WebSocketConstructor ?? WebSocket,
+        };
+        this.connect();
+    }
+    connect() {
+        this.abortController = new AbortController();
+        this.abortController.signal.addEventListener("abort", () => {
+            if (this.ws?.readyState === WebSocket.CONNECTING) {
+                this.ws.close();
+            }
+        });
+        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);
+            }
+            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.ws.addEventListener("error", (event) => {
+            this.emit("error", event);
+            // Error will typically cause connection to close, triggering reconnect
+        });
+    }
+    emit(event, payload) {
+        for (const listener of this.listeners[event]) {
+            listener(payload);
+        }
+    }
+    scheduleReconnect() {
+        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);
+    }
+    clearTimers() {
+        if (this.connectTimeout) {
+            clearTimeout(this.connectTimeout);
+            this.connectTimeout = undefined;
+        }
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = undefined;
+        }
+        if (this.abortController) {
+            this.abortController = undefined;
+        }
+    }
+    addEventListener(event, listener) {
+        this.listeners[event].push(listener);
+    }
+    removeEventListener(event, listener) {
+        this.listeners[event] = this.listeners[event].filter((l) => l !== listener);
+    }
+    send(...args) {
+        this.ws?.send(...args);
+    }
+    close(...args) {
+        this.forcedClose = true;
+        this.clearTimers();
+        if (this.ws) {
+            this.ws.close(...args);
+            this.ws = undefined;
+        }
+    }
+}

package/package.json

@@ -3,10 +3,14 @@
   "module": "src/index.ts",
   "type": "module",
   "license": "MIT",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "private": false,
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
   "files": [
     "dist"