@vueuse/integrations 13.9.0 → 14.0.0-alpha.1

package/dist/useAsyncValidator/component.d.ts

@@ -0,0 +1,19 @@
+import { UseAsyncValidatorOptions, UseAsyncValidatorReturn } from "@vueuse/integrations/useAsyncValidator";
+import * as vue0 from "vue";
+import { Reactive, SlotsType } from "vue";
+import { Rules } from "async-validator";
+
+//#region useAsyncValidator/component.d.ts
+interface UseAsyncValidatorProps {
+  form: Record<string, any>;
+  rules: Rules;
+  options?: UseAsyncValidatorOptions;
+}
+interface UseAsyncValidatorSlots {
+  default: (data: Reactive<UseAsyncValidatorReturn>) => any;
+}
+declare const UseAsyncValidator: vue0.DefineSetupFnComponent<UseAsyncValidatorProps, Record<string, never>, SlotsType<UseAsyncValidatorSlots>, UseAsyncValidatorProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue0.PublicProps>;
+//#endregion
+export { UseAsyncValidator, UseAsyncValidatorProps };

package/dist/useAsyncValidator/component.js

@@ -0,0 +1,20 @@
+import { useAsyncValidator } from "@vueuse/integrations/useAsyncValidator";
+import { defineComponent, reactive } from "vue";
+
+//#region useAsyncValidator/component.ts
+const UseAsyncValidator = /* @__PURE__ */ defineComponent((props, { slots }) => {
+	const data = reactive(useAsyncValidator(props.form, props.rules));
+	return () => {
+		if (slots.default) return slots.default(data);
+	};
+}, {
+	name: "UseAsyncValidator",
+	props: [
+		"form",
+		"options",
+		"rules"
+	]
+});
+
+//#endregion
+export { UseAsyncValidator };

package/dist/useAsyncValidator.d.ts

@@ -0,0 +1,48 @@
+import { Rules, ValidateError, ValidateOption } from "async-validator";
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region useAsyncValidator/index.d.ts
+type AsyncValidatorError = Error & {
+  errors: ValidateError[];
+  fields: Record<string, ValidateError[]>;
+};
+interface UseAsyncValidatorExecuteReturn {
+  pass: boolean;
+  errors: AsyncValidatorError['errors'] | undefined;
+  errorInfo: AsyncValidatorError | null;
+  errorFields: AsyncValidatorError['fields'] | undefined;
+}
+interface UseAsyncValidatorReturn {
+  pass: ShallowRef<boolean>;
+  isFinished: ShallowRef<boolean>;
+  errors: ComputedRef<AsyncValidatorError['errors'] | undefined>;
+  errorInfo: ShallowRef<AsyncValidatorError | null>;
+  errorFields: ComputedRef<AsyncValidatorError['fields'] | undefined>;
+  execute: () => Promise<UseAsyncValidatorExecuteReturn>;
+}
+interface UseAsyncValidatorOptions {
+  /**
+   * @see https://github.com/yiminghe/async-validator#options
+   */
+  validateOption?: ValidateOption;
+  /**
+   * The validation will be triggered right away for the first time.
+   * Only works when `manual` is not set to true.
+   *
+   * @default true
+   */
+  immediate?: boolean;
+  /**
+   * If set to true, the validation will not be triggered automatically.
+   */
+  manual?: boolean;
+}
+/**
+ * Wrapper for async-validator.
+ *
+ * @see https://vueuse.org/useAsyncValidator
+ * @see https://github.com/yiminghe/async-validator
+ */
+declare function useAsyncValidator(value: MaybeRefOrGetter<Record<string, any>>, rules: MaybeRefOrGetter<Rules>, options?: UseAsyncValidatorOptions): UseAsyncValidatorReturn & PromiseLike<UseAsyncValidatorReturn>;
+//#endregion
+export { AsyncValidatorError, UseAsyncValidatorExecuteReturn, UseAsyncValidatorOptions, UseAsyncValidatorReturn, useAsyncValidator };

package/dist/useAsyncValidator.iife.js

