@reause/integrations 0.1.2

package/dist/useAxios.iife.js

@@ -0,0 +1,288 @@
+(function(exports, _reause_shared, axios, react) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region \0rolldown/runtime.js
+	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 || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+	//#endregion
+	axios = __toESM(axios, 1);
+	//#region useAxios/index.tsx
+	/**
+	* React port of VueUse's `useAxios` — wrapper for
+	* [`axios`](https://github.com/axios/axios).
+	*
+	* Map from @vueuse/integrations `useAxios`
+	* (`source/vueuse/packages/integrations/useAxios/`). All 12 upstream overloads
+	* are kept verbatim (`(url, config?, options?)`, `(url, instance?, options?)`,
+	* `(url, config, instance, options?)`, `(config)`, `(instance)`,
+	* `(config, instance)`); the url-ful forms expose `execute(url?, config?)`,
+	* the url-less forms require `execute(url, config?)`. The returned object
+	* mirrors the upstream members — `response`, `data`, `isFinished`,
+	* `isLoading`, `isAborted`/`isCanceled`, `error`, `abort`/`cancel`, `execute` —
+	* but the members are plain values backed by live getters instead of refs
+	* (no `.value`), and the object is thenable (`await useAxios(url)` resolves
+	* with the shell once the request settled, rejecting when it failed).
+	*
+	* Adjustment for React:
+	* - the returned object is built with `Object.create` over a getter base whose
+	*   members read a synchronously-updated live mirror of the state, so a shell
+	*   captured earlier (e.g. the value `await` resolved with) still exposes
+	*   fresh values — the same shape `useAsyncState` uses. The base itself is
+	*   deliberately NOT thenable, so resolving it can never re-adopt `then`;
+	* - `execute` returns the shared thenable shell (upstream `return promise`):
+	*   `await execute()` resolves with the shell once the request finished,
+	*   rejecting with the request error on failure, and a bare unawaited
+	*   `execute()` never settles eagerly — so no unhandled rejection can
+	*   escape. `immediate` requests fire from a mount effect (upstream fires
+	*   during setup), and the shell is never left without a rejection handler
+	*   there;
+	* - a pending request is aborted on unmount (React-safety deviation: upstream
+	*   only relies on the `isAborted` guard), so a late response can never
+	*   populate `data`/`response` after the component is gone;
+	* - `shallow` is accepted for API parity but has no effect: React state is
+	*   never deep-wrapped, so there is no `shallowRef`/`ref` distinction here.
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @example
+	* const { data, isLoading, isFinished, execute, abort } = useAxios('/api/posts')
+	* await execute('/api/posts/2')
+	*
+	* @see https://vueuse.org/integrations/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 { onSuccess = _reause_shared.noop, onError = _reause_shared.noop, immediate, resetOnExecute = false } = options;
+		const initialData = options.initialData;
+		const urlRef = (0, react.useRef)(url);
+		urlRef.current = url;
+		const configRef = (0, react.useRef)(defaultConfig);
+		configRef.current = defaultConfig;
+		const instanceRef = (0, react.useRef)(instance);
+		instanceRef.current = instance;
+		const optionsRef = (0, react.useRef)(options);
+		optionsRef.current = options;
+		const immediateRef = (0, react.useRef)(immediate);
+		immediateRef.current = immediate;
+		const resetOnExecuteRef = (0, react.useRef)(resetOnExecute);
+		resetOnExecuteRef.current = resetOnExecute;
+		const initialDataRef = (0, react.useRef)(initialData);
+		initialDataRef.current = initialData;
+		const onSuccessRef = (0, react.useRef)(onSuccess);
+		onSuccessRef.current = onSuccess;
+		const onErrorRef = (0, react.useRef)(onError);
+		onErrorRef.current = onError;
+		const onFinishRef = (0, react.useRef)(options.onFinish);
+		onFinishRef.current = options.onFinish;
+		const [response, setResponse] = (0, react.useState)(void 0);
+		const [data, setData] = (0, react.useState)(initialData);
+		const [isFinished, setIsFinished] = (0, react.useState)(false);
+		const [isLoading, setIsLoading] = (0, react.useState)(false);
+		const [isAborted, setIsAborted] = (0, react.useState)(false);
+		const [error, setError] = (0, react.useState)(void 0);
+		const liveRef = (0, react.useRef)({
+			response,
+			data,
+			isFinished,
+			isLoading,
+			isAborted,
+			error
+		});
+		const abortControllerRef = (0, react.useRef)(null);
+		if (abortControllerRef.current === null) abortControllerRef.current = new AbortController();
+		const executeCounterRef = (0, react.useRef)(0);
+		const waitersRef = (0, react.useRef)([]);
+		const baseRef = (0, react.useRef)(null);
+		const shellRef = (0, react.useRef)(null);
+		const abort = (0, react.useCallback)((message) => {
+			var _abortControllerRef$c;
+			if (liveRef.current.isFinished || !liveRef.current.isLoading) return;
+			(_abortControllerRef$c = abortControllerRef.current) === null || _abortControllerRef$c === void 0 || _abortControllerRef$c.abort(message);
+			abortControllerRef.current = new AbortController();
+			liveRef.current.isAborted = true;
+			liveRef.current.isLoading = false;
+			liveRef.current.isFinished = false;
+			setIsAborted(true);
+			setIsLoading(false);
+			setIsFinished(false);
+		}, []);
+		const loading = (0, react.useCallback)((value) => {
+			liveRef.current.isLoading = value;
+			liveRef.current.isFinished = !value;
+			setIsLoading(value);
+			setIsFinished(!value);
+		}, []);
+		/**
+		* Reset data to initialData
+		*/
+		const resetData = (0, react.useCallback)(() => {
+			if (!resetOnExecuteRef.current) return;
+			liveRef.current.data = initialDataRef.current;
+			setData(initialDataRef.current);
+		}, []);
+		const drainWaiters = (0, react.useCallback)(() => {
+			const waiters = waitersRef.current;
+			if (waiters.length === 0) return;
+			waitersRef.current = [];
+			const currentError = liveRef.current.error;
+			const result = baseRef.current;
+			waiters.forEach(({ resolve, reject }) => {
+				if (currentError) reject(currentError);
+				else resolve(result);
+			});
+		}, []);
+		const execute = (0, react.useCallback)((executeUrl = urlRef.current, config = {}) => {
+			var _urlRef$current, _abortControllerRef$c2;
+			liveRef.current.error = void 0;
+			setError(void 0);
+			const _url = typeof executeUrl === "string" ? executeUrl : (_urlRef$current = urlRef.current) !== null && _urlRef$current !== void 0 ? _urlRef$current : config.url;
+			if (_url === void 0) {
+				const invalidUrlError = new axios.AxiosError(axios.AxiosError.ERR_INVALID_URL);
+				liveRef.current.error = invalidUrlError;
+				liveRef.current.isFinished = true;
+				setError(invalidUrlError);
+				setIsFinished(true);
+				return shellRef.current;
+			}
+			resetData();
+			if (optionsRef.current.abortPrevious !== false) abort();
+			loading(true);
+			executeCounterRef.current += 1;
+			const currentExecuteCounter = executeCounterRef.current;
+			liveRef.current.isAborted = false;
+			setIsAborted(false);
+			instanceRef.current(_url, {
+				...configRef.current,
+				...typeof executeUrl === "object" ? executeUrl : config,
+				signal: (_abortControllerRef$c2 = abortControllerRef.current) === null || _abortControllerRef$c2 === void 0 ? void 0 : _abortControllerRef$c2.signal
+			}).then((result) => {
+				if (liveRef.current.isAborted) return;
+				liveRef.current.response = result;
+				setResponse(result);
+				const payload = result === null || result === void 0 ? void 0 : result.data;
+				liveRef.current.data = payload;
+				setData(payload);
+				onSuccessRef.current(payload);
+			}).catch((e) => {
+				liveRef.current.error = e;
+				setError(e);
+				onErrorRef.current(e);
+			}).finally(() => {
+				var _onFinishRef$current;
+				(_onFinishRef$current = onFinishRef.current) === null || _onFinishRef$current === void 0 || _onFinishRef$current.call(onFinishRef);
+				if (currentExecuteCounter === executeCounterRef.current) {
+					loading(false);
+					drainWaiters();
+				}
+			});
+			return shellRef.current;
+		}, [
+			abort,
+			drainWaiters,
+			loading,
+			resetData
+		]);
+		const base = {
+			get response() {
+				return liveRef.current.response;
+			},
+			get data() {
+				return liveRef.current.data;
+			},
+			get isFinished() {
+				return liveRef.current.isFinished;
+			},
+			get isLoading() {
+				return liveRef.current.isLoading;
+			},
+			get isAborted() {
+				return liveRef.current.isAborted;
+			},
+			get isCanceled() {
+				return liveRef.current.isAborted;
+			},
+			get error() {
+				return liveRef.current.error;
+			},
+			abort,
+			cancel: abort,
+			execute
+		};
+		baseRef.current = base;
+		const waitUntilFinished = (0, react.useCallback)(() => {
+			return new Promise((resolve, reject) => {
+				if (!liveRef.current.isLoading) {
+					const currentError = liveRef.current.error;
+					if (currentError) reject(currentError);
+					else resolve(baseRef.current);
+					return;
+				}
+				waitersRef.current.push({
+					resolve,
+					reject
+				});
+			});
+		}, []);
+		(0, react.useEffect)(() => {
+			if (immediateRef.current && urlRef.current) execute().catch(_reause_shared.noop);
+		}, [execute]);
+		(0, react.useEffect)(() => () => {
+			var _abortControllerRef$c3;
+			(_abortControllerRef$c3 = abortControllerRef.current) === null || _abortControllerRef$c3 === void 0 || _abortControllerRef$c3.abort();
+		}, []);
+		(0, react.useEffect)(() => {
+			if (isLoading) return;
+			drainWaiters();
+		}, [isLoading, drainWaiters]);
+		const shell = Object.create(base);
+		shell.then = function then(onFulfilled, onRejected) {
+			return waitUntilFinished().then(onFulfilled, onRejected);
+		};
+		shell.catch = function catchFn(onRejected) {
+			return waitUntilFinished().catch(onRejected);
+		};
+		shellRef.current = shell;
+		return shell;
+	}
+	//#endregion
+	exports.useAxios = useAxios;
+})(this.reause = this.reause || {}, reause, axios, React);

