@eleven-am/pondsocket-client 0.0.14 → 0.0.15

package/browser/client.js

@@ -10,7 +10,7 @@ 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;
+var _PondClient_instances, _PondClient_channels, _PondClient_createPublisher, _PondClient_handleAcknowledge, _PondClient_init;
 Object.defineProperty(exports, "__esModule", { value: true });
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const channel_1 = require("../core/channel");
@@ -36,6 +36,7 @@ class PondClient {
         __classPrivateFieldSet(this, _PondClient_channels, {}, "f");
         this._broadcaster = new pondsocket_common_1.Subject();
         this._connectionState = new pondsocket_common_1.BehaviorSubject(false);
+        __classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_init).call(this);
     }
     /**
      * @desc Connects to the server and returns the socket.
@@ -83,7 +84,7 @@ class PondClient {
             return __classPrivateFieldGet(this, _PondClient_channels, "f")[name];
         }
         const publisher = __classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_createPublisher).call(this);
-        const channel = new channel_1.Channel(publisher, this._connectionState, name, this._broadcaster, params || {});
+        const channel = new channel_1.Channel(publisher, this._connectionState, name, params || {});
         __classPrivateFieldGet(this, _PondClient_channels, "f")[name] = channel;
         return channel;
     }
@@ -101,5 +102,15 @@ _PondClient_channels = new WeakMap(), _PondClient_instances = new WeakSet(), _Po
             this._socket.send(JSON.stringify(message));
         }
     };
+}, _PondClient_handleAcknowledge = function _PondClient_handleAcknowledge(message) {
+    var _a;
+    const channel = (_a = __classPrivateFieldGet(this, _PondClient_channels, "f")[message.channelName]) !== null && _a !== void 0 ? _a : new channel_1.Channel(__classPrivateFieldGet(this, _PondClient_instances, "m", _PondClient_createPublisher).call(this), this._connectionState, message.channelName, {});
+    channel.acknowledge(this._broadcaster);
+}, _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);
+        }
+    });
 };
 exports.default = PondClient;

package/core/channel.js

@@ -10,19 +10,19 @@ 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_publisher, _Channel_joinParams, _Channel_presenceSub, _Channel_receiver, _Channel_clientState, _Channel_joinState, _Channel_send, _Channel_publish, _Channel_subscribeToPresence, _Channel_init, _Channel_emptyQueue, _Channel_buildJoinMessage, _Channel_onMessage;
+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;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channel = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 class Channel {
-    constructor(publisher, clientState, name, receiver, params) {
+    constructor(publisher, clientState, name, params) {
         _Channel_instances.add(this);
         _Channel_name.set(this, void 0);
         _Channel_queue.set(this, void 0);
         _Channel_presence.set(this, void 0);
+        _Channel_presenceSub.set(this, void 0);
         _Channel_publisher.set(this, void 0);
         _Channel_joinParams.set(this, void 0);
-        _Channel_presenceSub.set(this, void 0);
         _Channel_receiver.set(this, void 0);
         _Channel_clientState.set(this, void 0);
         _Channel_joinState.set(this, void 0);
@@ -34,7 +34,9 @@ class Channel {
         __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");
-        __classPrivateFieldSet(this, _Channel_presenceSub, __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_init).call(this, receiver), "f");
+        __classPrivateFieldSet(this, _Channel_presenceSub, () => {
+            // do nothing
+        }, "f");
     }
     /**
      * @desc Gets the current connection state of the channel.
@@ -42,58 +44,65 @@ class Channel {
     get channelState() {
         return __classPrivateFieldGet(this, _Channel_joinState, "f").value;
     }
+    /**
+     * @desc Gets the current presence of the channel.
+     */
+    get presence() {
+        return __classPrivateFieldGet(this, _Channel_presence, "f");
+    }
+    /**
+     * @desc Acknowledges the channel has been joined on the server.
+     * @param receiver - The receiver to subscribe to.
+     */
+    acknowledge(receiver) {
+        __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);
+    }
     /**
      * @desc Connects to the channel.
      */
     join() {
-        if (__classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.CLOSED) {
-            throw new Error('This channel has been closed');
+        const message = {
+            action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+            event: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+            payload: __classPrivateFieldGet(this, _Channel_joinParams, "f"),
+            channelName: __classPrivateFieldGet(this, _Channel_name, "f"),
+            requestId: (0, pondsocket_common_1.uuid)(),
+        };
+        if (__classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.JOINED) {
+            return;
         }
-        const joinMessage = __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_buildJoinMessage).call(this);
         __classPrivateFieldGet(this, _Channel_joinState, "f").publish(pondsocket_common_1.ChannelState.JOINING);
         if (__classPrivateFieldGet(this, _Channel_clientState, "f").value) {
-            __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, joinMessage);
+            __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, message);
         }
         else {
-            __classPrivateFieldGet(this, _Channel_joinState, "f").publish(pondsocket_common_1.ChannelState.STALLED);
+            const unsubscribe = __classPrivateFieldGet(this, _Channel_clientState, "f").subscribe((state) => {
+                if (state) {
+                    unsubscribe();
+                    if (__classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.JOINING) {
+                        __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, message);
+                    }
+                }
+            });
         }
     }
     /**
      * @desc Disconnects from the channel.
      */
     leave() {
-        const leaveMessage = {
+        const message = {
             action: pondsocket_common_1.ClientActions.LEAVE_CHANNEL,
             event: pondsocket_common_1.ClientActions.LEAVE_CHANNEL,
             channelName: __classPrivateFieldGet(this, _Channel_name, "f"),
             requestId: (0, pondsocket_common_1.uuid)(),
             payload: {},
         };
-        __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_publish).call(this, leaveMessage);
+        __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_publish).call(this, message);
         __classPrivateFieldGet(this, _Channel_joinState, "f").publish(pondsocket_common_1.ChannelState.CLOSED);
         __classPrivateFieldGet(this, _Channel_presenceSub, "f").call(this);
     }
