@eleven-am/pondsocket-client 0.0.30 → 0.0.32

package/browser/client.js

@@ -10,13 +10,17 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _PondClient_instances, _PondClient_channels, _PondClient_createPublisher, _PondClient_handleAcknowledge, _PondClient_init;
+var _PondClient_instances, _PondClient_channels, _PondClient_clearTimeouts, _PondClient_createPublisher, _PondClient_handleAcknowledge, _PondClient_handleUnauthorized, _PondClient_init;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondClient = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const channel_1 = require("../core/channel");
+const types_1 = require("../types");
+const DEFAULT_CONNECTION_TIMEOUT = 10000;
+const DEFAULT_MAX_RECONNECT_DELAY = 30000;
 class PondClient {
-    constructor(endpoint, params = {}) {
+    constructor(endpoint, params = {}, options = {}) {
+        var _a, _b;
         _PondClient_instances.add(this);
         _PondClient_channels.set(this, void 0);
         let address;
@@ -28,6 +32,7 @@ class PondClient {
             address.pathname = endpoint;
         }
         this._disconnecting = false;
+        this._reconnectAttempts = 0;
         const query = new URLSearchParams(params);
         address.search = query.toString();
         const protocol = address.protocol === 'https:' ? 'wss:' : 'ws:';
@@ -35,9 +40,15 @@ class PondClient {
             address.protocol = protocol;
         }
         this._address = address;
+        this._options = {
+            connectionTimeout: (_a = options.connectionTimeout) !== null && _a !== void 0 ? _a : DEFAULT_CONNECTION_TIMEOUT,
+            maxReconnectDelay: (_b = options.maxReconnectDelay) !== null && _b !== void 0 ? _b : DEFAULT_MAX_RECONNECT_DELAY,
+            pingInterval: options.pingInterval,
+        };
         __classPrivateFieldSet(this, _PondClient_channels, new Map(), "f");
         this._broadcaster = new pondsocket_common_1.Subject();
-        this._connectionState = new pondsocket_common_1.BehaviorSubject(false);
+        this._connectionState = new pondsocket_common_1.BehaviorSubject(types_1.ConnectionState.DISCONNECTED);
+        this._errorSubject = new pondsocket_common_1.Subject();
         __classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_init).call(this);
     }
     /**
@@ -45,7 +56,26 @@ class PondClient {
      */
     connect() {
         this._disconnecting = false;
+        this._connectionState.publish(types_1.ConnectionState.CONNECTING);
         const socket = new WebSocket(this._address.toString());
+        this._connectionTimeoutId = setTimeout(() => {
+            if (socket.readyState === WebSocket.CONNECTING) {
+                const error = new Error('Connection timeout');
+                this._errorSubject.publish(error);
+                socket.close();
+            }
+        }, this._options.connectionTimeout);
+        socket.onopen = () => {
+            __classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_clearTimeouts).call(this);
+            this._reconnectAttempts = 0;
+            if (this._options.pingInterval) {
+                this._pingIntervalId = setInterval(() => {
+                    if (socket.readyState === WebSocket.OPEN) {
+                        socket.send(JSON.stringify({ action: 'ping' }));
+                    }
+                }, this._options.pingInterval);
+            }
+        };
         socket.onmessage = (message) => {
             const lines = message.data.trim().split('\n');
             for (const line of lines) {
@@ -56,15 +86,22 @@ class PondClient {
                 }
             }
         };
-        socket.onerror = () => socket.close();
+        socket.onerror = (event) => {
+            const error = new Error('WebSocket error');
+            this._errorSubject.publish(error);
+            socket.close();
+        };
         socket.onclose = () => {
-            this._connectionState.publish(false);
+            __classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_clearTimeouts).call(this);
+            this._connectionState.publish(types_1.ConnectionState.DISCONNECTED);
             if (this._disconnecting) {
                 return;
             }
+            const delay = Math.min(1000 * Math.pow(2, this._reconnectAttempts), this._options.maxReconnectDelay);
+            this._reconnectAttempts++;
             setTimeout(() => {
                 this.connect();
-            }, 1000);
+            }, delay);
         };
         this._socket = socket;
     }
@@ -79,8 +116,9 @@ class PondClient {
      */
     disconnect() {
         var _a;
-        this._connectionState.publish(false);
+        __classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_clearTimeouts).call(this);
         this._disconnecting = true;
+        this._connectionState.publish(types_1.ConnectionState.DISCONNECTED);
         (_a = this._socket) === null || _a === void 0 ? void 0 : _a.close();
         __classPrivateFieldGet(this, _PondClient_channels, "f").clear();
     }
@@ -106,11 +144,27 @@ class PondClient {
     onConnectionChange(callback) {
         return this._connectionState.subscribe(callback);
     }
+    /**
+     * @desc Subscribes to connection errors.
+     * @param callback - The callback to call when an error occurs.
+     */
+    onError(callback) {
+        return this._errorSubject.subscribe(callback);
+    }
 }
 exports.PondClient = PondClient;
