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

package/dist/index.js

@@ -503,6 +503,18 @@ var trackLogsDefaultConfig = {
   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 {
@@ -645,14 +657,14 @@ var Call = class {
 // 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"
   },
@@ -709,6 +721,10 @@ var Config = class {
     audioRef: void 0,
     constrains: constrainsDefault,
     socket: "",
+    reconnect: {
+      sip: SIP_RECONNECT_CONFIG,
+      incall: SOCKET_RECONNECT_CONFIG
+    },
     userInfo: {
       wsUrl: "",
       logGather: false,
@@ -793,7 +809,16 @@ var Config = class {
     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;
@@ -956,10 +981,6 @@ var formatGetInviteData = (inviteData) => {
 };
 
 // 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, '"');
@@ -991,10 +1012,6 @@ var initUserMedia = () => {
 };
 var Connect = class {
   callKit;
-  /**
-   *@description  Reconnect config
-   */
-  reconnectConfig;
   /**
    *@description  Whether muted
    */
@@ -1034,11 +1051,9 @@ var Connect = class {
   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;
@@ -1547,7 +1562,6 @@ var Connect = class {
         });
       },
       onDisconnect: (error) => {
-        console.log("onDisconnect", error);
         if (error) {
           this.callKit.logger.info("SIP User Agent Disconnected with error", {
             caller: "Connect.register",
@@ -1681,6 +1695,7 @@ var Connect = class {
         }
       });
     });
+    this.setRegister(false);
   }
   async call(callback) {
     this.callKit.logger.info("connect call", {
@@ -1704,6 +1719,8 @@ var Connect = class {
    * @param register
    */
   setRegister(register) {
+    if (this.isRegister === register)
+      return;
     this.callKit.logger.info("connect setRegister", {
       caller: "Connect.setRegister",
       type: "SIP",
@@ -1916,33 +1933,47 @@ var Connect = class {
 };
 
 // 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();
@@ -1955,19 +1986,22 @@ var Socket = class {
     });
     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();
@@ -1988,7 +2022,7 @@ var Socket = class {
       });
     }
     this.ws = void 0;
-    this.isConnected = false;
+    this.setConnectAuthState("isConnected", false);
   }
   connect(socketUrl) {
     if (this.ws) {
@@ -2006,11 +2040,11 @@ var Socket = class {
       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",
@@ -2023,15 +2057,28 @@ var Socket = class {
         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", {
@@ -2042,7 +2089,6 @@ var Socket = class {
     this.handleDisconnect();
   }
   onError(ev) {
-    this.socketError = true;
     this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
       event: "INCALL_CONNECT_ERROR",
       err: ev
@@ -2081,7 +2127,7 @@ var Socket = class {
       });
       content = data.data;
     }
-    this.callKit.logger.info("socket onMessage", {
+    this.callKit.logger.info(`socket onMessage: ${data.event}`, {
       caller: "Socket.onMessage",
       type: "INCALL",
       content: {
@@ -2095,134 +2141,38 @@ var Socket = class {
       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}`,
@@ -2234,7 +2184,7 @@ var Socket = class {
       });
     }
     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}`,
@@ -2246,14 +2196,6 @@ var Socket = class {
       });
     }
     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);
       }
@@ -2261,7 +2203,7 @@ var Socket = class {
     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"
       });
@@ -2320,23 +2262,16 @@ var Socket = class {
     }
   }
   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",
@@ -2352,21 +2287,29 @@ var Socket = class {
       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() {
@@ -2374,11 +2317,12 @@ var Socket = class {
       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",
@@ -2394,17 +2338,17 @@ var Socket = class {
         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
         }
       }
@@ -2431,17 +2375,34 @@ var CallKit = class {
     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
@@ -2479,6 +2440,13 @@ var CallKit = class {
         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,
@@ -2530,7 +2498,7 @@ var CallKit = class {
       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
@@ -2540,8 +2508,9 @@ var CallKit = class {
     }
     if (isReset) {
       await this.reset();
+    } else {
+      this.config.reset();
     }
-    this.trigger(KitEvent.KIT_LOGIN_CHANGE, false);
   }
   async call(extno = "", options = {
     sourceType: CallSourceType.phoneNum,
@@ -2606,9 +2575,6 @@ var CallKit = class {
     });
     this.connect.unregister();
   }
-  async stop() {
-    await this.connect.stop();
-  }
   async hangup() {
     if (!this.config.check())
       return;
@@ -2691,11 +2657,19 @@ var CallKit = class {
       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()) {
@@ -2704,9 +2678,10 @@ var CallKit = class {
     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({