-    /**
-     * @desc Monitors the channel for messages.
-     * @param callback - The callback to call when a message is received.
-     */
-    onMessage(callback) {
-        return __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_onMessage).call(this, (event, message) => {
-            callback(event, message);
-        });
-    }
-    /**
-     * @desc Monitors the channel for messages.
-     * @param event - The event to monitor.
-     * @param callback - The callback to call when a message is received.
-     */
-    onMessageEvent(event, callback) {
-        return this.onMessage((eventReceived, message) => {
-            if (eventReceived === event) {
-                return callback(message);
-            }
-        });
-    }
     /**
      * @desc Monitors the channel state of the channel.
      * @param callback - The callback to call when the connection state changes.
@@ -125,6 +134,27 @@ class Channel {
             }
         });
     }
+    /**
+     * @desc Monitors the channel for messages.
+     * @param callback - The callback to call when a message is received.
+     */
+    onMessage(callback) {
+        return __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_onMessage).call(this, (event, message) => {
+            callback(event, message);
+        });
+    }
+    /**
+     * @desc Monitors the channel for messages.
+     * @param event - The event to monitor.
+     * @param callback - The callback to call when a message is received.
+     */
+    onMessageEvent(event, callback) {
+        return this.onMessage((eventReceived, message) => {
+            if (eventReceived === event) {
+                return callback(message);
+            }
+        });
+    }
     /**
      * @desc Detects when clients change their presence in the channel.
      * @param callback - The callback to call when a client changes their presence in the channel.
@@ -136,6 +166,13 @@ class Channel {
             }
         });
     }
+    /**
+     * @desc Monitors the presence of the channel.
+     * @param callback - The callback to call when the presence changes.
+     */
+    onUsersChange(callback) {
+        return __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_subscribeToPresence).call(this, (_event, payload) => callback(payload.presence));
+    }
     /**
      * @desc Sends a message to specific clients in the channel.
      * @param event - The event to send.
@@ -143,7 +180,14 @@ class Channel {
      */
     sendMessage(event, payload) {
         const requestId = (0, pondsocket_common_1.uuid)();
-        __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_send).call(this, event, requestId, payload);
+        const message = {
+            action: pondsocket_common_1.ClientActions.BROADCAST,
+            channelName: __classPrivateFieldGet(this, _Channel_name, "f"),
+            requestId,
+            event,
+            payload,
+        };
+        __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_publish).call(this, message);
     }
     /**
      * @desc Sends a message to the server and waits for a response.
@@ -159,90 +203,39 @@ class Channel {
                     unsub();
                 }
             });
-            __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_send).call(this, sentEvent, requestId, payload);
-        });
-    }
-    /**
-     * @desc Gets the current presence of the channel.
-     */
-    getPresence() {
-        return __classPrivateFieldGet(this, _Channel_presence, "f");
-    }
-    /**
-     * @desc Monitors the presence of the channel.
-     * @param callback - The callback to call when the presence changes.
-     */
-    onUsersChange(callback) {
-        return __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_subscribeToPresence).call(this, (_event, payload) => callback(payload.presence));
-    }
-    /**
-     * @desc Checks if the channel is connected.
-     */
-    isConnected() {
-        return __classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.JOINED || __classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.STALLED;
-    }
-    /**
-     * @desc Checks if the channel is stalled.
-     */
-    isStalled() {
-        return __classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.STALLED;
-    }
-    /**
-     * @desc Checks if the channel is closed.
-     */
-    isClosed() {
-        return __classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.CLOSED;
-    }
-    /**
-     * @desc Monitors the connection state of the channel.
-     * @param callback - The callback to call when the connection state changes.
-     */
-    onConnectionChange(callback) {
-        return this.onChannelStateChange((state) => {
-            callback(state === pondsocket_common_1.ChannelState.JOINED || state === pondsocket_common_1.ChannelState.STALLED);
+            const message = {
+                action: pondsocket_common_1.ClientActions.BROADCAST,
+                channelName: __classPrivateFieldGet(this, _Channel_name, "f"),
+                requestId,
+                event: sentEvent,
+                payload,
+            };
+            __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_publish).call(this, message);
         });
     }
 }
 exports.Channel = Channel;