-_PondClient_channels = new WeakMap(), _PondClient_instances = new WeakSet(), _PondClient_createPublisher = function _PondClient_createPublisher() {
+_PondClient_channels = new WeakMap(), _PondClient_instances = new WeakSet(), _PondClient_clearTimeouts = function _PondClient_clearTimeouts() {
+    if (this._connectionTimeoutId) {
+        clearTimeout(this._connectionTimeoutId);
+        this._connectionTimeoutId = undefined;
+    }
+    if (this._pingIntervalId) {
+        clearInterval(this._pingIntervalId);
+        this._pingIntervalId = undefined;
+    }
+}, _PondClient_createPublisher = function _PondClient_createPublisher() {
     return (message) => {
-        if (this._connectionState.value) {
+        if (this._connectionState.value === types_1.ConnectionState.CONNECTED) {
             this._socket.send(JSON.stringify(message));
         }
     };
@@ -119,13 +173,22 @@ _PondClient_channels = new WeakMap(), _PondClient_instances = new WeakSet(), _Po
     const channel = (_a = __classPrivateFieldGet(this, _PondClient_channels, "f").get(message.channelName)) !== null && _a !== void 0 ? _a : new channel_1.Channel(__classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_createPublisher).call(this), this._connectionState, message.channelName, {});
     __classPrivateFieldGet(this, _PondClient_channels, "f").set(message.channelName, channel);
     channel.acknowledge(this._broadcaster);
+}, _PondClient_handleUnauthorized = function _PondClient_handleUnauthorized(message) {
+    const channel = __classPrivateFieldGet(this, _PondClient_channels, "f").get(message.channelName);
+    if (channel) {
+        const payload = message.payload;
+        channel.decline(payload);
+    }
 }, _PondClient_init = function _PondClient_init() {
     this._broadcaster.subscribe((message) => {
         if (message.event === pondsocket_common_1.Events.ACKNOWLEDGE) {
             __classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_handleAcknowledge).call(this, message);
         }
+        else if (message.event === pondsocket_common_1.Events.UNAUTHORIZED) {
+            __classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_handleUnauthorized).call(this, message);
+        }
         else if (message.event === pondsocket_common_1.Events.CONNECTION && message.action === pondsocket_common_1.ServerActions.CONNECT) {
-            this._connectionState.publish(true);
+            this._connectionState.publish(types_1.ConnectionState.CONNECTED);
         }
     });
 };

package/browser/client.test.js

@@ -11,14 +11,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const client_1 = require("./client");
+const types_1 = require("../types");
 class MockWebSocket {
     // eslint-disable-next-line no-useless-constructor
     constructor(url) {
         this.url = url;
         this.send = jest.fn();
         this.close = jest.fn();
+        this.readyState = MockWebSocket.CONNECTING;
     }
 }
+MockWebSocket.CONNECTING = 0;
+MockWebSocket.OPEN = 1;
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-expect-error
 global.WebSocket = MockWebSocket;
@@ -69,11 +73,12 @@ describe('PondClient', () => {
         expect(broadcasterSpy).not.toHaveBeenCalled();
     });
     test('socket should only pass to publish state when acknowledged event is received', () => {
-        pondClient.connect();
-        const mockWebSocket = pondClient['_socket'];
         const mockCallback = jest.fn();
         pondClient.onConnectionChange(mockCallback);
-        expect(mockCallback).not.toHaveBeenCalled();
+        mockCallback.mockClear();
+        pondClient.connect();
+        const mockWebSocket = pondClient['_socket'];
+        expect(mockCallback).toHaveBeenCalledWith(types_1.ConnectionState.CONNECTING);
         const acknowledgeEvent = {
             event: pondsocket_common_1.Events.CONNECTION,
             action: pondsocket_common_1.ServerActions.CONNECT,
@@ -82,7 +87,7 @@ describe('PondClient', () => {
             payload: {},
         };
         mockWebSocket.onmessage({ data: JSON.stringify(acknowledgeEvent) });
-        expect(mockCallback).toHaveBeenCalledWith(true);
+        expect(mockCallback).toHaveBeenCalledWith(types_1.ConnectionState.CONNECTED);
     });
     test('createChannel method should create a new channel or return an existing one', () => {
         const mockChannel = pondClient.createChannel('exampleChannel');
@@ -94,19 +99,20 @@ describe('PondClient', () => {
     test('onConnectionChange method should subscribe to connection state changes', () => {
         const mockCallback = jest.fn();
         const unsubscribe = pondClient.onConnectionChange(mockCallback);
-        pondClient['_connectionState'].publish(true);
-        expect(mockCallback).toHaveBeenCalledWith(true);
+        mockCallback.mockClear();
+        pondClient['_connectionState'].publish(types_1.ConnectionState.CONNECTED);
+        expect(mockCallback).toHaveBeenCalledWith(types_1.ConnectionState.CONNECTED);
         unsubscribe();
-        pondClient['_connectionState'].publish(false);
+        pondClient['_connectionState'].publish(types_1.ConnectionState.DISCONNECTED);
         // Should not be called again after unsubscribe
         expect(mockCallback).toHaveBeenCalledTimes(1);
     });
     test('getState method should return the current state of the socket', () => {
         const initialState = pondClient.getState();
-        expect(initialState).toBe(false);
-        pondClient['_connectionState'].publish(true);
+        expect(initialState).toBe(types_1.ConnectionState.DISCONNECTED);
+        pondClient['_connectionState'].publish(types_1.ConnectionState.CONNECTED);
         const updatedState = pondClient.getState();
-        expect(updatedState).toBe(true);
+        expect(updatedState).toBe(types_1.ConnectionState.CONNECTED);
     });
     test('publish method should send a message to the server', () => {
         pondClient.connect();
@@ -131,7 +137,7 @@ describe('PondClient', () => {
             channelName: 'exampleChannel',
         }));
     });
-    it('onError method should reconnect to the server', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should reconnect with exponential backoff', () => __awaiter(void 0, void 0, void 0, function* () {
         const connectSpy = jest.spyOn(pondClient, 'connect');
         pondClient.connect();
         let mockWebSocket = pondClient['_socket'];
@@ -146,4 +152,56 @@ describe('PondClient', () => {
         yield new Promise((resolve) => setTimeout(resolve, 2000));
         expect(connectSpy).toHaveBeenCalledTimes(1);
     }));
+    test('onError method should subscribe to error events', () => {
+        const errorCallback = jest.fn();
+        pondClient.onError(errorCallback);
+        pondClient.connect();
+        const mockWebSocket = pondClient['_socket'];
+        mockWebSocket.onerror({ type: 'error' });
+        expect(errorCallback).toHaveBeenCalledTimes(1);
+        expect(errorCallback).toHaveBeenCalledWith(expect.any(Error));
+    });
+    test('connect should transition through connection states', () => {
+        const stateCallback = jest.fn();
+        pondClient.onConnectionChange(stateCallback);
+        expect(pondClient.getState()).toBe(types_1.ConnectionState.DISCONNECTED);
+        pondClient.connect();
+        expect(stateCallback).toHaveBeenCalledWith(types_1.ConnectionState.CONNECTING);
+    });
+    test('connection timeout should trigger error and close', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.useFakeTimers();
+        const clientWithTimeout = new client_1.PondClient('ws://example.com', {}, { connectionTimeout: 5000 });
+        const errorCallback = jest.fn();
+        clientWithTimeout.onError(errorCallback);
+        clientWithTimeout.connect();
+        const mockWebSocket = clientWithTimeout['_socket'];
+        mockWebSocket.readyState = MockWebSocket.CONNECTING;
+        jest.advanceTimersByTime(5000);
+        expect(errorCallback).toHaveBeenCalledWith(expect.objectContaining({ message: 'Connection timeout' }));
+        expect(mockWebSocket.close).toHaveBeenCalled();
+        jest.useRealTimers();
+    }));
+    test('ping interval should send ping messages when connected', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.useFakeTimers();
+        const clientWithPing = new client_1.PondClient('ws://example.com', {}, { pingInterval: 1000 });
+        clientWithPing.connect();
+        const mockWebSocket = clientWithPing['_socket'];
+        mockWebSocket.readyState = MockWebSocket.OPEN;
+        mockWebSocket.onopen();
+        jest.advanceTimersByTime(1000);
+        expect(mockWebSocket.send).toHaveBeenCalledWith(JSON.stringify({ action: 'ping' }));
+        jest.advanceTimersByTime(1000);
+        expect(mockWebSocket.send).toHaveBeenCalledTimes(2);
+        jest.useRealTimers();
+    }));
+    test('disconnect should clear timeouts and stop reconnection', () => {
+        pondClient.connect();
+        const mockWebSocket = pondClient['_socket'];
+        pondClient.disconnect();
+        expect(pondClient.getState()).toBe(types_1.ConnectionState.DISCONNECTED);
+        expect(mockWebSocket.close).toHaveBeenCalled();
+        const connectSpy = jest.spyOn(pondClient, 'connect');
+        mockWebSocket.onclose();
+        expect(connectSpy).not.toHaveBeenCalled();
+    });
 });