package/dist/useAxios.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});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};n=((e,t,n)=>(n=e==null?{}:i(c(e)),u(t||!e||!e.__esModule||!l.call(e,`default`)?a(n,`default`,{value:e,enumerable:!0}):n,e)))(n,1);function d(...e){let i=typeof e[0]==`string`?e[0]:void 0,a=+(typeof i==`string`),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{onSuccess:d=t.noop,onError:f=t.noop,immediate:p,resetOnExecute:m=!1}=l,h=l.initialData,g=(0,r.useRef)(i);g.current=i;let _=(0,r.useRef)(s);_.current=s;let v=(0,r.useRef)(c);v.current=c;let y=(0,r.useRef)(l);y.current=l;let b=(0,r.useRef)(p);b.current=p;let x=(0,r.useRef)(m);x.current=m;let S=(0,r.useRef)(h);S.current=h;let C=(0,r.useRef)(d);C.current=d;let w=(0,r.useRef)(f);w.current=f;let T=(0,r.useRef)(l.onFinish);T.current=l.onFinish;let[E,D]=(0,r.useState)(void 0),[O,k]=(0,r.useState)(h),[A,j]=(0,r.useState)(!1),[M,N]=(0,r.useState)(!1),[P,F]=(0,r.useState)(!1),[I,L]=(0,r.useState)(void 0),R=(0,r.useRef)({response:E,data:O,isFinished:A,isLoading:M,isAborted:P,error:I}),z=(0,r.useRef)(null);z.current===null&&(z.current=new AbortController);let B=(0,r.useRef)(0),V=(0,r.useRef)([]),H=(0,r.useRef)(null),U=(0,r.useRef)(null),W=(0,r.useCallback)(e=>{var t;!R.current.isFinished&&R.current.isLoading&&((t=z.current)==null||t.abort(e),z.current=new AbortController,R.current.isAborted=!0,R.current.isLoading=!1,R.current.isFinished=!1,F(!0),N(!1),j(!1))},[]),G=(0,r.useCallback)(e=>{R.current.isLoading=e,R.current.isFinished=!e,N(e),j(!e)},[]),K=(0,r.useCallback)(()=>{x.current&&(R.current.data=S.current,k(S.current))},[]),q=(0,r.useCallback)(()=>{let e=V.current;if(e.length===0)return;V.current=[];let t=R.current.error,n=H.current;e.forEach(({resolve:e,reject:r})=>{t?r(t):e(n)})},[]),J=(0,r.useCallback)((e=g.current,t={})=>{var r,i;R.current.error=void 0,L(void 0);let a=typeof e==`string`?e:(r=g.current)==null?t.url:r;if(a===void 0){let e=new n.AxiosError(n.AxiosError.ERR_INVALID_URL);return R.current.error=e,R.current.isFinished=!0,L(e),j(!0),U.current}K(),y.current.abortPrevious!==!1&&W(),G(!0),B.current+=1;let o=B.current;return R.current.isAborted=!1,F(!1),v.current(a,{..._.current,...typeof e==`object`?e:t,signal:(i=z.current)==null?void 0:i.signal}).then(e=>{if(R.current.isAborted)return;R.current.response=e,D(e);let t=e==null?void 0:e.data;R.current.data=t,k(t),C.current(t)}).catch(e=>{R.current.error=e,L(e),w.current(e)}).finally(()=>{var e;(e=T.current)==null||e.call(T),o===B.current&&(G(!1),q())}),U.current},[W,q,G,K]),Y={get response(){return R.current.response},get data(){return R.current.data},get isFinished(){return R.current.isFinished},get isLoading(){return R.current.isLoading},get isAborted(){return R.current.isAborted},get isCanceled(){return R.current.isAborted},get error(){return R.current.error},abort:W,cancel:W,execute:J};H.current=Y;let X=(0,r.useCallback)(()=>new Promise((e,t)=>{if(!R.current.isLoading){let n=R.current.error;n?t(n):e(H.current);return}V.current.push({resolve:e,reject:t})}),[]);(0,r.useEffect)(()=>{b.current&&g.current&&J().catch(t.noop)},[J]),(0,r.useEffect)(()=>()=>{var e;(e=z.current)==null||e.abort()},[]),(0,r.useEffect)(()=>{M||q()},[M,q]);let Z=Object.create(Y);return Z.then=function(e,t){return X().then(e,t)},Z.catch=function(e){return X().catch(e)},U.current=Z,Z}e.useAxios=d})(this.reause=this.reause||{},reause,axios,React);

