@koi-design/callkit 2.0.3 → 2.0.5

package/dist/index.d.ts

@@ -55,32 +55,44 @@ interface SocketConfig {
     enabled: boolean;
     maxAttempts: number;
     delay: number;
-    backoffMultiplier: number;
     pingInterval: number;
     pingTimeout: number;
-    maxConnectsPerWindow?: number;
-    timeWindow?: number;
 }
 declare class Socket {
     private callKit;
     private ws?;
-    private socketConfig;
     lastPingTime: any;
-    isConnected: boolean;
     pingTimer?: ReturnType<typeof setInterval>;
-    satrtConfirm: boolean;
+    /**
+     * @description reconnect timer
+     */
     private reconnectTimer?;
-    private isReconnecting;
+    /**
+     * @description reconnect attempts
+     */
     private reconnectAttempts;
-    private socketError;
-    private connectAttemptTimes;
+    /**
+     * @description connect auth state
+     * @default {
+     *   satrtConfirm: false,
+     *   isConnected: false,
+     *   isReconnecting: false,
+     *   isAuthenticated: false,
+     *   isError: false
+     * }
+     */
+    private connectAuthState;
+    get satrtConfirm(): boolean;
+    get isError(): boolean;
     constructor(callKit: CallKit);
     init(): void;
+    private getSocketConfig;
+    private setConnectAuthState;
     private handleDisconnect;
     private clearWebSocket;
     private connect;
     private onOpen;
-    private resetReconnectState;
+    private resetConnectState;
     private onClose;
     private onError;
     private confirmAck;
@@ -91,7 +103,9 @@ declare class Socket {
     /**
      * reset socket connection and all states
      */
-    reset(): Promise<void>;
+    reset(config?: {
+        focus?: boolean;
+    }): Promise<void>;
     private attemptReconnect;
 }
 
@@ -504,7 +518,6 @@ declare class CallKit {
     refer(uri: string, options?: any): Promise<void>;
     register(): Promise<void>;
     unregister(): Promise<void>;
-    stop(): Promise<void>;
     hangup(): Promise<void>;
     hold(): void;
     unhold(): void;
@@ -515,6 +528,13 @@ declare class CallKit {
      * @param status
      */
     setUserStatus(status: number): Promise<void>;
+    protected _reset(config?: {
+        focus?: boolean;
+    }): Promise<void>;
+    /**
+     * reset callkit
+     * @description recover the callkit to the initial state
+     */
     reset(): Promise<void>;
     on(event: kitEventType, callback: (...args: any[]) => void): void;
     off(event: kitEventType, callback?: (...args: any[]) => void): void;

package/dist/index.global.js

@@ -3810,12 +3810,13 @@ var WebCall = (() => {
   // package.json
   var package_default = {
     name: "@koi-design/callkit",
-    version: "2.0.3",
+    version: "2.0.5",
     description: "callkit",
     author: "koi",
     license: "ISC",
     scripts: {
       build: "tsup",
+      "build:w": "tsup --watch",
       dev: "vite",
       lint: "eslint -c ../../.eslintrc.js --ext .jsx,.js,.tsx,.ts ./package --fix",
       release: "tsup && node scripts/pkg.js"
@@ -19481,36 +19482,48 @@ var WebCall = (() => {
   var RECONNECT_CONFIG = {
     enabled: true,
     maxAttempts: 3,
-    delay: 500,
-    backoffMultiplier: 1.5,
+    delay: 1e3,
     pingInterval: 3e4,
-    pingTimeout: 5e3,
-    maxConnectsPerWindow: 5,
-    timeWindow: 6e4
-    // 60 seconds
+    pingTimeout: 5e3
   };
   var Socket = class {
     callKit;
     ws;
-    socketConfig;
     lastPingTime = void 0;
-    isConnected = false;
     pingTimer;
-    // Whether received start confirmation
-    satrtConfirm = false;
+    /**
+     * @description reconnect timer
+     */
     reconnectTimer;
-    isReconnecting = false;
+    /**
+     * @description reconnect attempts
+     */
     reconnectAttempts = 0;
-    socketError = false;
-    // Track connection attempts for rate limiting
-    connectAttemptTimes = [];
+    /**
+     * @description connect auth state
+     * @default {
+     *   satrtConfirm: false,
+     *   isConnected: false,
+     *   isReconnecting: false,
+     *   isAuthenticated: false,
+     *   isError: false
+     * }
+     */
+    connectAuthState = {
+      satrtConfirm: false,
+      isConnected: false,
+      isReconnecting: false,
+      isAuthenticated: false,
+      isError: false
+    };
+    get satrtConfirm() {
+      return this.connectAuthState.satrtConfirm;
+    }
+    get isError() {
+      return this.connectAuthState.isError;
+    }
     constructor(callKit) {
       this.callKit = callKit;
-      const { reconnect } = this.callKit.config.getConfig();
-      this.socketConfig = {
-        ...RECONNECT_CONFIG,
-        ...reconnect
-      };
     }
     init() {
       const { socket } = this.callKit.config.getConfig();
@@ -19523,16 +19536,29 @@ var WebCall = (() => {
       });
       this.connect(socket);
     }
+    getSocketConfig() {
+      const { reconnect } = this.callKit.config.getConfig();
+      return {
+        ...RECONNECT_CONFIG,
+        ...reconnect
+      };
+    }
+    setConnectAuthState(key, value) {
+      if (this.connectAuthState[key] === value)
+        return;
+      this.connectAuthState[key] = value;
+    }
     handleDisconnect() {
-      this.isConnected = false;
-      if (!this.callKit.config.isLogin() || !this.socketConfig.enabled) {
-        this.reset();
+      this.setConnectAuthState("isConnected", false);
+      const { enabled } = this.getSocketConfig();
+      if (!this.callKit.config.isLogin() || !enabled) {
+        this.callKit.reset();
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_NOT_CONNECTED"
         });
         return;
       }
-      if (this.isReconnecting) {
+      if (this.connectAuthState.isReconnecting) {
         return;
       }
       this.attemptReconnect();
@@ -19553,13 +19579,12 @@ var WebCall = (() => {
         });
       }
       this.ws = void 0;
-      this.isConnected = false;
+      this.setConnectAuthState("isConnected", false);
     }
     connect(socketUrl) {
       if (this.ws) {
         this.clearWebSocket();
       }
-      this.connectAttemptTimes.push(Date.now());
       this.ws = new WebSocket(socketUrl);
       this.ws.onopen = (ev) => this.onOpen(ev);
       this.ws.onclose = (ev) => this.onClose(ev);
@@ -19572,11 +19597,11 @@ var WebCall = (() => {
         type: "INCALL",
         content: { ev }
       });
-      this.socketError = false;
-      this.isConnected = true;
+      this.setConnectAuthState("isConnected", true);
       this.lastPingTime = Date.now();
       this.checkPing();
-      if (this.isReconnecting) {
+      if (this.connectAuthState.isReconnecting) {
+        this.setConnectAuthState("isReconnecting", false);
         this.callKit.logger.info("reconnect success", {
           caller: "Socket.onOpen",
           type: "INCALL",
@@ -19589,10 +19614,15 @@ var WebCall = (() => {
           event: "INCALL_RECONNECT_SUCCESS"
         });
       }
-      this.resetReconnectState();
     }
-    resetReconnectState() {
-      this.isReconnecting = false;
+    resetConnectState() {
+      this.connectAuthState = {
+        satrtConfirm: false,
+        isConnected: false,
+        isReconnecting: false,
+        isAuthenticated: false,
+        isError: false
+      };
       this.reconnectAttempts = 0;
       if (this.reconnectTimer) {
         clearTimeout(this.reconnectTimer);
@@ -19605,13 +19635,9 @@ var WebCall = (() => {
         type: "INCALL",
         content: { ev }
       });
-      if (this.socketError) {
-        return;
-      }
       this.handleDisconnect();
     }
     onError(ev) {
-      this.socketError = true;
       this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
         event: "INCALL_CONNECT_ERROR",
         err: ev
@@ -19661,6 +19687,20 @@ var WebCall = (() => {
       this.confirmAck(data);
       if (data.event === SocketReceiveEvent.PONG) {
         this.lastPingTime = Date.now();
+        this.setConnectAuthState("isAuthenticated", true);
+        this.callKit.logger.info("socket onMessage pong Authenticated", {
+          caller: "Socket.onMessage",
+          type: "INCALL",
+          content: {
+            data: content,
+            event: SocketReceiveEvent.PONG,
+            isAuthenticated: true
+          }
+        });
+        this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
+          event: "INCALL_AUTHENTICATED",
+          isAuthenticated: true
+        });
         return;
       }
       if (data.event === SocketReceiveEvent.START_CONFIRM) {
@@ -19672,7 +19712,7 @@ var WebCall = (() => {
             event: SocketReceiveEvent.START_CONFIRM
           }
         });
-        this.satrtConfirm = true;
+        this.setConnectAuthState("satrtConfirm", true);
       }
       if (data.event === SocketReceiveEvent.CALL_SUCCESS) {
         this.callKit.logger.info("call success", {
@@ -19786,12 +19826,10 @@ var WebCall = (() => {
             event: SocketReceiveEvent.CLOSE
           }
         });
-        this.send(SocketSendEvent.END, {
-          agentId: userInfo.agentId
-        });
+        this.send(SocketSendEvent.END, { agentId: userInfo.agentId });
       }
       if (data.event === SocketReceiveEvent.ERROR) {
-        this.socketError = true;
+        this.setConnectAuthState("isError", true);
         this.callKit.reset();
         this.callKit.logger.error(data.msg, {
           caller: `Socket.onMessage:${data.event}`,
@@ -19803,7 +19841,7 @@ var WebCall = (() => {
         });
       }
       if (data.event === SocketReceiveEvent.SESSION_ERROR) {
-        this.socketError = true;
+        this.setConnectAuthState("isError", true);
         this.callKit.reset();
         this.callKit.logger.error(data.msg, {
           caller: `Socket.onMessage:${data.event}`,
@@ -19830,7 +19868,7 @@ var WebCall = (() => {
       this.callKit.trigger(KitEvent.SERVER_SOCKET_EVENT, data);
     }
     send(event, message) {
-      if (!this.isConnected) {
+      if (!this.connectAuthState.isConnected) {
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_NOT_CONNECTED"
         });
@@ -19889,7 +19927,7 @@ var WebCall = (() => {
       }
     }
     ping() {
-      if (!this.isConnected)
+      if (!this.connectAuthState.isConnected)
         return;
       this.send(SocketSendEvent.PING);
       this.callKit.logger.info(`socket ping`, {
@@ -19900,12 +19938,12 @@ var WebCall = (() => {
         }
       });
       const now = Date.now();
-      const { pingInterval, pingTimeout } = this.socketConfig;
+      const { pingInterval, pingTimeout } = this.getSocketConfig();
       if (now - this.lastPingTime > pingInterval + pingTimeout) {
-        if (this.ws && this.isConnected) {
+        if (this.ws && this.connectAuthState.isConnected) {
           this.ws.close(4001, "ping timeout");
         } else {
-          this.reset();
+          this.callKit.reset();
         }
         this.callKit.logger.error("socket ping timeout", {
           caller: "Socket.ping",
@@ -19921,23 +19959,29 @@ var WebCall = (() => {
         clearInterval(this.pingTimer);
       }
       this.ping();
+      const { pingInterval } = this.getSocketConfig();
       this.pingTimer = setInterval(() => {
         this.ping();
-      }, this.socketConfig.pingInterval);
+      }, pingInterval);
     }
     /**
      * reset socket connection and all states
      */
-    async reset() {
+    async reset(config) {
+      const { focus = false } = config || {};
       if (this.pingTimer) {
         clearInterval(this.pingTimer);
         this.pingTimer = void 0;
       }
-      this.resetReconnectState();
+      if (focus) {
+        this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
+          event: "INCALL_RESET"
+        });
+        this.resetConnectState();
+        this.setConnectAuthState("isConnected", false);
+      }
       this.lastPingTime = void 0;
-      this.satrtConfirm = false;
-      this.socketError = false;
-      this.connectAttemptTimes = [];
+      this.setConnectAuthState("satrtConfirm", false);
       this.clearWebSocket();
     }
     attemptReconnect() {
@@ -19945,34 +19989,12 @@ var WebCall = (() => {
         clearTimeout(this.reconnectTimer);
         this.reconnectTimer = void 0;
       }
-      const { maxConnectsPerWindow, timeWindow } = this.socketConfig;
-      if (maxConnectsPerWindow && timeWindow) {
-        const now = Date.now();
-        this.connectAttemptTimes = this.connectAttemptTimes.filter(
-          (time) => now - time < timeWindow
-        );
-        if (this.connectAttemptTimes.length >= maxConnectsPerWindow) {
-          this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
-            event: "INCALL_RECONNECT_ERROR"
-          });
-          this.callKit.logger.warn("Connection rate limit exceeded", {
-            caller: "Socket.attemptReconnect",
-            type: "INCALL",
-            content: {
-              errCode: ErrorCode.SOCKET_RECONNECT_FAILED,
-              attempts: this.connectAttemptTimes.length,
-              maxConnectsPerWindow,
-              timeWindow
-            }
-          });
-          return;
-        }
-      }
-      if (this.reconnectAttempts >= this.socketConfig.maxAttempts) {
+      const { maxAttempts } = this.getSocketConfig();
+      if (this.reconnectAttempts >= maxAttempts) {
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_RECONNECT_ERROR"
         });
-        this.reset();
+        this.callKit.reset();
         this.callKit.logger.error("Maximum reconnection attempts reached", {
           caller: "Socket.attemptReconnect",
           type: "INCALL",
@@ -19988,17 +20010,17 @@ var WebCall = (() => {
           event: "INCALL_RECONNECT_START"
         });
       }
-      this.isReconnecting = true;
+      this.setConnectAuthState("isReconnecting", true);
       this.reconnectAttempts += 1;
-      const { delay } = this.socketConfig;
+      const { delay } = this.getSocketConfig();
       this.callKit.logger.info(
-        `Preparing reconnection attempt ${this.reconnectAttempts}/${this.socketConfig.maxAttempts}, delay: ${delay}ms`,
+        `Preparing reconnection attempt ${this.reconnectAttempts}/${maxAttempts}, delay: ${delay}ms`,
         {
           caller: "Socket.attemptReconnect",
           type: "INCALL",
           content: {
             reconnectAttempts: this.reconnectAttempts,
-            maxAttempts: this.socketConfig.maxAttempts,
+            maxAttempts,
             delay
           }
         }
@@ -20073,6 +20095,13 @@ var WebCall = (() => {
           encryptionPassword
         }
       });
+      if (this.socket.isError) {
+        this.logger.warn("socket is error", {
+          caller: "CallKit.login",
+          content: { username, password, extra, socketError: this.socket.isError }
+        });
+        return;
+      }
       try {
         const user = await this.api.login({
           userName: username,
@@ -20124,7 +20153,7 @@ var WebCall = (() => {
         try {
           await this.api.loginOut({ sessionId });
         } catch (error) {
-          this.logger.error(error, {
+          this.logger.warn(error, {
             caller: "CallKit.logout",
             content: {
               errCode: ErrorCode.API_USER_LOGOUT_ERROR
@@ -20200,9 +20229,6 @@ var WebCall = (() => {
       });
       this.connect.unregister();
     }
-    async stop() {
-      await this.connect.stop();
-    }
     async hangup() {
       if (!this.config.check())
         return;
@@ -20285,11 +20311,13 @@ var WebCall = (() => {
         userStatus: status
       });
     }
-    async reset() {
+    async _reset(config) {
+      const { focus = false } = config || {};
       this.logger.info("reset", {
         caller: "CallKit.reset",
         content: {
-          connectStatus: this.connect.connectStatus
+          connectStatus: this.connect.connectStatus,
+          focus
         }
       });
       if (this.connect.isCalling()) {
@@ -20300,7 +20328,14 @@ var WebCall = (() => {
         await this.logout({ isReset: false });
       }
       await this.config.reset();
-      await this.socket.reset();
+      await this.socket.reset({ focus });
+    }
+    /**
+     * reset callkit
+     * @description recover the callkit to the initial state
+     */
+    async reset() {
+      await this._reset({ focus: true });
     }
     on(event, callback) {
       this.listener.push({