-_Channel_name = new WeakMap(), _Channel_queue = new WeakMap(), _Channel_presence = new WeakMap(), _Channel_publisher = new WeakMap(), _Channel_joinParams = new WeakMap(), _Channel_presenceSub = new WeakMap(), _Channel_receiver = new WeakMap(), _Channel_clientState = new WeakMap(), _Channel_joinState = new WeakMap(), _Channel_instances = new WeakSet(), _Channel_send = function _Channel_send(event, requestId, payload) {
-    const message = {
-        action: pondsocket_common_1.ClientActions.BROADCAST,
-        channelName: __classPrivateFieldGet(this, _Channel_name, "f"),
-        requestId,
-        event,
-        payload,
-    };
-    __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_publish).call(this, message);
-}, _Channel_publish = function _Channel_publish(data) {
-    if (__classPrivateFieldGet(this, _Channel_clientState, "f").value) {
-        if (__classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.JOINED) {
-            __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, data);
-        }
-        return;
-    }
-    __classPrivateFieldGet(this, _Channel_queue, "f").push(data);
-}, _Channel_subscribeToPresence = function _Channel_subscribeToPresence(callback) {
-    return __classPrivateFieldGet(this, _Channel_receiver, "f").subscribe((data) => {
-        if (data.action === pondsocket_common_1.ServerActions.PRESENCE) {
-            return callback(data.event, data.payload);
-        }
-    });
+_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() {
+    __classPrivateFieldGet(this, _Channel_queue, "f")
+        .forEach((message) => __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, message));
+    __classPrivateFieldSet(this, _Channel_queue, [], "f");
 }, _Channel_init = function _Channel_init(receiver) {
+    __classPrivateFieldGet(this, _Channel_presenceSub, "f").call(this);
     const unsubMessages = receiver.subscribe((data) => {
-        if (data.channelName === __classPrivateFieldGet(this, _Channel_name, "f")) {
-            if (data.event === pondsocket_common_1.Events.ACKNOWLEDGE) {
-                __classPrivateFieldGet(this, _Channel_joinState, "f").publish(pondsocket_common_1.ChannelState.JOINED);
-                __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_emptyQueue).call(this);
-            }
-            else {
-                __classPrivateFieldGet(this, _Channel_receiver, "f").publish(data);
-            }
+        if (data.channelName === __classPrivateFieldGet(this, _Channel_name, "f") && this.channelState === pondsocket_common_1.ChannelState.JOINED) {
+            __classPrivateFieldGet(this, _Channel_receiver, "f").publish(data);
         }
     });
     const unsubStateChange = __classPrivateFieldGet(this, _Channel_clientState, "f").subscribe((state) => {
         if (state && __classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.STALLED) {
-            const joinMessage = __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_buildJoinMessage).call(this);
-            __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, joinMessage);
+            const message = {
+                action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+                event: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+                payload: __classPrivateFieldGet(this, _Channel_joinParams, "f"),
+                channelName: __classPrivateFieldGet(this, _Channel_name, "f"),
+                requestId: (0, pondsocket_common_1.uuid)(),
+            };
+            __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, message);
         }
         else if (!state && __classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.JOINED) {
             __classPrivateFieldGet(this, _Channel_joinState, "f").publish(pondsocket_common_1.ChannelState.STALLED);
@@ -251,30 +244,26 @@ _Channel_name = new WeakMap(), _Channel_queue = new WeakMap(), _Channel_presence
     const unsubPresence = __classPrivateFieldGet(this, _Channel_instances, "m", _Channel_subscribeToPresence).call(this, (_, payload) => {
         __classPrivateFieldSet(this, _Channel_presence, payload.presence, "f");
     });
-    return () => {
+    __classPrivateFieldSet(this, _Channel_presenceSub, () => {
         unsubMessages();
         unsubStateChange();
         unsubPresence();
-    };
-}, _Channel_emptyQueue = function _Channel_emptyQueue() {
-    __classPrivateFieldGet(this, _Channel_queue, "f")
-        .filter((message) => message.action !== pondsocket_common_1.ClientActions.JOIN_CHANNEL)
-        .forEach((message) => {
-        __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, message);
-    });
-    __classPrivateFieldSet(this, _Channel_queue, [], "f");
-}, _Channel_buildJoinMessage = function _Channel_buildJoinMessage() {
-    return {
-        action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
-        event: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
-        payload: __classPrivateFieldGet(this, _Channel_joinParams, "f"),
-        channelName: __classPrivateFieldGet(this, _Channel_name, "f"),
-        requestId: (0, pondsocket_common_1.uuid)(),
-    };
+    }, "f");
 }, _Channel_onMessage = function _Channel_onMessage(callback) {
     return __classPrivateFieldGet(this, _Channel_receiver, "f").subscribe((data) => {
         if (data.action !== pondsocket_common_1.ServerActions.PRESENCE) {
             return callback(data.event, data.payload, data.requestId);
         }
     });
+}, _Channel_publish = function _Channel_publish(data) {
+    if (__classPrivateFieldGet(this, _Channel_joinState, "f").value === pondsocket_common_1.ChannelState.JOINED) {
+        return __classPrivateFieldGet(this, _Channel_publisher, "f").call(this, data);
+    }
+    __classPrivateFieldGet(this, _Channel_queue, "f").push(data);
+}, _Channel_subscribeToPresence = function _Channel_subscribeToPresence(callback) {
+    return __classPrivateFieldGet(this, _Channel_receiver, "f").subscribe((data) => {
+        if (data.action === pondsocket_common_1.ServerActions.PRESENCE) {
+            return callback(data.event, data.payload);
+        }
+    });
 };

