@eleven-am/pondsocket-client 0.0.34 → 0.0.35

package/browser/client.js

@@ -1,28 +1,9 @@
 "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 _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 = {}, options = {}) {
-        var _a, _b;
-        _PondClient_instances.add(this);
-        _PondClient_channels.set(this, void 0);
+const webSocketClient_1 = require("../core/webSocketClient");
+class PondClient extends webSocketClient_1.WebSocketClient {
+    _resolveAddress(endpoint, params) {
         let address;
         try {
             address = new URL(endpoint);
@@ -32,164 +13,13 @@ class PondClient {
             address.pathname = endpoint;
             address.hash = '';
         }
-        this._disconnecting = false;
-        this._reconnectAttempts = 0;
         const query = new URLSearchParams(params);
         address.search = query.toString();
         const protocol = address.protocol === 'https:' ? 'wss:' : 'ws:';
         if (address.protocol !== 'wss:' && address.protocol !== 'ws:') {
             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(types_1.ConnectionState.DISCONNECTED);
-        this._errorSubject = new pondsocket_common_1.Subject();
-        __classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_init).call(this);
-    }
-    /**
-     * @desc Connects to the server and returns the socket.
-     */
-    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) {
-                if (line.trim()) {
-                    const data = JSON.parse(line);
-                    const event = pondsocket_common_1.channelEventSchema.parse(data);
-                    this._broadcaster.publish(event);
-                }
-            }
-        };
-        socket.onerror = (event) => {
-            const error = new Error('WebSocket error');
-            this._errorSubject.publish(error);
-            socket.close();
-        };
-        socket.onclose = () => {
-            __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();
-            }, delay);
-        };
-        this._socket = socket;
-    }
-    /**
-     * @desc Returns the current state of the socket.
-     */
-    getState() {
-        return this._connectionState.value;
-    }
-    /**
-     * @desc Disconnects the socket.
-     */
-    disconnect() {
-        var _a;
-        __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();
-    }
-    /**
-     * @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(name, params) {
-        const channel = __classPrivateFieldGet(this, _PondClient_channels, "f").get(name);
-        if (channel && channel.channelState !== pondsocket_common_1.ChannelState.CLOSED) {
-            return channel;
-        }
-        const publisher = __classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_createPublisher).call(this);
-        const newChannel = new channel_1.Channel(publisher, this._connectionState, name, params || {});
-        __classPrivateFieldGet(this, _PondClient_channels, "f").set(name, newChannel);
-        return newChannel;
-    }
-    /**
-     * @desc Subscribes to the connection state.
-     * @param callback - The callback to call when the state changes.
-     */
-    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);
+        return address;
     }
 }
 exports.PondClient = PondClient;
-_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 === types_1.ConnectionState.CONNECTED) {
-            this._socket.send(JSON.stringify(message));
-        }
-    };
-}, _PondClient_handleAcknowledge = function _PondClient_handleAcknowledge(message) {
-    var _a;
-    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(types_1.ConnectionState.CONNECTED);
-        }
-    });
-};

package/browser/client.test.js

