mezon-js 2.13.61 → 2.13.62

package/dist/mezon-js.cjs.js

@@ -57,6 +57,7 @@ __export(index_exports, {
   ChannelStreamMode: () => ChannelStreamMode,
   ChannelType: () => ChannelType,
   Client: () => Client,
+  ConnectionState: () => ConnectionState,
   DefaultSocket: () => DefaultSocket,
   NotificationType: () => NotificationType,
   Session: () => Session,
@@ -7469,6 +7470,12 @@ function CreateChannelMessageFromEvent(message) {
   };
   return e;
 }
+var __hasConnectedOnce = false;
+var ConnectionState = {
+  DISCONNECTED: "disconnected",
+  CONNECTING: "connecting",
+  CONNECTED: "connected"
+};
 var _DefaultSocket = class _DefaultSocket {
   constructor(host, port, useSSL = false, verbose = false, adapter = new WebSocketAdapterText(), sendTimeoutMs = _DefaultSocket.DefaultSendTimeoutMs) {
     this.host = host;
@@ -7480,7 +7487,7 @@ var _DefaultSocket = class _DefaultSocket {
     this.cIds = {};
     this.nextCid = 1;
     this._heartbeatTimeoutMs = _DefaultSocket.DefaultHeartbeatTimeoutMs;
-    this.hasConnectedBefore = false;
+    this._connectionState = ConnectionState.DISCONNECTED;
   }
   generatecid() {
     const cid = this.nextCid.toString();
@@ -7488,12 +7495,17 @@ var _DefaultSocket = class _DefaultSocket {
     return cid;
   }
   isOpen() {
-    return this.adapter.isOpen();
+    return this._connectionState === ConnectionState.CONNECTED;
   }
   connect(session, createStatus = false, platform = "", connectTimeoutMs = _DefaultSocket.DefaultConnectTimeoutMs, signal) {
-    if (this.adapter.isOpen()) {
+    if (this._connectionState === ConnectionState.CONNECTED) {
       return Promise.resolve(session);
     }
+    if (this._connectionState === ConnectionState.CONNECTING && this._connectPromise) {
+      return this._connectPromise;
+    }
+    this.clearConnectTimeout();
+    this._connectionState = ConnectionState.CONNECTING;
     const scheme = this.useSSL ? "wss://" : "ws://";
     this.adapter.connect(
       scheme,
@@ -7505,11 +7517,11 @@ var _DefaultSocket = class _DefaultSocket {
       signal
     );
     this.adapter.onClose = (evt) => {
+      this._connectionState = ConnectionState.DISCONNECTED;
+      this.stopHeartbeatLoop();
+      this.clearConnectTimeout();
       this.ondisconnect(evt);
     };
-    this.adapter.onError = (evt) => {
-      this.onerror(evt);
-    };
     this.adapter.onMessage = (message) => __async(this, null, function* () {
       if (this.verbose && window && window.console) {
         console.log("Response: %o", JSON.stringify(message));
@@ -7714,29 +7726,46 @@ var _DefaultSocket = class _DefaultSocket {
         }
       }
     });
-    return new Promise((resolve, reject) => {
+    const connectPromise = new Promise((resolve, reject) => {
       this.adapter.onOpen = (evt) => {
         if (this.verbose && window && window.console) {
           console.log(evt);
         }
-        const isReconnect = this.hasConnectedBefore;
-        this.hasConnectedBefore = true;
-        this.pingPong();
+        const isReconnect = __hasConnectedOnce;
+        __hasConnectedOnce = true;
+        this.clearConnectTimeout();
+        this._connectionState = ConnectionState.CONNECTED;
+        this.startHeartbeatLoop();
+        this._connectPromise = void 0;
         resolve(session);
         if (isReconnect) {
           this.onreconnect(evt);
         }
       };
       this.adapter.onError = (evt) => {
-        reject(evt);
+        this._connectionState = ConnectionState.DISCONNECTED;
+        this.stopHeartbeatLoop();
+        this.clearConnectTimeout();
+        this.onerror(evt);
+        this._connectPromise = void 0;
         this.adapter.close();
+        reject(evt);
       };
-      setTimeout(() => {
+      this._connectTimeoutTimer = setTimeout(() => {
+        this._connectionState = ConnectionState.DISCONNECTED;
+        this.stopHeartbeatLoop();
+        this.adapter.close();
+        this._connectPromise = void 0;
         reject("The socket timed out when trying to connect.");
+        this._connectTimeoutTimer = void 0;
       }, connectTimeoutMs);
     });
+    this._connectPromise = connectPromise;
+    return this._connectPromise;
   }
   disconnect(fireDisconnectEvent = true) {
+    this._connectionState = ConnectionState.DISCONNECTED;
+    this.stopHeartbeatLoop();
     if (this.adapter.isOpen()) {
       this.adapter.close();
     }
@@ -7761,6 +7790,8 @@ var _DefaultSocket = class _DefaultSocket {
     }
   }
   onerror(evt) {
+    this._connectionState = ConnectionState.DISCONNECTED;
+    this.stopHeartbeatLoop();
     if (this.verbose && window && window.console) {
       console.log(evt);
     }
@@ -8131,9 +8162,11 @@ var _DefaultSocket = class _DefaultSocket {
         }
         const cid = this.generatecid();
         this.cIds[cid] = { resolve, reject };
-        setTimeout(() => {
-          reject("The socket timed out while waiting for a response.");
-        }, sendTimeout);
+        if (sendTimeout !== Infinity && sendTimeout > 0) {
+          setTimeout(() => {
+            reject("The socket timed out while waiting for a response.");
+          }, sendTimeout);
+        }
         untypedMessage.cid = cid;
         this.adapter.send(untypedMessage);
       }
@@ -8326,7 +8359,7 @@ var _DefaultSocket = class _DefaultSocket {
           code,
           topic_id
         }
-      });
+      }, Infinity);
       return response.channel_message_ack;
     });
   }
@@ -8531,12 +8564,16 @@ var _DefaultSocket = class _DefaultSocket {
   }
   pingPong() {
     return __async(this, null, function* () {
-      if (!this.adapter.isOpen()) {
+      if (!this.isOpen()) {
+        this._connectionState = ConnectionState.DISCONNECTED;
+        this.stopHeartbeatLoop();
         return;
       }
       try {
         yield this.send({ ping: {} }, this._heartbeatTimeoutMs);
       } catch (e) {
+        this._connectionState = ConnectionState.DISCONNECTED;
+        this.stopHeartbeatLoop();
         if (this.adapter.isOpen()) {
           if (window && window.console) {
             console.error("Server unreachable from heartbeat.");
@@ -8546,9 +8583,28 @@ var _DefaultSocket = class _DefaultSocket {
         }
         return;
       }
-      setTimeout(() => this.pingPong(), this._heartbeatTimeoutMs);
+      this.startHeartbeatLoop();
     });
   }
+  startHeartbeatLoop() {
+    this.stopHeartbeatLoop();
+    this._heartbeatTimer = setTimeout(
+      () => this.pingPong(),
+      this._heartbeatTimeoutMs
+    );
+  }
+  stopHeartbeatLoop() {
+    if (this._heartbeatTimer !== void 0) {
+      clearTimeout(this._heartbeatTimer);
+      this._heartbeatTimer = void 0;
+    }
+  }
+  clearConnectTimeout() {
+    if (this._connectTimeoutTimer !== void 0) {
+      clearTimeout(this._connectTimeoutTimer);
+      this._connectTimeoutTimer = void 0;
+    }
+  }
 };
 _DefaultSocket.DefaultHeartbeatTimeoutMs = 1e4;
 _DefaultSocket.DefaultSendTimeoutMs = 1e4;

package/dist/mezon-js.esm.mjs

@@ -7435,6 +7435,12 @@ function CreateChannelMessageFromEvent(message) {
   };
   return e;
 }
+var __hasConnectedOnce = false;
+var ConnectionState = {
+  DISCONNECTED: "disconnected",
+  CONNECTING: "connecting",
+  CONNECTED: "connected"
+};
 var _DefaultSocket = class _DefaultSocket {
   constructor(host, port, useSSL = false, verbose = false, adapter = new WebSocketAdapterText(), sendTimeoutMs = _DefaultSocket.DefaultSendTimeoutMs) {
     this.host = host;
@@ -7446,7 +7452,7 @@ var _DefaultSocket = class _DefaultSocket {
     this.cIds = {};
     this.nextCid = 1;
     this._heartbeatTimeoutMs = _DefaultSocket.DefaultHeartbeatTimeoutMs;
-    this.hasConnectedBefore = false;
+    this._connectionState = ConnectionState.DISCONNECTED;
   }
   generatecid() {
     const cid = this.nextCid.toString();
@@ -7454,12 +7460,17 @@ var _DefaultSocket = class _DefaultSocket {
     return cid;
   }
   isOpen() {
-    return this.adapter.isOpen();
+    return this._connectionState === ConnectionState.CONNECTED;
   }
   connect(session, createStatus = false, platform = "", connectTimeoutMs = _DefaultSocket.DefaultConnectTimeoutMs, signal) {
-    if (this.adapter.isOpen()) {
+    if (this._connectionState === ConnectionState.CONNECTED) {
       return Promise.resolve(session);
     }
+    if (this._connectionState === ConnectionState.CONNECTING && this._connectPromise) {
+      return this._connectPromise;
+    }
+    this.clearConnectTimeout();
+    this._connectionState = ConnectionState.CONNECTING;
     const scheme = this.useSSL ? "wss://" : "ws://";
     this.adapter.connect(
       scheme,
@@ -7471,11 +7482,11 @@ var _DefaultSocket = class _DefaultSocket {
       signal
     );
     this.adapter.onClose = (evt) => {
+      this._connectionState = ConnectionState.DISCONNECTED;
+      this.stopHeartbeatLoop();
+      this.clearConnectTimeout();
       this.ondisconnect(evt);
     };
-    this.adapter.onError = (evt) => {
-      this.onerror(evt);
-    };
     this.adapter.onMessage = (message) => __async(this, null, function* () {
       if (this.verbose && window && window.console) {
         console.log("Response: %o", JSON.stringify(message));
@@ -7680,29 +7691,46 @@ var _DefaultSocket = class _DefaultSocket {
         }
       }
     });
-    return new Promise((resolve, reject) => {
+    const connectPromise = new Promise((resolve, reject) => {
       this.adapter.onOpen = (evt) => {
         if (this.verbose && window && window.console) {
           console.log(evt);
         }
-        const isReconnect = this.hasConnectedBefore;
-        this.hasConnectedBefore = true;
-        this.pingPong();
+        const isReconnect = __hasConnectedOnce;
+        __hasConnectedOnce = true;
+        this.clearConnectTimeout();
+        this._connectionState = ConnectionState.CONNECTED;
+        this.startHeartbeatLoop();
+        this._connectPromise = void 0;
         resolve(session);
         if (isReconnect) {
           this.onreconnect(evt);
         }
       };
       this.adapter.onError = (evt) => {
-        reject(evt);
+        this._connectionState = ConnectionState.DISCONNECTED;
+        this.stopHeartbeatLoop();
+        this.clearConnectTimeout();
+        this.onerror(evt);
+        this._connectPromise = void 0;
         this.adapter.close();
+        reject(evt);
       };
-      setTimeout(() => {
+      this._connectTimeoutTimer = setTimeout(() => {
+        this._connectionState = ConnectionState.DISCONNECTED;
+        this.stopHeartbeatLoop();
+        this.adapter.close();
+        this._connectPromise = void 0;
         reject("The socket timed out when trying to connect.");
+        this._connectTimeoutTimer = void 0;
       }, connectTimeoutMs);
     });
+    this._connectPromise = connectPromise;
+    return this._connectPromise;
   }
   disconnect(fireDisconnectEvent = true) {
+    this._connectionState = ConnectionState.DISCONNECTED;
+    this.stopHeartbeatLoop();
     if (this.adapter.isOpen()) {
       this.adapter.close();
     }
@@ -7727,6 +7755,8 @@ var _DefaultSocket = class _DefaultSocket {
     }
   }
   onerror(evt) {
+    this._connectionState = ConnectionState.DISCONNECTED;
+    this.stopHeartbeatLoop();
     if (this.verbose && window && window.console) {
       console.log(evt);
     }
@@ -8097,9 +8127,11 @@ var _DefaultSocket = class _DefaultSocket {
         }
         const cid = this.generatecid();
         this.cIds[cid] = { resolve, reject };
-        setTimeout(() => {
-          reject("The socket timed out while waiting for a response.");
-        }, sendTimeout);
+        if (sendTimeout !== Infinity && sendTimeout > 0) {
+          setTimeout(() => {
+            reject("The socket timed out while waiting for a response.");
+          }, sendTimeout);
+        }
         untypedMessage.cid = cid;
         this.adapter.send(untypedMessage);
       }
@@ -8292,7 +8324,7 @@ var _DefaultSocket = class _DefaultSocket {
           code,
           topic_id
         }
-      });
+      }, Infinity);
       return response.channel_message_ack;
     });
   }
@@ -8497,12 +8529,16 @@ var _DefaultSocket = class _DefaultSocket {
   }
   pingPong() {
     return __async(this, null, function* () {
-      if (!this.adapter.isOpen()) {
+      if (!this.isOpen()) {
+        this._connectionState = ConnectionState.DISCONNECTED;
+        this.stopHeartbeatLoop();
         return;
       }
       try {
         yield this.send({ ping: {} }, this._heartbeatTimeoutMs);
       } catch (e) {
+        this._connectionState = ConnectionState.DISCONNECTED;
+        this.stopHeartbeatLoop();
         if (this.adapter.isOpen()) {
           if (window && window.console) {
             console.error("Server unreachable from heartbeat.");
@@ -8512,9 +8548,28 @@ var _DefaultSocket = class _DefaultSocket {
         }
         return;
       }
-      setTimeout(() => this.pingPong(), this._heartbeatTimeoutMs);
+      this.startHeartbeatLoop();
     });
   }
+  startHeartbeatLoop() {
+    this.stopHeartbeatLoop();
+    this._heartbeatTimer = setTimeout(
+      () => this.pingPong(),
+      this._heartbeatTimeoutMs
+    );
+  }
+  stopHeartbeatLoop() {
+    if (this._heartbeatTimer !== void 0) {
+      clearTimeout(this._heartbeatTimer);
+      this._heartbeatTimer = void 0;
+    }
+  }
+  clearConnectTimeout() {
+    if (this._connectTimeoutTimer !== void 0) {
+      clearTimeout(this._connectTimeoutTimer);
+      this._connectTimeoutTimer = void 0;
+    }
+  }
 };
 _DefaultSocket.DefaultHeartbeatTimeoutMs = 1e4;
 _DefaultSocket.DefaultSendTimeoutMs = 1e4;
@@ -11232,6 +11287,7 @@ export {
   ChannelStreamMode,
   ChannelType,
   Client,
+  ConnectionState,
   DefaultSocket,
   NotificationType,
   Session,

package/dist/socket.d.ts

@@ -1073,7 +1073,12 @@ export interface SocketError {
     /** A message in English to help developers debug the response. */
     message: string;
 }
-/** A socket connection to Mezon server implemented with the DOM's WebSocket API. */
+export declare const ConnectionState: {
+    readonly DISCONNECTED: "disconnected";
+    readonly CONNECTING: "connecting";
+    readonly CONNECTED: "connected";
+};
+export type ConnectionStateType = typeof ConnectionState[keyof typeof ConnectionState];
 export declare class DefaultSocket implements Socket {
     readonly host: string;
     readonly port: string;
@@ -1087,7 +1092,10 @@ export declare class DefaultSocket implements Socket {
     private readonly cIds;
     private nextCid;
     private _heartbeatTimeoutMs;
-    private hasConnectedBefore;
+    private _connectionState;
+    private _heartbeatTimer?;
+    private _connectTimeoutTimer?;
+    private _connectPromise?;
     constructor(host: string, port: string, useSSL?: boolean, verbose?: boolean, adapter?: WebSocketAdapter, sendTimeoutMs?: number);
     generatecid(): string;
     isOpen(): boolean;
@@ -1196,5 +1204,8 @@ export declare class DefaultSocket implements Socket {
     writeChannelAppEvent(clan_id: string, channel_id: string, action: number): Promise<ChannelAppEvent>;
     listDataSocket(request: ListDataSocket): Promise<any>;
     private pingPong;
+    private startHeartbeatLoop;
+    private stopHeartbeatLoop;
+    private clearConnectTimeout;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mezon-js",
-  "version": "2.13.61",
+  "version": "2.13.62",
   "scripts": {
     "build": "npx tsc && npx rollup -c --bundleConfigAsCjs && node build.mjs"
   },

package/socket.ts

@@ -1859,6 +1859,16 @@ export interface SocketError {
 }
 
 /** A socket connection to Mezon server implemented with the DOM's WebSocket API. */
+let __hasConnectedOnce = false;
+
+export const ConnectionState = {
+  DISCONNECTED: "disconnected",
+  CONNECTING: "connecting",
+  CONNECTED: "connected",
+} as const;
+
+export type ConnectionStateType = typeof ConnectionState[keyof typeof ConnectionState];
+
 export class DefaultSocket implements Socket {
   public static readonly DefaultHeartbeatTimeoutMs = 10000;
   public static readonly DefaultSendTimeoutMs = 10000;
@@ -1867,7 +1877,10 @@ export class DefaultSocket implements Socket {
   private readonly cIds: { [key: string]: PromiseExecutor };
   private nextCid: number;
   private _heartbeatTimeoutMs: number;
-  private hasConnectedBefore: boolean;
+  private _connectionState: ConnectionStateType;
+  private _heartbeatTimer?: ReturnType<typeof setTimeout>;
+  private _connectTimeoutTimer?: ReturnType<typeof setTimeout>;
+  private _connectPromise?: Promise<Session>;
 
   constructor(
     readonly host: string,
@@ -1880,7 +1893,7 @@ export class DefaultSocket implements Socket {
     this.cIds = {};
     this.nextCid = 1;
     this._heartbeatTimeoutMs = DefaultSocket.DefaultHeartbeatTimeoutMs;
-    this.hasConnectedBefore = false;
+    this._connectionState = ConnectionState.DISCONNECTED;
   }
 
   generatecid(): string {
@@ -1890,7 +1903,7 @@ export class DefaultSocket implements Socket {
   }
 
   isOpen(): boolean {
-    return this.adapter.isOpen();
+    return this._connectionState === ConnectionState.CONNECTED;
   }
 
   connect(
@@ -1900,10 +1913,17 @@ export class DefaultSocket implements Socket {
     connectTimeoutMs: number = DefaultSocket.DefaultConnectTimeoutMs,
     signal?: AbortSignal
   ): Promise<Session> {
-    if (this.adapter.isOpen()) {
+    if (this._connectionState === ConnectionState.CONNECTED) {
       return Promise.resolve(session);
     }
 
+    if (this._connectionState === ConnectionState.CONNECTING && this._connectPromise) {
+      return this._connectPromise;
+    }
+
+    this.clearConnectTimeout();
+    this._connectionState = ConnectionState.CONNECTING;
+
     const scheme = this.useSSL ? "wss://" : "ws://";
     this.adapter.connect(
       scheme,
@@ -1916,13 +1936,12 @@ export class DefaultSocket implements Socket {
     );
 
     this.adapter.onClose = (evt: Event) => {
+      this._connectionState = ConnectionState.DISCONNECTED;
+      this.stopHeartbeatLoop();
+      this.clearConnectTimeout();
       this.ondisconnect(evt);
     };
 
-    this.adapter.onError = (evt: Event) => {
-      this.onerror(evt);
-    };
-
     this.adapter.onMessage = async (message: any) => {
       if (this.verbose && window && window.console) {
         console.log("Response: %o", JSON.stringify(message));
@@ -2130,16 +2149,20 @@ export class DefaultSocket implements Socket {
       }
     };
 
-    return new Promise((resolve, reject) => {
+    const connectPromise = new Promise<Session>((resolve, reject) => {
       this.adapter.onOpen = (evt: Event) => {
         if (this.verbose && window && window.console) {
           console.log(evt);
         }
 
-        const isReconnect = this.hasConnectedBefore;
-        this.hasConnectedBefore = true;
+        const isReconnect = __hasConnectedOnce;
+        __hasConnectedOnce = true;
 
-        this.pingPong();
+        this.clearConnectTimeout();
+        this._connectionState = ConnectionState.CONNECTED;
+        this.startHeartbeatLoop();
+        this._connectPromise = undefined;
+        
         resolve(session);
 
         if (isReconnect) {
@@ -2147,18 +2170,33 @@ export class DefaultSocket implements Socket {
         }
       };
       this.adapter.onError = (evt: Event) => {
-        reject(evt);
+        this._connectionState = ConnectionState.DISCONNECTED;
+        this.stopHeartbeatLoop();
+        this.clearConnectTimeout();
+        this.onerror(evt);
+        this._connectPromise = undefined;
         this.adapter.close();
+        reject(evt);
       };
 
-      setTimeout(() => {
+      this._connectTimeoutTimer = setTimeout(() => {
         // if promise has resolved by now, the reject() is a no-op
+        this._connectionState = ConnectionState.DISCONNECTED;
+        this.stopHeartbeatLoop();
+        this.adapter.close();
+        this._connectPromise = undefined;
         reject("The socket timed out when trying to connect.");
+        this._connectTimeoutTimer = undefined;
       }, connectTimeoutMs);
     });
+
+    this._connectPromise = connectPromise;
+    return this._connectPromise;
   }
 
   disconnect(fireDisconnectEvent: boolean = true) {
+    this._connectionState = ConnectionState.DISCONNECTED;
+    this.stopHeartbeatLoop();
     if (this.adapter.isOpen()) {
       this.adapter.close();
     }
@@ -2188,6 +2226,8 @@ export class DefaultSocket implements Socket {
   }
 
   onerror(evt: Event) {
+    this._connectionState = ConnectionState.DISCONNECTED;
+    this.stopHeartbeatLoop();
     if (this.verbose && window && window.console) {
       console.log(evt);
     }
@@ -2653,11 +2693,12 @@ export class DefaultSocket implements Socket {
 
         const cid = this.generatecid();
         this.cIds[cid] = { resolve, reject };
-        setTimeout(() => {
-          reject("The socket timed out while waiting for a response.");
-        }, sendTimeout);
+        if (sendTimeout !== Infinity && sendTimeout > 0) {
+          setTimeout(() => {
+            reject("The socket timed out while waiting for a response.");
+          }, sendTimeout);
+        }
 
-        /** Add id for promise executor. */
         untypedMessage.cid = cid;
         this.adapter.send(untypedMessage);
       }
@@ -2933,7 +2974,7 @@ export class DefaultSocket implements Socket {
         code: code,
         topic_id: topic_id,
       },
-    });
+    }, Infinity);
     return response.channel_message_ack;
   }
 
@@ -3212,13 +3253,17 @@ export class DefaultSocket implements Socket {
   }
 
   private async pingPong(): Promise<void> {
-    if (!this.adapter.isOpen()) {
+    if (!this.isOpen()) {
+      this._connectionState = ConnectionState.DISCONNECTED;
+      this.stopHeartbeatLoop();
       return;
     }
 
     try {
       await this.send({ ping: {} }, this._heartbeatTimeoutMs);
     } catch {
+      this._connectionState = ConnectionState.DISCONNECTED;
+      this.stopHeartbeatLoop();
       if (this.adapter.isOpen()) {
         if (window && window.console) {
           console.error("Server unreachable from heartbeat.");
@@ -3230,9 +3275,29 @@ export class DefaultSocket implements Socket {
       return;
     }
 
-    // reuse the timeout as the interval for now.
-    // we can separate them out into separate values if needed later.
-    setTimeout(() => this.pingPong(), this._heartbeatTimeoutMs);
+    this.startHeartbeatLoop();
+  }
+
+  private startHeartbeatLoop() {
+    this.stopHeartbeatLoop();
+    this._heartbeatTimer = setTimeout(
+      () => this.pingPong(),
+      this._heartbeatTimeoutMs
+    );
+  }
+
+  private stopHeartbeatLoop() {
+    if (this._heartbeatTimer !== undefined) {
+      clearTimeout(this._heartbeatTimer);
+      this._heartbeatTimer = undefined;
+    }
+  }
+
+  private clearConnectTimeout() {
+    if (this._connectTimeoutTimer !== undefined) {
+      clearTimeout(this._connectTimeoutTimer);
+      this._connectTimeoutTimer = undefined;
+    }
   }
 }