package/core/channel.test.js

@@ -15,7 +15,7 @@ const createChannel = (params = {}) => {
     const publisher = jest.fn();
     const state = new pondsocket_common_1.BehaviorSubject(true);
     const receiver = new pondsocket_common_1.Subject();
-    const channel = new channel_1.Channel(publisher, state, 'test', receiver, params);
+    const channel = new channel_1.Channel(publisher, state, 'test', params);
     return {
         channel,
         publisher,
@@ -24,213 +24,132 @@ const createChannel = (params = {}) => {
     };
 };
 describe('Channel', () => {
-    it('should correctly send a join message', () => {
-        const { channel, publisher, state } = createChannel();
-        expect(publisher).not.toHaveBeenCalled();
-        expect(state.value).toBe(true);
+    it('should correctly perform the join process', () => {
+        const { channel, publisher, state, receiver } = createChannel();
+        // 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);
         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);
+        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.JOINING);
         expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
             action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
             channelName: 'test',
             event: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
             payload: {},
         }));
-        const { channel: channel2, publisher: publisher2, state: state2 } = createChannel();
-        state2.publish(false);
-        expect(state2.value).toBe(false);
-        expect(publisher2).not.toHaveBeenCalled();
-        channel2.join();
-        expect(publisher2).not.toHaveBeenCalled();
-        state2.publish(true);
-        expect(publisher2).toHaveBeenCalledWith(expect.objectContaining({
+        // once the server responds with an ack, the channel state should be joined
+        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);
+        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);
+        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.STALLED);
+        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
             action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
             channelName: 'test',
             event: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
             payload: {},
         }));
-        const { channel: channel3 } = createChannel();
-        channel3.leave();
-        expect(() => channel3.join())
-            .toThrow('This channel has been closed');
-    });
-    it('should correctly send a leave message', () => {
-        const { channel, publisher, receiver } = createChannel();
-        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.IDLE);
-        channel.join();
-        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.JOINING);
-        receiver.publish({
-            requestId: 'test',
-            action: pondsocket_common_1.ServerActions.SYSTEM,
-            channelName: 'test',
-            event: 'SYSTEM',
-            payload: {
-                event: 'JOIN',
-            },
-        });
-        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.JOINING);
         // once the server responds with an ack, the channel state should be joined
-        receiver.publish({
-            requestId: 'test',
-            action: pondsocket_common_1.ServerActions.SYSTEM,
-            channelName: 'test',
-            event: pondsocket_common_1.Events.ACKNOWLEDGE,
-            payload: {
-                event: 'JOIN',
-            },
-        });
+        channel.acknowledge(receiver);
         expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.JOINED);
+        // if the channel is closed, the channel should be closed
         channel.leave();
         expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.CLOSED);