package/browser/sseClient.js

@@ -0,0 +1,199 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SSEClient_instances, _SSEClient_channels, _SSEClient_handleMessage, _SSEClient_clearTimeout, _SSEClient_createPublisher, _SSEClient_handleAcknowledge, _SSEClient_handleUnauthorized, _SSEClient_init;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSEClient = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const channel_1 = require("../core/channel");
+const types_1 = require("../types");
+const DEFAULT_CONNECTION_TIMEOUT = 10000;
+const DEFAULT_MAX_RECONNECT_DELAY = 30000;
+class SSEClient {
+    constructor(endpoint, params = {}, options = {}) {
+        var _a, _b;
+        _SSEClient_instances.add(this);
+        _SSEClient_channels.set(this, void 0);
+        let address;
+        try {
+            address = new URL(endpoint);
+        }
+        catch (e) {
+            address = new URL(window.location.toString());
+            address.pathname = endpoint;
+        }
+        this._disconnecting = false;
+        this._reconnectAttempts = 0;
+        const query = new URLSearchParams(params);
+        address.search = query.toString();
+        if (address.protocol !== 'https:' && address.protocol !== 'http:') {
+            address.protocol = window.location.protocol;
+        }
+        this._address = address;
+        this._postAddress = new URL(address.toString());
+        this._options = {
+            connectionTimeout: (_a = options.connectionTimeout) !== null && _a !== void 0 ? _a : DEFAULT_CONNECTION_TIMEOUT,
+            maxReconnectDelay: (_b = options.maxReconnectDelay) !== null && _b !== void 0 ? _b : DEFAULT_MAX_RECONNECT_DELAY,
+            pingInterval: options.pingInterval,
+            withCredentials: options.withCredentials,
+        };
+        __classPrivateFieldSet(this, _SSEClient_channels, new Map(), "f");
+        this._broadcaster = new pondsocket_common_1.Subject();
+        this._connectionState = new pondsocket_common_1.BehaviorSubject(types_1.ConnectionState.DISCONNECTED);
+        this._errorSubject = new pondsocket_common_1.Subject();
+        __classPrivateFieldGet(this, _SSEClient_instances, "m", _SSEClient_init).call(this);
+    }
+    connect() {
+        var _a;
+        this._disconnecting = false;
+        this._connectionState.publish(types_1.ConnectionState.CONNECTING);
+        const eventSource = new EventSource(this._address.toString(), {
+            withCredentials: (_a = this._options.withCredentials) !== null && _a !== void 0 ? _a : false,
+        });
+        this._connectionTimeoutId = setTimeout(() => {
+            if (eventSource.readyState === EventSource.CONNECTING) {
+                const error = new Error('Connection timeout');
+                this._errorSubject.publish(error);
+                eventSource.close();
+            }
+        }, this._options.connectionTimeout);
+        eventSource.onopen = () => {
+            __classPrivateFieldGet(this, _SSEClient_instances, "m", _SSEClient_clearTimeout).call(this);
+            this._reconnectAttempts = 0;
+        };
+        eventSource.onmessage = (event) => {
+            __classPrivateFieldGet(this, _SSEClient_instances, "m", _SSEClient_handleMessage).call(this, event.data);
+        };
+        eventSource.onerror = () => {
+            const error = new Error('SSE connection error');
+            this._errorSubject.publish(error);
+            eventSource.close();
+            __classPrivateFieldGet(this, _SSEClient_instances, "m", _SSEClient_clearTimeout).call(this);
+            this._connectionState.publish(types_1.ConnectionState.DISCONNECTED);
+            if (this._disconnecting) {
+                return;
+            }
+            const delay = Math.min(1000 * Math.pow(2, this._reconnectAttempts), this._options.maxReconnectDelay);
+            this._reconnectAttempts++;
+            setTimeout(() => {
+                this.connect();
+            }, delay);
+        };
+        this._eventSource = eventSource;
+    }
+    getState() {
+        return this._connectionState.value;
+    }
+    getConnectionId() {
+        return this._connectionId;
+    }
+    disconnect() {
+        var _a;
+        __classPrivateFieldGet(this, _SSEClient_instances, "m", _SSEClient_clearTimeout).call(this);
+        this._disconnecting = true;
+        this._connectionState.publish(types_1.ConnectionState.DISCONNECTED);
+        if (this._connectionId) {
+            fetch(this._postAddress.toString(), {
+                method: 'DELETE',
+                headers: {
+                    'X-Connection-ID': this._connectionId,
+                },
+                credentials: this._options.withCredentials ? 'include' : 'same-origin',
+            }).catch(() => {
+            });
+        }
+        (_a = this._eventSource) === null || _a === void 0 ? void 0 : _a.close();
+        this._connectionId = undefined;
+        __classPrivateFieldGet(this, _SSEClient_channels, "f").clear();
+    }
+    createChannel(name, params) {
+        const channel = __classPrivateFieldGet(this, _SSEClient_channels, "f").get(name);
+        if (channel && channel.channelState !== pondsocket_common_1.ChannelState.CLOSED) {
+            return channel;
+        }
+        const publisher = __classPrivateFieldGet(this, _SSEClient_instances, "m", _SSEClient_createPublisher).call(this);
+        const newChannel = new channel_1.Channel(publisher, this._connectionState, name, params || {});
+        __classPrivateFieldGet(this, _SSEClient_channels, "f").set(name, newChannel);
+        return newChannel;
+    }
+    onConnectionChange(callback) {
+        return this._connectionState.subscribe(callback);
+    }
+    onError(callback) {
+        return this._errorSubject.subscribe(callback);
+    }
+}
+exports.SSEClient = SSEClient;
+_SSEClient_channels = new WeakMap(), _SSEClient_instances = new WeakSet(), _SSEClient_handleMessage = function _SSEClient_handleMessage(data) {
+    try {
+        const lines = data.trim().split('\n');
+        for (const line of lines) {
+            if (line.trim()) {
+                const parsed = JSON.parse(line);
+                const event = pondsocket_common_1.channelEventSchema.parse(parsed);
+                if (event.event === pondsocket_common_1.Events.CONNECTION && event.action === pondsocket_common_1.ServerActions.CONNECT) {
+                    if (event.payload && typeof event.payload === 'object' && 'connectionId' in event.payload) {
+                        this._connectionId = event.payload.connectionId;
+                    }
+                }
+                this._broadcaster.publish(event);
+            }
+        }
+    }
+    catch (e) {
+        this._errorSubject.publish(e instanceof Error ? e : new Error('Failed to parse SSE message'));
+    }
+}, _SSEClient_clearTimeout = function _SSEClient_clearTimeout() {
+    if (this._connectionTimeoutId) {
+        clearTimeout(this._connectionTimeoutId);
+        this._connectionTimeoutId = undefined;
+    }
+}, _SSEClient_createPublisher = function _SSEClient_createPublisher() {
+    return (message) => {
+        if (this._connectionState.value === types_1.ConnectionState.CONNECTED && this._connectionId) {
+            fetch(this._postAddress.toString(), {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Connection-ID': this._connectionId,
+                },
+                body: JSON.stringify(message),
+                credentials: this._options.withCredentials ? 'include' : 'same-origin',
+            }).catch((err) => {
+                this._errorSubject.publish(err instanceof Error ? err : new Error('Failed to send message'));
+            });
+        }
+    };
+}, _SSEClient_handleAcknowledge = function _SSEClient_handleAcknowledge(message) {
+    var _a;
+    const channel = (_a = __classPrivateFieldGet(this, _SSEClient_channels, "f").get(message.channelName)) !== null && _a !== void 0 ? _a : new channel_1.Channel(__classPrivateFieldGet(this, _SSEClient_instances, "m", _SSEClient_createPublisher).call(this), this._connectionState, message.channelName, {});
+    __classPrivateFieldGet(this, _SSEClient_channels, "f").set(message.channelName, channel);
+    channel.acknowledge(this._broadcaster);
+}, _SSEClient_handleUnauthorized = function _SSEClient_handleUnauthorized(message) {
+    const channel = __classPrivateFieldGet(this, _SSEClient_channels, "f").get(message.channelName);
+    if (channel) {
+        const payload = message.payload;
+        channel.decline(payload);
+    }
+}, _SSEClient_init = function _SSEClient_init() {
+    this._broadcaster.subscribe((message) => {
+        if (message.event === pondsocket_common_1.Events.ACKNOWLEDGE) {
+            __classPrivateFieldGet(this, _SSEClient_instances, "m", _SSEClient_handleAcknowledge).call(this, message);
+        }
+        else if (message.event === pondsocket_common_1.Events.UNAUTHORIZED) {
+            __classPrivateFieldGet(this, _SSEClient_instances, "m", _SSEClient_handleUnauthorized).call(this, message);
+        }
+        else if (message.event === pondsocket_common_1.Events.CONNECTION && message.action === pondsocket_common_1.ServerActions.CONNECT) {
+            this._connectionState.publish(types_1.ConnectionState.CONNECTED);
+        }
+    });
+};

