@nanawan/axle 1.0.3 → 1.0.4

package/dist/api.d.mts

@@ -0,0 +1,27 @@
+import { c as AxleRequestConfig, s as AxleInstance, y as RunnerMethod } from "./instance-9YUALwMk.mjs";
+import { UseAxle, UseAxleInstance, UseAxleOptions, UseAxleOptionsWithRunnable, WatchOptions } from "./use.mjs";
+
+//#region src/api.d.ts
+type ApiPathParams = Record<string, any> | (() => Record<string, any>);
+type ApiWatchOptions = WatchOptions & {
+  pathParams?: boolean;
+};
+type ApiUseOptions<V, R, P, D> = Partial<UseAxleOptions<V, R, P, D>> & {
+  pathParams?: ApiPathParams;
+  watch?: ApiWatchOptions;
+};
+type ApiUseOptionsWithRunnable<V, R, P, D> = Partial<Omit<UseAxleOptionsWithRunnable<V, R, P, D>, 'runnable'>> & Pick<UseAxleOptionsWithRunnable<V, R, P, D>, 'runnable'> & {
+  pathParams?: ApiPathParams;
+  watch?: ApiWatchOptions;
+};
+declare function createApi(axle: AxleInstance, useAxle: UseAxle): <R = any, P = Record<string, any>, D = Record<string, any>>(url: string, method: RunnerMethod) => {
+  url: string;
+  load: (params?: P | undefined, pathParams?: ApiPathParams, config?: AxleRequestConfig<D, Record<string, any>> | undefined) => Promise<R>;
+  use: {
+    <V = R>(options?: ApiUseOptionsWithRunnable<V, R, P, D> | undefined): UseAxleInstance<V, R | undefined, P, D>;
+    <V_1 = R>(options?: ApiUseOptions<V_1, R, P, D> | undefined): UseAxleInstance<V_1, R, P, D>;
+  };
+  patchUrl: (url: string, pathParams: ApiPathParams) => string;
+};
+//#endregion
+export { ApiPathParams, ApiUseOptions, ApiUseOptionsWithRunnable, ApiWatchOptions, createApi };

package/dist/api.mjs

@@ -0,0 +1,46 @@
+import { isFunction } from "parattail";
+//#region src/api.ts
+function createApi(axle, useAxle) {
+	return function api(url, method) {
+		function load(params, pathParams, config) {
+			return axle[method](patchUrl(url, pathParams ?? {}), params, config);
+		}
+		function use(options = {}) {
+			const { pathParams = {}, watch: watchOptions, ...rest } = options;
+			const enableWatchPathParams = isFunction(pathParams) && (watchOptions?.pathParams || watchOptions === true);
+			return useAxle({
+				url: () => patchUrl(url, pathParams),
+				method,
+				watch: watchOptions === true ? {
+					params: true,
+					config: true,
+					_custom: enableWatchPathParams ? pathParams : void 0
+				} : watchOptions === false ? {
+					params: false,
+					config: false
+				} : {
+					params: false,
+					config: false,
+					...watchOptions,
+					_custom: enableWatchPathParams ? pathParams : void 0
+				},
+				...rest
+			});
+		}
+		function patchUrl(url, pathParams) {
+			const params = isFunction(pathParams) ? pathParams() : pathParams;
+			Object.entries(params).forEach(([key, value]) => {
+				url = url.replace(`:${key}`, value);
+			});
+			return url;
+		}
+		return {
+			url,
+			load,
+			use,
+			patchUrl
+		};
+	};
+}
+//#endregion
+export { createApi };

package/dist/index.d.mts