package/dist/useAxios.js

@@ -0,0 +1,265 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { noop } from "@reause/shared";
+import axios, { AxiosError } from "axios";
+//#region useAxios/index.tsx
+/**
+* React port of VueUse's `useAxios` — wrapper for
+* [`axios`](https://github.com/axios/axios).
+*
+* Map from @vueuse/integrations `useAxios`
+* (`source/vueuse/packages/integrations/useAxios/`). All 12 upstream overloads
+* are kept verbatim (`(url, config?, options?)`, `(url, instance?, options?)`,
+* `(url, config, instance, options?)`, `(config)`, `(instance)`,
+* `(config, instance)`); the url-ful forms expose `execute(url?, config?)`,
+* the url-less forms require `execute(url, config?)`. The returned object
+* mirrors the upstream members — `response`, `data`, `isFinished`,
+* `isLoading`, `isAborted`/`isCanceled`, `error`, `abort`/`cancel`, `execute` —
+* but the members are plain values backed by live getters instead of refs
+* (no `.value`), and the object is thenable (`await useAxios(url)` resolves
+* with the shell once the request settled, rejecting when it failed).
+*
+* Adjustment for React:
+* - the returned object is built with `Object.create` over a getter base whose
+*   members read a synchronously-updated live mirror of the state, so a shell
+*   captured earlier (e.g. the value `await` resolved with) still exposes
+*   fresh values — the same shape `useAsyncState` uses. The base itself is
+*   deliberately NOT thenable, so resolving it can never re-adopt `then`;
+* - `execute` returns the shared thenable shell (upstream `return promise`):
+*   `await execute()` resolves with the shell once the request finished,
+*   rejecting with the request error on failure, and a bare unawaited
+*   `execute()` never settles eagerly — so no unhandled rejection can
+*   escape. `immediate` requests fire from a mount effect (upstream fires
+*   during setup), and the shell is never left without a rejection handler
+*   there;
+* - a pending request is aborted on unmount (React-safety deviation: upstream
+*   only relies on the `isAborted` guard), so a late response can never
+*   populate `data`/`response` after the component is gone;
+* - `shallow` is accepted for API parity but has no effect: React state is
+*   never deep-wrapped, so there is no `shallowRef`/`ref` distinction here.
+*
+* @__NO_SIDE_EFFECTS__
+* @example
+* const { data, isLoading, isFinished, execute, abort } = useAxios('/api/posts')
+* await execute('/api/posts/2')
+*
+* @see https://vueuse.org/integrations/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;
+	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 { onSuccess = noop, onError = noop, immediate, resetOnExecute = false } = options;
+	const initialData = options.initialData;
+	const urlRef = useRef(url);
+	urlRef.current = url;
+	const configRef = useRef(defaultConfig);
+	configRef.current = defaultConfig;
+	const instanceRef = useRef(instance);
+	instanceRef.current = instance;
+	const optionsRef = useRef(options);
+	optionsRef.current = options;
+	const immediateRef = useRef(immediate);
+	immediateRef.current = immediate;
+	const resetOnExecuteRef = useRef(resetOnExecute);
+	resetOnExecuteRef.current = resetOnExecute;
+	const initialDataRef = useRef(initialData);
+	initialDataRef.current = initialData;
+	const onSuccessRef = useRef(onSuccess);
+	onSuccessRef.current = onSuccess;
+	const onErrorRef = useRef(onError);
+	onErrorRef.current = onError;
+	const onFinishRef = useRef(options.onFinish);
+	onFinishRef.current = options.onFinish;
+	const [response, setResponse] = useState(void 0);
+	const [data, setData] = useState(initialData);
+	const [isFinished, setIsFinished] = useState(false);
+	const [isLoading, setIsLoading] = useState(false);
+	const [isAborted, setIsAborted] = useState(false);
+	const [error, setError] = useState(void 0);
+	const liveRef = useRef({
+		response,
+		data,
+		isFinished,
+		isLoading,
+		isAborted,
+		error
+	});
+	const abortControllerRef = useRef(null);
+	if (abortControllerRef.current === null) abortControllerRef.current = new AbortController();
+	const executeCounterRef = useRef(0);
+	const waitersRef = useRef([]);
+	const baseRef = useRef(null);
+	const shellRef = useRef(null);
+	const abort = useCallback((message) => {
+		var _abortControllerRef$c;
+		if (liveRef.current.isFinished || !liveRef.current.isLoading) return;
+		(_abortControllerRef$c = abortControllerRef.current) === null || _abortControllerRef$c === void 0 || _abortControllerRef$c.abort(message);
+		abortControllerRef.current = new AbortController();
+		liveRef.current.isAborted = true;
+		liveRef.current.isLoading = false;
+		liveRef.current.isFinished = false;
+		setIsAborted(true);
+		setIsLoading(false);
+		setIsFinished(false);
+	}, []);
+	const loading = useCallback((value) => {
+		liveRef.current.isLoading = value;
+		liveRef.current.isFinished = !value;
+		setIsLoading(value);
+		setIsFinished(!value);
+	}, []);
+	/**
+	* Reset data to initialData
+	*/
+	const resetData = useCallback(() => {
+		if (!resetOnExecuteRef.current) return;
+		liveRef.current.data = initialDataRef.current;
+		setData(initialDataRef.current);
+	}, []);
+	const drainWaiters = useCallback(() => {
+		const waiters = waitersRef.current;
+		if (waiters.length === 0) return;
+		waitersRef.current = [];
+		const currentError = liveRef.current.error;
+		const result = baseRef.current;
+		waiters.forEach(({ resolve, reject }) => {
+			if (currentError) reject(currentError);
+			else resolve(result);
+		});
+	}, []);
+	const execute = useCallback((executeUrl = urlRef.current, config = {}) => {
+		var _urlRef$current, _abortControllerRef$c2;
+		liveRef.current.error = void 0;
+		setError(void 0);
+		const _url = typeof executeUrl === "string" ? executeUrl : (_urlRef$current = urlRef.current) !== null && _urlRef$current !== void 0 ? _urlRef$current : config.url;
+		if (_url === void 0) {
+			const invalidUrlError = new AxiosError(AxiosError.ERR_INVALID_URL);
+			liveRef.current.error = invalidUrlError;
+			liveRef.current.isFinished = true;
+			setError(invalidUrlError);
+			setIsFinished(true);
+			return shellRef.current;
+		}
+		resetData();
+		if (optionsRef.current.abortPrevious !== false) abort();
+		loading(true);
+		executeCounterRef.current += 1;
+		const currentExecuteCounter = executeCounterRef.current;
+		liveRef.current.isAborted = false;
+		setIsAborted(false);
+		instanceRef.current(_url, {
+			...configRef.current,
+			...typeof executeUrl === "object" ? executeUrl : config,
+			signal: (_abortControllerRef$c2 = abortControllerRef.current) === null || _abortControllerRef$c2 === void 0 ? void 0 : _abortControllerRef$c2.signal
+		}).then((result) => {
+			if (liveRef.current.isAborted) return;
+			liveRef.current.response = result;
+			setResponse(result);
+			const payload = result === null || result === void 0 ? void 0 : result.data;
+			liveRef.current.data = payload;
+			setData(payload);
+			onSuccessRef.current(payload);
+		}).catch((e) => {
+			liveRef.current.error = e;
+			setError(e);
+			onErrorRef.current(e);
+		}).finally(() => {
+			var _onFinishRef$current;
+			(_onFinishRef$current = onFinishRef.current) === null || _onFinishRef$current === void 0 || _onFinishRef$current.call(onFinishRef);
+			if (currentExecuteCounter === executeCounterRef.current) {
+				loading(false);
+				drainWaiters();
+			}
+		});
+		return shellRef.current;
+	}, [
+		abort,
+		drainWaiters,
+		loading,
+		resetData
+	]);
+	const base = {
+		get response() {
+			return liveRef.current.response;
+		},
+		get data() {
+			return liveRef.current.data;
+		},
+		get isFinished() {
+			return liveRef.current.isFinished;
+		},
+		get isLoading() {
+			return liveRef.current.isLoading;
+		},
+		get isAborted() {
+			return liveRef.current.isAborted;
+		},
+		get isCanceled() {
+			return liveRef.current.isAborted;
+		},
+		get error() {
+			return liveRef.current.error;
+		},
+		abort,
+		cancel: abort,
+		execute
+	};
+	baseRef.current = base;
+	const waitUntilFinished = useCallback(() => {
+		return new Promise((resolve, reject) => {
+			if (!liveRef.current.isLoading) {
+				const currentError = liveRef.current.error;
+				if (currentError) reject(currentError);
+				else resolve(baseRef.current);
+				return;
+			}
+			waitersRef.current.push({
+				resolve,
+				reject
+			});
+		});
+	}, []);
+	useEffect(() => {
+		if (immediateRef.current && urlRef.current) execute().catch(noop);
+	}, [execute]);
+	useEffect(() => () => {
+		var _abortControllerRef$c3;
+		(_abortControllerRef$c3 = abortControllerRef.current) === null || _abortControllerRef$c3 === void 0 || _abortControllerRef$c3.abort();
+	}, []);
+	useEffect(() => {
+		if (isLoading) return;
+		drainWaiters();
+	}, [isLoading, drainWaiters]);
+	const shell = Object.create(base);
+	shell.then = function then(onFulfilled, onRejected) {
+		return waitUntilFinished().then(onFulfilled, onRejected);
+	};
+	shell.catch = function catchFn(onRejected) {
+		return waitUntilFinished().catch(onRejected);
+	};
+	shellRef.current = shell;
+	return shell;
+}
+//#endregion
+export { useAxios };