package/browser/sseClient.test.js

@@ -0,0 +1,202 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const sseClient_1 = require("./sseClient");
+const types_1 = require("../types");
+class MockEventSource {
+    constructor(url, options) {
+        this.onopen = null;
+        this.onmessage = null;
+        this.onerror = null;
+        this.readyState = MockEventSource.CONNECTING;
+        this.close = jest.fn();
+        this.url = url;
+        this.options = options;
+    }
+}
+MockEventSource.CONNECTING = 0;
+MockEventSource.OPEN = 1;
+MockEventSource.CLOSED = 2;
+// @ts-expect-error
+global.EventSource = MockEventSource;
+global.fetch = jest.fn(() => Promise.resolve({
+    ok: true,
+    status: 202,
+}));
+describe('SSEClient', () => {
+    let sseClient;
+    beforeEach(() => {
+        sseClient = new sseClient_1.SSEClient('http://example.com/events');
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    test('connect method should set up EventSource events', () => {
+        sseClient.connect();
+        const mockEventSource = sseClient['_eventSource'];
+        expect(mockEventSource === null || mockEventSource === void 0 ? void 0 : mockEventSource.onmessage).toBeInstanceOf(Function);
+        expect(mockEventSource === null || mockEventSource === void 0 ? void 0 : mockEventSource.onerror).toBeInstanceOf(Function);
+        expect(mockEventSource === null || mockEventSource === void 0 ? void 0 : mockEventSource.onopen).toBeInstanceOf(Function);
+    });
+    test('connect should transition to CONNECTING state', () => {
+        const stateCallback = jest.fn();
+        sseClient.onConnectionChange(stateCallback);
+        stateCallback.mockClear();
+        sseClient.connect();
+        expect(stateCallback).toHaveBeenCalledWith(types_1.ConnectionState.CONNECTING);
+    });
+    test('it should publish messages received from the server', () => {
+        var _a;
+        sseClient.connect();
+        const mockEventSource = sseClient['_eventSource'];
+        const broadcasterSpy = jest.spyOn(sseClient['_broadcaster'], 'publish');
+        const event = {
+            data: JSON.stringify({
+                action: pondsocket_common_1.ServerActions.SYSTEM,
+                channelName: 'testChannel',
+                requestId: '123',
+                payload: {},
+                event: 'testEvent',
+            }),
+        };
+        (_a = mockEventSource === null || mockEventSource === void 0 ? void 0 : mockEventSource.onmessage) === null || _a === void 0 ? void 0 : _a.call(mockEventSource, event);
+        expect(broadcasterSpy).toHaveBeenCalledTimes(1);
+        expect(broadcasterSpy).toHaveBeenCalledWith({
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: 'testChannel',
+            requestId: '123',
+            payload: {},
+            event: 'testEvent',
+        });
+    });
+    test('should extract connectionId from CONNECTION event', () => {
+        var _a;
+        sseClient.connect();
+        const mockEventSource = sseClient['_eventSource'];
+        const connectEvent = {
+            event: pondsocket_common_1.Events.CONNECTION,
+            action: pondsocket_common_1.ServerActions.CONNECT,
+            channelName: 'GATEWAY',
+            requestId: '123',
+            payload: { connectionId: 'test-conn-id' },
+        };
+        (_a = mockEventSource === null || mockEventSource === void 0 ? void 0 : mockEventSource.onmessage) === null || _a === void 0 ? void 0 : _a.call(mockEventSource, { data: JSON.stringify(connectEvent) });
+        expect(sseClient.getConnectionId()).toBe('test-conn-id');
+    });
+    test('should transition to CONNECTED state on CONNECTION event', () => {
+        var _a;
+        const mockCallback = jest.fn();
+        sseClient.onConnectionChange(mockCallback);
+        mockCallback.mockClear();
+        sseClient.connect();
+        const mockEventSource = sseClient['_eventSource'];
+        const connectEvent = {
+            event: pondsocket_common_1.Events.CONNECTION,
+            action: pondsocket_common_1.ServerActions.CONNECT,
+            channelName: 'GATEWAY',
+            requestId: '123',
+            payload: { connectionId: 'test-conn-id' },
+        };
+        (_a = mockEventSource === null || mockEventSource === void 0 ? void 0 : mockEventSource.onmessage) === null || _a === void 0 ? void 0 : _a.call(mockEventSource, { data: JSON.stringify(connectEvent) });
+        expect(mockCallback).toHaveBeenCalledWith(types_1.ConnectionState.CONNECTED);
+    });
+    test('createChannel method should create a new channel', () => {
+        const channel = sseClient.createChannel('testChannel');
+        expect(channel).toBeDefined();
+        expect(sseClient.createChannel('testChannel')).toBe(channel);
+    });
+    test('getState method should return the current state', () => {
+        expect(sseClient.getState()).toBe(types_1.ConnectionState.DISCONNECTED);
+        sseClient['_connectionState'].publish(types_1.ConnectionState.CONNECTED);
+        expect(sseClient.getState()).toBe(types_1.ConnectionState.CONNECTED);
+    });
+    test('onError method should subscribe to error events', () => {
+        var _a;
+        const errorCallback = jest.fn();
+        sseClient.onError(errorCallback);
+        sseClient.connect();
+        const mockEventSource = sseClient['_eventSource'];
+        (_a = mockEventSource === null || mockEventSource === void 0 ? void 0 : mockEventSource.onerror) === null || _a === void 0 ? void 0 : _a.call(mockEventSource, new Event('error'));
+        expect(errorCallback).toHaveBeenCalledTimes(1);
+        expect(errorCallback).toHaveBeenCalledWith(expect.any(Error));
+    });
+    test('disconnect should close EventSource and send DELETE request', () => {
+        sseClient.connect();
+        const mockEventSource = sseClient['_eventSource'];
+        sseClient['_connectionId'] = 'test-conn-id';
+        sseClient.disconnect();
+        expect(mockEventSource === null || mockEventSource === void 0 ? void 0 : mockEventSource.close).toHaveBeenCalled();
+        expect(sseClient.getState()).toBe(types_1.ConnectionState.DISCONNECTED);
+        expect(global.fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            method: 'DELETE',
+            headers: expect.objectContaining({
+                'X-Connection-ID': 'test-conn-id',
+            }),
+        }));
+    });
+    test('should send messages via POST with connection ID', () => __awaiter(void 0, void 0, void 0, function* () {
+        sseClient.connect();
+        sseClient['_connectionId'] = 'test-conn-id';
+        sseClient['_connectionState'].publish(types_1.ConnectionState.CONNECTED);
+        const channel = sseClient.createChannel('testChannel');
+        const connectEvent = {
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: 'testChannel',
+            requestId: '123',
+            payload: {},
+        };
+        sseClient['_broadcaster'].publish(connectEvent);
+        channel.sendMessage('testEvent', { data: 'test' });
+        yield new Promise((resolve) => setTimeout(resolve, 10));
+        expect(global.fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({
+                'Content-Type': 'application/json',
+                'X-Connection-ID': 'test-conn-id',
+            }),
+            body: expect.any(String),
+        }));
+    }));
+    test('connection timeout should trigger error', () => {
+        jest.useFakeTimers();
+        const clientWithTimeout = new sseClient_1.SSEClient('http://example.com/events', {}, { connectionTimeout: 5000 });
+        const errorCallback = jest.fn();
+        clientWithTimeout.onError(errorCallback);
+        clientWithTimeout.connect();
+        const mockEventSource = clientWithTimeout['_eventSource'];
+        mockEventSource.readyState = MockEventSource.CONNECTING;
+        jest.advanceTimersByTime(5000);
+        expect(errorCallback).toHaveBeenCalledWith(expect.objectContaining({ message: 'Connection timeout' }));
+        expect(mockEventSource.close).toHaveBeenCalled();
+        jest.useRealTimers();
+    });
+    test('should reconnect with exponential backoff on error', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const connectSpy = jest.spyOn(sseClient, 'connect');
+        sseClient.connect();
+        const mockEventSource = sseClient['_eventSource'];
+        expect(connectSpy).toHaveBeenCalledTimes(1);
+        connectSpy.mockClear();
+        (_a = mockEventSource === null || mockEventSource === void 0 ? void 0 : mockEventSource.onerror) === null || _a === void 0 ? void 0 : _a.call(mockEventSource, new Event('error'));
+        yield new Promise((resolve) => setTimeout(resolve, 1100));
+        expect(connectSpy).toHaveBeenCalledTimes(1);
+    }));
+    test('should use withCredentials option when set', () => {
+        var _a;
+        const clientWithCredentials = new sseClient_1.SSEClient('http://example.com/events', {}, { withCredentials: true });
+        clientWithCredentials.connect();
+        const mockEventSource = clientWithCredentials['_eventSource'];
+        expect((_a = mockEventSource.options) === null || _a === void 0 ? void 0 : _a.withCredentials).toBe(true);
+    });
+});