-        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
-            action: pondsocket_common_1.ClientActions.LEAVE_CHANNEL,
-            channelName: 'test',
-            event: pondsocket_common_1.ClientActions.LEAVE_CHANNEL,
-            payload: {},
-        }));
+        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);
+        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);
+        channel2.join();
+        expect(publisher2).not.toHaveBeenCalled();
+        expect(channel2.channelState).toBe(pondsocket_common_1.ChannelState.JOINING);
+        channel2.leave();
+        state2.publish(true);
+        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);
+        expect(channel2.channelState).toBe(pondsocket_common_1.ChannelState.JOINED);
     });
     it('should notify subscribers when the channel state changes', () => {
-        const { channel, receiver } = createChannel();
+        const { channel, receiver, state } = createChannel();
         const stateListener = jest.fn();
         channel.onChannelStateChange(stateListener);
         expect(stateListener).toHaveBeenCalledWith(pondsocket_common_1.ChannelState.IDLE);
         channel.join();
-        receiver.publish({
-            requestId: 'test',
-            action: 'SYSTEM',
-            channelName: 'test',
-            event: pondsocket_common_1.Events.ACKNOWLEDGE,
-            payload: {
-                event: 'JOIN',
-            },
-        });
+        expect(stateListener).toHaveBeenCalledWith(pondsocket_common_1.ChannelState.JOINING);
+        channel.acknowledge(receiver);
         expect(stateListener).toHaveBeenCalledWith(pondsocket_common_1.ChannelState.JOINED);
-        channel.leave();
-        expect(stateListener).toHaveBeenCalledWith(pondsocket_common_1.ChannelState.CLOSED);
-    });
-    it('should notify subscribers when state changes BOOLEAN', () => {
-        const { channel, receiver, state, publisher } = createChannel();
-        const stateListener = jest.fn();
-        expect(channel.isClosed()).toBe(false);
-        expect(channel.isConnected()).toBe(false);
-        expect(channel.isStalled()).toBe(false);
-        channel.onConnectionChange(stateListener);
-        expect(stateListener).toHaveBeenCalledWith(false);
-        expect(channel.isClosed()).toBe(false);
-        expect(channel.isConnected()).toBe(false);
-        expect(channel.isStalled()).toBe(false);
-        channel.join();
-        expect(channel.isConnected()).toBe(false);
-        expect(channel.isStalled()).toBe(false);
-        receiver.publish({
-            requestId: 'test',
-            action: 'SYSTEM',
-            channelName: 'test',
-            event: pondsocket_common_1.Events.ACKNOWLEDGE,
-            payload: {
-                event: 'JOIN',
-            },
-        });
-        expect(stateListener).toHaveBeenCalledWith(true);
-        expect(channel.isConnected()).toBe(true);
-        expect(channel.isStalled()).toBe(false);
-        publisher.mockClear();
         state.publish(false);
-        expect(publisher).not.toHaveBeenCalled();
-        expect(channel.isStalled()).toBe(true);
-        expect(channel.isConnected()).toBe(true);
-        state.publish(true);
-        expect(publisher).toHaveBeenCalledTimes(1);
-        receiver.publish({
-            requestId: 'test',
-            action: 'SYSTEM',
-            channelName: 'test',
-            event: pondsocket_common_1.Events.ACKNOWLEDGE,
-            payload: {
-                event: 'JOIN',
-            },
-        });
-        expect(channel.isStalled()).toBe(false);
-        expect(channel.isConnected()).toBe(true);
+        expect(stateListener).toHaveBeenCalledWith(pondsocket_common_1.ChannelState.STALLED);
         channel.leave();
-        expect(channel.isClosed()).toBe(true);
-        expect(channel.isConnected()).toBe(false);
-        expect(channel.isStalled()).toBe(false);
-        expect(stateListener).toHaveBeenCalledWith(false);
+        expect(stateListener).toHaveBeenCalledWith(pondsocket_common_1.ChannelState.CLOSED);
     });
     it('should correctly send a message', () => {
-        const { channel, publisher, state, receiver } = createChannel();
-        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.IDLE);
-        expect(publisher).not.toHaveBeenCalled();
-        // when the socket is connected but the channel is not joined, the message would not be queued
-        channel.sendMessage('test', { test: false });
+        const { channel, publisher, receiver, state } = createChannel();
+        // the channel should not send a message if it is not joined, the message should be queued
+        channel.sendMessage('test', {
+            test: 'test',
+        });
         expect(publisher).not.toHaveBeenCalled();
+        // however, if the channel is joined, the queued message should be sent
         channel.join();
         publisher.mockClear();
-        receiver.publish({
-            requestId: 'test',
-            action: 'SYSTEM',
-            channelName: 'test',
-            event: pondsocket_common_1.Events.ACKNOWLEDGE,
-            payload: {
-                event: 'JOIN',
-            },
-        });
-        // however once the channel is joined, the message should be sent
-        channel.sendMessage('test', { test: true });
+        // acknowledge the join
+        channel.acknowledge(receiver);
         expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
             action: pondsocket_common_1.ClientActions.BROADCAST,
             channelName: 'test',
             event: 'test',
             payload: {
-                test: true,
+                test: 'test',
             },
         }));