@@ -0,0 +1,99 @@
+(function(exports, __vueuse_shared, async_validator, vue) {
+
+//#region rolldown:runtime
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+__vueuse_shared = __toESM(__vueuse_shared);
+async_validator = __toESM(async_validator);
+vue = __toESM(vue);
+
+//#region useAsyncValidator/index.ts
+const AsyncValidatorSchema = async_validator.default.default || async_validator.default;
+/**
+* Wrapper for async-validator.
+*
+* @see https://vueuse.org/useAsyncValidator
+* @see https://github.com/yiminghe/async-validator
+*/
+function useAsyncValidator(value, rules, options = {}) {
+	const { validateOption = {}, immediate = true, manual = false } = options;
+	const valueRef = (0, __vueuse_shared.toRef)(value);
+	const errorInfo = (0, vue.shallowRef)(null);
+	const isFinished = (0, vue.shallowRef)(true);
+	const pass = (0, vue.shallowRef)(!immediate || manual);
+	const errors = (0, vue.computed)(() => {
+		var _errorInfo$value;
+		return ((_errorInfo$value = errorInfo.value) === null || _errorInfo$value === void 0 ? void 0 : _errorInfo$value.errors) || [];
+	});
+	const errorFields = (0, vue.computed)(() => {
+		var _errorInfo$value2;
+		return ((_errorInfo$value2 = errorInfo.value) === null || _errorInfo$value2 === void 0 ? void 0 : _errorInfo$value2.fields) || {};
+	});
+	const validator = (0, vue.computed)(() => new AsyncValidatorSchema((0, vue.toValue)(rules)));
+	const execute = async () => {
+		isFinished.value = false;
+		pass.value = false;
+		try {
+			await validator.value.validate(valueRef.value, validateOption);
+			pass.value = true;
+			errorInfo.value = null;
+		} catch (err) {
+			errorInfo.value = err;
+		} finally {
+			isFinished.value = true;
+		}
+		return {
+			pass: pass.value,
+			errorInfo: errorInfo.value,
+			errors: errors.value,
+			errorFields: errorFields.value
+		};
+	};
+	if (!manual) (0, vue.watch)([valueRef, validator], () => execute(), {
+		immediate,
+		deep: true
+	});
+	const shell = {
+		isFinished,
+		pass,
+		errors,
+		errorInfo,
+		errorFields,
+		execute
+	};
+	function waitUntilFinished() {
+		return new Promise((resolve, reject) => {
+			(0, __vueuse_shared.until)(isFinished).toBe(true).then(() => resolve(shell)).catch((error) => reject(error));
+		});
+	}
+	return {
+		...shell,
+		then(onFulfilled, onRejected) {
+			return waitUntilFinished().then(onFulfilled, onRejected);
+		}
+	};
+}
+
+//#endregion
+exports.useAsyncValidator = useAsyncValidator;
+})(this.VueUse = this.VueUse || {}, VueUse, AsyncValidator, Vue);

package/dist/useAsyncValidator.iife.min.js

@@ -0,0 +1 @@
+(function(exports,t,n,r){var i=Object.create,a=Object.defineProperty,o=Object.getOwnPropertyDescriptor,s=Object.getOwnPropertyNames,c=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,u=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=s(t),c=0,u=i.length,d;c<u;c++)d=i[c],!l.call(e,d)&&d!==n&&a(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=o(t,d))||r.enumerable});return e},d=(e,t,n)=>(n=e==null?{}:i(c(e)),u(t||!e||!e.__esModule?a(n,`default`,{value:e,enumerable:!0}):n,e));t=d(t),n=d(n),r=d(r);let f=n.default.default||n.default;function p(e,n,i={}){let{validateOption:a={},immediate:o=!0,manual:s=!1}=i,c=(0,t.toRef)(e),l=(0,r.shallowRef)(null),u=(0,r.shallowRef)(!0),d=(0,r.shallowRef)(!o||s),p=(0,r.computed)(()=>{var e;return((e=l.value)==null?void 0:e.errors)||[]}),m=(0,r.computed)(()=>{var e;return((e=l.value)==null?void 0:e.fields)||{}}),h=(0,r.computed)(()=>new f((0,r.toValue)(n))),g=async()=>{u.value=!1,d.value=!1;try{await h.value.validate(c.value,a),d.value=!0,l.value=null}catch(e){l.value=e}finally{u.value=!0}return{pass:d.value,errorInfo:l.value,errors:p.value,errorFields:m.value}};s||(0,r.watch)([c,h],()=>g(),{immediate:o,deep:!0});let _={isFinished:u,pass:d,errors:p,errorInfo:l,errorFields:m,execute:g};function v(){return new Promise((e,n)=>{(0,t.until)(u).toBe(!0).then(()=>e(_)).catch(e=>n(e))})}return{..._,then(e,t){return v().then(e,t)}}}exports.useAsyncValidator=p})(this.VueUse=this.VueUse||{},VueUse,AsyncValidator,Vue);