@@ -13,7 +13,6 @@ 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();
@@ -23,7 +22,6 @@ class MockWebSocket {
 }
 MockWebSocket.CONNECTING = 0;
 MockWebSocket.OPEN = 1;
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-expect-error
 global.WebSocket = MockWebSocket;
 describe('PondClient', () => {
@@ -92,7 +90,6 @@ describe('PondClient', () => {
     test('createChannel method should create a new channel or return an existing one', () => {
         const mockChannel = pondClient.createChannel('exampleChannel');
         const mockExistingChannel = pondClient.createChannel('exampleChannel');
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
         expect(mockChannel).toBeInstanceOf(require('../core/channel').Channel);
         expect(mockExistingChannel).toBe(mockChannel);
     });
@@ -104,7 +101,6 @@ describe('PondClient', () => {
         expect(mockCallback).toHaveBeenCalledWith(types_1.ConnectionState.CONNECTED);
         unsubscribe();
         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', () => {

package/browser/sseClient.js

@@ -1,28 +1,23 @@
 "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;
+var _SSEClient_instances, _SSEClient_handleMessage;
 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 baseClient_1 = require("../core/baseClient");
 const types_1 = require("../types");
-const DEFAULT_CONNECTION_TIMEOUT = 10000;
-const DEFAULT_MAX_RECONNECT_DELAY = 30000;
-class SSEClient {
+class SSEClient extends baseClient_1.BaseClient {
     constructor(endpoint, params = {}, options = {}) {
-        var _a, _b;
+        super(endpoint, params, options);
         _SSEClient_instances.add(this);
-        _SSEClient_channels.set(this, void 0);
+        this._postAddress = new URL(this._address.toString());
+        this._withCredentials = options.withCredentials;
+    }
+    _resolveAddress(endpoint, params) {
         let address;
         try {
             address = new URL(endpoint);
@@ -31,33 +26,20 @@ class SSEClient {
             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);
+        return address;
     }
     connect() {
         var _a;
         this._disconnecting = false;
+        this._connectionId = undefined;
         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,
+            withCredentials: (_a = this._withCredentials) !== null && _a !== void 0 ? _a : false,
         });
         this._connectionTimeoutId = setTimeout(() => {
             if (eventSource.readyState === EventSource.CONNECTING) {
@@ -67,7 +49,7 @@ class SSEClient {
             }
         }, this._options.connectionTimeout);
         eventSource.onopen = () => {
-            __classPrivateFieldGet(this, _SSEClient_instances, "m", _SSEClient_clearTimeout).call(this);
+            this._clearConnectionTimeout();
             this._reconnectAttempts = 0;
         };
         eventSource.onmessage = (event) => {
@@ -77,28 +59,18 @@ class SSEClient {
             const error = new Error('SSE connection error');
             this._errorSubject.publish(error);
             eventSource.close();
-            __classPrivateFieldGet(this, _SSEClient_instances, "m", _SSEClient_clearTimeout).call(this);
+            this._clearConnectionTimeout();
             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._scheduleReconnect();
         };
         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._clearConnectionTimeout();
         this._disconnecting = true;
         this._connectionState.publish(types_1.ConnectionState.DISCONNECTED);
         if (this._connectionId) {
@@ -107,93 +79,46 @@ class SSEClient {
                 headers: {
                     'X-Connection-ID': this._connectionId,
                 },
-                credentials: this._options.withCredentials ? 'include' : 'same-origin',
+                credentials: this._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;
+        this._clearChannels();
     }
-    onConnectionChange(callback) {
-        return this._connectionState.subscribe(callback);
-    }
-    onError(callback) {
-        return this._errorSubject.subscribe(callback);
+    _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._withCredentials ? 'include' : 'same-origin',
+                }).catch((err) => {
+                    this._errorSubject.publish(err instanceof Error ? err : new Error('Failed to send message'));
+                });
+            }
+        };
     }
 }
 exports.SSEClient = SSEClient;
-_SSEClient_channels = new WeakMap(), _SSEClient_instances = new WeakSet(), _SSEClient_handleMessage = function _SSEClient_handleMessage(data) {
+_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;
-                    }
+        const events = this._parseMessages(data);
+        for (const event of events) {
+            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);
             }
+            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/core/baseClient.js

@@ -0,0 +1,116 @@
+"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 _BaseClient_instances, _BaseClient_channels, _BaseClient_handleAcknowledge, _BaseClient_handleUnauthorized, _BaseClient_init;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseClient = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const channel_1 = require("./channel");
+const types_1 = require("../types");
+const DEFAULT_CONNECTION_TIMEOUT = 10000;
+const DEFAULT_MAX_RECONNECT_DELAY = 30000;
+class BaseClient {
+    constructor(endpoint, params = {}, options = {}) {
+        var _a, _b;
+        _BaseClient_instances.add(this);
+        _BaseClient_channels.set(this, void 0);
+        this._address = this._resolveAddress(endpoint, params);
+        this._disconnecting = false;
+        this._reconnectAttempts = 0;
+        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, _BaseClient_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, _BaseClient_instances, "m", _BaseClient_init).call(this);
+    }
+    _clearConnectionTimeout() {
+        if (this._connectionTimeoutId) {
+            clearTimeout(this._connectionTimeoutId);
+            this._connectionTimeoutId = undefined;
+        }
+    }
+    _scheduleReconnect() {
+        if (this._disconnecting) {
+            return;
+        }
+        const delay = Math.min(1000 * Math.pow(2, this._reconnectAttempts), this._options.maxReconnectDelay);
+        this._reconnectAttempts++;
+        setTimeout(() => {
+            this.connect();
+        }, delay);
+    }
+    getState() {
+        return this._connectionState.value;
+    }
+    createChannel(name, params) {
+        const channel = __classPrivateFieldGet(this, _BaseClient_channels, "f").get(name);
+        if (channel && channel.channelState !== pondsocket_common_1.ChannelState.CLOSED) {
+            return channel;
+        }
+        const publisher = this._createPublisher();
+        const newChannel = new channel_1.Channel(publisher, this._connectionState, name, params || {});
+        __classPrivateFieldGet(this, _BaseClient_channels, "f").set(name, newChannel);
+        return newChannel;
+    }
+    onConnectionChange(callback) {
+        return this._connectionState.subscribe(callback);
+    }
+    onError(callback) {
+        return this._errorSubject.subscribe(callback);
+    }
+    _parseMessages(data) {
+        const events = [];
+        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);
+                events.push(event);
+            }
+        }
+        return events;
+    }
+    _clearChannels() {
+        __classPrivateFieldGet(this, _BaseClient_channels, "f").clear();
+    }
+}
+exports.BaseClient = BaseClient;
+_BaseClient_channels = new WeakMap(), _BaseClient_instances = new WeakSet(), _BaseClient_handleAcknowledge = function _BaseClient_handleAcknowledge(message) {
+    const channel = __classPrivateFieldGet(this, _BaseClient_channels, "f").get(message.channelName);
+    if (!channel) {
+        return;
+    }
+    channel.acknowledge(this._broadcaster);
+}, _BaseClient_handleUnauthorized = function _BaseClient_handleUnauthorized(message) {
+    const channel = __classPrivateFieldGet(this, _BaseClient_channels, "f").get(message.channelName);
+    if (channel) {
+        const payload = message.payload;
+        channel.decline(payload);
+    }
+}, _BaseClient_init = function _BaseClient_init() {
+    this._broadcaster.subscribe((message) => {
+        if (message.event === pondsocket_common_1.Events.ACKNOWLEDGE) {
+            __classPrivateFieldGet(this, _BaseClient_instances, "m", _BaseClient_handleAcknowledge).call(this, message);
+        }
+        else if (message.event === pondsocket_common_1.Events.UNAUTHORIZED) {
+            __classPrivateFieldGet(this, _BaseClient_instances, "m", _BaseClient_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/core/channel.js

@@ -10,13 +10,13 @@ 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 _Channel_instances, _Channel_name, _Channel_queue, _Channel_presence, _Channel_presenceSub, _Channel_publisher, _Channel_joinParams, _Channel_receiver, _Channel_clientState, _Channel_joinState, _Channel_emptyQueue, _Channel_init, _Channel_onMessage, _Channel_publish, _Channel_subscribeToPresence;
+var _Channel_instances, _Channel_name, _Channel_queue, _Channel_presence, _Channel_presenceSub, _Channel_publisher, _Channel_joinParams, _Channel_receiver, _Channel_clientState, _Channel_joinState, _Channel_maxQueueSize, _Channel_emptyQueue, _Channel_init, _Channel_onMessage, _Channel_publish, _Channel_subscribeToPresence;
 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) {
+    constructor(publisher, clientState, name, params, maxQueueSize = 100) {
         _Channel_instances.add(this);
         _Channel_name.set(this, void 0);
         _Channel_queue.set(this, void 0);
@@ -27,11 +27,13 @@ class Channel {
         _Channel_receiver.set(this, void 0);
         _Channel_clientState.set(this, void 0);
         _Channel_joinState.set(this, void 0);
+        _Channel_maxQueueSize.set(this, void 0);
         __classPrivateFieldSet(this, _Channel_name, name, "f");
         __classPrivateFieldSet(this, _Channel_queue, [], "f");
         __classPrivateFieldSet(this, _Channel_presence, [], "f");
         __classPrivateFieldSet(this, _Channel_joinParams, params, "f");
         __classPrivateFieldSet(this, _Channel_publisher, publisher, "f");
+        __classPrivateFieldSet(this, _Channel_maxQueueSize, maxQueueSize, "f");
         __classPrivateFieldSet(this, _Channel_clientState, clientState, "f");
         __classPrivateFieldSet(this, _Channel_receiver, new pondsocket_common_1.Subject(), "f");
         __classPrivateFieldSet(this, _Channel_joinState, new pondsocket_common_1.BehaviorSubject(pondsocket_common_1.ChannelState.IDLE), "f");
@@ -56,6 +58,9 @@ class Channel {
      * @param receiver - The receiver to subscribe to.
      */
     acknowledge(receiver) {
+        if (__classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.JOINED) {
+            return;
+        }
         __classPrivateFieldGet(this, _Channel_joinState, "f").publish(pondsocket_common_1.ChannelState.JOINED);
         __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_init).call(this, receiver);
         __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_emptyQueue).call(this);
@@ -198,20 +203,22 @@ class Channel {
         };
         __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_publish).call(this, message);
     }
-    /**
-     * @desc Sends a message to the server and waits for a response.
-     * @param sentEvent - The event to send.
-     * @param payload - The message to send.
-     */
-    sendForResponse(sentEvent, payload) {
+    sendForResponse(sentEvent, payload, timeoutMs = 30000) {
         const requestId = (0, pondsocket_common_1.uuid)();
-        return new Promise((resolve) => {
-            const unsub = __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_onMessage).call(this, (_, message, responseId) => {
+        return new Promise((resolve, reject) => {
+            const cleanup = { timer: undefined,
+                unsub: () => { } };
+            cleanup.unsub = __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_onMessage).call(this, (_, message, responseId) => {
                 if (requestId === responseId) {
+                    clearTimeout(cleanup.timer);
                     resolve(message);
-                    unsub();
+                    cleanup.unsub();
                 }
             });
+            cleanup.timer = setTimeout(() => {
+                cleanup.unsub();
+                reject(new Error(`sendForResponse timed out after ${timeoutMs}ms for event "${String(sentEvent)}"`));
+            }, timeoutMs);
             const message = {
                 action: pondsocket_common_1.ClientActions.BROADCAST,
                 channelName: __classPrivateFieldGet(this, _Channel_name, "f"),
@@ -224,7 +231,7 @@ class Channel {
     }
 }
 exports.Channel = Channel;
-_Channel_name = new WeakMap(), _Channel_queue = new WeakMap(), _Channel_presence = new WeakMap(), _Channel_presenceSub = new WeakMap(), _Channel_publisher = new WeakMap(), _Channel_joinParams = new WeakMap(), _Channel_receiver = new WeakMap(), _Channel_clientState = new WeakMap(), _Channel_joinState = new WeakMap(), _Channel_instances = new WeakSet(), _Channel_emptyQueue = function _Channel_emptyQueue() {
+_Channel_name = new WeakMap(), _Channel_queue = new WeakMap(), _Channel_presence = new WeakMap(), _Channel_presenceSub = new WeakMap(), _Channel_publisher = new WeakMap(), _Channel_joinParams = new WeakMap(), _Channel_receiver = new WeakMap(), _Channel_clientState = new WeakMap(), _Channel_joinState = new WeakMap(), _Channel_maxQueueSize = new WeakMap(), _Channel_instances = new WeakSet(), _Channel_emptyQueue = function _Channel_emptyQueue() {
     __classPrivateFieldGet(this, _Channel_queue, "f")
         .forEach((message) => __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, message));
     __classPrivateFieldSet(this, _Channel_queue, [], "f");
@@ -268,6 +275,9 @@ _Channel_name = new WeakMap(), _Channel_queue = new WeakMap(), _Channel_presence
     if (__classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.JOINED) {
         return __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, data);
     }
+    if (__classPrivateFieldGet(this, _Channel_queue, "f").length >= __classPrivateFieldGet(this, _Channel_maxQueueSize, "f")) {
+        __classPrivateFieldGet(this, _Channel_queue, "f").shift();
+    }
     __classPrivateFieldGet(this, _Channel_queue, "f").push(data);
 }, _Channel_subscribeToPresence = function _Channel_subscribeToPresence(callback) {
     return __classPrivateFieldGet(this, _Channel_receiver, "f").subscribe((data) => {

package/core/channel.test.js

@@ -685,6 +685,32 @@ describe('Channel', () => {
         });
         expect(specificMessageListener).not.toHaveBeenCalled();
     });
+    it('should handle decline by setting state to DECLINED and clearing queue', () => {
+        const { channel } = createChannel();
+        channel.sendMessage('queued', { data: 'test' });
+        channel.decline({ message: 'Not authorized', statusCode: 403 });
+        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.DECLINED);
+    });
+    it('should not re-join when already in JOINED state', () => {
+        const { channel, publisher, receiver } = createChannel();
+        channel.join();
+        channel.acknowledge(receiver);
+        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.JOINED);
+        publisher.mockClear();
+        channel.join();
+        expect(publisher).not.toHaveBeenCalled();
+    });
+    it('sendForResponse should reject with timeout error', () => __awaiter(void 0, void 0, void 0, function* () {
+        const publisher = jest.fn();
+        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', {});
+        channel.join();
+        channel.acknowledge(receiver);
+        // @ts-expect-error - testing timeout behavior
+        const promise = channel.sendForResponse('timeout-event', { data: 'test' }, 100);
+        yield expect(promise).rejects.toThrow(/sendForResponse timed out after 100ms/);
+    }));
     it('should be able to wait for a message', () => __awaiter(void 0, void 0, void 0, function* () {
         const state = new pondsocket_common_1.BehaviorSubject(types_1.ConnectionState.CONNECTED);
         const receiver = new pondsocket_common_1.Subject();

package/core/webSocketClient.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = void 0;
+const baseClient_1 = require("./baseClient");
+const types_1 = require("../types");
+class WebSocketClient extends baseClient_1.BaseClient {
+    constructor() {
+        super(...arguments);
+        this._lastMessageTime = 0;
+    }
+    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 = () => {
+            this._clearConnectionTimeout();
+            this._clearPingInterval();
+            this._clearPongTimeout();
+            this._reconnectAttempts = 0;
+            this._lastMessageTime = Date.now();
+            if (this._options.pingInterval) {
+                this._pingIntervalId = setInterval(() => {
+                    if (socket.readyState === WebSocket.OPEN) {
+                        socket.send(JSON.stringify({ action: 'ping' }));
+                    }
+                }, this._options.pingInterval);
+                this._schedulePongTimeout(socket);
+            }
+        };
+        socket.onmessage = (message) => {
+            this._lastMessageTime = Date.now();
+            const events = this._parseMessages(message.data);
+            for (const event of events) {
+                this._broadcaster.publish(event);
+            }
+        };
+        socket.onerror = () => {
+            const error = new Error('WebSocket error');
+            this._errorSubject.publish(error);
+            socket.close();
+        };
+        socket.onclose = () => {
+            this._clearConnectionTimeout();
+            this._clearPingInterval();
+            this._clearPongTimeout();
+            this._connectionState.publish(types_1.ConnectionState.DISCONNECTED);
+            this._scheduleReconnect();
+        };
+        this._socket = socket;
+    }
+    disconnect() {
+        var _a;
+        this._clearConnectionTimeout();
+        this._clearPingInterval();
+        this._clearPongTimeout();
+        this._disconnecting = true;
+        this._connectionState.publish(types_1.ConnectionState.DISCONNECTED);
+        (_a = this._socket) === null || _a === void 0 ? void 0 : _a.close();
+        this._clearChannels();
+    }
+    _createPublisher() {
+        return (message) => {
+            var _a;
+            if (this._connectionState.value === types_1.ConnectionState.CONNECTED) {
+                (_a = this._socket) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify(message));
+            }
+        };
+    }
+    _clearPingInterval() {
+        if (this._pingIntervalId) {
+            clearInterval(this._pingIntervalId);
+            this._pingIntervalId = undefined;
+        }
+    }
+    _clearPongTimeout() {
+        if (this._pongTimeoutId) {
+            clearTimeout(this._pongTimeoutId);
+            this._pongTimeoutId = undefined;
+        }
+    }
+    _schedulePongTimeout(socket) {
+        this._clearPongTimeout();
+        const timeout = this._options.pingInterval * 2;
+        this._pongTimeoutId = setTimeout(() => {
+            if (Date.now() - this._lastMessageTime >= timeout) {
+                this._errorSubject.publish(new Error('Connection lost: no response from server'));
+                socket.close();
+                return;
+            }
+            this._schedulePongTimeout(socket);
+        }, timeout);
+    }
+}
+exports.WebSocketClient = WebSocketClient;

package/dist.d.ts

@@ -102,7 +102,7 @@ declare class Channel<EventMap extends PondEventMap = PondEventMap, Presence ext
      * @param sentEvent - The event to send.
      * @param payload - The message to send.
      */
-    sendForResponse<Event extends EventWithResponse<EventMap>> (sentEvent: Event, payload: PayloadForResponse<EventMap, Event>): Promise<ResponseForEvent<EventMap, Event>>;
+    sendForResponse<Event extends EventWithResponse<EventMap>> (sentEvent: Event, payload: PayloadForResponse<EventMap, Event>, timeoutMs?: number): Promise<ResponseForEvent<EventMap, Event>>;
 }
 
 declare class PondClient {

package/node/node.js

@@ -1,85 +1,17 @@
 "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() {
-        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) {
-                if (line.trim()) {
-                    const data = JSON.parse(line);
-                    const event = pondsocket_common_1.channelEventSchema.parse(data);
-                    this._broadcaster.publish(event);
-                }
-            }
-        };
-        socket.onerror = () => {
-            const error = new Error('WebSocket error');
-            this._errorSubject.publish(error);
-            socket.close();
-        };
-        socket.onclose = () => {
-            __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();
-            }, delay);
-        };
-        this._socket = socket;
+const webSocketClient_1 = require("../core/webSocketClient");
+class PondClient extends webSocketClient_1.WebSocketClient {
+    _resolveAddress(endpoint, params) {
+        const address = new URL(endpoint);
+        const query = new URLSearchParams(params);
+        address.search = query.toString();
+        const protocol = address.protocol === 'https:' ? 'wss:' : 'ws:';
+        if (address.protocol !== 'wss:' && address.protocol !== 'ws:') {
+            address.protocol = protocol;
+        }
+        return address;
     }
 }
 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/node/node.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_1 = require("./node");
+describe('PondClient (Node)', () => {
+    it('should resolve http endpoint to ws protocol', () => {
+        const client = new node_1.PondClient('http://localhost:3000/ws', { token: 'abc' });
+        const address = client._address;
+        expect(address.protocol).toBe('ws:');
+        expect(address.hostname).toBe('localhost');
+        expect(address.port).toBe('3000');
+        expect(address.pathname).toBe('/ws');
+        expect(address.searchParams.get('token')).toBe('abc');
+    });
+    it('should resolve https endpoint to wss protocol', () => {
+        const client = new node_1.PondClient('https://example.com/ws', {});
+        const address = client._address;
+        expect(address.protocol).toBe('wss:');
+        expect(address.hostname).toBe('example.com');
+    });
+    it('should keep ws protocol if already specified', () => {
+        const client = new node_1.PondClient('ws://localhost:3000/ws', {});
+        const address = client._address;
+        expect(address.protocol).toBe('ws:');
+    });
+    it('should keep wss protocol if already specified', () => {
+        const client = new node_1.PondClient('wss://example.com/ws', {});
+        const address = client._address;
+        expect(address.protocol).toBe('wss:');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket-client",
-  "version": "0.0.34",
+  "version": "0.0.35",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -30,18 +30,23 @@
     "pipeline": "npm run test && npm run build && npm run push"
   },
   "dependencies": {
-    "@eleven-am/pondsocket-common": "^0.0.34",
-    "websocket": "^1.0.35"
+    "@eleven-am/pondsocket-common": "^0.0.37"
   },
   "devDependencies": {
+    "@eslint/compat": "^2.0.2",
+    "@eslint/eslintrc": "^3.3.4",
+    "@eslint/js": "^9.39.3",
+    "@stylistic/eslint-plugin-ts": "^4.4.1",
     "@types/jest": "^30.0.0",
-    "@types/websocket": "^1.0.10",
-    "@typescript-eslint/eslint-plugin": "^8.49.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
+    "eslint": "^9.39.3",
     "eslint-plugin-file-progress": "^3.0.2",
     "eslint-plugin-import": "^2.32.0",
+    "globals": "^17.4.0",
     "jest": "^30.2.0",
-    "prettier": "^3.7.4",
-    "supertest": "^7.1.4",
+    "prettier": "^3.8.1",
+    "supertest": "^7.2.2",
     "ts-jest": "^29.4.6",
     "ts-loader": "^9.5.4",
     "ts-node": "^10.9.2",
@@ -56,12 +61,25 @@
     "rootDir": "src",
     "testRegex": ".*\\.test\\.ts$",
     "transform": {
-      "^.+\\.(t|j)s$": "ts-jest"
+      "^.+\\.(t|j)s$": [
+        "ts-jest",
+        {
+          "diagnostics": false
+        }
+      ]
     },
     "collectCoverageFrom": [
-      "**/*.(t|j)s"
+      "**/*.(t|j)s",
+      "!**/*.test.ts",
+      "!**/*.d.ts",
+      "!**/index.ts",
+      "!**/index.d.ts",
+      "!**/dist.d.ts"
     ],
     "coverageDirectory": "../coverage",
-    "testEnvironment": "node"
+    "testEnvironment": "node",
+    "moduleNameMapper": {
+      "^@eleven-am/pondsocket-common$": "<rootDir>/../../comnon/dist"
+    }
   }
 }