-        // if for some reason the socket is disconnected, the message should be queued
         publisher.mockClear();
+        // if the channel stalls and rejoins the previous message should not be sent again
         state.publish(false);
-        expect(state.value).toBe(false);
-        channel.sendMessage('test', { test: true });
-        expect(publisher).not.toHaveBeenCalled();
-        // once the socket is reconnected, a join message should be sent and the queued messages should be sent
-        publisher.mockClear();
         state.publish(true);
-        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
-            action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
-            channelName: 'test',
-            event: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
-            payload: {},
-        }));
-        // until it receives an ack message the queued messages should not be sent
-        expect(publisher).toHaveBeenCalledTimes(1);
-        receiver.publish({
-            requestId: 'test',
-            action: 'SYSTEM',
+        // acknowledge the join
+        channel.acknowledge(receiver);
+        expect(publisher).toHaveBeenCalledTimes(1); // The join message
+        expect(publisher).not.toHaveBeenCalledWith(expect.objectContaining({
+            action: pondsocket_common_1.ClientActions.BROADCAST,
             channelName: 'test',
-            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+            event: 'test',
             payload: {
-                event: 'JOIN',
+                test: 'test',
             },
+        }));
+        publisher.mockClear();
+        // if a message is sent while the channel is stalled, it should be queued
+        state.publish(false);
+        channel.sendMessage('test', {
+            test: 'test stalling',
         });
+        expect(publisher).not.toHaveBeenCalled();
+        state.publish(true);
+        publisher.mockClear(); // The join message
+        // acknowledge the join
+        channel.acknowledge(receiver);
         expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
             action: pondsocket_common_1.ClientActions.BROADCAST,
             channelName: 'test',
             event: 'test',
             payload: {
-                test: true,
+                test: 'test stalling',
             },
         }));
-        // if the channel is closed, the message should not be sent, and should not be queued
-        publisher.mockClear();
-        channel.leave();
-        // the leave message should be sent
-        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
-            action: pondsocket_common_1.ClientActions.LEAVE_CHANNEL,
-            channelName: 'test',
-            event: pondsocket_common_1.ClientActions.LEAVE_CHANNEL,
-            payload: {},
-        }));
-        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.CLOSED);
-        channel.sendMessage('test', { test: true });
         expect(publisher).toHaveBeenCalledTimes(1);
     });
     // The presence system tests
