@varlet/axle 0.3.2 → 0.3.3-alpha.1703057804193

package/lib/index.cjs

@@ -0,0 +1,478 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 src_exports = {};
+__export(src_exports, {
+  createAxle: () => createAxle,
+  createFetchRunner: () => createFetchRunner,
+  createMatcher: () => createMatcher,
+  createModifyRunner: () => createModifyRunner,
+  download: () => download,
+  matchPattern: () => matchPattern,
+  requestHeadersInterceptor: () => requestHeadersInterceptor,
+  requestMd5Interceptor: () => requestMd5Interceptor,
+  requestMockInterceptor: () => requestMockInterceptor,
+  responseBlobInterceptor: () => responseBlobInterceptor,
+  responseRetryInterceptor: () => responseRetryInterceptor,
+  responseStatusInterceptor: () => responseStatusInterceptor,
+  responseTimeoutInterceptor: () => responseTimeoutInterceptor
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/instance.ts
+var import_axios = __toESM(require("axios"), 1);
+var import_qs = __toESM(require("qs"), 1);
+var import_shared = require("@varlet/shared");
+
+// src/utils/index.ts
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+function formDataToObject(formData) {
+  const normalizedData = {};
+  formData.forEach((value, key) => {
+    normalizedData[key] = value;
+  });
+  return normalizedData;
+}
+function objectToFormData(object) {
+  const formData = new FormData();
+  Object.keys(object).forEach((key) => formData.append(key, object[key]));
+  return formData;
+}
+
+// src/instance.ts
+function createFetchRunner(service, method, responseType) {
+  return function(url, params, config) {
+    return service[method](url, __spreadValues({
+      params,
+      responseType
+    }, config));
+  };
+}
+function createModifyRunner(service, method, contentType) {
+  return function(url, params, config) {
+    if (contentType === "application/x-www-form-urlencoded") {
+      params = import_qs.default.stringify(params);
+    }
+    if (contentType === "multipart/form-data") {
+      params = objectToFormData(params);
+    }
+    return service[method](url, params, __spreadValues({
+      headers: {
+        "Content-Type": contentType
+      }
+    }, config));
+  };
+}
+function download(url, filename) {
+  if (!(0, import_shared.inBrowser)()) {
+    return;
+  }
+  const a = document.createElement("a");
+  a.download = filename;
+  a.style.display = "none";
+  a.href = typeof url === "string" ? url : URL.createObjectURL(url);
+  document.body.appendChild(a);
+  a.click();
+  URL.revokeObjectURL(a.href);
+  document.body.removeChild(a);
+}
+function createAxle(config = {}) {
+  const service = import_axios.default.create(config);
+  function getHeaders() {
+    return service.defaults.headers.common;
+  }
+  function setHeader(key, value) {
+    ;
+    service.defaults.headers.common[key] = value;
+  }
+  function removeHeader(key) {
+    if (typeof key === "string") {
+      Reflect.deleteProperty(service.defaults.headers.common, key);
+      return;
+    }
+    key.forEach((k) => Reflect.deleteProperty(service.defaults.headers.common, k));
+  }
+  function useRequestInterceptor(...interceptors) {
+    interceptors.forEach((interceptor) => {
+      service.interceptors.request.use(interceptor.onFulfilled, interceptor.onRejected, interceptor.options);
+    });
+  }
+  function useResponseInterceptor(...interceptors) {
+    interceptors.forEach((interceptor) => {
+      service.interceptors.response.use(interceptor.onFulfilled, interceptor.onRejected, interceptor.options);
+    });
+  }
+  return {
+    get: createFetchRunner(service, "get", "json"),
+    getBlob: createFetchRunner(service, "get", "blob"),
+    getDocument: createFetchRunner(service, "get", "document"),
+    getArrayBuffer: createFetchRunner(service, "get", "arraybuffer"),
+    getText: createFetchRunner(service, "get", "text"),
+    getStream: createFetchRunner(service, "get", "stream"),
+    head: createFetchRunner(service, "head", "json"),
+    headBlob: createFetchRunner(service, "head", "blob"),
+    headDocument: createFetchRunner(service, "head", "document"),
+    headArrayBuffer: createFetchRunner(service, "head", "arraybuffer"),
+    headText: createFetchRunner(service, "head", "text"),
+    headStream: createFetchRunner(service, "head", "stream"),
+    options: createFetchRunner(service, "options", "json"),
+    optionsBlob: createFetchRunner(service, "options", "blob"),
+    optionsDocument: createFetchRunner(service, "options", "document"),
+    optionsArrayBuffer: createFetchRunner(service, "options", "arraybuffer"),
+    optionsText: createFetchRunner(service, "options", "text"),
+    optionsStream: createFetchRunner(service, "options", "stream"),
+    delete: createFetchRunner(service, "delete", "json"),
+    deleteBlob: createFetchRunner(service, "delete", "blob"),
+    deleteDocument: createFetchRunner(service, "delete", "document"),
+    deleteArrayBuffer: createFetchRunner(service, "delete", "arraybuffer"),
+    deleteText: createFetchRunner(service, "delete", "text"),
+    deleteStream: createFetchRunner(service, "delete", "stream"),
+    post: createModifyRunner(service, "post", "application/json"),
+    postUrlEncode: createModifyRunner(service, "post", "application/x-www-form-urlencoded"),
+    postMultipart: createModifyRunner(service, "post", "multipart/form-data"),
+    put: createModifyRunner(service, "put", "application/json"),
+    putUrlEncode: createModifyRunner(service, "put", "application/x-www-form-urlencoded"),
+    putMultipart: createModifyRunner(service, "put", "multipart/form-data"),
+    patch: createModifyRunner(service, "patch", "application/json"),
+    patchUrlEncode: createModifyRunner(service, "patch", "application/x-www-form-urlencoded"),
+    patchMultipart: createModifyRunner(service, "patch", "multipart/form-data"),
+    getHeaders,
+    setHeader,
+    removeHeader,
+    useRequestInterceptor,
+    useResponseInterceptor,
+    axios: service
+  };
+}
+
+// src/matcher.ts
+var import_minimatch = require("minimatch");
+function matchPattern(pattern, method, url, status) {
+  if (pattern.startsWith("status:")) {
+    return pattern.replace("status:", "").trim() === String(status);
+  }
+  return pattern.startsWith("method:") ? pattern.replace("method:", "").trim() === method : (0, import_minimatch.minimatch)(url != null ? url : "", pattern);
+}
+function createMatcher(include, exclude) {
+  function matcher(method, url, status) {
+    if (!include && !exclude) {
+      return true;
+    }
+    const isExclude = (exclude != null ? exclude : []).some((pattern) => matchPattern(pattern, method, url, status));
+    if (isExclude) {
+      return false;
+    }
+    if (!include) {
+      return true;
+    }
+    const isInclude = (include != null ? include : []).some((pattern) => matchPattern(pattern, method, url, status));
+    return isInclude;
+  }
+  return matcher;
+}
+
+// src/interceptors/requestHeadersInterceptor.ts
+var import_shared2 = require("@varlet/shared");
+function requestHeadersInterceptor(options = {}) {
+  const { headers: headersOrGetter } = options;
+  return {
+    onFulfilled(config) {
+      var _a, _b, _c;
+      const matcher = createMatcher(options.include, options.exclude);
+      if (!matcher((_a = config.method) != null ? _a : "", (_b = config.url) != null ? _b : "")) {
+        return config;
+      }
+      const headers = (_c = (0, import_shared2.isFunction)(headersOrGetter) ? headersOrGetter() : headersOrGetter) != null ? _c : {};
+      Object.entries(headers).forEach(([key, value]) => {
+        config.headers[key] = value;
+      });
+      return config;
+    },
+    onRejected: (error) => Promise.reject(error),
+    options: options.axiosInterceptorOptions
+  };
+}
+
+// src/interceptors/requestMockInterceptor.ts
+var import_axios2 = require("axios");
+var import_minimatch2 = require("minimatch");
+function settle(response, resolve, reject, delay = 0) {
+  if (delay > 0) {
+    setTimeout(() => {
+      settle(response, resolve, reject);
+    }, delay);
+    return;
+  }
+  if (!response.config.validateStatus || response.config.validateStatus(response.status)) {
+    resolve(response);
+  } else {
+    reject(new import_axios2.AxiosError(`Request failed with status code ${response.status}`, void 0, response.config, response));
+  }
+}
+function requestMockInterceptor(options = {}) {
+  return {
+    onFulfilled(config) {
+      var _a, _b;
+      const matcher = createMatcher(options.include, options.exclude);
+      if (!matcher((_a = config.method) != null ? _a : "", (_b = config.url) != null ? _b : "")) {
+        return config;
+      }
+      const findMapping = () => {
+        var _a2;
+        return ((_a2 = options.mappings) != null ? _a2 : []).find((mapping2) => {
+          var _a3;
+          const isMatchUrl = (0, import_minimatch2.minimatch)((_a3 = config.url) != null ? _a3 : "", mapping2.url);
+          const isMatchMethod = mapping2.method != null ? config.method === mapping2.method : true;
+          return isMatchUrl && isMatchMethod;
+        });
+      };
+      const mapping = findMapping();
+      if (!mapping) {
+        return config;
+      }
+      config.adapter = () => {
+        var _a2, _b2;
+        const partialResponse = mapping.handler(config);
+        const response = __spreadProps(__spreadValues({}, partialResponse), {
+          headers: config.headers,
+          config,
+          request: {},
+          data: partialResponse.data,
+          status: (_a2 = partialResponse.status) != null ? _a2 : 200,
+          statusText: (_b2 = partialResponse.statusText) != null ? _b2 : "OK"
+        });
+        return new Promise((resolve, reject) => {
+          settle(response, resolve, reject, mapping.delay);
+        });
+      };
+      return config;
+    },
+    onRejected: (error) => Promise.reject(error),
+    options: options.axiosInterceptorOptions
+  };
+}
+
+// src/interceptors/responseBlobInterceptor.ts
+function responseBlobInterceptor(options = {}) {
+  return {
+    onFulfilled(response) {
+      var _a, _b, _c, _d;
+      const matcher = createMatcher(options.include, options.exclude);
+      if (!matcher((_a = response.config.method) != null ? _a : "", (_b = response.config.url) != null ? _b : "", response.status)) {
+        return response;
+      }
+      if (response.request.responseType === "blob") {
+        return (_d = (_c = options.onResponse) == null ? void 0 : _c.call(options, response)) != null ? _d : response;
+      }
+      return response;
+    },
+    onRejected: (error) => Promise.reject(error),
+    options: options.axiosInterceptorOptions
+  };
+}
+
+// src/interceptors/responseTimeoutInterceptor.ts
+function responseTimeoutInterceptor(options = {}) {
+  return {
+    onFulfilled: (response) => response,
+    onRejected(error) {
+      var _a, _b, _c, _d;
+      const matcher = createMatcher(options.include, options.exclude);
+      if (!matcher((_a = error.config.method) != null ? _a : "", (_b = error.config.url) != null ? _b : "", (_c = error == null ? void 0 : error.response) == null ? void 0 : _c.status)) {
+        return Promise.reject(error);
+      }
+      if (error.code === "ECONNABORTED" && error.message.includes("timeout") || error.code === "ETIMEDOUT") {
+        error.code = (_d = options == null ? void 0 : options.normalizeErrorCode) != null ? _d : "TIMEOUT";
+      }
+      return Promise.reject(error);
+    },
+    options: options.axiosInterceptorOptions
+  };
+}
+
+// src/interceptors/responseRetryInterceptor.ts
+var import_axios3 = __toESM(require("axios"), 1);
+function responseRetryInterceptor(options) {
+  return {
+    onFulfilled: (response) => response,
+    async onRejected(error) {
+      var _a, _b, _c;
+      const matcher = createMatcher(options.include, options.exclude);
+      if (!matcher((_a = error.config.method) != null ? _a : "", (_b = error.config.url) != null ? _b : "", (_c = error == null ? void 0 : error.response) == null ? void 0 : _c.status) || (0, import_axios3.isCancel)(error)) {
+        return Promise.reject(error);
+      }
+      const { count = 1 } = options;
+      let retryCount = 0;
+      async function retry() {
+        try {
+          retryCount++;
+          return await import_axios3.default.create()(error.config);
+        } catch (error2) {
+          if (retryCount === count) {
+            return Promise.reject(error2);
+          }
+          return retry();
+        }
+      }
+      return retry();
+    },
+    options: options.axiosInterceptorOptions
+  };
+}
+
+// src/interceptors/responseStatusInterceptor.ts
+function responseStatusInterceptor(options) {
+  return {
+    onFulfilled: (response) => {
+      var _a, _b, _c;
+      const matcher = createMatcher(options.include, options.exclude);
+      if (!matcher((_a = response.config.method) != null ? _a : "", (_b = response.config.url) != null ? _b : "", response.status)) {
+        return response;
+      }
+      const handler = ((_c = options.validStatusHandler) != null ? _c : {})[response.status];
+      if (!handler) {
+        return response;
+      }
+      const handlerResponse = handler(response);
+      return handlerResponse != null ? handlerResponse : response;
+    },
+    onRejected: (error) => {
+      var _a, _b, _c, _d;
+      const matcher = createMatcher(options.include, options.exclude);
+      if (!matcher((_a = error.config.method) != null ? _a : "", (_b = error.config.url) != null ? _b : "", (_c = error == null ? void 0 : error.response) == null ? void 0 : _c.status)) {
+        return Promise.reject(error);
+      }
+      const handler = ((_d = options.invalidStatusHandler) != null ? _d : {})[error.response.status];
+      if (!handler) {
+        return Promise.reject(error);
+      }
+      const handlerError = handler(error);
+      return handlerError != null ? handlerError : Promise.reject(error);
+    },
+    options: options.axiosInterceptorOptions
+  };
+}
+
+// src/interceptors/requestMd5Interceptor.ts
+var import_qs2 = __toESM(require("qs"), 1);
+var import_md5 = __toESM(require("crypto-js/md5"), 1);
+var import_minimatch3 = require("minimatch");
+var import_lodash_es = require("lodash-es");
+var import_shared3 = require("@varlet/shared");
+function withCtxMd5(ctx, mapping) {
+  mapping.path.forEach((path) => {
+    const targetValue = (0, import_lodash_es.get)(ctx, path);
+    if (targetValue != null) {
+      (0, import_lodash_es.set)(ctx, path, (0, import_md5.default)(String(targetValue)).toString());
+    }
+  });
+}
+function withMd5(config, mapping) {
+  const { data = {}, params = {}, headers = {} } = config;
+  const ctx = {
+    data: isFormData(data) ? data : JSON.parse(JSON.stringify(data)),
+    params: JSON.parse(JSON.stringify(params)),
+    headers: JSON.parse(JSON.stringify(headers))
+  };
+  if ((0, import_shared3.isString)(ctx.data) && ctx.data.length > 0 && ctx.headers["Content-Type"] === "application/x-www-form-urlencoded") {
+    ctx.data = import_qs2.default.parse(ctx.data);
+    withCtxMd5(ctx, mapping);
+    ctx.data = import_qs2.default.stringify(ctx.data);
+  } else if (isFormData(ctx.data)) {
+    ctx.data = formDataToObject(ctx.data);
+    withCtxMd5(ctx, mapping);
+    ctx.data = objectToFormData(ctx.data);
+  } else {
+    withCtxMd5(ctx, mapping);
+  }
+  return __spreadValues(__spreadValues({}, config), ctx);
+}
+function requestMd5Interceptor(options = {}) {
+  return {
+    onFulfilled(config) {
+      var _a, _b;
+      const matcher = createMatcher(options.include, options.exclude);
+      if (!matcher((_a = config.method) != null ? _a : "", (_b = config.url) != null ? _b : "")) {
+        return config;
+      }
+      const findMapping = () => {
+        var _a2;
+        return ((_a2 = options.mappings) != null ? _a2 : []).find((mapping2) => {
+          var _a3;
+          const isMatchUrl = (0, import_minimatch3.minimatch)((_a3 = config.url) != null ? _a3 : "", mapping2.url);
+          const isMatchMethod = mapping2.method != null ? config.method === mapping2.method : true;
+          return isMatchUrl && isMatchMethod;
+        });
+      };
+      const mapping = findMapping();
+      if (!mapping) {
+        return config;
+      }
+      return withMd5(config, mapping);
+    },
+    onRejected: (error) => Promise.reject(error),
+    options: options.axiosInterceptorOptions
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAxle,
+  createFetchRunner,
+  createMatcher,
+  createModifyRunner,
+  download,
+  matchPattern,
+  requestHeadersInterceptor,
+  requestMd5Interceptor,
+  requestMockInterceptor,
+  responseBlobInterceptor,
+  responseRetryInterceptor,
+  responseStatusInterceptor,
+  responseTimeoutInterceptor
+});

package/lib/index.d.ts

@@ -0,0 +1,80 @@
+import { R as RequestInterceptor, a as ResponseInterceptor } from './instance-8e68a761.js';
+export { e as AxleInstance, A as AxleRequestConfig, b as FetchMethod, F as FetchRunner, I as Interceptor, c as ModifyMethod, M as ModifyRunner, d as RunnerMethod, i as createAxle, f as createFetchRunner, g as createModifyRunner, h as download } from './instance-8e68a761.js';
+import { AxiosInterceptorOptions, AxiosRequestConfig, AxiosResponse } from 'axios';
+
+declare function matchPattern(pattern: string, method: string, url: string, status?: number | null | undefined): boolean;
+declare function createMatcher(include?: string[], exclude?: string[]): (method: string, url: string, status?: number | null | undefined) => boolean;
+
+interface RequestHeadersInterceptorOptions {
+    headers?: Record<string, string> | (() => Record<string, string>);
+    include?: string[];
+    exclude?: string[];
+    axiosInterceptorOptions?: AxiosInterceptorOptions;
+}
+declare function requestHeadersInterceptor(options?: RequestHeadersInterceptorOptions): RequestInterceptor;
+
+type RequestMockInterceptorMapping = {
+    url: string;
+    handler: (config: AxiosRequestConfig) => {
+        data: any;
+        status?: number;
+        statusText?: string;
+    };
+    method?: string;
+    delay?: number;
+};
+interface RequestMockInterceptorOptions {
+    mappings?: RequestMockInterceptorMapping[];
+    include?: string[];
+    exclude?: string[];
+    axiosInterceptorOptions?: AxiosInterceptorOptions;
+}
+declare function requestMockInterceptor(options?: RequestMockInterceptorOptions): RequestInterceptor;
+
+interface ResponseBlobInterceptorOptions {
+    onResponse?: (response: AxiosResponse<any, any>) => any;
+    include?: string[];
+    exclude?: string[];
+    axiosInterceptorOptions?: AxiosInterceptorOptions;
+}
+declare function responseBlobInterceptor(options?: ResponseBlobInterceptorOptions): ResponseInterceptor;
+
+interface ResponseTimeoutInterceptorOptions {
+    normalizeErrorCode?: string;
+    include?: string[];
+    exclude?: string[];
+    axiosInterceptorOptions?: AxiosInterceptorOptions;
+}
+declare function responseTimeoutInterceptor(options?: ResponseTimeoutInterceptorOptions): ResponseInterceptor;
+
+interface ResponseRetryInterceptorOptions {
+    count?: number;
+    include?: string[];
+    exclude?: string[];
+    axiosInterceptorOptions?: AxiosInterceptorOptions;
+}
+declare function responseRetryInterceptor(options: ResponseRetryInterceptorOptions): ResponseInterceptor;
+
+interface ResponseStatusInterceptorOptions {
+    validStatusHandler?: Record<number | string, (response: AxiosResponse<any, any>) => any>;
+    invalidStatusHandler?: Record<number | string, (error: any) => any>;
+    include?: string[];
+    exclude?: string[];
+    axiosInterceptorOptions?: AxiosInterceptorOptions;
+}
+declare function responseStatusInterceptor(options: ResponseStatusInterceptorOptions): ResponseInterceptor;
+
+type RequestMd5InterceptorMapping = {
+    url: string;
+    path: string[];
+    method?: string;
+};
+interface RequestMd5InterceptorOptions {
+    mappings?: RequestMd5InterceptorMapping[];
+    include?: string[];
+    exclude?: string[];
+    axiosInterceptorOptions?: AxiosInterceptorOptions;
+}
+declare function requestMd5Interceptor(options?: RequestMd5InterceptorOptions): RequestInterceptor;
+
+export { RequestHeadersInterceptorOptions, RequestInterceptor, RequestMd5InterceptorMapping, RequestMd5InterceptorOptions, RequestMockInterceptorMapping, RequestMockInterceptorOptions, ResponseBlobInterceptorOptions, ResponseInterceptor, ResponseRetryInterceptorOptions, ResponseStatusInterceptorOptions, ResponseTimeoutInterceptorOptions, createMatcher, matchPattern, requestHeadersInterceptor, requestMd5Interceptor, requestMockInterceptor, responseBlobInterceptor, responseRetryInterceptor, responseStatusInterceptor, responseTimeoutInterceptor };

package/lib/use.cjs

@@ -0,0 +1,199 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/use.ts
+var use_exports = {};
+__export(use_exports, {
+  createUseAxle: () => createUseAxle,
+  useAverageProgress: () => useAverageProgress,
+  useHasLoading: () => useHasLoading,
+  useValues: () => useValues
+});
+module.exports = __toCommonJS(use_exports);
+var import_vue4 = require("vue");
+var import_shared = require("@varlet/shared");
+
+// src/composables/useValues.ts
+var import_vue = require("vue");
+function useValues(...valueCollection) {
+  return (0, import_vue.computed)({
+    get: () => valueCollection.map((value) => value.value),
+    set(values) {
+      valueCollection.forEach((value, index) => {
+        value.value = values[index];
+      });
+    }
+  });
+}
+
+// src/composables/useHasLoading.ts
+var import_vue2 = require("vue");
+function useHasLoading(...loadings) {
+  const hasLoading = (0, import_vue2.ref)(false);
+  (0, import_vue2.watch)(
+    () => loadings.map((loading) => loading.value),
+    (newLoadings) => {
+      hasLoading.value = newLoadings.some(Boolean);
+    },
+    { immediate: true }
+  );
+  return hasLoading;
+}
+
+// src/composables/useAverageProgress.ts
+var import_vue3 = require("vue");
+function useAverageProgress(...progressCollection) {
+  const averageProgress = (0, import_vue3.ref)(0);
+  (0, import_vue3.watch)(
+    () => progressCollection.map((progress) => progress.value),
+    (newProgressCollection) => {
+      const total = newProgressCollection.reduce((total2, progress) => total2 + progress, 0);
+      averageProgress.value = total / progressCollection.length;
+    },
+    { immediate: true }
+  );
+  return averageProgress;
+}
+
+// src/use.ts
+function createUseAxle(options) {
+  const { axle, onTransform: defaultOnTransform, immediate: defaultImmediate = false } = options;
+  const useAxle = (options2) => {
+    const {
+      url,
+      method,
+      immediate = defaultImmediate,
+      value: initialValue,
+      resetValue: initialResetValue,
+      params: initialParamsOrGetter,
+      config: initialConfig,
+      onBefore = () => {
+      },
+      onAfter = () => {
+      },
+      onTransform = defaultOnTransform != null ? defaultOnTransform : (response) => response,
+      onSuccess = () => {
+      },
+      onError = () => {
+      }
+    } = options2;
+    const initialUrl = url;
+    const value = (0, import_vue4.ref)(initialValue);
+    const loading = (0, import_vue4.ref)(false);
+    const error = (0, import_vue4.ref)();
+    const downloadProgress = (0, import_vue4.ref)(0);
+    const uploadProgress = (0, import_vue4.ref)(0);
+    const refs = {
+      value,
+      loading,
+      error,
+      downloadProgress,
+      uploadProgress
+    };
+    let controller = new AbortController();
+    const run = async (options3 = {}) => {
+      var _a, _b, _c;
+      if (controller.signal.aborted) {
+        controller = new AbortController();
+      }
+      const resetValue = (_b = (_a = options3.resetValue) != null ? _a : initialResetValue) != null ? _b : false;
+      if (resetValue === true) {
+        value.value = initialValue;
+      }
+      uploadProgress.value = 0;
+      downloadProgress.value = 0;
+      const url2 = (_c = options3.url) != null ? _c : initialUrl;
+      onBefore(refs);
+      loading.value = true;
+      try {
+        const getterParams = (0, import_shared.isFunction)(initialParamsOrGetter) ? initialParamsOrGetter() : {};
+        const response = await axle[method](
+          url2,
+          __spreadValues(__spreadValues({}, getterParams), options3.params),
+          __spreadValues({
+            signal: controller.signal,
+            onUploadProgress(event) {
+              var _a2;
+              uploadProgress.value = (_a2 = event.progress) != null ? _a2 : 0;
+            },
+            onDownloadProgress(event) {
+              var _a2;
+              downloadProgress.value = (_a2 = event.progress) != null ? _a2 : 0;
+            }
+          }, options3.config)
+        );
+        value.value = onTransform(response, refs);
+        error.value = void 0;
+        onSuccess(response, refs);
+        loading.value = false;
+        onAfter(refs);
+        return response;
+      } catch (responseError) {
+        error.value = responseError;
+        onError(responseError, refs);
+        loading.value = false;
+        onAfter(refs);
+        throw responseError;
+      }
+    };
+    const abort = () => {
+      controller.abort();
+    };
+    if (immediate) {
+      run({
+        url: initialUrl,
+        params: (0, import_shared.isFunction)(initialParamsOrGetter) ? {} : initialParamsOrGetter,
+        config: initialConfig
+      });
+    }
+    return [
+      value,
+      run,
+      {
+        loading,
+        error,
+        uploadProgress,
+        downloadProgress,
+        abort
+      }
+    ];
+  };
+  return useAxle;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createUseAxle,
+  useAverageProgress,
+  useHasLoading,
+  useValues
+});

package/lib/use.d.ts

@@ -0,0 +1,57 @@
+import { Ref, WritableComputedRef } from 'vue';
+import { A as AxleRequestConfig, d as RunnerMethod, e as AxleInstance } from './instance-8e68a761.js';
+import 'axios';
+
+declare function useValues<T extends Ref<any>[]>(...valueCollection: T): WritableComputedRef<T[number]['value'][]>;
+
+declare function useHasLoading(...loadings: Ref<boolean>[]): Ref<boolean>;
+
+declare function useAverageProgress(...progressCollection: Ref<number>[]): Ref<number>;
+
+interface RunOptions<P> {
+    url?: string;
+    params?: P;
+    config?: AxleRequestConfig;
+    resetValue?: boolean;
+}
+type Run<R, P> = (options?: RunOptions<P>) => Promise<R>;
+interface UseAxleRefs<V> {
+    value: Ref<V>;
+    loading: Ref<boolean>;
+    error: Ref<Error | undefined>;
+    uploadProgress: Ref<number>;
+    downloadProgress: Ref<number>;
+}
+interface UseAxleOptions<V = any, R = any, P = Record<string, any>> {
+    url: string;
+    method: RunnerMethod;
+    value?: V;
+    params?: P | (() => P);
+    resetValue?: boolean;
+    config?: AxleRequestConfig;
+    immediate?: boolean;
+    onBefore?(refs: UseAxleRefs<V>): void;
+    onAfter?(refs: UseAxleRefs<V>): void;
+    onTransform?(response: R, refs: UseAxleRefs<V>): V;
+    onSuccess?(response: R, refs: UseAxleRefs<V>): void;
+    onError?(error: Error, refs: UseAxleRefs<V>): void;
+}
+type UseAxleInstance<V, R, P> = [
+    value: Ref<V>,
+    run: Run<R, P>,
+    extra: {
+        uploadProgress: Ref<number>;
+        downloadProgress: Ref<number>;
+        loading: Ref<boolean>;
+        error: Ref<Error | undefined>;
+        abort(): void;
+    }
+];
+interface CreateUseAxleOptions {
+    axle: AxleInstance;
+    immediate?: boolean;
+    onTransform?(response: any, refs: any): any;
+}
+declare function createUseAxle(options: CreateUseAxleOptions): <V = any, R = any, P = Record<string, any>>(options: UseAxleOptions<V, R, P>) => UseAxleInstance<V, R, P>;
+
+export { CreateUseAxleOptions, Run, RunOptions, UseAxleInstance, UseAxleOptions, UseAxleRefs, createUseAxle, useAverageProgress, useHasLoading, useValues };

package/package.json

@@ -1,25 +1,26 @@
 {
   "name": "@varlet/axle",
-  "version": "0.3.2",
+  "version": "0.3.3-alpha.1703057804193",
   "description": "Progressive request tool based on axios",
   "type": "module",
-  "main": "es/index.js",
-  "module": "es/index.js",
-  "types": "index.d.ts",
-  "typesVersions": {
-    "*": {
-      "*": [
-        "./es/*"
-      ]
-    }
-  },
+  "main": "lib/index.cjs",
+  "module": "lib/index.js",
+  "types": "lib/index.d.ts",
   "exports": {
-    ".": "./es/index.js",
-    "./use": "./es/use.js",
+    ".": {
+      "import": "./lib/index.js",
+      "require": "./lib/index.cjs",
+      "types": "./lib/index.d.ts"
+    },
+    "./use": {
+      "import": "./lib/use.js",
+      "require": "./lib/use.cjs",
+      "types": "./lib/use.d.ts"
+    },
     "./*": "./*"
   },
   "files": [
-    "es"
+    "lib"
   ],
   "keywords": [
     "axle",
@@ -58,7 +59,7 @@
     "url": "https://github.com/varletjs/axle/issues"
   },
   "scripts": {
-    "dev": "tsup src/index.ts src/use.ts --format esm --out-dir=es --watch --dts",
-    "build": "tsup src/index.ts src/use.ts --format esm --out-dir=es --dts --clean"
+    "dev": "tsup src/index.ts src/use.ts --format esm --out-dir=lib --watch --dts",
+    "build": "tsup src/index.ts src/use.ts --format esm,cjs --out-dir=lib --dts --clean"
   }
 }