axios-wrapper-pro 1.0.4 → 1.0.5

package/dist/index.js

@@ -1,325 +1,374 @@
-import axios from "axios";
-import { isFunction, sleep } from "./utils";
-import { DEFAULT_CONFIG, DEFAULT_RETRY_CONFIG, DEFAULT_INTERCEPTOR } from "./config";
-class AxiosWrapperPro {
-    constructor(options = {}) {
-        this._abortControllers = new Map();
-        // 接口重试配置
-        this._retryConfig = {
-            ...DEFAULT_RETRY_CONFIG,
-            ...((options === null || options === void 0 ? void 0 : options.retry) || {}),
-        };
-        // 保存参数序列化函数
-        this._paramsSerializer = isFunction(options.paramsSerializer) ? options.paramsSerializer : null;
-        // 创建axios实例
-        const axiosConfig = {
-            ...DEFAULT_CONFIG,
-            ...(options.baseURL && { baseURL: options.baseURL }),
-            ...(options.timeout && { timeout: options.timeout }),
-            headers: { ...DEFAULT_CONFIG.headers, ...options.headers },
-        };
-        if (this._paramsSerializer) {
-            axiosConfig.paramsSerializer = this._paramsSerializer;
-        }
-        this._instance = axios.create(axiosConfig);
-        // 保存拦截器配置
-        this._interceptorConfig = options.interceptors || {};
-        // 初始化拦截器
-        this._initRequestInterceptors();
-        this._initResponseInterceptors();
-    }
-    /**
-     * 获取拦截器配置，未配置的使用默认值
-     * @returns {InterceptorConfig} 完整的拦截器配置
-     */
-    _getInterceptors() {
-        const { request, requestError, response, responseError } = this._interceptorConfig;
-        return {
-            request: isFunction(request) ? request : DEFAULT_INTERCEPTOR.request,
-            requestError: isFunction(requestError) ? requestError : DEFAULT_INTERCEPTOR.requestError,
-            response: isFunction(response) ? response : DEFAULT_INTERCEPTOR.response,
-            responseError: isFunction(responseError) ? responseError : DEFAULT_INTERCEPTOR.responseError,
-        };
-    }
-    /**
-     * 初始化请求拦截器
-     */
-    _initRequestInterceptors() {
-        const { request, requestError } = this._getInterceptors();
-        this._requestInterceptorId = this._instance.interceptors.request.use(request, requestError);
-    }
-    /**
-     * 初始化响应拦截器
-     */
-    _initResponseInterceptors() {
-        const { response, responseError } = this._getInterceptors();
-        // 响应拦截器
-        this._responseInterceptorId = this._instance.interceptors.response.use((res) => {
-            // 清理AbortController，使用请求时保存的 key 确保一致性
-            const key = res.config._requestKey;
-            key && this._abortControllers.delete(key);
-            // 执行自定义响应拦截器
-            return response(res);
-        }, (error) => {
-            var _a;
-            // 清理AbortController，使用请求时保存的 key 确保一致性
-            const key = (_a = error.config) === null || _a === void 0 ? void 0 : _a._requestKey;
-            key && this._abortControllers.delete(key);
-            // 执行自定义响应错误拦截器
-            return responseError(error);
-        });
-    }
-    /**
-     * 设置请求拦截器，移除旧拦截器，更新拦截器配置，重新初始化拦截器
-     * @param {InterceptorConfig["request"]} interceptor 拦截器
-     * @param {InterceptorConfig["requestError"]} errorInterceptor 错误拦截器
-     */
-    setRequestInterceptor(interceptor, errorInterceptor) {
-        if (this._requestInterceptorId !== undefined) {
-            this._instance.interceptors.request.eject(this._requestInterceptorId);
-        }
-        this._interceptorConfig.request = interceptor;
-        this._interceptorConfig.requestError = errorInterceptor;
-        this._initRequestInterceptors();
-    }
-    /**
-     * 设置响应拦截器，移除旧拦截器，更新拦截器配置，重新初始化拦截器
-     * @param {InterceptorConfig["response"]} interceptor 拦截器
-     * @param {InterceptorConfig["responseError"]} errorInterceptor 错误拦截器
-     */
-    setResponseInterceptor(interceptor, errorInterceptor) {
-        if (this._responseInterceptorId !== undefined) {
-            this._instance.interceptors.response.eject(this._responseInterceptorId);
-        }
-        this._interceptorConfig.response = interceptor;
-        this._interceptorConfig.responseError = errorInterceptor;
-        this._initResponseInterceptors();
-    }
-    /**
-     * 设置取消控制器
-     * @param {AxiosRequestConfig} config 请求配置
-     * @param {RequestKey} customKey 自定义key
-     * @returns {InternalAxiosRequestConfig} 处理后的配置
-     */
-    _setupAbortController(config, customKey) {
-        const key = customKey !== null && customKey !== void 0 ? customKey : this._generateRequestKey(config);
-        // 取消已存在的相同请求
-        this.cancelRequest(key);
-        // 设置当前请求的AbortController
-        const controller = new AbortController();
-        this._abortControllers.set(key, controller);
-        // 将 key 保存到 config 中，确保响应拦截器使用相同的 key
-        return { ...config, signal: controller.signal, _requestKey: key };
-    }
-    /**
-     * 生成请求唯一标识
-     * @param {AxiosRequestConfig} config 请求配置
-     * @returns {string} 请求唯一标识
-     */
-    _generateRequestKey(config) {
-        const method = (config.method || "GET").toUpperCase();
-        const url = config.url || "";
-        // 复制params对象，避免修改原始配置
-        const params = config.params ? { ...config.params } : null;
-        // 删除_t参数，避免影响生成请求唯一标识
-        if (params === null || params === void 0 ? void 0 : params._t) {
-            delete params._t;
-        }
-        // 获取序列化函数：优先使用请求级配置，其次使用实例级配置
-        const serializer = isFunction(config.paramsSerializer) ? config.paramsSerializer : this._paramsSerializer;
-        let paramsStr = "";
-        // 所有HTTP方法都可能携带params参数
-        if (params) {
-            paramsStr = serializer ? serializer(params) : this._stableStringify(params);
-        }
-        // POST/PUT/PATCH/DELETE 可能同时携带 data
-        let dataStr = "";
-        if (["POST", "PUT", "PATCH", "DELETE"].includes(method) && config.data) {
-            dataStr = typeof config.data === "string" ? config.data : this._stableStringify(config.data);
-        }
-        return `${method}|${url}|${paramsStr}|${dataStr}`;
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AxiosWrapperPro: () => AxiosWrapperPro
+});
+module.exports = __toCommonJS(index_exports);
+var import_axios2 = __toESM(require("axios"));
+
+// src/utils.ts
+var import_axios = __toESM(require("axios"));
+function isFunction(variable) {
+  return typeof variable === "function";
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isCancel(error) {
+  return import_axios.default.isCancel(error);
+}
+
+// src/config.ts
+var DEFAULT_CONFIG = {
+  baseURL: "",
+  timeout: 1e4,
+  headers: {
+    "Content-Type": "application/json;charset=utf-8"
+  }
+};
+var DEFAULT_RETRY_CONFIG = {
+  count: 0,
+  delay: 1e3,
+  condition: (error) => {
+    var _a;
+    if (isCancel(error)) return false;
+    if (!(error == null ? void 0 : error.response)) return true;
+    return ((_a = error == null ? void 0 : error.response) == null ? void 0 : _a.status) >= 500;
+  }
+};
+var DEFAULT_INTERCEPTOR = {
+  request: (config) => config,
+  requestError: (error) => Promise.reject(error),
+  response: (response) => response,
+  responseError: (error) => Promise.reject(error)
+};
+
+// src/index.ts
+var AxiosWrapperPro = class {
+  constructor(options = {}) {
+    this._abortControllers = /* @__PURE__ */ new Map();
+    this._retryConfig = {
+      ...DEFAULT_RETRY_CONFIG,
+      ...(options == null ? void 0 : options.retry) || {}
+    };
+    this._paramsSerializer = isFunction(options.paramsSerializer) ? options.paramsSerializer : null;
+    const axiosConfig = {
+      ...DEFAULT_CONFIG,
+      ...options.baseURL && { baseURL: options.baseURL },
+      ...options.timeout && { timeout: options.timeout },
+      headers: { ...DEFAULT_CONFIG.headers, ...options.headers }
+    };
+    if (this._paramsSerializer) {
+      axiosConfig.paramsSerializer = this._paramsSerializer;
     }
-    /**
-     * 稳定的JSON序列化，确保相同内容生成相同字符串
-     * @param {any} obj 待序列化对象
-     * @returns {string} 序列化后的字符串
-     */
-    _stableStringify(obj) {
-        if (obj === null || obj === undefined) {
-            return "";
-        }
-        if (Array.isArray(obj)) {
-            return "[" + obj.map((item) => this._stableStringify(item)).join(",") + "]";
-        }
-        if (typeof obj === "object") {
-            const sortedKeys = Object.keys(obj).sort();
-            const pairs = sortedKeys.map((key) => `"${key}":${this._stableStringify(obj[key])}`);
-            return "{" + pairs.join(",") + "}";
-        }
-        return JSON.stringify(obj);
+    this._instance = import_axios2.default.create(axiosConfig);
+    this._interceptorConfig = options.interceptors || {};
+    this._initRequestInterceptors();
+    this._initResponseInterceptors();
+  }
+  /**
+   * 获取拦截器配置，未配置的使用默认值
+   * @returns {InterceptorConfig} 完整的拦截器配置
+   */
+  _getInterceptors() {
+    const { request, requestError, response, responseError } = this._interceptorConfig;
+    return {
+      request: isFunction(request) ? request : DEFAULT_INTERCEPTOR.request,
+      requestError: isFunction(requestError) ? requestError : DEFAULT_INTERCEPTOR.requestError,
+      response: isFunction(response) ? response : DEFAULT_INTERCEPTOR.response,
+      responseError: isFunction(responseError) ? responseError : DEFAULT_INTERCEPTOR.responseError
+    };
+  }
+  /**
+   * 初始化请求拦截器
+   */
+  _initRequestInterceptors() {
+    const { request, requestError } = this._getInterceptors();
+    this._requestInterceptorId = this._instance.interceptors.request.use(request, requestError);
+  }
+  /**
+   * 初始化响应拦截器
+   */
+  _initResponseInterceptors() {
+    const { response, responseError } = this._getInterceptors();
+    this._responseInterceptorId = this._instance.interceptors.response.use(
+      (res) => {
+        const key = res.config._requestKey;
+        key && this._abortControllers.delete(key);
+        return response(res);
+      },
+      (error) => {
+        var _a;
+        const key = (_a = error.config) == null ? void 0 : _a._requestKey;
+        key && this._abortControllers.delete(key);
+        return responseError(error);
+      }
+    );
+  }
+  /**
+   * 设置请求拦截器，移除旧拦截器，更新拦截器配置，重新初始化拦截器
+   * @param {InterceptorConfig["request"]} interceptor 拦截器
+   * @param {InterceptorConfig["requestError"]} errorInterceptor 错误拦截器
+   */
+  setRequestInterceptor(interceptor, errorInterceptor) {
+    if (this._requestInterceptorId !== void 0) {
+      this._instance.interceptors.request.eject(this._requestInterceptorId);
     }
-    /**
-     * 取消指定请求
-     * @param {RequestKey} key 请求标识
-     * @param {string} [reason] 取消原因
-     * @returns {boolean} 是否成功取消
-     */
-    cancelRequest(key, reason) {
-        const controller = this._abortControllers.get(key);
-        if (controller) {
-            controller.abort(reason || "请求已取消");
-            this._abortControllers.delete(key);
-            return true;
-        }
-        return false;
+    this._interceptorConfig.request = interceptor;
+    this._interceptorConfig.requestError = errorInterceptor;
+    this._initRequestInterceptors();
+  }
+  /**
+   * 设置响应拦截器，移除旧拦截器，更新拦截器配置，重新初始化拦截器
+   * @param {InterceptorConfig["response"]} interceptor 拦截器
+   * @param {InterceptorConfig["responseError"]} errorInterceptor 错误拦截器
+   */
+  setResponseInterceptor(interceptor, errorInterceptor) {
+    if (this._responseInterceptorId !== void 0) {
+      this._instance.interceptors.response.eject(this._responseInterceptorId);
     }
-    /**
-     * 取消所有请求
-     * @param {string} [reason] 取消原因
-     * @returns {number} 被取消的请求数量
-     */
-    cancelAllRequests(reason) {
-        const count = this._abortControllers.size;
-        this._abortControllers.forEach((controller) => {
-            controller.abort(reason || "请求已取消");
-        });
-        this._abortControllers.clear();
-        return count;
+    this._interceptorConfig.response = interceptor;
+    this._interceptorConfig.responseError = errorInterceptor;
+    this._initResponseInterceptors();
+  }
+  /**
+   * 设置取消控制器
+   * @param {AxiosRequestConfig} config 请求配置
+   * @param {RequestKey} customKey 自定义key
+   * @returns {InternalAxiosRequestConfig} 处理后的配置
+   */
+  _setupAbortController(config, customKey) {
+    const key = customKey != null ? customKey : this._generateRequestKey(config);
+    this.cancelRequest(key);
+    const controller = new AbortController();
+    this._abortControllers.set(key, controller);
+    return { ...config, signal: controller.signal, _requestKey: key };
+  }
+  /**
+   * 生成请求唯一标识
+   * @param {AxiosRequestConfig} config 请求配置
+   * @returns {string} 请求唯一标识
+   */
+  _generateRequestKey(config) {
+    const method = (config.method || "GET").toUpperCase();
+    const url = config.url || "";
+    const params = config.params ? { ...config.params } : null;
+    if (params == null ? void 0 : params._t) {
+      delete params._t;
     }
-    /**
-     * 设置默认请求头
-     * @param {string} key 请求头名称
-     * @param {string} value 请求头值
-     */
-    setHeader(key, value) {
-        this._instance.defaults.headers.common[key] = value;
+    const serializer = isFunction(config.paramsSerializer) ? config.paramsSerializer : this._paramsSerializer;
+    let paramsStr = "";
+    if (params) {
+      paramsStr = serializer ? serializer(params) : this._stableStringify(params);
     }
-    /**
-     * 批量设置请求头
-     * @param {Record<string, string>} headers 请求头对象
-     */
-    setHeaders(headers) {
-        Object.entries(headers).forEach(([key, value]) => {
-            this._instance.defaults.headers.common[key] = value;
-        });
+    let dataStr = "";
+    if (["POST", "PUT", "PATCH", "DELETE"].includes(method) && config.data) {
+      dataStr = typeof config.data === "string" ? config.data : this._stableStringify(config.data);
     }
-    /**
-     * 移除请求头
-     * @param {string} key 请求头名称
-     */
-    removeHeader(key) {
-        delete this._instance.defaults.headers.common[key];
+    return `${method}|${url}|${paramsStr}|${dataStr}`;
+  }
+  /**
+   * 稳定的JSON序列化，确保相同内容生成相同字符串
+   * @param {any} obj 待序列化对象
+   * @returns {string} 序列化后的字符串
+   */
+  _stableStringify(obj) {
+    if (obj === null || obj === void 0) {
+      return "";
     }
-    /** 获取基础URL */
-    getBaseURL() {
-        return this._instance.defaults.baseURL || "";
+    if (Array.isArray(obj)) {
+      return "[" + obj.map((item) => this._stableStringify(item)).join(",") + "]";
     }
-    /** 设置基础URL */
-    setBaseURL(url) {
-        this._instance.defaults.baseURL = url;
+    if (typeof obj === "object") {
+      const sortedKeys = Object.keys(obj).sort();
+      const pairs = sortedKeys.map((key) => `"${key}":${this._stableStringify(obj[key])}`);
+      return "{" + pairs.join(",") + "}";
     }
-    /** 获取 Axios 实例 */
-    getInstance() {
-        return this._instance;
+    return JSON.stringify(obj);
+  }
+  /**
+   * 取消指定请求
+   * @param {RequestKey} key 请求标识
+   * @param {string} [reason] 取消原因
+   * @returns {boolean} 是否成功取消
+   */
+  cancelRequest(key, reason) {
+    const controller = this._abortControllers.get(key);
+    if (controller) {
+      controller.abort(reason || "\u8BF7\u6C42\u5DF2\u53D6\u6D88");
+      this._abortControllers.delete(key);
+      return true;
     }
-    /**
-     * 通用请求方法
-     * @param {string} method 请求方法
-     * @param {string} url 请求地址
-     * @param {RequestConfig} [config={}] 请求配置
-     * @returns {Promise<AxiosResponse>} 响应数据
-     */
-    async request(method, url, config = {}) {
-        const { requestKey, retry, ...restConfig } = config;
-        // 合并重试配置
-        const retryConfig = {
-            ...this._retryConfig,
-            ...(retry || {}),
-        };
-        // 构建请求配置，避免重复的 method 和 url
-        const requestConfig = { method, url, ...restConfig };
-        let lastError = null;
-        const configKey = requestKey !== null && requestKey !== void 0 ? requestKey : this._generateRequestKey(requestConfig);
-        // 重试循环
-        for (let attempt = 0; attempt <= retryConfig.count; attempt++) {
-            try {
-                // 重试时清理旧的AbortController
-                if (attempt > 0) {
-                    this._abortControllers.delete(configKey);
-                }
-                // 设置AbortController
-                const finalConfig = this._setupAbortController(requestConfig, configKey);
-                // 调用接口
-                const result = await this._instance.request(finalConfig);
-                return result;
-            }
-            catch (error) {
-                lastError = error;
-                // 清理旧的AbortController
-                this._abortControllers.delete(configKey);
-                // 判断是否继续重试
-                const isLast = attempt === retryConfig.count;
-                const shouldRetry = retryConfig.condition(error);
-                const isCancelled = axios.isCancel(error);
-                if (isLast || !shouldRetry || isCancelled) {
-                    break;
-                }
-                // 延迟重试
-                if (retryConfig.delay > 0) {
-                    await sleep(retryConfig.delay);
-                }
-            }
+    return false;
+  }
+  /**
+   * 取消所有请求
+   * @param {string} [reason] 取消原因
+   * @returns {number} 被取消的请求数量
+   */
+  cancelAllRequests(reason) {
+    const count = this._abortControllers.size;
+    this._abortControllers.forEach((controller) => {
+      controller.abort(reason || "\u8BF7\u6C42\u5DF2\u53D6\u6D88");
+    });
+    this._abortControllers.clear();
+    return count;
+  }
+  /**
+   * 设置默认请求头
+   * @param {string} key 请求头名称
+   * @param {string} value 请求头值
+   */
+  setHeader(key, value) {
+    this._instance.defaults.headers.common[key] = value;
+  }
+  /**
+   * 批量设置请求头
+   * @param {Record<string, string>} headers 请求头对象
+   */
+  setHeaders(headers) {
+    Object.entries(headers).forEach(([key, value]) => {
+      this._instance.defaults.headers.common[key] = value;
+    });
+  }
+  /**
+   * 移除请求头
+   * @param {string} key 请求头名称
+   */
+  removeHeader(key) {
+    delete this._instance.defaults.headers.common[key];
+  }
+  /** 获取基础URL */
+  getBaseURL() {
+    return this._instance.defaults.baseURL || "";
+  }
+  /** 设置基础URL */
+  setBaseURL(url) {
+    this._instance.defaults.baseURL = url;
+  }
+  /** 获取 Axios 实例 */
+  getInstance() {
+    return this._instance;
+  }
+  /**
+   * 通用请求方法
+   * @param {string} method 请求方法
+   * @param {string} url 请求地址
+   * @param {RequestConfig} [config={}] 请求配置
+   * @returns {Promise<AxiosResponse>} 响应数据
+   */
+  async request(method, url, config = {}) {
+    const { requestKey, retry, ...restConfig } = config;
+    const retryConfig = {
+      ...this._retryConfig,
+      ...retry || {}
+    };
+    const requestConfig = { method, url, ...restConfig };
+    let lastError = null;
+    const configKey = requestKey != null ? requestKey : this._generateRequestKey(requestConfig);
+    for (let attempt = 0; attempt <= retryConfig.count; attempt++) {
+      try {
+        if (attempt > 0) {
+          this._abortControllers.delete(configKey);
         }
-        return Promise.reject(lastError);
-    }
-    /**
-     * GET请求
-     * @param {string} url 请求地址
-     * @param {RequestConfig} [options] 请求选项
-     * @returns {Promise<AxiosResponse>} 响应数据
-     */
-    get(url, options = {}) {
-        return this.request("GET", url, options);
-    }
-    /**
-     * POST请求
-     * @param {string} url 请求地址
-     * @param {any} [data] 请求数据
-     * @param {RequestConfig} [options] 其他选项
-     * @returns {Promise<AxiosResponse>} 响应数据
-     */
-    post(url, data = {}, options = {}) {
-        return this.request("POST", url, { ...options, data });
-    }
-    /**
-     * PUT请求
-     * @param {string} url 请求地址
-     * @param {any} [data] 请求数据
-     * @param {RequestConfig} [options] 其他选项
-     * @returns {Promise<AxiosResponse>} 响应数据
-     */
-    put(url, data = {}, options = {}) {
-        return this.request("PUT", url, { ...options, data });
-    }
-    /**
-     * DELETE请求
-     * @param {string} url 请求地址
-     * @param {RequestConfig} [options] 请求选项
-     * @returns {Promise<AxiosResponse>} 响应数据
-     */
-    delete(url, options = {}) {
-        return this.request("DELETE", url, options);
-    }
-    /**
-     * PATCH请求
-     * @param {string} url 请求地址
-     * @param {any} [data] 请求数据
-     * @param {RequestConfig} [options] 其他选项
-     * @returns {Promise<AxiosResponse>} 响应数据
-     */
-    patch(url, data = {}, options = {}) {
-        return this.request("PATCH", url, { ...options, data });
+        const finalConfig = this._setupAbortController(requestConfig, configKey);
+        const result = await this._instance.request(finalConfig);
+        return result;
+      } catch (error) {
+        lastError = error;
+        this._abortControllers.delete(configKey);
+        const isLast = attempt === retryConfig.count;
+        const shouldRetry = retryConfig.condition(error);
+        const isCancelled = import_axios2.default.isCancel(error);
+        if (isLast || !shouldRetry || isCancelled) {
+          break;
+        }
+        if (retryConfig.delay > 0) {
+          await sleep(retryConfig.delay);
+        }
+      }
     }
-}
-export { AxiosWrapperPro };
-//# sourceMappingURL=index.js.map
+    return Promise.reject(lastError);
+  }
+  /**
+   * GET请求
+   * @param {string} url 请求地址
+   * @param {RequestConfig} [options] 请求选项
+   * @returns {Promise<AxiosResponse>} 响应数据
+   */
+  get(url, options = {}) {
+    return this.request("GET", url, options);
+  }
+  /**
+   * POST请求
+   * @param {string} url 请求地址
+   * @param {any} [data] 请求数据
+   * @param {RequestConfig} [options] 其他选项
+   * @returns {Promise<AxiosResponse>} 响应数据
+   */
+  post(url, data = {}, options = {}) {
+    return this.request("POST", url, { ...options, data });
+  }
+  /**
+   * PUT请求
+   * @param {string} url 请求地址
+   * @param {any} [data] 请求数据
+   * @param {RequestConfig} [options] 其他选项
+   * @returns {Promise<AxiosResponse>} 响应数据
+   */
+  put(url, data = {}, options = {}) {
+    return this.request("PUT", url, { ...options, data });
+  }
+  /**
+   * DELETE请求
+   * @param {string} url 请求地址
+   * @param {RequestConfig} [options] 请求选项
+   * @returns {Promise<AxiosResponse>} 响应数据
+   */
+  delete(url, options = {}) {
+    return this.request("DELETE", url, options);
+  }
+  /**
+   * PATCH请求
+   * @param {string} url 请求地址
+   * @param {any} [data] 请求数据
+   * @param {RequestConfig} [options] 其他选项
+   * @returns {Promise<AxiosResponse>} 响应数据
+   */
+  patch(url, data = {}, options = {}) {
+    return this.request("PATCH", url, { ...options, data });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AxiosWrapperPro
+});