package/dist/useAsyncValidator.js

@@ -0,0 +1,73 @@
+import { toRef, until } from "@vueuse/shared";
+import Schema from "async-validator";
+import { computed, shallowRef, toValue, watch } from "vue";
+
+//#region useAsyncValidator/index.ts
+const AsyncValidatorSchema = Schema.default || Schema;
+/**
+* Wrapper for async-validator.
+*
+* @see https://vueuse.org/useAsyncValidator
+* @see https://github.com/yiminghe/async-validator
+*/
+function useAsyncValidator(value, rules, options = {}) {
+	const { validateOption = {}, immediate = true, manual = false } = options;
+	const valueRef = toRef(value);
+	const errorInfo = shallowRef(null);
+	const isFinished = shallowRef(true);
+	const pass = shallowRef(!immediate || manual);
+	const errors = computed(() => {
+		var _errorInfo$value;
+		return ((_errorInfo$value = errorInfo.value) === null || _errorInfo$value === void 0 ? void 0 : _errorInfo$value.errors) || [];
+	});
+	const errorFields = computed(() => {
+		var _errorInfo$value2;
+		return ((_errorInfo$value2 = errorInfo.value) === null || _errorInfo$value2 === void 0 ? void 0 : _errorInfo$value2.fields) || {};
+	});
+	const validator = computed(() => new AsyncValidatorSchema(toValue(rules)));
+	const execute = async () => {
+		isFinished.value = false;
+		pass.value = false;
+		try {
+			await validator.value.validate(valueRef.value, validateOption);
+			pass.value = true;
+			errorInfo.value = null;
+		} catch (err) {
+			errorInfo.value = err;
+		} finally {
+			isFinished.value = true;
+		}
+		return {
+			pass: pass.value,
+			errorInfo: errorInfo.value,
+			errors: errors.value,
+			errorFields: errorFields.value
+		};
+	};
+	if (!manual) watch([valueRef, validator], () => execute(), {
+		immediate,
+		deep: true
+	});
+	const shell = {
+		isFinished,
+		pass,
+		errors,
+		errorInfo,
+		errorFields,
+		execute
+	};
+	function waitUntilFinished() {
+		return new Promise((resolve, reject) => {
+			until(isFinished).toBe(true).then(() => resolve(shell)).catch((error) => reject(error));
+		});
+	}
+	return {
+		...shell,
+		then(onFulfilled, onRejected) {
+			return waitUntilFinished().then(onFulfilled, onRejected);
+		}
+	};
+}
+
+//#endregion
+export { useAsyncValidator };

package/{useAxios.d.mts → dist/useAxios.d.ts}

@@ -1,96 +1,97 @@
-import { AxiosResponse, AxiosRequestConfig, AxiosInstance } from 'axios';
-import { ShallowRef, Ref } from 'vue';
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "axios";
+import { Ref, ShallowRef } from "vue";
 
