@koi-design/callkit 1.0.24 → 1.0.25

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { AxiosRequestConfig } from 'axios';
 import { Invitation, UserAgent, Registerer } from 'sip.js';
 
 declare class Api {
@@ -17,7 +18,9 @@ declare class Api {
      * @returns
      */
     setUserStatus(params: any): Promise<any>;
+    measureRTT(config?: AxiosRequestConfig): Promise<any>;
     private post;
+    private get;
 }
 
 declare class Call {
@@ -140,7 +143,14 @@ declare const KitEvent: {
      * User status change
      */
     USER_STATUS_CHANGE: string;
+    /**
+     * SOCKET CONNECT EVENT
+     */
     CONNECT_EVENT: string;
+    /**
+     * NETWORK EVENT
+     */
+    NETWORK_EVENT: string;
 };
 declare const SocketSendEvent: {
     /**
@@ -229,8 +239,11 @@ declare class Socket {
     private reconnectTimer?;
     private isReconnecting;
     private reconnectAttempts;
+    closing: boolean;
     constructor(callKit: CallKit);
     init(): void;
+    close(code?: number, reason?: string): void;
+    gracefulClose(): void;
     private reconnect;
     private connect;
     private onOpen;
@@ -254,6 +267,22 @@ declare class Socket {
     private attemptReconnect;
 }
 
+interface MonitorConfig {
+    interval: number;
+    apiEndpoint: string;
+}
+declare class Monitor {
+    private callKit;
+    interval: number;
+    apiEndpoint: string;
+    monitorIntervalHandler: ReturnType<typeof setInterval> | null;
+    constructor(callKit: CallKit);
+    getEndPointPath: () => string;
+    measureRTT: () => Promise<void>;
+    stopRTTMonitoring(): void;
+    startRTTMonitoring(): void;
+}
+
 interface WebrtcConstranis {
     audio: {
         autoGainControl?: boolean;
@@ -270,6 +299,7 @@ interface IConfig {
     constrains: WebrtcConstranis;
     socket: string;
     reconnect?: SocketConfig;
+    monitor?: MonitorConfig;
     userInfo: {
         wsUrl: string;
         sessionId: string;
@@ -456,6 +486,7 @@ declare class CallKit {
     connect: Connect;
     socket: Socket;
     user: User;
+    monitor: Monitor;
     listener: Listener[];
     constructor(options: ConfigEntity);
     login(username: string, password: string, extra?: {
@@ -474,6 +505,8 @@ declare class CallKit {
     setSleep(): Promise<void>;
     setBusy(): Promise<void>;
     reset(): Promise<void>;
+    startRTTMonitoring(): void;
+    stopRTTMonitoring(): void;
     on(event: kitEventType, callback: (...args: any[]) => void): void;
     off(event: kitEventType, callback?: (...args: any[]) => void): void;
     removeAllListeners(): void;

package/dist/index.global.js

@@ -3128,29 +3128,29 @@ var WebCall = (() => {
       var Axios = require_Axios();
       var mergeConfig = require_mergeConfig();
       var defaults = require_defaults();
-      function createInstance(defaultConfig) {
-        var context = new Axios(defaultConfig);
+      function createInstance(defaultConfig2) {
+        var context = new Axios(defaultConfig2);
         var instance2 = bind(Axios.prototype.request, context);
         utils.extend(instance2, Axios.prototype, context);
         utils.extend(instance2, context);
         instance2.create = function create(instanceConfig) {
-          return createInstance(mergeConfig(defaultConfig, instanceConfig));
+          return createInstance(mergeConfig(defaultConfig2, instanceConfig));
         };
         return instance2;
       }
-      var axios2 = createInstance(defaults);
-      axios2.Axios = Axios;
-      axios2.Cancel = require_Cancel();
-      axios2.CancelToken = require_CancelToken();
-      axios2.isCancel = require_isCancel();
-      axios2.VERSION = require_data().version;
-      axios2.all = function all(promises) {
+      var axios3 = createInstance(defaults);
+      axios3.Axios = Axios;
+      axios3.Cancel = require_Cancel();
+      axios3.CancelToken = require_CancelToken();
+      axios3.isCancel = require_isCancel();
+      axios3.VERSION = require_data().version;
+      axios3.all = function all(promises) {
         return Promise.all(promises);
       };
-      axios2.spread = require_spread();
-      axios2.isAxiosError = require_isAxiosError();
-      module.exports = axios2;
-      module.exports.default = axios2;
+      axios3.spread = require_spread();
+      axios3.isAxiosError = require_isAxiosError();
+      module.exports = axios3;
+      module.exports.default = axios3;
     }
   });
 
@@ -3216,6 +3216,10 @@ var WebCall = (() => {
         data: params
       });
     }
+    async measureRTT(config) {
+      this.callKit.logger.debug(`Request ${config.url}:`, config.data);
+      return axios_default(config);
+    }
     async post(config) {
       this.callKit.logger.debug(`Request ${config.url}:`, config.data);
       const { userInfo, host } = this.callKit.config.getConfig();
@@ -3247,6 +3251,12 @@ var WebCall = (() => {
       }
       throw new Error(message ?? "Request failed");
     }
+    async get(config) {
+      return this.post({
+        ...config,
+        method: "get"
+      });
+    }
   };
 
   // package/const.ts
@@ -3379,7 +3389,14 @@ var WebCall = (() => {
      * User status change
      */
     USER_STATUS_CHANGE: "userStatusChange",
-    CONNECT_EVENT: "CONNECT_EVENT"
+    /**
+     * SOCKET CONNECT EVENT
+     */
+    CONNECT_EVENT: "CONNECT_EVENT",
+    /**
+     * NETWORK EVENT
+     */
+    NETWORK_EVENT: "NETWORK_EVENT"
   };
   var ErrorCode = {
     /**
@@ -3601,7 +3618,13 @@ var WebCall = (() => {
     INCALL_RECONNECT_ERROR: "INCALL_RECONNECT_ERROR",
     INCALL_RECONNECT_SUCCESS: "INCALL_RECONNECT_SUCCESS",
     OPTIONS_HEARTBEAT_EXPIRED: "OPTIONS_HEARTBEAT_EXPIRED",
-    USER_AGENT_START_ERROR: "USER_AGENT_START_ERROR"
+    USER_AGENT_START_ERROR: "USER_AGENT_START_ERROR",
+    CONNECT_CLOSING: "CONNECT_CLOSING",
+    CONNECT_CLOSING_END: "CONNECT_CLOSING_END"
+  };
+  var NetWorkEvent = {
+    RTT_MEASURE_SUCCESS: "RTT_MEASURE_SUCCESS",
+    RTT_MEASURE_FAILED: "RTT_MEASURE_FAILED"
   };
 
   // package/call.ts
@@ -18917,6 +18940,59 @@ var WebCall = (() => {
     }
   };
 
+  // package/monitor.ts
+  var import_axios3 = __toESM(require_axios2());
+  var defaultConfig = {
+    interval: 5e3,
+    apiEndpoint: "/livez"
+  };
+  var Monitor = class {
+    callKit;
+    interval = defaultConfig.interval;
+    apiEndpoint = defaultConfig.apiEndpoint;
+    monitorIntervalHandler = null;
+    constructor(callKit) {
+      this.callKit = callKit;
+      const { monitor } = this.callKit.config.getConfig();
+      this.interval = monitor?.interval ?? defaultConfig.interval;
+      this.apiEndpoint = monitor?.apiEndpoint ?? defaultConfig.apiEndpoint;
+      this.monitorIntervalHandler = null;
+    }
+    getEndPointPath = () => {
+      const config = this.callKit.config.getConfig();
+      const defaultPath = `${config.host}${this.apiEndpoint}`;
+      const endPointPath = config.monitor?.apiEndpoint ?? defaultPath;
+      return endPointPath;
+    };
+    measureRTT = async () => {
+      try {
+        const endPoint = this.getEndPointPath();
+        const startTime = performance.now();
+        await import_axios3.default.get(endPoint);
+        const endTime = performance.now();
+        const rtt = Math.round(endTime - startTime);
+        this.callKit.trigger(KitEvent.NETWORK_EVENT, {
+          event: NetWorkEvent.RTT_MEASURE_SUCCESS,
+          rtt
+        });
+      } catch (error) {
+        this.callKit.trigger(KitEvent.NETWORK_EVENT, {
+          event: NetWorkEvent.RTT_MEASURE_FAILED,
+          rtt: 0
+        });
+      }
+    };
+    stopRTTMonitoring() {
+      if (this.monitorIntervalHandler) {
+        clearInterval(this.monitorIntervalHandler);
+      }
+    }
+    startRTTMonitoring() {
+      this.stopRTTMonitoring();
+      this.monitorIntervalHandler = setInterval(this.measureRTT, this.interval);
+    }
+  };
+
   // package/socket.ts
   var RECONNECT_CONFIG = {
     enabled: true,
@@ -18940,6 +19016,7 @@ var WebCall = (() => {
     reconnectTimer;
     isReconnecting = false;
     reconnectAttempts = 0;
+    closing = false;
     constructor(callKit) {
       this.callKit = callKit;
       const { reconnect } = this.callKit.config.getConfig();
@@ -18953,6 +19030,16 @@ var WebCall = (() => {
       this.callKit.logger.debug(`socket init: ${socket}`);
       this.connect(socket);
     }
+    close(code, reason) {
+      this.ws?.close(code, reason);
+    }
+    gracefulClose() {
+      this.closing = true;
+      this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+        event: ConnectEvent.CONNECT_CLOSING
+      });
+      this.close(1e3, "normal");
+    }
     reconnect(ev) {
       this.callKit.logger.debug("socket reconnect", ev);
       this.isConnected = false;
@@ -19018,6 +19105,10 @@ var WebCall = (() => {
         }
         this.callKit.connect.hangup();
         this.reset();
+        this.closing = false;
+        this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+          event: ConnectEvent.CONNECT_CLOSING_END
+        });
       }
     }
     onError(ev) {
@@ -19319,6 +19410,7 @@ var WebCall = (() => {
     connect;
     socket;
     user;
+    monitor;
     listener = [];
     constructor(options) {
       this.config = new Config(this);
@@ -19336,6 +19428,8 @@ var WebCall = (() => {
       );
       this.config.setConfig("reconnect", options.reconnect);
       this.logger = new Logger(this, options.log);
+      this.config.setConfig("monitor", options.monitor);
+      this.monitor = new Monitor(this);
       this.logger.debug("callKit init", options);
       this.api = new Api(this);
       this.connect = new Connect(this);
@@ -19405,6 +19499,9 @@ var WebCall = (() => {
       await this.user.setUserStatus(UserStatus.offline);
       if (this.config.isLogin()) {
         const { sessionId } = this.config.getConfig().userInfo;
+        this.unregister();
+        this.stop();
+        this.socket.gracefulClose();
         this.api.loginOut({ sessionId }).catch((err) => {
           this.logger.error(err, { errCode: ErrorCode.API_USER_LOGOUT_ERROR });
         });
@@ -19512,6 +19609,12 @@ var WebCall = (() => {
         await this.user.setUserStatus(UserStatus.offline);
       }
     }
+    startRTTMonitoring() {
+      this.monitor.startRTTMonitoring();
+    }
+    stopRTTMonitoring() {
+      this.monitor.stopRTTMonitoring();
+    }
     on(event, callback) {
       this.logger.debug(`on ${event}`);
       this.listener.push({