@@ -0,0 +1,91 @@
+import { C as isAxiosError, S as createModifyRunner, _ as ResponseInterceptor, a as AxiosRequestHeaders, b as createAxle, c as AxleRequestConfig, d as HeadersDefaults, f as Interceptor, g as RequestInterceptor, h as ModifyRunner, i as AxiosRequestConfig, l as FetchMethod, m as ModifyMethod, n as AxiosInstance, o as AxiosResponse, p as InternalAxiosRequestConfig, r as AxiosInterceptorOptions, s as AxleInstance, t as AxiosError, u as FetchRunner, v as ResponseType, x as createFetchRunner, y as RunnerMethod } from "./instance-9YUALwMk.mjs";
+import { AxiosInterceptorOptions as AxiosInterceptorOptions$1, AxiosRequestConfig as AxiosRequestConfig$1, AxiosResponse as AxiosResponse$1 } from "axios";
+
+//#region src/matcher.d.ts
+type MatchPattern = string | ((options: {
+  url: string;
+  method: string;
+  status?: number;
+}) => boolean);
+declare function matchPattern(pattern: MatchPattern, method: string, url: string, status?: number): boolean;
+declare function createMatcher(include?: MatchPattern[], exclude?: MatchPattern[]): (method: string, url: string, status?: number) => boolean;
+//#endregion
+//#region src/helper.d.ts
+interface WithResponseReturn<R> {
+  response: R | undefined;
+  errorResponse: AxiosResponse$1 | undefined;
+}
+declare function withResponse<R>(promise: Promise<R>): Promise<WithResponseReturn<R>>;
+declare function download(url: string | Blob, filename: string): void;
+//#endregion
+//#region src/interceptors/requestHeadersInterceptor.d.ts
+interface RequestHeadersInterceptorOptions {
+  headers?: Record<string, string> | (() => Record<string, string>);
+  include?: MatchPattern[];
+  exclude?: MatchPattern[];
+  axiosInterceptorOptions?: AxiosInterceptorOptions$1;
+}
+declare function requestHeadersInterceptor(options?: RequestHeadersInterceptorOptions): RequestInterceptor;
+//#endregion
+//#region src/interceptors/requestMockInterceptor.d.ts
+type RequestMockInterceptorMapping = {
+  url: string | ((url: string) => boolean);
+  handler: (config: AxiosRequestConfig$1) => {
+    data: any;
+    status?: number;
+    statusText?: string;
+  };
+  method?: string;
+  delay?: number;
+};
+interface RequestMockInterceptorOptions {
+  mappings?: RequestMockInterceptorMapping[];
+  include?: MatchPattern[];
+  exclude?: MatchPattern[];
+  axiosInterceptorOptions?: AxiosInterceptorOptions$1;
+}
+declare function requestMockInterceptor(options?: RequestMockInterceptorOptions): RequestInterceptor;
+//#endregion
+//#region src/interceptors/responseBlobInterceptor.d.ts
+interface ResponseBlobInterceptorOptions {
+  onResponse?: (response: AxiosResponse$1<any, any>) => any;
+  include?: MatchPattern[];
+  exclude?: MatchPattern[];
+  axiosInterceptorOptions?: AxiosInterceptorOptions$1;
+}
+declare function responseBlobInterceptor(options?: ResponseBlobInterceptorOptions): ResponseInterceptor;
+//#endregion
+//#region src/interceptors/responseRetryInterceptor.d.ts
+interface ResponseRetryInterceptorOptions {
+  count?: number;
+  include?: MatchPattern[];
+  exclude?: MatchPattern[];
+  axiosInterceptorOptions?: AxiosInterceptorOptions$1;
+}
+declare function responseRetryInterceptor(options: ResponseRetryInterceptorOptions): ResponseInterceptor;
+//#endregion
+//#region src/interceptors/responseStatusInterceptor.d.ts
+interface ResponseStatusInterceptorOptions {
+  validStatusHandler?: Record<number | string, (response: AxiosResponse$1<any, any>) => any>;
+  invalidStatusHandler?: Record<number | string, (error: any) => any>;
+  include?: MatchPattern[];
+  exclude?: MatchPattern[];
+  axiosInterceptorOptions?: AxiosInterceptorOptions$1;
+}
+declare function responseStatusInterceptor(options: ResponseStatusInterceptorOptions): ResponseInterceptor;
+//#endregion
+//#region src/interceptors/requestMd5Interceptor.d.ts
+type RequestMd5InterceptorMapping = {
+  url: string | ((url: string) => boolean);
+  path: string[];
+  method?: string;
+};
+interface RequestMd5InterceptorOptions {
+  mappings?: RequestMd5InterceptorMapping[];
+  include?: MatchPattern[];
+  exclude?: MatchPattern[];
+  axiosInterceptorOptions?: AxiosInterceptorOptions$1;
+}
+declare function requestMd5Interceptor(options?: RequestMd5InterceptorOptions): RequestInterceptor;
+//#endregion
+export { AxiosError, AxiosInstance, AxiosInterceptorOptions, AxiosRequestConfig, AxiosRequestHeaders, AxiosResponse, AxleInstance, AxleRequestConfig, FetchMethod, FetchRunner, HeadersDefaults, Interceptor, InternalAxiosRequestConfig, MatchPattern, ModifyMethod, ModifyRunner, RequestHeadersInterceptorOptions, RequestInterceptor, RequestMd5InterceptorMapping, RequestMd5InterceptorOptions, RequestMockInterceptorMapping, RequestMockInterceptorOptions, ResponseBlobInterceptorOptions, ResponseInterceptor, ResponseRetryInterceptorOptions, ResponseStatusInterceptorOptions, ResponseType, RunnerMethod, WithResponseReturn, createAxle, createFetchRunner, createMatcher, createModifyRunner, download, isAxiosError, matchPattern, requestHeadersInterceptor, requestMd5Interceptor, requestMockInterceptor, responseBlobInterceptor, responseRetryInterceptor, responseStatusInterceptor, withResponse };