@@ -239,8 +158,8 @@ describe('Channel', () => {
         const presenceListener = jest.fn();
         channel.onJoin(presenceListener);
         expect(presenceListener).not.toHaveBeenCalled();
-        // usually the server wouldn't send a presence if the channel is not joined
-        // but for testing purposes, we'll just send it anyway
+        // acknowledge the join
+        channel.acknowledge(receiver);
         receiver.publish({
             requestId: 'test',
             action: pondsocket_common_1.ServerActions.PRESENCE,
@@ -321,8 +240,8 @@ describe('Channel', () => {
         const presenceListener = jest.fn();
         channel.onLeave(presenceListener);
         expect(presenceListener).not.toHaveBeenCalled();
-        // usually the server wouldn't send a presence if the channel is not joined
-        // but for testing purposes, we'll just send it anyway
+        // acknowledge the join
+        channel.acknowledge(receiver);
         receiver.publish({
             requestId: 'test',
             action: pondsocket_common_1.ServerActions.PRESENCE,
@@ -403,8 +322,8 @@ describe('Channel', () => {
         const presenceListener = jest.fn();
         channel.onUsersChange(presenceListener);
         expect(presenceListener).not.toHaveBeenCalled();
-        // usually the server wouldn't send a presence if the channel is not joined
-        // but for testing purposes, we'll just send it anyway
+        // acknowledge the join
+        channel.acknowledge(receiver);
         receiver.publish({
             requestId: 'test',
             action: pondsocket_common_1.ServerActions.PRESENCE,
@@ -437,7 +356,7 @@ describe('Channel', () => {
                 status: 'online',
             },
         ]);
-        expect(channel.getPresence()).toBe(presenceListener.mock.calls[0][0]);
+        expect(channel.presence).toBe(presenceListener.mock.calls[0][0]);
         presenceListener.mockClear();
         // if we receive a leave or join event, it should be sent to the listener
         // this is because we are listening for all presence events
@@ -465,7 +384,7 @@ describe('Channel', () => {
                 status: 'online',
             },
         ]);
-        expect(channel.getPresence()).toBe(presenceListener.mock.calls[0][0]);
+        expect(channel.presence).toBe(presenceListener.mock.calls[0][0]);
         presenceListener.mockClear();
         // also, if a presence event is received for a different channel, it should not be sent to the listener
         receiver.publish({
@@ -524,15 +443,15 @@ describe('Channel', () => {
                 status: 'online',
             },
         ]);
-        expect(channel.getPresence()).toBe(presenceListener.mock.calls[0][0]);
+        expect(channel.presence).toBe(presenceListener.mock.calls[0][0]);
     });
     it('should notify subscribers when any presence event occurs', () => {
-        const { channel, receiver } = createChannel();
+        const { channel, receiver, state } = createChannel();
         const presenceListener = jest.fn();
         channel.onPresenceChange(presenceListener);
         expect(presenceListener).not.toHaveBeenCalled();
-        // usually the server wouldn't send a presence if the channel is not joined
-        // but for testing purposes, we'll just send it anyway
+        // acknowledge the join
+        channel.acknowledge(receiver);
         receiver.publish({
             requestId: 'test',
             action: pondsocket_common_1.ServerActions.PRESENCE,
@@ -571,11 +490,115 @@ describe('Channel', () => {
                 },
             ],
         });
+        // messages for other channels should not be sent to the listener
+        // since the other presence events listeners rely on this function we don't need to test this on those tests
+        presenceListener.mockClear();
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.UPDATE,
+            channelName: 'test2',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
+        // if the channel is stalled, the presence event should not be sent to the listener
+        state.publish(false);
+        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.STALLED);
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.UPDATE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
+        state.publish(true);
+        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.STALLED);
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.UPDATE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
+        // if the channel is closed, the presence event should not be sent to the listener
+        channel.acknowledge(receiver);
+        channel.leave();
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.UPDATE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
     });
     // message events
     it('should notify subscribers when a message is received', () => {
         const { channel, receiver } = createChannel();
         const messageListener = jest.fn();
+        channel.join();
         channel.onMessage(messageListener);
         expect(messageListener).not.toHaveBeenCalled();
         receiver.publish({
@@ -588,6 +611,19 @@ describe('Channel', () => {
                 message: 'test',
             },
         });
+        expect(messageListener).not.toHaveBeenCalled(); // the server should acknowledge the join first
+        // acknowledge the join
+        channel.acknowledge(receiver);
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            event: 'message',
+            channelName: 'test',
+            payload: {
+                id: 'test',
+                message: 'test',
+            },
+        });
         expect(messageListener).toHaveBeenCalledWith('message', {
             id: 'test',
             message: 'test',
@@ -648,55 +684,6 @@ describe('Channel', () => {
         });
         expect(specificMessageListener).not.toHaveBeenCalled();
     });
-    it('should be able to broadcast a message', () => {
-        const { channel, receiver, publisher } = createChannel();
-        channel.join();
-        publisher.mockClear();
-        receiver.publish({
-            requestId: 'test',
-            action: 'SYSTEM',
-            channelName: 'test',
-            event: pondsocket_common_1.Events.ACKNOWLEDGE,
-            payload: {
-                event: 'JOIN',
-            },
-        });
-        channel.sendMessage('test', {
-            test: 'test',
-        });
-        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
-            action: pondsocket_common_1.ClientActions.BROADCAST,
-            channelName: 'test',
-            event: 'test',
-            payload: {
-                test: 'test',
-            },
-        }));
-        publisher.mockClear();
-        channel.sendMessage('test', {
-            test: 'test',
-        });
-        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
-            action: pondsocket_common_1.ClientActions.BROADCAST,
-            channelName: 'test',
-            event: 'test',
-            payload: {
-                test: 'test',
-            },
-        }));
-        publisher.mockClear();
-        channel.sendMessage('test', {
-            test: 'test',
-        });
-        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
-            action: pondsocket_common_1.ClientActions.BROADCAST,
-            channelName: 'test',
-            event: 'test',
-            payload: {
-                test: 'test',
-            },
-        }));
-    });
     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 receiver = new pondsocket_common_1.Subject();
@@ -727,17 +714,9 @@ describe('Channel', () => {
                 });
             }
         };
-        const channel = new channel_1.Channel(publisher, state, 'test', receiver, params);
+        const channel = new channel_1.Channel(publisher, state, 'test', params);
         channel.join();