+//#region useAxios/index.d.ts
 interface UseAxiosReturn<T, R = AxiosResponse<T>, _D = any, O extends UseAxiosOptions = UseAxiosOptions<T>> {
-    /**
-     * Axios Response
-     */
-    response: ShallowRef<R | undefined>;
-    /**
-     * Axios response data
-     */
-    data: O extends UseAxiosOptionsWithInitialData<T> ? Ref<T> : Ref<T | undefined>;
-    /**
-     * Indicates if the request has finished
-     */
-    isFinished: Ref<boolean>;
-    /**
-     * Indicates if the request is currently loading
-     */
-    isLoading: Ref<boolean>;
-    /**
-     * Indicates if the request was canceled
-     */
-    isAborted: Ref<boolean>;
-    /**
-     * Any errors that may have occurred
-     */
-    error: ShallowRef<unknown | undefined>;
-    /**
-     * Aborts the current request
-     */
-    abort: (message?: string | undefined) => void;
-    /**
-     * Alias to `abort`
-     */
-    cancel: (message?: string | undefined) => void;
-    /**
-     * Alias to `isAborted`
-     */
-    isCanceled: Ref<boolean>;
+  /**
+   * Axios Response
+   */
+  response: ShallowRef<R | undefined>;
+  /**
+   * Axios response data
+   */
+  data: O extends UseAxiosOptionsWithInitialData<T> ? Ref<T> : Ref<T | undefined>;
+  /**
+   * Indicates if the request has finished
+   */
+  isFinished: Ref<boolean>;
+  /**
+   * Indicates if the request is currently loading
+   */
+  isLoading: Ref<boolean>;
+  /**
+   * Indicates if the request was canceled
+   */
+  isAborted: Ref<boolean>;
+  /**
+   * Any errors that may have occurred
+   */
+  error: ShallowRef<unknown | undefined>;
+  /**
+   * Aborts the current request
+   */
+  abort: (message?: string | undefined) => void;
+  /**
+   * Alias to `abort`
+   */
+  cancel: (message?: string | undefined) => void;
+  /**
+   * Alias to `isAborted`
+   */
+  isCanceled: Ref<boolean>;
 }
 interface StrictUseAxiosReturn<T, R, D, O extends UseAxiosOptions = UseAxiosOptions<T>> extends UseAxiosReturn<T, R, D, O> {
-    /**
-     * Manually call the axios request
-     */
-    execute: (url?: string | AxiosRequestConfig<D>, config?: AxiosRequestConfig<D>) => Promise<StrictUseAxiosReturn<T, R, D, O>>;
+  /**
+   * Manually call the axios request
+   */
+  execute: (url?: string | AxiosRequestConfig<D>, config?: AxiosRequestConfig<D>) => Promise<StrictUseAxiosReturn<T, R, D, O>>;
 }
 interface EasyUseAxiosReturn<T, R, D> extends UseAxiosReturn<T, R, D> {
-    /**
-     * Manually call the axios request
-     */
-    execute: (url: string, config?: AxiosRequestConfig<D>) => Promise<EasyUseAxiosReturn<T, R, D>>;
+  /**
+   * Manually call the axios request
+   */
+  execute: (url: string, config?: AxiosRequestConfig<D>) => Promise<EasyUseAxiosReturn<T, R, D>>;
 }
 interface UseAxiosOptionsBase<T = any> {
-    /**
-     * Will automatically run axios request when `useAxios` is used
-     *
-     */
-    immediate?: boolean;
-    /**
-     * Use shallowRef.
-     *
-     * @default true
-     */
-    shallow?: boolean;
-    /**
-     * Abort previous request when a new request is made.
-     *
-     * @default true
-     */
-    abortPrevious?: boolean;
-    /**
-     * Callback when error is caught.
-     */
-    onError?: (e: unknown) => void;
-    /**
-     * Callback when success is caught.
-     */
-    onSuccess?: (data: T) => void;
-    /**
-     * Sets the state to initialState before executing the promise.
-     */
-    resetOnExecute?: boolean;
-    /**
-     * Callback when request is finished.
-     */
-    onFinish?: () => void;
+  /**
+   * Will automatically run axios request when `useAxios` is used
+   *
+   */
+  immediate?: boolean;
+  /**
+   * Use shallowRef.
+   *
+   * @default true
+   */
+  shallow?: boolean;
+  /**
+   * Abort previous request when a new request is made.
+   *
+   * @default true
+   */
+  abortPrevious?: boolean;
+  /**
+   * Callback when error is caught.
+   */
+  onError?: (e: unknown) => void;
+  /**
+   * Callback when success is caught.
+   */
+  onSuccess?: (data: T) => void;
+  /**
+   * Sets the state to initialState before executing the promise.
+   */
+  resetOnExecute?: boolean;
+  /**
+   * Callback when request is finished.
+   */
+  onFinish?: () => void;
 }
 interface UseAxiosOptionsWithInitialData<T> extends UseAxiosOptionsBase<T> {
-    /**
-     * Initial data
-     */
-    initialData: T;
+  /**
+   * Initial data
+   */
+  initialData: T;
 }
 type UseAxiosOptions<T = any> = UseAxiosOptionsBase<T> | UseAxiosOptionsWithInitialData<T>;
 declare function useAxios<T = any, R = AxiosResponse<T>, D = any, O extends UseAxiosOptionsWithInitialData<T> = UseAxiosOptionsWithInitialData<T>>(url: string, config?: AxiosRequestConfig<D>, options?: O): StrictUseAxiosReturn<T, R, D, O> & Promise<StrictUseAxiosReturn<T, R, D, O>>;