package/dist/useChangeCase.d.ts

@@ -0,0 +1,57 @@
+import { Dispatch, SetStateAction } from "react";
+import { RefOrValue } from "@reause/shared";
+import * as changeCase from "change-case";
+import { Options } from "change-case";
+//#region useChangeCase/index.d.ts
+type EndsWithCase<T> = T extends `${infer _}Case` ? T : never;
+type FilterKeys<T> = { [K in keyof T as K extends string ? K : never]: EndsWithCase<K>; };
+type ChangeCaseKeys = FilterKeys<typeof changeCase>;
+/**
+ * Union of the transformations `change-case` exports as `*Case` functions —
+ * derived from the module the same way VueUse does (`noCase`, `camelCase`,
+ * `capitalCase`, `constantCase`, `dotCase`, `kebabCase`, `pascalCase`,
+ * `pascalSnakeCase`, `pathCase`, `sentenceCase`, `snakeCase`, `trainCase`).
+ */
+export type ChangeCaseType = ChangeCaseKeys[keyof ChangeCaseKeys];
+/**
+ * React return type: `[value, setValue]` tuple — the writable-side analog of
+ * the upstream `WritableComputedRef<string>` (issue §2B). `value` is the
+ * transformed string; `setValue` updates the internal input state.
+ */
+export type UseChangeCaseReturn = [string, Dispatch<SetStateAction<string>>];
+/**
+ * React port of VueUse's `useChangeCase`.
+ *
+ * Map from @vueuse/integrations `useChangeCase`
+ * (`source/vueuse/packages/integrations/useChangeCase/`), a reactive wrapper
+ * around the `change-case` package. Upstream returns a writable
+ * `WritableComputedRef<string>`; here the writable computed ref maps to a
+ * `[value, setValue]` tuple: `value` is the transformed string (`change-case`
+ * applied to the internal input state with the current `type`), and
+ * `setValue` updates that internal input state like a controlled `useState`.
+ * `input` is the hook's **read-only value source** and takes a plain `string`
+ * (upstream: `MaybeRef<string>` / `MaybeRefOrGetter<string>`); `type` and
+ * `options` stay `RefOrValue` (format knobs, upstream `MaybeRefOrGetter`) and
+ * are resolved with `toValue` from `@reause/shared`.
+ *
+ * Adjustment for React:
+ * - upstream's writable computed captures a plain `input` once at setup. Here
+ *   a changed `input` prop re-syncs the internal state on the next render, so
+ *   a parent re-render with a new string is reflected; a `setValue` write is
+ *   never clobbered while the `input` prop is unchanged (the baseline records
+ *   the last externally synced value);
+ * - writes are **not** propagated back to the caller: `setValue` updates the
+ *   internal input state only (upstream's writable computed writes through to
+ *   a ref input). A changed `input` prop always wins over the internal state;
+ * - `setValue` writes the RAW string; the transform is re-applied on the next
+ *   render (the upstream computed's `get` re-derives from the ref on access).
+ *
+ * @__NO_SIDE_EFFECTS__
+ * @example
+ * const [changeCase, setChangeCase] = useChangeCase('hello world', 'camelCase')
+ * changeCase // 'helloWorld'
+ * setChangeCase('vue use')
+ * changeCase // 'vueUse'
+ */
+export declare function useChangeCase(input: string, type: RefOrValue<ChangeCaseType>, options?: RefOrValue<Options> | undefined): UseChangeCaseReturn;
+//#endregion