-        receiver.publish({
-            requestId: 'test',
-            action: 'SYSTEM',
-            channelName: 'test',
-            event: pondsocket_common_1.Events.ACKNOWLEDGE,
-            payload: {
-                event: 'JOIN',
-            },
-        });
+        channel.acknowledge(receiver);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         // @ts-expect-error - this is a test
         const response = yield channel.sendForResponse('WAITING', {

package/dist.d.ts

@@ -16,6 +16,11 @@ declare class Channel<EventMap extends PondEventMap = PondEventMap, Presence ext
      */
     channelState: ChannelState;
 
+    /**
+     * @desc Gets the current presence of the channel.
+     */
+    presence (): Presence[];
+
     /**
      * @desc Connects to the channel.
      */
@@ -26,19 +31,6 @@ declare class Channel<EventMap extends PondEventMap = PondEventMap, Presence ext
      */
     leave (): void;
 
-    /**
-     * @desc Monitors the channel for messages.
-     * @param callback - The callback to call when a message is received.
-     */
-    onMessage<Event extends keyof EventMap> (callback: (event: Event, message: EventMap[Event]) => void): Unsubscribe;
-
-    /**
-     * @desc Monitors the channel for messages.
-     * @param event - The event to monitor.
-     * @param callback - The callback to call when a message is received.
-     */
-    onMessageEvent<Event extends keyof EventMap> (event: Event, callback: (message: EventMap[Event]) => void): Unsubscribe;
-
     /**
      * @desc Monitors the channel state of the channel.
      * @param callback - The callback to call when the connection state changes.
@@ -58,29 +50,23 @@ declare class Channel<EventMap extends PondEventMap = PondEventMap, Presence ext
     onLeave (callback: (presence: Presence) => void): Unsubscribe;
 
     /**
-     * @desc Detects when clients change their presence in the channel.
-     * @param callback - The callback to call when a client changes their presence in the channel.
-     */
-    onPresenceChange (callback: (presence: PresencePayload<Presence>) => void): Unsubscribe;
-
-    /**
-     * @desc Sends a message to specific clients in the channel.
-     * @param event - The event to send.
-     * @param payload - The message to send.
+     * @desc Monitors the channel for messages.
+     * @param callback - The callback to call when a message is received.
      */
-    sendMessage<Event extends keyof EventMap> (event: Event, payload: EventMap[Event]): void;
+    onMessage<Event extends keyof EventMap> (callback: (event: Event, message: EventMap[Event]) => void): Unsubscribe;
 
     /**
-     * @desc Sends a message to the server and waits for a response.
-     * @param sentEvent - The event to send.
-     * @param payload - The message to send.
+     * @desc Monitors the channel for messages.
+     * @param event - The event to monitor.
+     * @param callback - The callback to call when a message is received.
      */
-    sendForResponse<Event extends EventWithResponse<EventMap>> (sentEvent: Event, payload: PayloadForResponse<EventMap, Event>): Promise<ResponseForEvent<EventMap, Event>>;
+    onMessageEvent<Event extends keyof EventMap> (event: Event, callback: (message: EventMap[Event]) => void): Unsubscribe;
 
     /**
-     * @desc Gets the current presence of the channel.
+     * @desc Detects when clients change their presence in the channel.
+     * @param callback - The callback to call when a client changes their presence in the channel.
      */
-    getPresence (): Presence[];
+    onPresenceChange (callback: (presence: PresencePayload<Presence>) => void): Unsubscribe;
 
     /**
      * @desc Monitors the presence of the channel.
@@ -89,25 +75,18 @@ declare class Channel<EventMap extends PondEventMap = PondEventMap, Presence ext
     onUsersChange (callback: (users: Presence[]) => void): Unsubscribe;
 
     /**
-     * @desc Checks if the channel is connected.
-     */
-    isConnected (): boolean;
-
-    /**
-     * @desc Checks if the channel is stalled.
-     */
-    isStalled (): boolean;
-
-    /**
-     * @desc Checks if the channel is closed.
+     * @desc Sends a message to specific clients in the channel.
+     * @param event - The event to send.
+     * @param payload - The message to send.
      */
-    isClosed (): boolean;
+    sendMessage<Event extends keyof EventMap> (event: Event, payload: EventMap[Event]): void;
 
     /**
-     * @desc Monitors the connection state of the channel.
-     * @param callback - The callback to call when the connection state changes.
+     * @desc Sends a message to the server and waits for a response.
+     * @param sentEvent - The event to send.
+     * @param payload - The message to send.
      */
-    onConnectionChange (callback: (connected: boolean) => void): Unsubscribe;
+    sendForResponse<Event extends EventWithResponse<EventMap>> (sentEvent: Event, payload: PayloadForResponse<EventMap, Event>): Promise<ResponseForEvent<EventMap, Event>>;
 }
 
 declare class PondClient {
@@ -116,7 +95,7 @@ declare class PondClient {
     /**
      * @desc Connects to the server and returns the socket.
      */
-    connect (backoff?: number): void;
+    connect (): void;
 
     /**
      * @desc Returns the current state of the socket.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket-client",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",