package/dist/index.mjs

@@ -0,0 +1,324 @@
+import axios, { AxiosError, AxiosError as AxiosError$1, isAxiosError, isAxiosError as isAxiosError$1, isCancel } from "axios";
+import qs from "qs";
+import { inBrowser, isFunction, isString } from "parattail";
+import md5 from "crypto-js/md5.js";
+import get from "lodash/get.js";
+import set from "lodash/set.js";
+//#region 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;
+}
+//#endregion
+//#region src/instance.ts
+function createFetchRunner(service, method, responseType) {
+	return function(url, params, config) {
+		return service[method](url, {
+			params,
+			responseType,
+			...config
+		});
+	};
+}
+function createModifyRunner(service, method, contentType) {
+	return function(url, params, config) {
+		let normalizedParams = params ?? {};
+		if (contentType === "application/x-www-form-urlencoded") normalizedParams = qs.stringify(normalizedParams);
+		if (contentType === "multipart/form-data") normalizedParams = objectToFormData(normalizedParams);
+		return service[method](url, normalizedParams, {
+			headers: { "Content-Type": contentType },
+			...config
+		});
+	};
+}
+function createAxle(config = {}) {
+	const service = axios.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
+	};
+}
+//#endregion
+//#region src/matcher.ts
+function matchPattern(pattern, method, url, status) {
+	if (isFunction(pattern)) return pattern({
+		url,
+		method,
+		status
+	});
+	if (pattern.startsWith("status:")) return pattern.replace("status:", "").trim() === String(status);
+	return pattern.startsWith("method:") ? pattern.replace("method:", "").trim() === method : url === pattern;
+}
+function createMatcher(include, exclude) {
+	function matcher(method, url, status) {
+		if (!include && !exclude) return true;
+		if ((exclude ?? []).some((pattern) => matchPattern(pattern, method, url, status))) return false;
+		if (!include) return true;
+		return (include ?? []).some((pattern) => matchPattern(pattern, method, url, status));
+	}
+	return matcher;
+}
+//#endregion
+//#region src/helper.ts
+function withResponse(promise) {
+	return new Promise((resolve, reject) => {
+		promise.then((response) => {
+			resolve({
+				response,
+				errorResponse: void 0
+			});
+		}).catch((error) => {
+			if (isAxiosError$1(error)) resolve({
+				response: void 0,
+				errorResponse: error.response
+			});
+			else reject(error);
+		});
+	});
+}
+function download(url, filename) {
+	if (!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);
+}
+//#endregion
+//#region src/interceptors/requestHeadersInterceptor.ts
+function requestHeadersInterceptor(options = {}) {
+	const { headers: headersOrGetter } = options;
+	return {
+		onFulfilled(config) {
+			if (!createMatcher(options.include, options.exclude)(config.method ?? "", config.url ?? "")) return config;
+			const headers = (isFunction(headersOrGetter) ? headersOrGetter() : headersOrGetter) ?? {};
+			Object.entries(headers).forEach(([key, value]) => {
+				config.headers[key] = value;
+			});
+			return config;
+		},
+		onRejected: (error) => Promise.reject(error),
+		options: options.axiosInterceptorOptions
+	};
+}
+//#endregion
+//#region src/interceptors/requestMockInterceptor.ts
+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 AxiosError$1(`Request failed with status code ${response.status}`, void 0, response.config, response));
+}
+function requestMockInterceptor(options = {}) {
+	return {
+		onFulfilled(config) {
+			if (!createMatcher(options.include, options.exclude)(config.method ?? "", config.url ?? "")) return config;
+			const findMapping = () => (options.mappings ?? []).find((mapping) => {
+				const isMatchUrl = isFunction(mapping.url) ? mapping.url(config.url ?? "") : mapping.url === (config.url ?? "");
+				const isMatchMethod = mapping.method != null ? config.method === mapping.method : true;
+				return isMatchUrl && isMatchMethod;
+			});
+			const mapping = findMapping();
+			if (!mapping) return config;
+			config.adapter = () => {
+				const partialResponse = mapping.handler(config);
+				const response = {
+					...partialResponse,
+					headers: config.headers,
+					config,
+					request: {},
+					data: partialResponse.data,
+					status: partialResponse.status ?? 200,
+					statusText: partialResponse.statusText ?? "OK"
+				};
+				return new Promise((resolve, reject) => {
+					settle(response, resolve, reject, mapping.delay);
+				});
+			};
+			return config;
+		},
+		onRejected: (error) => Promise.reject(error),
+		options: options.axiosInterceptorOptions
+	};
+}
+//#endregion
+//#region src/interceptors/responseBlobInterceptor.ts
+function responseBlobInterceptor(options = {}) {
+	return {
+		onFulfilled(response) {
+			if (!createMatcher(options.include, options.exclude)(response.config.method ?? "", response.config.url ?? "", response.status)) return response;
+			if (response.request.responseType === "blob") return options.onResponse?.(response) ?? response;
+			return response;
+		},
+		onRejected: (error) => Promise.reject(error),
+		options: options.axiosInterceptorOptions
+	};
+}
+//#endregion
+//#region src/interceptors/responseRetryInterceptor.ts
+function responseRetryInterceptor(options) {
+	return {
+		onFulfilled: (response) => response,
+		onRejected(error) {
+			if (!createMatcher(options.include, options.exclude)(error.config.method ?? "", error.config.url ?? "", error?.response?.status) || isCancel(error)) return Promise.reject(error);
+			const { count = 1 } = options;
+			let retryCount = 0;
+			async function retry() {
+				try {
+					retryCount++;
+					return await axios.create()(error.config);
+				} catch (error) {
+					if (retryCount === count) return Promise.reject(error);
+					return retry();
+				}
+			}
+			return retry();
+		},
+		options: options.axiosInterceptorOptions
+	};
+}
+//#endregion
+//#region src/interceptors/responseStatusInterceptor.ts
+function responseStatusInterceptor(options) {
+	return {
+		onFulfilled: (response) => {
+			if (!createMatcher(options.include, options.exclude)(response.config.method ?? "", response.config.url ?? "", response.status)) return response;
+			const handler = (options.validStatusHandler ?? {})[response.status];
+			if (!handler) return response;
+			return handler(response) ?? response;
+		},
+		onRejected: (error) => {
+			if (!createMatcher(options.include, options.exclude)(error.config.method ?? "", error.config.url ?? "", error?.response?.status)) return Promise.reject(error);
+			const handler = (options.invalidStatusHandler ?? {})[error.response.status];
+			if (!handler) return Promise.reject(error);
+			return handler(error) ?? Promise.reject(error);
+		},
+		options: options.axiosInterceptorOptions
+	};
+}
+//#endregion
+//#region src/interceptors/requestMd5Interceptor.ts
+function withCtxMd5(ctx, mapping) {
+	mapping.path.forEach((path) => {
+		const targetValue = get(ctx, path);
+		if (targetValue != null) set(ctx, path, md5(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 (isString(ctx.data) && ctx.data.length > 0 && ctx.headers["Content-Type"] === "application/x-www-form-urlencoded") {
+		ctx.data = qs.parse(ctx.data);
+		withCtxMd5(ctx, mapping);
+		ctx.data = qs.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 {
+		...config,
+		...ctx
+	};
+}
+function requestMd5Interceptor(options = {}) {
+	return {
+		onFulfilled(config) {
+			if (!createMatcher(options.include, options.exclude)(config.method ?? "", config.url ?? "")) return config;
+			const findMapping = () => (options.mappings ?? []).find((mapping) => {
+				const isMatchUrl = isFunction(mapping.url) ? mapping.url(config.url ?? "") : mapping.url === (config.url ?? "");
+				const isMatchMethod = mapping.method != null ? config.method === mapping.method : true;
+				return isMatchUrl && isMatchMethod;
+			});
+			const mapping = findMapping();
+			if (!mapping) return config;
+			return withMd5(config, mapping);
+		},
+		onRejected: (error) => Promise.reject(error),
+		options: options.axiosInterceptorOptions
+	};
+}
+//#endregion
+export { AxiosError, createAxle, createFetchRunner, createMatcher, createModifyRunner, download, isAxiosError, matchPattern, requestHeadersInterceptor, requestMd5Interceptor, requestMockInterceptor, responseBlobInterceptor, responseRetryInterceptor, responseStatusInterceptor, withResponse };

package/dist/instance-9YUALwMk.d.mts

@@ -0,0 +1,64 @@
+import { AxiosError as AxiosError$1, AxiosInstance, AxiosInterceptorOptions as AxiosInterceptorOptions$1, AxiosRequestConfig as AxiosRequestConfig$1, AxiosRequestHeaders, AxiosResponse as AxiosResponse$1, HeadersDefaults, InternalAxiosRequestConfig, ResponseType, isAxiosError as isAxiosError$1 } from "axios";
+
+//#region src/instance.d.ts
+interface AxleRequestConfig<D = any, E = Record<string, any>> extends AxiosRequestConfig$1<D> {
+  extra?: E;
+}
+type FetchRunner = <R = AxiosResponse$1, P = Record<string, any>, D = Record<string, any>>(url: string, params?: P, config?: AxleRequestConfig<D>) => Promise<R>;
+type ModifyRunner = <R = AxiosResponse$1, P = Record<string, any>, D = Record<string, any>>(url: string, params?: P, config?: AxleRequestConfig<D>) => Promise<R>;
+type FetchMethod = 'get' | 'delete' | 'options' | 'head';
+type ModifyMethod = 'post' | 'put' | 'patch';
+type RunnerMethod = keyof Omit<AxleInstance, 'axios' | 'getHeaders' | 'setHeader' | 'removeHeader' | 'useRequestInterceptor' | 'useResponseInterceptor'>;
+interface Interceptor<V> {
+  onFulfilled?: ((value: V) => any) | null;
+  onRejected?: ((error: any) => any) | null;
+  options?: AxiosInterceptorOptions$1;
+}
+type RequestInterceptor = Interceptor<InternalAxiosRequestConfig>;
+type ResponseInterceptor<V = AxiosResponse$1<any, any>> = Interceptor<V>;
+type AxleInstance = {
+  get: FetchRunner;
+  getBlob: FetchRunner;
+  getDocument: FetchRunner;
+  getText: FetchRunner;
+  getArrayBuffer: FetchRunner;
+  getStream: FetchRunner;
+  head: FetchRunner;
+  headBlob: FetchRunner;
+  headDocument: FetchRunner;
+  headText: FetchRunner;
+  headArrayBuffer: FetchRunner;
+  headStream: FetchRunner;
+  options: FetchRunner;
+  optionsBlob: FetchRunner;
+  optionsDocument: FetchRunner;
+  optionsText: FetchRunner;
+  optionsArrayBuffer: FetchRunner;
+  optionsStream: FetchRunner;
+  delete: FetchRunner;
+  deleteBlob: FetchRunner;
+  deleteDocument: FetchRunner;
+  deleteText: FetchRunner;
+  deleteArrayBuffer: FetchRunner;
+  deleteStream: FetchRunner;
+  post: ModifyRunner;
+  postUrlEncode: ModifyRunner;
+  postMultipart: ModifyRunner;
+  put: ModifyRunner;
+  putUrlEncode: ModifyRunner;
+  putMultipart: ModifyRunner;
+  patch: ModifyRunner;
+  patchUrlEncode: ModifyRunner;
+  patchMultipart: ModifyRunner;
+  getHeaders(): HeadersDefaults['common'];
+  setHeader(key: string, value: string): void;
+  removeHeader(key: string | string[]): void;
+  useRequestInterceptor(...interceptors: RequestInterceptor[]): void;
+  useResponseInterceptor(...interceptors: ResponseInterceptor[]): void;
+  axios: AxiosInstance;
+};
+declare function createFetchRunner(service: AxiosInstance, method: FetchMethod, responseType: ResponseType): <R = AxiosResponse$1<any, any, {}>, P = Record<string, any>, D = Record<string, any>>(url: string, params?: P | undefined, config?: AxleRequestConfig<D, Record<string, any>> | undefined) => Promise<R>;
+declare function createModifyRunner(service: AxiosInstance, method: ModifyMethod, contentType: 'application/json' | 'multipart/form-data' | 'application/x-www-form-urlencoded'): <R = AxiosResponse$1<any, any, {}>, P = Record<string, any>, D = Record<string, any>>(url: string, params?: P | undefined, config?: AxleRequestConfig<D, Record<string, any>> | undefined) => Promise<R>;
+declare function createAxle(config?: AxleRequestConfig): AxleInstance;
+//#endregion
+export { isAxiosError$1 as C, createModifyRunner as S, ResponseInterceptor as _, AxiosRequestHeaders as a, createAxle as b, AxleRequestConfig as c, HeadersDefaults as d, Interceptor as f, RequestInterceptor as g, ModifyRunner as h, AxiosRequestConfig$1 as i, FetchMethod as l, ModifyMethod as m, AxiosInstance as n, AxiosResponse$1 as o, InternalAxiosRequestConfig as p, AxiosInterceptorOptions$1 as r, AxleInstance as s, AxiosError$1 as t, FetchRunner as u, ResponseType as v, createFetchRunner as x, RunnerMethod as y };

package/dist/use.d.mts

@@ -0,0 +1,85 @@
+import { c as AxleRequestConfig, s as AxleInstance, y as RunnerMethod } from "./instance-9YUALwMk.mjs";
+import { Ref } from "vue";
+
+//#region src/use.d.ts
+type Runnable = () => boolean;
+interface RunOptions<V, P, D> {
+  url?: string;
+  params?: P;
+  config?: AxleRequestConfig<D>;
+  resetValue?: boolean;
+  cloneResetValue?: boolean | ((value: V) => V);
+}
+type UseAxleExtra<V> = {
+  loading: Ref<boolean>;
+  error: Ref<Error | undefined>;
+  uploadProgress: Ref<number>;
+  downloadProgress: Ref<number>;
+  pollingCanceled: Ref<boolean>;
+  abort(): void;
+  resetValue(options?: ResetValueOptions<V>): void;
+  invalidateCache(): void;
+  cancelPolling(): void;
+};
+interface UseAxleRefs<V> {
+  value: Ref<V>;
+  loading: Ref<boolean>;
+  error: Ref<Error | undefined>;
+  uploadProgress: Ref<number>;
+  downloadProgress: Ref<number>;
+  pollingCanceled: Ref<boolean>;
+}
+type Run<V, R, P, D> = {
+  (options?: RunOptions<V, P, D>): Promise<R>;
+} & UseAxleExtra<V>;
+type WatchOptions = boolean | {
+  params?: boolean;
+  config?: boolean;
+  _custom?: () => any;
+};
+interface UseAxleOptions<V = any, R = any, P = Record<string, any>, D = Record<string, any>> {
+  url: string | (() => string);
+  method: RunnerMethod;
+  value?: V;
+  immediate?: boolean;
+  resetValue?: boolean;
+  cloneResetValue?: boolean | ((value: V) => V);
+  abortOnUnmount?: boolean;
+  cacheKey?: string | (() => string);
+  cacheTime?: number;
+  config?: AxleRequestConfig<D> | (() => AxleRequestConfig<D>);
+  watch?: WatchOptions;
+  pollingInterval?: number;
+  pollingOnHidden?: boolean;
+  pollingOnDeactivated?: boolean;
+  refreshOnWindowFocus?: boolean;
+  params?: P | (() => P);
+  onBefore?(refs: UseAxleRefs<V>): void;
+  onAfter?(refs: UseAxleRefs<V>): void;
+  onTransform?(response: R, refs: UseAxleRefs<V>): V | Promise<V>;
+  onSuccess?(response: R, refs: UseAxleRefs<V>): void;
+  onError?(error: Error, refs: UseAxleRefs<V>): void;
+}
+interface ResetValueOptions<V> {
+  cloneResetValue?: boolean | ((value: V) => V);
+}
+type UseAxleInstance<V, R, P, D> = [value: Ref<V>, run: Run<V, R, P, D>, extra: UseAxleExtra<V>];
+interface CreateUseAxleOptions {
+  axle: AxleInstance;
+  immediate?: boolean;
+  abortOnUnmount?: boolean;
+  cacheTime?: number;
+  onTransform?(response: any, refs: any): any;
+}
+type UseAxleOptionsWithRunnable<V = any, R = any, P = Record<string, any>, D = Record<string, any>> = UseAxleOptions<V, R, P, D> & {
+  runnable: Runnable;
+};
+interface UseAxle {
+  <V = any, R = any, P = Record<string, any>, D = Record<string, any>>(options: UseAxleOptionsWithRunnable<V, R, P, D>): UseAxleInstance<V, R | undefined, P, D>;
+  <V = any, R = any, P = Record<string, any>, D = Record<string, any>>(options: UseAxleOptions<V, R, P, D>): UseAxleInstance<V, R, P, D>;
+}
+declare function normalizeValueGetter<T>(valueGetter: T | (() => T)): T;
+declare function cleanupCacheBuffer(): void;
+declare function createUseAxle(options: CreateUseAxleOptions): UseAxle;
+//#endregion
+export { CreateUseAxleOptions, ResetValueOptions, Run, RunOptions, Runnable, UseAxle, UseAxleExtra, UseAxleInstance, UseAxleOptions, UseAxleOptionsWithRunnable, UseAxleRefs, WatchOptions, cleanupCacheBuffer, createUseAxle, normalizeValueGetter };

package/dist/use.mjs

@@ -0,0 +1,229 @@
+import { isFunction } from "parattail";
+import { getCurrentInstance, onActivated, onDeactivated, onMounted, onUnmounted, ref, watch } from "vue";
+//#region src/use.ts
+function normalizeValueGetter(valueGetter) {
+	return isFunction(valueGetter) ? valueGetter() : valueGetter;
+}
+const cacheBuffer = /* @__PURE__ */ new Map();
+function cleanupCacheBuffer() {
+	cacheBuffer.forEach((value, key) => {
+		if (value.expiredTime && Date.now() >= value.expiredTime) cacheBuffer.delete(key);
+	});
+}
+function createUseAxle(options) {
+	const { axle, onTransform: defaultOnTransform, immediate: defaultImmediate = true, abortOnUnmount: defaultAbortOnUnmount = true, cacheTime: defaultCacheTime = Infinity } = options;
+	const useAxle = (options) => {
+		const { url: initialUrlOrGetter, method, immediate = defaultImmediate, abortOnUnmount = defaultAbortOnUnmount, cacheTime = defaultCacheTime, cacheKey, pollingInterval, pollingOnHidden = true, pollingOnDeactivated = false, refreshOnWindowFocus = false, value: initialValue, resetValue: initialResetValue, cloneResetValue: initialCloneResetValue, params: initialParamsOrGetter, config: initialConfigOrGetter, watch: watchOptions, runnable = () => true, onBefore = () => {}, onAfter = () => {}, onTransform = defaultOnTransform ?? ((response) => response), onSuccess = () => {}, onError = () => {} } = options;
+		const value = ref(initialValue);
+		const loading = ref(false);
+		const error = ref();
+		const downloadProgress = ref(0);
+		const uploadProgress = ref(0);
+		const pollingCanceled = ref(false);
+		const refs = {
+			value,
+			loading,
+			error,
+			downloadProgress,
+			uploadProgress,
+			pollingCanceled
+		};
+		const extra = {
+			uploadProgress,
+			downloadProgress,
+			loading,
+			error,
+			pollingCanceled,
+			abort,
+			resetValue,
+			invalidateCache,
+			cancelPolling
+		};
+		let controller = new AbortController();
+		let pollingTimer = null;
+		let deactivated = false;
+		let hidden = false;
+		let unmounted = false;
+		const run = Object.assign(async (options = {}) => {
+			if (!runnable() || abortOnUnmount && unmounted) return;
+			pollingCanceled.value = false;
+			if (controller.signal.aborted) controller = new AbortController();
+			if ((options.resetValue ?? initialResetValue ?? false) === true) resetValue(options);
+			uploadProgress.value = 0;
+			downloadProgress.value = 0;
+			const url = options.url ?? normalizeValueGetter(initialUrlOrGetter);
+			const params = options.params ?? normalizeValueGetter(initialParamsOrGetter);
+			const config = options.config ?? normalizeValueGetter(initialConfigOrGetter);
+			const normalizedCacheKey = cacheKey ? normalizeValueGetter(cacheKey) : void 0;
+			onBefore(refs);
+			loading.value = true;
+			try {
+				cleanupCacheBuffer();
+				const response = await getResponse();
+				if (shouldSetCacheResponse(normalizedCacheKey)) {
+					const cache = cacheBuffer.get(normalizedCacheKey);
+					cache.response = response;
+					cache.expiredTime = Date.now() + cacheTime;
+				}
+				value.value = await 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;
+			} finally {
+				clearPolling();
+				startPolling();
+			}
+			function getResponse() {
+				if (shouldUseCache(normalizedCacheKey)) return JSON.parse(JSON.stringify(cacheBuffer.get(normalizedCacheKey).response));
+				if (shouldAwaitCachePromise(normalizedCacheKey)) return cacheBuffer.get(normalizedCacheKey).promise;
+				const promise = fetchResponse();
+				if (shouldSetCachePromise(normalizedCacheKey)) cacheBuffer.set(normalizedCacheKey, { promise });
+				return promise;
+			}
+			function fetchResponse() {
+				return axle[method](url, params, {
+					signal: controller.signal,
+					onUploadProgress(event) {
+						uploadProgress.value = event.progress ?? 0;
+					},
+					onDownloadProgress(event) {
+						downloadProgress.value = event.progress ?? 0;
+					},
+					...config
+				});
+			}
+			function shouldUseCache(key) {
+				if (!key || !cacheBuffer.has(key)) return false;
+				return cacheBuffer.get(key).response != null;
+			}
+			function shouldAwaitCachePromise(key) {
+				if (!key || !cacheBuffer.has(key)) return false;
+				return cacheBuffer.get(key).promise;
+			}
+			function shouldSetCachePromise(key) {
+				if (!key || cacheBuffer.has(key)) return false;
+				return true;
+			}
+			function shouldSetCacheResponse(key) {
+				if (!key || !cacheBuffer.has(key)) return false;
+				return cacheBuffer.get(key).response == null;
+			}
+		}, extra);
+		if (immediate) runWithInitialConfig();
+		if (getCurrentInstance()) {
+			onActivated(() => {
+				deactivated = false;
+				addVisibilityChangeListener();
+				addWindowFocusListener();
+				startPolling();
+			});
+			onMounted(() => {
+				addVisibilityChangeListener();
+				addWindowFocusListener();
+			});
+			onDeactivated(() => {
+				deactivated = true;
+				removeVisibilityChangeListener();
+				removeWindowFocusListener();
+				clearPolling();
+			});
+			onUnmounted(() => {
+				removeVisibilityChangeListener();
+				removeWindowFocusListener();
+				cancelPolling();
+			});
+			onUnmounted(() => {
+				unmounted = true;
+				if (abortOnUnmount) abort();
+			});
+			if (watchOptions) {
+				const normalizedWatchOptions = watchOptions === true ? {
+					params: true,
+					config: true
+				} : {
+					params: false,
+					config: false,
+					...watchOptions
+				};
+				const enableWatchParams = isFunction(initialParamsOrGetter) && normalizedWatchOptions.params;
+				const enableWatchConfig = isFunction(initialConfigOrGetter) && normalizedWatchOptions.config;
+				watch(() => [
+					enableWatchParams ? normalizeValueGetter(initialParamsOrGetter) : void 0,
+					enableWatchConfig ? normalizeValueGetter(initialConfigOrGetter) : void 0,
+					normalizedWatchOptions._custom ? normalizedWatchOptions._custom() : void 0
+				], () => {
+					runWithInitialConfig();
+				});
+			}
+		}
+		function runWithInitialConfig() {
+			return run({
+				url: normalizeValueGetter(initialUrlOrGetter),
+				params: normalizeValueGetter(initialParamsOrGetter),
+				config: normalizeValueGetter(initialConfigOrGetter)
+			});
+		}
+		function resetValue(options = {}) {
+			value.value = ((options.cloneResetValue ?? initialCloneResetValue ?? false) === true ? (v) => v == null ? null : JSON.parse(JSON.stringify(v)) : isFunction(initialCloneResetValue) ? initialCloneResetValue : (v) => v)(initialValue);
+		}
+		function abort() {
+			controller.abort();
+		}
+		function addWindowFocusListener() {
+			if (typeof window !== "undefined") window.addEventListener("focus", handleWindowFocus);
+		}
+		function removeWindowFocusListener() {
+			if (typeof window !== "undefined") window.removeEventListener("focus", handleWindowFocus);
+		}
+		function handleWindowFocus() {
+			if (refreshOnWindowFocus) runWithInitialConfig();
+		}
+		function addVisibilityChangeListener() {
+			if (typeof document !== "undefined") document.addEventListener("visibilitychange", handleVisibilityChange);
+		}
+		function removeVisibilityChangeListener() {
+			if (typeof document !== "undefined") document.removeEventListener("visibilitychange", handleVisibilityChange);
+		}
+		function handleVisibilityChange() {
+			hidden = document.visibilityState === "hidden";
+			if (pollingOnHidden) return;
+			hidden ? clearPolling() : startPolling();
+		}
+		function startPolling() {
+			if (pollingInterval == null || pollingCanceled.value || pollingTimer != null || deactivated && !pollingOnDeactivated || hidden && !pollingOnHidden) return;
+			pollingTimer = setTimeout(() => {
+				runWithInitialConfig();
+			}, pollingInterval);
+		}
+		function clearPolling() {
+			if (pollingTimer == null) return;
+			clearTimeout(pollingTimer);
+			pollingTimer = null;
+		}
+		function cancelPolling() {
+			clearPolling();
+			pollingCanceled.value = true;
+		}
+		function invalidateCache() {
+			const normalizedCacheKey = cacheKey ? normalizeValueGetter(cacheKey) : void 0;
+			if (!normalizedCacheKey || !cacheBuffer.has(normalizedCacheKey)) return;
+			cacheBuffer.delete(normalizedCacheKey);
+		}
+		return [
+			value,
+			run,
+			extra
+		];
+	};
+	return useAxle;
+}
+//#endregion
+export { cleanupCacheBuffer, createUseAxle, normalizeValueGetter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanawan/axle",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Progressive request tool based on axios",
   "keywords": [
     "axios",
@@ -67,7 +67,7 @@
     "crypto-js": "^4.2.0",
     "lodash": "4.17.21",
     "qs": "^6.11.0",
-    "parattail": "^2.0.3"
+    "parattail": "^2.0.10"
   },
   "devDependencies": {
     "@types/crypto-js": "^4.2.1",