@koi-design/callkit 2.0.4 → 2.0.5-beta.1

package/dist/index.global.js

@@ -3668,6 +3668,18 @@ var WebCall = (() => {
     interval: 5e3,
     maxSize: 8192
   };
+  var SOCKET_RECONNECT_CONFIG = {
+    enabled: true,
+    maxAttempts: 3,
+    delay: 1e3,
+    pingInterval: 3e4,
+    pingTimeout: 5e3
+  };
+  var SIP_RECONNECT_CONFIG = {
+    enabled: true,
+    maxAttempts: 3,
+    delay: 1e3
+  };
 
   // core/call.ts
   var Call = class {
@@ -3810,14 +3822,14 @@ var WebCall = (() => {
   // package.json
   var package_default = {
     name: "@koi-design/callkit",
-    version: "2.0.4",
+    version: "2.0.5-beta.1",
     description: "callkit",
     author: "koi",
     license: "ISC",
     scripts: {
       build: "tsup",
-      "build:watch": "tsup --watch",
-      dev: "vite",
+      sraet: "vite",
+      dev: "tsup --watch",
       lint: "eslint -c ../../.eslintrc.js --ext .jsx,.js,.tsx,.ts ./package --fix",
       release: "tsup && node scripts/pkg.js"
     },
@@ -3874,6 +3886,10 @@ var WebCall = (() => {
       audioRef: void 0,
       constrains: constrainsDefault,
       socket: "",
+      reconnect: {
+        sip: SIP_RECONNECT_CONFIG,
+        incall: SOCKET_RECONNECT_CONFIG
+      },
       userInfo: {
         wsUrl: "",
         logGather: false,
@@ -3958,7 +3974,16 @@ var WebCall = (() => {
       return true;
     }
     getTrackLogsConfig() {
-      return this.config?.trackLogs ?? trackLogsDefaultConfig;
+      return {
+        ...trackLogsDefaultConfig,
+        ...this.config?.trackLogs
+      };
+    }
+    getReconnectConfig(type) {
+      const config = this.config?.reconnect?.[type] ?? (type === "sip" ? SIP_RECONNECT_CONFIG : SOCKET_RECONNECT_CONFIG);
+      return {
+        ...config
+      };
     }
     enableTrackLogs(enabled) {
       this.config.trackLogs.enabled = enabled;
@@ -18519,10 +18544,6 @@ var WebCall = (() => {
   };
 
   // core/connect.ts
-  var DEFAULT_RECONNECT_CONFIG = {
-    maxAttempts: 3,
-    delay: 500
-  };
   var MAX_HEARTBEAT_COUNT = 6;
   function convertObjectStringToJSON(input) {
     const corrected = input.replace(/(\w+):\s*'(.*?)'/g, '"$1": "$2"').replace(/'/g, '"');
@@ -18554,10 +18575,6 @@ var WebCall = (() => {
   };
   var Connect = class {
     callKit;
-    /**
-     *@description  Reconnect config
-     */
-    reconnectConfig;
     /**
      *@description  Whether muted
      */
@@ -18597,11 +18614,9 @@ var WebCall = (() => {
     hasInvite = false;
     constructor(callKit) {
       this.callKit = callKit;
-      const { reconnect = {} } = this.callKit.config.getConfig();
-      this.reconnectConfig = {
-        ...DEFAULT_RECONNECT_CONFIG,
-        ...reconnect
-      };
+    }
+    get reconnectConfig() {
+      return this.callKit.config.getReconnectConfig("sip");
     }
     // current call id for invite data
     currentCallId = null;
@@ -19110,7 +19125,6 @@ var WebCall = (() => {
           });
         },
         onDisconnect: (error) => {
-          console.log("onDisconnect", error);
           if (error) {
             this.callKit.logger.info("SIP User Agent Disconnected with error", {
               caller: "Connect.register",
@@ -19244,6 +19258,7 @@ var WebCall = (() => {
           }
         });
       });
+      this.setRegister(false);
     }
     async call(callback) {
       this.callKit.logger.info("connect call", {
@@ -19267,6 +19282,8 @@ var WebCall = (() => {
      * @param register
      */
     setRegister(register) {
+      if (this.isRegister === register)
+        return;
       this.callKit.logger.info("connect setRegister", {
         caller: "Connect.setRegister",
         type: "SIP",
@@ -19479,33 +19496,47 @@ var WebCall = (() => {
   };
 
   // core/socket.ts
-  var RECONNECT_CONFIG = {
-    enabled: true,
-    maxAttempts: 3,
-    delay: 1e3,
-    pingInterval: 3e4,
-    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;
+    /**
+     * @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
-      };
+    }
+    get reconnectConfig() {
+      return this.callKit.config.getReconnectConfig("incall");
     }
     init() {
       const { socket } = this.callKit.config.getConfig();
@@ -19518,19 +19549,22 @@ var WebCall = (() => {
       });
       this.connect(socket);
     }
+    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.reconnectConfig;
+      if (!this.callKit.config.isLogin() || !enabled) {
+        this.callKit.reset();
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_NOT_CONNECTED"
         });
         return;
       }
-      if (this.socketError) {
-        return;
-      }
-      if (this.isReconnecting) {
+      if (this.connectAuthState.isReconnecting) {
         return;
       }
       this.attemptReconnect();
@@ -19551,7 +19585,7 @@ var WebCall = (() => {
         });
       }
       this.ws = void 0;
-      this.isConnected = false;
+      this.setConnectAuthState("isConnected", false);
     }
     connect(socketUrl) {
       if (this.ws) {
@@ -19569,11 +19603,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",
@@ -19586,15 +19620,28 @@ 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);
         this.reconnectTimer = void 0;
       }
+      this.callKit.logger.info("reset connect state", {
+        caller: "Socket.resetConnectState",
+        type: "INCALL",
+        content: {
+          reconnectAttempts: this.reconnectAttempts,
+          connectAuthState: this.connectAuthState
+        }
+      });
     }
     onClose(ev) {
       this.callKit.logger.info("socket onClose", {
@@ -19605,7 +19652,6 @@ var WebCall = (() => {
       this.handleDisconnect();
     }
     onError(ev) {
-      this.socketError = true;
       this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
         event: "INCALL_CONNECT_ERROR",
         err: ev
@@ -19644,7 +19690,7 @@ var WebCall = (() => {
         });
         content = data.data;
       }
-      this.callKit.logger.info("socket onMessage", {
+      this.callKit.logger.info(`socket onMessage: ${data.event}`, {
         caller: "Socket.onMessage",
         type: "INCALL",
         content: {
@@ -19658,134 +19704,38 @@ var WebCall = (() => {
         return;
       }
       if (data.event === SocketReceiveEvent.START_CONFIRM) {
-        this.callKit.logger.info("start confirm success", {
-          caller: "Socket.onMessage",
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.START_CONFIRM
-          }
-        });
-        this.satrtConfirm = true;
-      }
-      if (data.event === SocketReceiveEvent.CALL_SUCCESS) {
-        this.callKit.logger.info("call success", {
-          caller: "Socket.onMessage",
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.CALL_SUCCESS
-          }
-        });
-      }
-      if (data.event === SocketReceiveEvent.CALL_FAILED) {
-        this.callKit.logger.info(data.msg, {
-          caller: "Socket.onMessage",
-          type: "INCALL",
-          content: {
-            data: content,
-            errCode: ErrorCode.SOCKET_CALL_ERROR
-          }
-        });
+        this.setConnectAuthState("satrtConfirm", true);
       }
       if (data.event === SocketReceiveEvent.CUSTOMER_RINGING) {
         this.callKit.trigger(KitEvent.CALL_RINGING, /* @__PURE__ */ new Date());
-        this.callKit.logger.info(data.msg, {
-          caller: `Socket.onMessage:${data.event}`,
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.CUSTOMER_RINGING
-          }
-        });
       }
       if (data.event === SocketReceiveEvent.CUSTOMER_PICK_UP) {
-        this.callKit.logger.info(data.msg, {
-          caller: "Socket.onMessage",
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.CUSTOMER_PICK_UP
-          }
-        });
         this.callKit.trigger(KitEvent.CALL_PICK_UP, /* @__PURE__ */ new Date());
       }
       if (data.event === SocketReceiveEvent.AGENT_PICK_UP) {
-        this.callKit.logger.info(data.msg, {
-          caller: "Socket.onMessage",
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.AGENT_PICK_UP
-          }
-        });
         this.callKit.trigger(KitEvent.AGENT_PICK_UP, /* @__PURE__ */ new Date());
       }
       if (data.event === SocketReceiveEvent.CUSTOMER_HANG_UP) {
-        this.callKit.logger.info(data.msg, {
-          caller: `Socket.onMessage:${data.event}`,
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.CUSTOMER_HANG_UP
-          }
-        });
         this.callKit.trigger(KitEvent.CALL_HANG_UP, /* @__PURE__ */ new Date());
         if (content?.callUuid) {
           this.callKit.connect.socketTriggerHangup(content.callUuid);
         }
       }
       if (data.event === SocketReceiveEvent.CUSTOMER_NO_ANSWER) {
-        this.callKit.logger.info(data.msg, {
-          caller: "Socket.onMessage",
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.CUSTOMER_NO_ANSWER
-          }
-        });
         this.callKit.trigger(KitEvent.CALL_NO_ANSWER);
         if (content?.callUuid) {
           this.callKit.connect.socketTriggerHangup(content.callUuid);
         }
       }
       if (data.event === SocketReceiveEvent.CALL_CDR) {
-        this.callKit.logger.info(data.msg, {
-          caller: `Socket.onMessage:${data.event}`,
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.CALL_CDR
-          }
-        });
         this.callKit.trigger(KitEvent.CALL_CDR, content);
       }
-      if (data.event === SocketReceiveEvent.STOP_CONFIRM) {
-        this.callKit.logger.info(data.msg, {
-          caller: `Socket.onMessage:${data.event}`,
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.STOP_CONFIRM
-          }
-        });
-      }
       if (data.event === SocketReceiveEvent.CLOSE) {
         const { userInfo } = this.callKit.config.getConfig();
-        this.callKit.logger.info(data.msg, {
-          caller: `Socket.onMessage:${data.event}`,
-          type: "INCALL",
-          content: {
-            data: content,
-            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}`,
@@ -19797,7 +19747,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}`,
@@ -19809,14 +19759,6 @@ var WebCall = (() => {
         });
       }
       if (data.event === SocketReceiveEvent.AGENT_NO_ANSWER) {
-        this.callKit.logger.info(data.msg, {
-          caller: `Socket.onMessage:${data.event}`,
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.AGENT_NO_ANSWER
-          }
-        });
         if (content?.callUuid) {
           this.callKit.connect.socketTriggerHangup(content.callUuid);
         }
@@ -19824,7 +19766,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"
         });
@@ -19883,23 +19825,16 @@ var WebCall = (() => {
       }
     }
     ping() {
-      if (!this.isConnected)
+      if (!this.connectAuthState.isConnected)
         return;
       this.send(SocketSendEvent.PING);
-      this.callKit.logger.info(`socket ping`, {
-        caller: "Socket.ping",
-        type: "INCALL",
-        content: {
-          lastPingTime: this.lastPingTime
-        }
-      });
       const now = Date.now();
-      const { pingInterval, pingTimeout } = this.socketConfig;
+      const { pingInterval, pingTimeout } = this.reconnectConfig;
       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",
@@ -19915,21 +19850,29 @@ var WebCall = (() => {
         clearInterval(this.pingTimer);
       }
       this.ping();
+      const { pingInterval } = this.reconnectConfig;
       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.setConnectAuthState("satrtConfirm", false);
       this.clearWebSocket();
     }
     attemptReconnect() {
@@ -19937,11 +19880,12 @@ var WebCall = (() => {
         clearTimeout(this.reconnectTimer);
         this.reconnectTimer = void 0;
       }
-      if (this.reconnectAttempts >= this.socketConfig.maxAttempts) {
+      const { maxAttempts } = this.reconnectConfig;
+      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",
@@ -19957,17 +19901,17 @@ var WebCall = (() => {
           event: "INCALL_RECONNECT_START"
         });
       }
-      this.isReconnecting = true;
+      this.setConnectAuthState("isReconnecting", true);
       this.reconnectAttempts += 1;
-      const { delay } = this.socketConfig;
+      const { delay } = this.reconnectConfig;
       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
           }
         }
@@ -19994,17 +19938,34 @@ var WebCall = (() => {
       this.connect = new Connect(this);
       this.callCenter = new Call(this);
       this.socket = new Socket(this);
-      this.config.setConfig("log", options.log);
-      this.config.setConfig("trackLogs", options.trackLogs);
-      this.config.setConfig("audioRef", options.audioRef);
-      this.config.setConfig("host", options.host);
+      this.logger = new Logger(this, options.log);
+      if (options.log) {
+        this.config.setConfig("log", options.log);
+      }
+      if (options.trackLogs) {
+        this.config.setConfig("trackLogs", {
+          ...trackLogsDefaultConfig,
+          ...options.trackLogs
+        });
+      }
+      if (options.audioRef) {
+        this.config.setConfig("audioRef", options.audioRef);
+      }
+      if (options.host) {
+        this.config.setConfig("host", options.host);
+      }
       this.config.setConfig(
         "constrains",
         options.constrains || constrainsDefault
       );
       this.config.setConfig("socket", options.socket);
-      this.config.setConfig("reconnect", options.reconnect);
-      this.logger = new Logger(this, options.log);
+      this.config.setConfig("reconnect", {
+        sip: { ...SIP_RECONNECT_CONFIG, ...options.reconnect?.sip || {} },
+        incall: {
+          ...SOCKET_RECONNECT_CONFIG,
+          ...options.reconnect?.incall || {}
+        }
+      });
       this.logger.info("callKit init", {
         caller: "CallKit.init",
         content: options
@@ -20042,6 +20003,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,
@@ -20093,7 +20061,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
@@ -20103,8 +20071,9 @@ var WebCall = (() => {
       }
       if (isReset) {
         await this.reset();
+      } else {
+        this.config.reset();
       }
-      this.trigger(KitEvent.KIT_LOGIN_CHANGE, false);
     }
     async call(extno = "", options = {
       sourceType: CallSourceType.phoneNum,
@@ -20169,9 +20138,6 @@ var WebCall = (() => {
       });
       this.connect.unregister();
     }
-    async stop() {
-      await this.connect.stop();
-    }
     async hangup() {
       if (!this.config.check())
         return;
@@ -20254,11 +20220,19 @@ var WebCall = (() => {
         userStatus: status
       });
     }
-    async reset() {
+    /**
+     * reset callkit
+     * @description recover the callkit to the initial state
+     * @default focus is false
+     * @param config.focus is true, the callkit reset socket connection and all states
+     */
+    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()) {
@@ -20267,9 +20241,10 @@ var WebCall = (() => {
       await this.connect.reset();
       if (this.config.isLogin()) {
         await this.logout({ isReset: false });
+      } else {
+        await this.config.reset();
       }
-      await this.config.reset();
-      await this.socket.reset();
+      await this.socket.reset({ focus });
     }
     on(event, callback) {
       this.listener.push({