@@ -102,6 +103,5 @@ declare function useAxios<T = any, R = AxiosResponse<T>, D = any, O extends UseA
 declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(config?: AxiosRequestConfig<D>): EasyUseAxiosReturn<T, R, D> & Promise<EasyUseAxiosReturn<T, R, D>>;
 declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(instance?: AxiosInstance): EasyUseAxiosReturn<T, R, D> & Promise<EasyUseAxiosReturn<T, R, D>>;
 declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(config?: AxiosRequestConfig<D>, instance?: AxiosInstance): EasyUseAxiosReturn<T, R, D> & Promise<EasyUseAxiosReturn<T, R, D>>;
-
-export { useAxios };
-export type { EasyUseAxiosReturn, StrictUseAxiosReturn, UseAxiosOptions, UseAxiosOptionsBase, UseAxiosOptionsWithInitialData, UseAxiosReturn };
+//#endregion
+export { EasyUseAxiosReturn, StrictUseAxiosReturn, UseAxiosOptions, UseAxiosOptionsBase, UseAxiosOptionsWithInitialData, UseAxiosReturn, useAxios };

package/dist/useAxios.iife.js

@@ -0,0 +1,150 @@
+(function(exports, __vueuse_shared, axios, vue) {
+
+//#region rolldown:runtime
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+__vueuse_shared = __toESM(__vueuse_shared);
+axios = __toESM(axios);
+vue = __toESM(vue);
+
+//#region useAxios/index.ts
+/**
+* Wrapper for axios.
+*
+* @see https://vueuse.org/useAxios
+*/
+function useAxios(...args) {
+	const url = typeof args[0] === "string" ? args[0] : void 0;
+	const argsPlaceholder = typeof url === "string" ? 1 : 0;
+	const defaultOptions = {
+		immediate: !!argsPlaceholder,
+		shallow: true,
+		abortPrevious: true
+	};
+	let defaultConfig = {};
+	let instance = axios.default;
+	let options = defaultOptions;
+	const isAxiosInstance = (val) => !!(val === null || val === void 0 ? void 0 : val.request);
+	if (args.length > 0 + argsPlaceholder)
+ /**
+	* Unable to use `instanceof` here because of (https://github.com/axios/axios/issues/737)
+	* so instead we are checking if there is a `request` on the object to see if it is an
+	* axios instance
+	*/
+	if (isAxiosInstance(args[0 + argsPlaceholder])) instance = args[0 + argsPlaceholder];
+	else defaultConfig = args[0 + argsPlaceholder];
+	if (args.length > 1 + argsPlaceholder) {
+		if (isAxiosInstance(args[1 + argsPlaceholder])) instance = args[1 + argsPlaceholder];
+	}
+	if (args.length === 2 + argsPlaceholder && !isAxiosInstance(args[1 + argsPlaceholder]) || args.length === 3 + argsPlaceholder) options = args[args.length - 1] || defaultOptions;
+	const { shallow, onSuccess = __vueuse_shared.noop, onError = __vueuse_shared.noop, immediate, resetOnExecute = false } = options;
+	const initialData = options.initialData;
+	const response = (0, vue.shallowRef)();
+	const data = (shallow ? vue.shallowRef : vue.ref)(initialData);
+	const isFinished = (0, vue.shallowRef)(false);
+	const isLoading = (0, vue.shallowRef)(false);
+	const isAborted = (0, vue.shallowRef)(false);
+	const error = (0, vue.shallowRef)();
+	let abortController = new AbortController();
+	const abort = (message) => {
+		if (isFinished.value || !isLoading.value) return;
+		abortController.abort(message);
+		abortController = new AbortController();
+		isAborted.value = true;
+		isLoading.value = false;
+		isFinished.value = false;
+	};
+	const loading = (loading$1) => {
+		isLoading.value = loading$1;
+		isFinished.value = !loading$1;
+	};
+	/**
+	* Reset data to initialData
+	*/
+	const resetData = () => {
+		if (resetOnExecute) data.value = initialData;
+	};
+	const waitUntilFinished = () => new Promise((resolve, reject) => {
+		(0, __vueuse_shared.until)(isFinished).toBe(true).then(() => error.value ? reject(error.value) : resolve(result));
+	});
+	const promise = {
+		then: (...args$1) => waitUntilFinished().then(...args$1),
+		catch: (...args$1) => waitUntilFinished().catch(...args$1)
+	};
+	let executeCounter = 0;
+	const execute = (executeUrl = url, config = {}) => {
+		error.value = void 0;
+		const _url = typeof executeUrl === "string" ? executeUrl : url !== null && url !== void 0 ? url : config.url;
+		if (_url === void 0) {
+			error.value = new axios.AxiosError(axios.AxiosError.ERR_INVALID_URL);
+			isFinished.value = true;
+			return promise;
+		}
+		resetData();
+		if (options.abortPrevious !== false) abort();
+		loading(true);
+		executeCounter += 1;
+		const currentExecuteCounter = executeCounter;
+		isAborted.value = false;
+		instance(_url, {
+			...defaultConfig,
+			...typeof executeUrl === "object" ? executeUrl : config,
+			signal: abortController.signal
+		}).then((r) => {
+			if (isAborted.value) return;
+			response.value = r;
+			const result$1 = r.data;
+			data.value = result$1;
+			onSuccess(result$1);
+		}).catch((e) => {
+			error.value = e;
+			onError(e);
+		}).finally(() => {
+			var _options$onFinish;
+			(_options$onFinish = options.onFinish) === null || _options$onFinish === void 0 || _options$onFinish.call(options);
+			if (currentExecuteCounter === executeCounter) loading(false);
+		});
+		return promise;
+	};
+	if (immediate && url) execute();
+	const result = {
+		response,
+		data,
+		error,
+		isFinished,
+		isLoading,
+		cancel: abort,
+		isAborted,
+		isCanceled: isAborted,
+		abort,
+		execute
+	};
+	return {
+		...result,
+		...promise
+	};
+}
+
+//#endregion
+exports.useAxios = useAxios;
+})(this.VueUse = this.VueUse || {}, VueUse, axios, Vue);