package/core/channel.js

@@ -14,6 +14,7 @@ var _Channel_instances, _Channel_name, _Channel_queue, _Channel_presence, _Chann
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channel = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const types_1 = require("../types");
 class Channel {
     constructor(publisher, clientState, name, params) {
         _Channel_instances.add(this);
@@ -59,6 +60,14 @@ class Channel {
         __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_init).call(this, receiver);
         __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_emptyQueue).call(this);
     }
+    /**
+     * @desc Marks the channel join as declined by the server.
+     * @param payload - The decline payload containing status code and message.
+     */
+    decline(payload) {
+        __classPrivateFieldGet(this, _Channel_joinState, "f").publish(pondsocket_common_1.ChannelState.DECLINED);
+        __classPrivateFieldSet(this, _Channel_queue, [], "f");
+    }
     /**
      * @desc Connects to the channel.
      */
@@ -74,12 +83,12 @@ class Channel {
             return;
         }
         __classPrivateFieldGet(this, _Channel_joinState, "f").publish(pondsocket_common_1.ChannelState.JOINING);
-        if (__classPrivateFieldGet(this, _Channel_clientState, "f").value) {
+        if (__classPrivateFieldGet(this, _Channel_clientState, "f").value === types_1.ConnectionState.CONNECTED) {
             __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, message);
         }
         else {
             const unsubscribe = __classPrivateFieldGet(this, _Channel_clientState, "f").subscribe((state) => {
-                if (state) {
+                if (state === types_1.ConnectionState.CONNECTED) {
                     unsubscribe();
                     if (__classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.JOINING) {
                         __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, message);
@@ -227,7 +236,7 @@ _Channel_name = new WeakMap(), _Channel_queue = new WeakMap(), _Channel_presence
         }
     });
     const unsubStateChange = __classPrivateFieldGet(this, _Channel_clientState, "f").subscribe((state) => {
-        if (state && __classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.STALLED) {
+        if (state === types_1.ConnectionState.CONNECTED && __classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.STALLED) {
             const message = {
                 action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
                 event: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
@@ -237,7 +246,7 @@ _Channel_name = new WeakMap(), _Channel_queue = new WeakMap(), _Channel_presence
             };
             __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, message);
         }
-        else if (!state && __classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.JOINED) {
+        else if (state !== types_1.ConnectionState.CONNECTED && __classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.JOINED) {
             __classPrivateFieldGet(this, _Channel_joinState, "f").publish(pondsocket_common_1.ChannelState.STALLED);
         }
     });

package/core/channel.test.js

@@ -11,9 +11,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const channel_1 = require("./channel");
+const types_1 = require("../types");
 const createChannel = (params = {}) => {
     const publisher = jest.fn();
-    const state = new pondsocket_common_1.BehaviorSubject(true);
+    const state = new pondsocket_common_1.BehaviorSubject(types_1.ConnectionState.CONNECTED);
     const receiver = new pondsocket_common_1.Subject();
     const channel = new channel_1.Channel(publisher, state, 'test', params);
     return {
@@ -29,12 +30,12 @@ describe('Channel', () => {
         // the channel should be in the idle state when it is created
         expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.IDLE);
         // if the socket is not connected the channel should not post a join message
-        state.publish(false);
+        state.publish(types_1.ConnectionState.DISCONNECTED);
         channel.join();
         expect(publisher).not.toHaveBeenCalled();
         expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.JOINING);
         // once the socket is connected, the channel should attempt to join
-        state.publish(true);
+        state.publish(types_1.ConnectionState.CONNECTED);
         expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.JOINING);
         expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
             action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
@@ -46,11 +47,11 @@ describe('Channel', () => {
         channel.acknowledge(receiver);
         expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.JOINED);
         // if the socket is disconnected, the channel should be stalled
-        state.publish(false);
+        state.publish(types_1.ConnectionState.DISCONNECTED);
         expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.STALLED);
         // once the socket is reconnected, a join message should be sent
         publisher.mockClear();
-        state.publish(true);
+        state.publish(types_1.ConnectionState.CONNECTED);
         expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.STALLED);
         expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
             action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
@@ -66,17 +67,17 @@ describe('Channel', () => {
         expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.CLOSED);
         publisher.mockClear();
         // if the socket closes, while the channel is closed, the channel should not attempt to join when the socket reconnects
-        state.publish(false);
-        state.publish(true);
+        state.publish(types_1.ConnectionState.DISCONNECTED);
+        state.publish(types_1.ConnectionState.CONNECTED);
         expect(publisher).not.toHaveBeenCalled();
         // if the channel is closed, during a join process, the channel should not attempt to join when the socket reconnects
         const { channel: channel2, publisher: publisher2, state: state2 } = createChannel();
-        state2.publish(false);
+        state2.publish(types_1.ConnectionState.DISCONNECTED);
         channel2.join();
         expect(publisher2).not.toHaveBeenCalled();
         expect(channel2.channelState).toBe(pondsocket_common_1.ChannelState.JOINING);
         channel2.leave();
-        state2.publish(true);
+        state2.publish(types_1.ConnectionState.CONNECTED);
         expect(publisher2).not.toHaveBeenCalled();
         // if for some reason the server responds with an ack, the channel should still join, (The server is the source of truth)
         channel2.acknowledge(receiver);
@@ -91,7 +92,7 @@ describe('Channel', () => {
         expect(stateListener).toHaveBeenCalledWith(pondsocket_common_1.ChannelState.JOINING);
         channel.acknowledge(receiver);
         expect(stateListener).toHaveBeenCalledWith(pondsocket_common_1.ChannelState.JOINED);
-        state.publish(false);
+        state.publish(types_1.ConnectionState.DISCONNECTED);
         expect(stateListener).toHaveBeenCalledWith(pondsocket_common_1.ChannelState.STALLED);
         channel.leave();
         expect(stateListener).toHaveBeenCalledWith(pondsocket_common_1.ChannelState.CLOSED);
@@ -118,8 +119,8 @@ describe('Channel', () => {
         }));
         publisher.mockClear();
         // if the channel stalls and rejoins the previous message should not be sent again
-        state.publish(false);
-        state.publish(true);
+        state.publish(types_1.ConnectionState.DISCONNECTED);
+        state.publish(types_1.ConnectionState.CONNECTED);
         // acknowledge the join
         channel.acknowledge(receiver);
         expect(publisher).toHaveBeenCalledTimes(1); // The join message
@@ -133,12 +134,12 @@ describe('Channel', () => {
         }));
         publisher.mockClear();
         // if a message is sent while the channel is stalled, it should be queued
-        state.publish(false);
+        state.publish(types_1.ConnectionState.DISCONNECTED);
         channel.sendMessage('test', {
             test: 'test stalling',
         });
         expect(publisher).not.toHaveBeenCalled();
-        state.publish(true);
+        state.publish(types_1.ConnectionState.CONNECTED);
         publisher.mockClear(); // The join message
         // acknowledge the join
         channel.acknowledge(receiver);
@@ -517,7 +518,7 @@ describe('Channel', () => {
         });
         expect(presenceListener).not.toHaveBeenCalled();
         // if the channel is stalled, the presence event should not be sent to the listener
-        state.publish(false);
+        state.publish(types_1.ConnectionState.DISCONNECTED);
         expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.STALLED);
         receiver.publish({
             requestId: 'test',
@@ -542,7 +543,7 @@ describe('Channel', () => {
             },
         });
         expect(presenceListener).not.toHaveBeenCalled();
-        state.publish(true);
+        state.publish(types_1.ConnectionState.CONNECTED);
         expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.STALLED);
         receiver.publish({
             requestId: 'test',
@@ -685,7 +686,7 @@ describe('Channel', () => {
         expect(specificMessageListener).not.toHaveBeenCalled();
     });
     it('should be able to wait for a message', () => __awaiter(void 0, void 0, void 0, function* () {
-        const state = new pondsocket_common_1.BehaviorSubject(true);
+        const state = new pondsocket_common_1.BehaviorSubject(types_1.ConnectionState.CONNECTED);
         const receiver = new pondsocket_common_1.Subject();
         const params = {};
         const publisher = (data) => {

package/dist.d.ts

@@ -10,6 +10,22 @@ import {
     Unsubscribe,
 } from '@eleven-am/pondsocket-common';
 
+declare enum ConnectionState {
+    DISCONNECTED = 'DISCONNECTED',
+    CONNECTING = 'CONNECTING',
+    CONNECTED = 'CONNECTED',
+}
+
+interface ClientOptions {
+    connectionTimeout?: number;
+    maxReconnectDelay?: number;
+    pingInterval?: number;
+}
+
+interface SSEClientOptions extends ClientOptions {
+    withCredentials?: boolean;
+}
+
 declare class Channel<EventMap extends PondEventMap = PondEventMap, Presence extends PondPresence = PondPresence> {
     /**
      * @desc The current connection state of the channel.
@@ -90,7 +106,7 @@ declare class Channel<EventMap extends PondEventMap = PondEventMap, Presence ext
 }
 
 declare class PondClient {
-    constructor (endpoint: string, params?: Record<string, any>);
+    constructor (endpoint: string, params?: Record<string, any>, options?: ClientOptions);
 
     /**
      * @desc Connects to the server and returns the socket.
@@ -100,7 +116,7 @@ declare class PondClient {
     /**
      * @desc Returns the current state of the socket.
      */
-    getState (): boolean;
+    getState (): ConnectionState;
 
     /**
      * @desc Disconnects the socket.
@@ -118,5 +134,54 @@ declare class PondClient {
      * @desc Subscribes to the connection state.
      * @param callback - The callback to call when the state changes.
      */
-    onConnectionChange (callback: (state: boolean) => void): Unsubscribe;
+    onConnectionChange (callback: (state: ConnectionState) => void): Unsubscribe;
+
+    /**
+     * @desc Subscribes to error events.
+     * @param callback - The callback to call when an error occurs.
+     */
+    onError (callback: (error: Error) => void): Unsubscribe;
+}
+
+declare class SSEClient {
+    constructor (endpoint: string, params?: Record<string, any>, options?: SSEClientOptions);
+
+    /**
+     * @desc Connects to the server using Server-Sent Events.
+     */
+    connect (): void;
+
+    /**
+     * @desc Returns the current state of the connection.
+     */
+    getState (): ConnectionState;
+
+    /**
+     * @desc Returns the connection ID assigned by the server.
+     */
+    getConnectionId (): string | undefined;
+
+    /**
+     * @desc Disconnects the SSE connection.
+     */
+    disconnect (): void;
+
+    /**
+     * @desc Creates a channel with the given name and params.
+     * @param name - The name of the channel.
+     * @param params - The params to send to the server.
+     */
+    createChannel<EventType extends PondEventMap = PondEventMap, Presence extends PondPresence = PondPresence> (name: string, params?: JoinParams): Channel<EventType, Presence>;
+
+    /**
+     * @desc Subscribes to the connection state.
+     * @param callback - The callback to call when the state changes.
+     */
+    onConnectionChange (callback: (state: ConnectionState) => void): Unsubscribe;
+
+    /**
+     * @desc Subscribes to error events.
+     * @param callback - The callback to call when an error occurs.
+     */
+    onError (callback: (error: Error) => void): Unsubscribe;
 }

package/index.d.ts

@@ -1,4 +1,4 @@
-import { PondClient } from './dist';
+import { PondClient, SSEClient, ConnectionState } from './dist';
 import { ChannelState } from '@eleven-am/pondsocket-common';
 
-export { ChannelState, PondClient };
+export { ChannelState, ConnectionState, PondClient, SSEClient };

package/index.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PondClient = exports.ChannelState = void 0;
+exports.SSEClient = exports.PondClient = exports.ConnectionState = exports.ChannelState = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 Object.defineProperty(exports, "ChannelState", { enumerable: true, get: function () { return pondsocket_common_1.ChannelState; } });
 const client_1 = require("./browser/client");
+const sseClient_1 = require("./browser/sseClient");
+Object.defineProperty(exports, "SSEClient", { enumerable: true, get: function () { return sseClient_1.SSEClient; } });
 const node_1 = require("./node/node");
+const types_1 = require("./types");
+Object.defineProperty(exports, "ConnectionState", { enumerable: true, get: function () { return types_1.ConnectionState; } });
 const PondClient = typeof window === 'undefined' ? node_1.PondClient : client_1.PondClient;
 exports.PondClient = PondClient;

package/node/node.js

@@ -1,18 +1,47 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PondClient_instances, _PondClient_clearTimeouts;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondClient = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const client_1 = require("../browser/client");
+const types_1 = require("../types");
 // eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-require-imports
 const WebSocket = require('websocket').w3cwebsocket;
 class PondClient extends client_1.PondClient {
+    constructor() {
+        super(...arguments);
+        _PondClient_instances.add(this);
+    }
     /**
      * @desc Connects to the server and returns the socket.
      */
-    connect(backoff = 1) {
+    connect() {
         this._disconnecting = false;
+        this._connectionState.publish(types_1.ConnectionState.CONNECTING);
         const socket = new WebSocket(this._address.toString());
-        socket.onopen = () => this._connectionState.publish(true);
+        this._connectionTimeoutId = setTimeout(() => {
+            if (socket.readyState === WebSocket.CONNECTING) {
+                const error = new Error('Connection timeout');
+                this._errorSubject.publish(error);
+                socket.close();
+            }
+        }, this._options.connectionTimeout);
+        socket.onopen = () => {
+            __classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_clearTimeouts).call(this);
+            this._reconnectAttempts = 0;
+            if (this._options.pingInterval) {
+                this._pingIntervalId = setInterval(() => {
+                    if (socket.readyState === WebSocket.OPEN) {
+                        socket.send(JSON.stringify({ action: 'ping' }));
+                    }
+                }, this._options.pingInterval);
+            }
+        };
         socket.onmessage = (message) => {
             const lines = message.data.trim().split('\n');
             for (const line of lines) {
@@ -23,16 +52,34 @@ class PondClient extends client_1.PondClient {
                 }
             }
         };
-        socket.onerror = () => socket.close();
+        socket.onerror = () => {
+            const error = new Error('WebSocket error');
+            this._errorSubject.publish(error);
+            socket.close();
+        };
         socket.onclose = () => {
-            this._connectionState.publish(false);
+            __classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_clearTimeouts).call(this);
+            this._connectionState.publish(types_1.ConnectionState.DISCONNECTED);
             if (this._disconnecting) {
                 return;
             }
+            const delay = Math.min(1000 * Math.pow(2, this._reconnectAttempts), this._options.maxReconnectDelay);
+            this._reconnectAttempts++;
             setTimeout(() => {
                 this.connect();
-            }, 1000);
+            }, delay);
         };
+        this._socket = socket;
     }
 }
 exports.PondClient = PondClient;
+_PondClient_instances = new WeakSet(), _PondClient_clearTimeouts = function _PondClient_clearTimeouts() {
+    if (this._connectionTimeoutId) {
+        clearTimeout(this._connectionTimeoutId);
+        this._connectionTimeoutId = undefined;
+    }
+    if (this._pingIntervalId) {
+        clearInterval(this._pingIntervalId);
+        this._pingIntervalId = undefined;
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket-client",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -30,19 +30,19 @@
     "pipeline": "npm run test && npm run build && npm run push"
   },
   "dependencies": {
-    "@eleven-am/pondsocket-common": "^0.0.32",
+    "@eleven-am/pondsocket-common": "^0.0.34",
     "websocket": "^1.0.35"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
     "@types/websocket": "^1.0.10",
-    "@typescript-eslint/eslint-plugin": "^8.46.1",
+    "@typescript-eslint/eslint-plugin": "^8.49.0",
     "eslint-plugin-file-progress": "^3.0.2",
     "eslint-plugin-import": "^2.32.0",
     "jest": "^30.2.0",
-    "prettier": "^3.6.2",
+    "prettier": "^3.7.4",
     "supertest": "^7.1.4",
-    "ts-jest": "^29.4.5",
+    "ts-jest": "^29.4.6",
     "ts-loader": "^9.5.4",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"

package/types.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionState = void 0;
+var ConnectionState;
+(function (ConnectionState) {
+    ConnectionState["DISCONNECTED"] = "disconnected";
+    ConnectionState["CONNECTING"] = "connecting";
+    ConnectionState["CONNECTED"] = "connected";
+})(ConnectionState || (exports.ConnectionState = ConnectionState = {}));