@koi-design/callkit 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/index.d.ts

@@ -473,7 +473,7 @@ declare class CallKit {
      * set userstatus
      * @param status
      */
-    setUserStatus(status: number): void;
+    setUserStatus(status: number): Promise<void>;
     reset(): Promise<void>;
     on(event: kitEventType, callback: (...args: any[]) => void): void;
     off(event: kitEventType, callback?: (...args: any[]) => void): void;

package/dist/index.global.js

@@ -1083,16 +1083,16 @@ var WebCall = (() => {
         createDebug.names = [];
         createDebug.skips = [];
         createDebug.formatters = {};
-        function selectColor(namespace2) {
+        function selectColor(namespace) {
           let hash = 0;
-          for (let i = 0; i < namespace2.length; i++) {
-            hash = (hash << 5) - hash + namespace2.charCodeAt(i);
+          for (let i = 0; i < namespace.length; i++) {
+            hash = (hash << 5) - hash + namespace.charCodeAt(i);
             hash |= 0;
           }
           return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
         }
         createDebug.selectColor = selectColor;
-        function createDebug(namespace2) {
+        function createDebug(namespace) {
           let prevTime;
           let enableOverride = null;
           let namespacesCache;
@@ -1131,9 +1131,9 @@ var WebCall = (() => {
             const logFn = self.log || createDebug.log;
             logFn.apply(self, args);
           }
-          debug.namespace = namespace2;
+          debug.namespace = namespace;
           debug.useColors = createDebug.useColors();
-          debug.color = createDebug.selectColor(namespace2);
+          debug.color = createDebug.selectColor(namespace);
           debug.extend = extend;
           debug.destroy = createDebug.destroy;
           Object.defineProperty(debug, "enabled", {
@@ -1145,7 +1145,7 @@ var WebCall = (() => {
               }
               if (namespacesCache !== createDebug.namespaces) {
                 namespacesCache = createDebug.namespaces;
-                enabledCache = createDebug.enabled(namespace2);
+                enabledCache = createDebug.enabled(namespace);
               }
               return enabledCache;
             },
@@ -1158,8 +1158,8 @@ var WebCall = (() => {
           }
           return debug;
         }
-        function extend(namespace2, delimiter) {
-          const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace2);
+        function extend(namespace, delimiter) {
+          const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
           newDebug.log = this.log;
           return newDebug;
         }
@@ -1208,7 +1208,7 @@ var WebCall = (() => {
         function disable() {
           const namespaces = [
             ...createDebug.names,
-            ...createDebug.skips.map((namespace2) => "-" + namespace2)
+            ...createDebug.skips.map((namespace) => "-" + namespace)
           ].join(",");
           createDebug.enable("");
           return namespaces;
@@ -3161,47 +3161,6 @@ var WebCall = (() => {
     }
   });
 
-  // node_modules/.pnpm/is-retry-allowed@2.2.0/node_modules/is-retry-allowed/index.js
-  var require_is_retry_allowed = __commonJS({
-    "node_modules/.pnpm/is-retry-allowed@2.2.0/node_modules/is-retry-allowed/index.js"(exports, module) {
-      "use strict";
-      var denyList = /* @__PURE__ */ new Set([
-        "ENOTFOUND",
-        "ENETUNREACH",
-        // SSL errors from https://github.com/nodejs/node/blob/fc8e3e2cdc521978351de257030db0076d79e0ab/src/crypto/crypto_common.cc#L301-L328
-        "UNABLE_TO_GET_ISSUER_CERT",
-        "UNABLE_TO_GET_CRL",
-        "UNABLE_TO_DECRYPT_CERT_SIGNATURE",
-        "UNABLE_TO_DECRYPT_CRL_SIGNATURE",
-        "UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY",
-        "CERT_SIGNATURE_FAILURE",
-        "CRL_SIGNATURE_FAILURE",
-        "CERT_NOT_YET_VALID",
-        "CERT_HAS_EXPIRED",
-        "CRL_NOT_YET_VALID",
-        "CRL_HAS_EXPIRED",
-        "ERROR_IN_CERT_NOT_BEFORE_FIELD",
-        "ERROR_IN_CERT_NOT_AFTER_FIELD",
-        "ERROR_IN_CRL_LAST_UPDATE_FIELD",
-        "ERROR_IN_CRL_NEXT_UPDATE_FIELD",
-        "OUT_OF_MEM",
-        "DEPTH_ZERO_SELF_SIGNED_CERT",
-        "SELF_SIGNED_CERT_IN_CHAIN",
-        "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
-        "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
-        "CERT_CHAIN_TOO_LONG",
-        "CERT_REVOKED",
-        "INVALID_CA",
-        "PATH_LENGTH_EXCEEDED",
-        "INVALID_PURPOSE",
-        "CERT_UNTRUSTED",
-        "CERT_REJECTED",
-        "HOSTNAME_MISMATCH"
-      ]);
-      module.exports = (error) => !denyList.has(error && error.code);
-    }
-  });
-
   // node_modules/.pnpm/json-stringify-safe@5.0.1/node_modules/json-stringify-safe/stringify.js
   var require_stringify = __commonJS({
     "node_modules/.pnpm/json-stringify-safe@5.0.1/node_modules/json-stringify-safe/stringify.js"(exports, module) {
@@ -3242,189 +3201,6 @@ var WebCall = (() => {
 
   // package/axios.ts
   var import_axios = __toESM(require_axios2());
-
-  // node_modules/.pnpm/axios-retry@4.5.0_axios@0.26.1/node_modules/axios-retry/dist/esm/index.js
-  var import_is_retry_allowed = __toESM(require_is_retry_allowed(), 1);
-  var namespace = "axios-retry";
-  function isNetworkError(error) {
-    const CODE_EXCLUDE_LIST = ["ERR_CANCELED", "ECONNABORTED"];
-    if (error.response) {
-      return false;
-    }
-    if (!error.code) {
-      return false;
-    }
-    if (CODE_EXCLUDE_LIST.includes(error.code)) {
-      return false;
-    }
-    return (0, import_is_retry_allowed.default)(error);
-  }
-  var SAFE_HTTP_METHODS = ["get", "head", "options"];
-  var IDEMPOTENT_HTTP_METHODS = SAFE_HTTP_METHODS.concat(["put", "delete"]);
-  function isRetryableError(error) {
-    return error.code !== "ECONNABORTED" && (!error.response || error.response.status === 429 || error.response.status >= 500 && error.response.status <= 599);
-  }
-  function isSafeRequestError(error) {
-    if (!error.config?.method) {
-      return false;
-    }
-    return isRetryableError(error) && SAFE_HTTP_METHODS.indexOf(error.config.method) !== -1;
-  }
-  function isIdempotentRequestError(error) {
-    if (!error.config?.method) {
-      return false;
-    }
-    return isRetryableError(error) && IDEMPOTENT_HTTP_METHODS.indexOf(error.config.method) !== -1;
-  }
-  function isNetworkOrIdempotentRequestError(error) {
-    return isNetworkError(error) || isIdempotentRequestError(error);
-  }
-  function retryAfter(error = void 0) {
-    const retryAfterHeader = error?.response?.headers["retry-after"];
-    if (!retryAfterHeader) {
-      return 0;
-    }
-    let retryAfterMs = (Number(retryAfterHeader) || 0) * 1e3;
-    if (retryAfterMs === 0) {
-      retryAfterMs = (new Date(retryAfterHeader).valueOf() || 0) - Date.now();
-    }
-    return Math.max(0, retryAfterMs);
-  }
-  function noDelay(_retryNumber = 0, error = void 0) {
-    return Math.max(0, retryAfter(error));
-  }
-  function exponentialDelay(retryNumber = 0, error = void 0, delayFactor = 100) {
-    const calculatedDelay = 2 ** retryNumber * delayFactor;
-    const delay = Math.max(calculatedDelay, retryAfter(error));
-    const randomSum = delay * 0.2 * Math.random();
-    return delay + randomSum;
-  }
-  function linearDelay(delayFactor = 100) {
-    return (retryNumber = 0, error = void 0) => {
-      const delay = retryNumber * delayFactor;
-      return Math.max(delay, retryAfter(error));
-    };
-  }
-  var DEFAULT_OPTIONS = {
-    retries: 3,
-    retryCondition: isNetworkOrIdempotentRequestError,
-    retryDelay: noDelay,
-    shouldResetTimeout: false,
-    onRetry: () => {
-    },
-    onMaxRetryTimesExceeded: () => {
-    },
-    validateResponse: null
-  };
-  function getRequestOptions(config, defaultOptions) {
-    return { ...DEFAULT_OPTIONS, ...defaultOptions, ...config[namespace] };
-  }
-  function setCurrentState(config, defaultOptions, resetLastRequestTime = false) {
-    const currentState = getRequestOptions(config, defaultOptions || {});
-    currentState.retryCount = currentState.retryCount || 0;
-    if (!currentState.lastRequestTime || resetLastRequestTime) {
-      currentState.lastRequestTime = Date.now();
-    }
-    config[namespace] = currentState;
-    return currentState;
-  }
-  function fixConfig(axiosInstance, config) {
-    if (axiosInstance.defaults.agent === config.agent) {
-      delete config.agent;
-    }
-    if (axiosInstance.defaults.httpAgent === config.httpAgent) {
-      delete config.httpAgent;
-    }
-    if (axiosInstance.defaults.httpsAgent === config.httpsAgent) {
-      delete config.httpsAgent;
-    }
-  }
-  async function shouldRetry(currentState, error) {
-    const { retries, retryCondition } = currentState;
-    const shouldRetryOrPromise = (currentState.retryCount || 0) < retries && retryCondition(error);
-    if (typeof shouldRetryOrPromise === "object") {
-      try {
-        const shouldRetryPromiseResult = await shouldRetryOrPromise;
-        return shouldRetryPromiseResult !== false;
-      } catch (_err) {
-        return false;
-      }
-    }
-    return shouldRetryOrPromise;
-  }
-  async function handleRetry(axiosInstance, currentState, error, config) {
-    currentState.retryCount += 1;
-    const { retryDelay, shouldResetTimeout, onRetry } = currentState;
-    const delay = retryDelay(currentState.retryCount, error);
-    fixConfig(axiosInstance, config);
-    if (!shouldResetTimeout && config.timeout && currentState.lastRequestTime) {
-      const lastRequestDuration = Date.now() - currentState.lastRequestTime;
-      const timeout = config.timeout - lastRequestDuration - delay;
-      if (timeout <= 0) {
-        return Promise.reject(error);
-      }
-      config.timeout = timeout;
-    }
-    config.transformRequest = [(data) => data];
-    await onRetry(currentState.retryCount, error, config);
-    if (config.signal?.aborted) {
-      return Promise.resolve(axiosInstance(config));
-    }
-    return new Promise((resolve) => {
-      const abortListener = () => {
-        clearTimeout(timeout);
-        resolve(axiosInstance(config));
-      };
-      const timeout = setTimeout(() => {
-        resolve(axiosInstance(config));
-        if (config.signal?.removeEventListener) {
-          config.signal.removeEventListener("abort", abortListener);
-        }
-      }, delay);
-      if (config.signal?.addEventListener) {
-        config.signal.addEventListener("abort", abortListener, { once: true });
-      }
-    });
-  }
-  async function handleMaxRetryTimesExceeded(currentState, error) {
-    if (currentState.retryCount >= currentState.retries)
-      await currentState.onMaxRetryTimesExceeded(error, currentState.retryCount);
-  }
-  var axiosRetry = (axiosInstance, defaultOptions) => {
-    const requestInterceptorId = axiosInstance.interceptors.request.use((config) => {
-      setCurrentState(config, defaultOptions, true);
-      if (config[namespace]?.validateResponse) {
-        config.validateStatus = () => false;
-      }
-      return config;
-    });
-    const responseInterceptorId = axiosInstance.interceptors.response.use(null, async (error) => {
-      const { config } = error;
-      if (!config) {
-        return Promise.reject(error);
-      }
-      const currentState = setCurrentState(config, defaultOptions);
-      if (error.response && currentState.validateResponse?.(error.response)) {
-        return error.response;
-      }
-      if (await shouldRetry(currentState, error)) {
-        return handleRetry(axiosInstance, currentState, error, config);
-      }
-      await handleMaxRetryTimesExceeded(currentState, error);
-      return Promise.reject(error);
-    });
-    return { requestInterceptorId, responseInterceptorId };
-  };
-  axiosRetry.isNetworkError = isNetworkError;
-  axiosRetry.isSafeRequestError = isSafeRequestError;
-  axiosRetry.isIdempotentRequestError = isIdempotentRequestError;
-  axiosRetry.isNetworkOrIdempotentRequestError = isNetworkOrIdempotentRequestError;
-  axiosRetry.exponentialDelay = exponentialDelay;
-  axiosRetry.linearDelay = linearDelay;
-  axiosRetry.isRetryableError = isRetryableError;
-  var esm_default = axiosRetry;
-
-  // package/axios.ts
   var instance = import_axios.default.create({
     headers: {
       "Content-Type": "application/x-www-form-urlencoded"
@@ -3435,23 +3211,6 @@ var WebCall = (() => {
     (response) => response.data,
     (error) => Promise.reject(error)
   );
-  esm_default(instance, {
-    retries: 3,
-    // Maximum number of retries, default is 3
-    retryDelay: (retryCount, error) => {
-      console.log(
-        `AJAX Retrying attempt ${retryCount}, error: ${error?.message}`
-      );
-      return retryCount * 1e3;
-    },
-    retryCondition: (error) => {
-      if (!error.response)
-        return true;
-      return error.response.status < 200 || error.response.status >= 300;
-    },
-    shouldResetTimeout: true
-    // Whether to reset axios timeout on retry
-  });
   var request = (config) => instance.request(config);
   var axios_default = request;
 
@@ -13204,8 +12963,8 @@ var WebCall = (() => {
           this.logger.warn(msg);
           return;
         };
-        const retryAfter2 = Math.floor(Math.random() * 10) + 1;
-        const extraHeaders = [`Retry-After: ${retryAfter2}`];
+        const retryAfter = Math.floor(Math.random() * 10) + 1;
+        const extraHeaders = [`Retry-After: ${retryAfter}`];
         if (this.ackProcessing) {
           this.core.replyStateless(message, { statusCode: 500, extraHeaders });
           warning();
@@ -20267,9 +20026,9 @@ var WebCall = (() => {
      * set userstatus
      * @param status
      */
-    setUserStatus(status) {
+    async setUserStatus(status) {
       const { agentId } = this.config.getConfig().userInfo;
-      this.api.updateUserStatus({
+      await this.api.updateUserStatus({
         agentId,
         status
       });