package/dist/useAxios.iife.min.js

@@ -0,0 +1 @@
+(function(exports,t,n,r){var i=Object.create,a=Object.defineProperty,o=Object.getOwnPropertyDescriptor,s=Object.getOwnPropertyNames,c=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,u=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=s(t),c=0,u=i.length,d;c<u;c++)d=i[c],!l.call(e,d)&&d!==n&&a(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=o(t,d))||r.enumerable});return e},d=(e,t,n)=>(n=e==null?{}:i(c(e)),u(t||!e||!e.__esModule?a(n,`default`,{value:e,enumerable:!0}):n,e));t=d(t),n=d(n),r=d(r);function f(...e){let i=typeof e[0]==`string`?e[0]:void 0,a=typeof i==`string`?1:0,o={immediate:!!a,shallow:!0,abortPrevious:!0},s={},c=n.default,l=o,u=e=>!!(e!=null&&e.request);e.length>0+a&&(u(e[0+a])?c=e[0+a]:s=e[0+a]),e.length>1+a&&u(e[1+a])&&(c=e[1+a]),(e.length===2+a&&!u(e[1+a])||e.length===3+a)&&(l=e[e.length-1]||o);let{shallow:d,onSuccess:f=t.noop,onError:p=t.noop,immediate:m,resetOnExecute:h=!1}=l,g=l.initialData,_=(0,r.shallowRef)(),v=(d?r.shallowRef:r.ref)(g),y=(0,r.shallowRef)(!1),b=(0,r.shallowRef)(!1),x=(0,r.shallowRef)(!1),S=(0,r.shallowRef)(),C=new AbortController,w=e=>{y.value||!b.value||(C.abort(e),C=new AbortController,x.value=!0,b.value=!1,y.value=!1)},T=e=>{b.value=e,y.value=!e},E=()=>{h&&(v.value=g)},D=()=>new Promise((e,n)=>{(0,t.until)(y).toBe(!0).then(()=>S.value?n(S.value):e(j))}),O={then:(...e)=>D().then(...e),catch:(...e)=>D().catch(...e)},k=0,A=(e=i,t={})=>{S.value=void 0;let r=typeof e==`string`?e:i==null?t.url:i;if(r===void 0)return S.value=new n.AxiosError(n.AxiosError.ERR_INVALID_URL),y.value=!0,O;E(),l.abortPrevious!==!1&&w(),T(!0),k+=1;let a=k;return x.value=!1,c(r,{...s,...typeof e==`object`?e:t,signal:C.signal}).then(e=>{if(x.value)return;_.value=e;let t=e.data;v.value=t,f(t)}).catch(e=>{S.value=e,p(e)}).finally(()=>{var e;(e=l.onFinish)==null||e.call(l),a===k&&T(!1)}),O};m&&i&&A();let j={response:_,data:v,error:S,isFinished:y,isLoading:b,cancel:w,isAborted:x,isCanceled:x,abort:w,execute:A};return{...j,...O}}exports.useAxios=f})(this.VueUse=this.VueUse||{},VueUse,axios,Vue);