@hairy/react-lib 1.46.0 → 1.49.0

package/dist/index.cjs

@@ -1,862 +1,504 @@
-"use strict";
+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 __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;
+	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(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Case: () => Case,
-  Default: () => Default,
-  Else: () => Else,
-  If: () => If,
-  Injector: () => Injector,
-  Switch: () => Switch,
-  Then: () => Then,
-  Trigger: () => Trigger,
-  Unless: () => Unless,
-  cls: () => cls,
-  defienAsyncStore: () => defienAsyncStore,
-  defineStore: () => defineStore,
-  defineStoreAsync: () => defineStoreAsync,
-  proxyWithPersistant: () => proxyWithPersistant,
-  track: () => track,
-  tryUseCallback: () => tryUseCallback,
-  tryUseEffect: () => tryUseEffect,
-  tryUseInsertionEffect: () => tryUseInsertionEffect,
-  tryUseReducer: () => tryUseReducer,
-  tryUseRef: () => tryUseRef,
-  tryUseState: () => tryUseState,
-  tryUseUpdate: () => tryUseUpdate,
-  useAsyncCallback: () => useAsyncCallback,
-  useAsyncState: () => useAsyncState,
-  useDebounce: () => useDebounce,
-  useEventBus: () => useEventBus,
-  useFetchRequestIntercept: () => useFetchRequestIntercept,
-  useFetchResponseIntercept: () => useFetchResponseIntercept,
-  useMounted: () => useMounted,
-  useOffsetPagination: () => useOffsetPagination,
-  useStatus: () => useStatus,
-  useStore: () => useStore,
-  useUpdate: () => useUpdate,
-  useWatch: () => useWatch,
-  useWhenever: () => useWhenever,
-  wrapper: () => wrapper
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/utils/cls.ts
-var hasOwn = {}.hasOwnProperty;
+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
+let _hairy_utils = require("@hairy/utils");
+let valtio = require("valtio");
+let react = require("react");
+let valtio_utils = require("valtio/utils");
+let mitt = require("mitt");
+mitt = __toESM(mitt);
+let react_use = require("react-use");
+
+//#region src/utils/cls.ts
+const hasOwn = {}.hasOwnProperty;
+/**
+* A simple JavaScript utility for conditionally joining classNames together.
+*/
 function cls(...args) {
-  let classes = "";
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg)
-      classes = cls.append(classes, cls.parse(arg));
-  }
-  return classes;
+	let classes = "";
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg) classes = cls.append(classes, cls.parse(arg));
+	}
+	return classes;
 }
 cls.parse = function(arg) {
-  if (typeof arg === "string")
-    return arg;
-  if (typeof arg !== "object")
-    return "";
-  if (Array.isArray(arg))
-    return cls.apply(null, arg);
-  if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes("[native code]"))
-    return cls.toString();
-  let classes = "";
-  for (const key in arg) {
-    if (hasOwn.call(arg, key) && arg[key])
-      classes = cls.append(classes, key);
-  }
-  return classes;
+	if (typeof arg === "string") return arg;
+	if (typeof arg !== "object") return "";
+	if (Array.isArray(arg)) return cls.apply(null, arg);
+	if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes("[native code]")) return cls.toString();
+	let classes = "";
+	for (const key in arg) if (hasOwn.call(arg, key) && arg[key]) classes = cls.append(classes, key);
+	return classes;
 };
 cls.append = function(value, newClass) {
-  if (!newClass)
-    return value;
-  return value ? `${value} ${newClass}` : newClass;
+	if (!newClass) return value;
+	return value ? `${value} ${newClass}` : newClass;
 };
 
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_freeGlobal.js
-var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
-var freeGlobal_default = freeGlobal;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_root.js
-var freeSelf = typeof self == "object" && self && self.Object === Object && self;
-var root = freeGlobal_default || freeSelf || Function("return this")();
-var root_default = root;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Symbol.js
-var Symbol2 = root_default.Symbol;
-var Symbol_default = Symbol2;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getRawTag.js
-var objectProto = Object.prototype;
-var hasOwnProperty = objectProto.hasOwnProperty;
-var nativeObjectToString = objectProto.toString;
-var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
-function getRawTag(value) {
-  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
-  try {
-    value[symToStringTag] = void 0;
-    var unmasked = true;
-  } catch (e) {
-  }
-  var result = nativeObjectToString.call(value);
-  if (unmasked) {
-    if (isOwn) {
-      value[symToStringTag] = tag;
-    } else {
-      delete value[symToStringTag];
-    }
-  }
-  return result;
-}
-var getRawTag_default = getRawTag;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_objectToString.js
-var objectProto2 = Object.prototype;
-var nativeObjectToString2 = objectProto2.toString;
-function objectToString(value) {
-  return nativeObjectToString2.call(value);
-}
-var objectToString_default = objectToString;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseGetTag.js
-var nullTag = "[object Null]";
-var undefinedTag = "[object Undefined]";
-var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
-function baseGetTag(value) {
-  if (value == null) {
-    return value === void 0 ? undefinedTag : nullTag;
-  }
-  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
-}
-var baseGetTag_default = baseGetTag;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isObject.js
-function isObject(value) {
-  var type = typeof value;
-  return value != null && (type == "object" || type == "function");
-}
-var isObject_default = isObject;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isFunction.js
-var asyncTag = "[object AsyncFunction]";
-var funcTag = "[object Function]";
-var genTag = "[object GeneratorFunction]";
-var proxyTag = "[object Proxy]";
-function isFunction(value) {
-  if (!isObject_default(value)) {
-    return false;
-  }
-  var tag = baseGetTag_default(value);
-  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
-}
-var isFunction_default = isFunction;
-
-// ../util-core/src/util/noop.ts
-var noop = () => {
-};
-
-// ../util-core/src/util/deferred.ts
-var Deferred = class extends Promise {
-  resolve;
-  reject;
-  constructor(executor = noop) {
-    let _resolve, _reject;
-    super((resolve_, reject_) => {
-      _resolve = resolve_;
-      _reject = reject_;
-      return executor(resolve_, reject_);
-    });
-    this.resolve = (value) => {
-      _resolve(value);
-      return this;
-    };
-    this.reject = (reason) => {
-      _reject(reason);
-      return this;
-    };
-  }
-};
-
-// ../util-core/src/util/json.ts
-function tryParseJson(text) {
-  try {
-    return JSON.parse(text || "");
-  } catch {
-    return void 0;
-  }
-}
-
-// src/utils/track.ts
-var import_valtio = require("valtio");
+//#endregion
+//#region src/utils/track.ts
+/**
+* @requires `Trigger` component to be mounted in the tree.
+*
+* @example
+* ```tsx
+* // Obtain externally
+* import { track } from '@hairy/lib-react'
+* const context = await track(() => useContext(YourContext))
+* console.log(context) // { ... }
+*/
 function track(fn, ...args) {
-  const deferred = (0, import_valtio.ref)(new Deferred());
-  const exposer = { fn, args, deferred, id: ++Trigger.id };
-  Trigger.tasks.set(exposer.id, exposer);
-  deferred.then(() => Trigger.tasks.delete(exposer.id));
-  return deferred;
-}
-
-// src/utils/wrapper.ts
-var import_react = require("react");
+	const deferred = (0, valtio.ref)(new _hairy_utils.Deferred());
+	const exposer = {
+		fn,
+		args,
+		deferred,
+		id: ++Trigger.id
+	};
+	Trigger.tasks.set(exposer.id, exposer);
+	deferred.then(() => Trigger.tasks.delete(exposer.id));
+	return deferred;
+}
+
+//#endregion
+//#region src/utils/wrapper.ts
 function wrapper(asChild, props, children) {
-  return asChild ? (0, import_react.createElement)(asChild, props, children) : children;
+	return asChild ? (0, react.createElement)(asChild, props, children) : children;
 }
 
-// src/components/condition/Case.ts
+//#endregion
+//#region src/components/condition/Case.ts
 function Case(props) {
-  const { cond, children, tag, as: asChild, ...attrs } = props;
-  return wrapper(tag || asChild, attrs, children);
+	const { cond, children, tag, as: asChild, ...attrs } = props;
+	return wrapper(tag || asChild, attrs, children);
 }
 
-// src/components/condition/Default.ts
+//#endregion
+//#region src/components/condition/Default.ts
 function Default(props) {
-  const { children, tag, as: asChild, ...attrs } = props;
-  return wrapper(tag || asChild, attrs, children);
+	const { children, tag, as: asChild, ...attrs } = props;
+	return wrapper(tag || asChild, attrs, children);
 }
 
-// src/components/condition/If.ts
-var import_react2 = require("react");
-
-// src/components/condition/Then.ts
+//#endregion
+//#region src/components/condition/Then.ts
 function Then(props) {
-  const { children, cond, else: _else, then, tag, as: asChild, ...attrs } = props;
-  return Object.keys(props).includes("cond") ? wrapper(If, props, children) : wrapper(tag || asChild, attrs, children);
+	const { children, cond, else: _else, then, tag, as: asChild, ...attrs } = props;
+	return Object.keys(props).includes("cond") ? wrapper(If, props, children) : wrapper(tag || asChild, attrs, children);
 }
 
-// src/components/condition/If.ts
+//#endregion
+//#region src/components/condition/If.ts
 function If(props) {
-  const { then, cond, else: _else, children = props.then, tag, as: asChild, ...attrs } = props;
-  const elements = import_react2.Children.toArray(children);
-  const thenChild = elements.find((c) => c.type === Then);
-  const elseChild = elements.find((c) => c.type === Else);
-  const child = thenChild || elseChild ? cond ? thenChild : elseChild : cond ? children : _else;
-  return wrapper(tag || asChild, attrs, child);
+	const { then, cond, else: _else, children = props.then, tag, as: asChild, ...attrs } = props;
+	const elements = react.Children.toArray(children);
+	const thenChild = elements.find((c) => c.type === Then);
+	const elseChild = elements.find((c) => c.type === Else);
+	return wrapper(tag || asChild, attrs, thenChild || elseChild ? cond ? thenChild : elseChild : cond ? children : _else);
 }
 
-// src/components/condition/Else.ts
+//#endregion
+//#region src/components/condition/Else.ts
 function Else(props) {
-  const { children, tag, as: asChild, ...attrs } = props;
-  return Object.keys(props).includes("cond") ? wrapper(If, props, children) : wrapper(tag || asChild, attrs, children);
+	const { children, tag, as: asChild, ...attrs } = props;
+	return Object.keys(props).includes("cond") ? wrapper(If, props, children) : wrapper(tag || asChild, attrs, children);
 }
 
-// src/components/condition/Switch.ts
-var import_react3 = require("react");
+//#endregion
+//#region src/components/condition/Switch.ts
 function Switch(props) {
-  const isUseValue = props.value !== void 0;
-  let matchingCase;
-  let defaultCase;
-  import_react3.Children.forEach(props.children, (child) => {
-    if (!(0, import_react3.isValidElement)(child) || matchingCase)
-      return;
-    if (child.type === Case) {
-      const cond = child?.props?.cond;
-      if (isUseValue ? props.value === cond : cond) {
-        matchingCase = child;
-        return;
-      }
-    }
-    if (!defaultCase && child.type === Default)
-      defaultCase = child;
-  });
-  return matchingCase ?? defaultCase ?? null;
-}
-
-// src/components/condition/Unless.ts
-var import_react4 = require("react");
+	const isUseValue = props.value !== void 0;
+	let matchingCase;
+	let defaultCase;
+	react.Children.forEach(props.children, (child) => {
+		if (!(0, react.isValidElement)(child) || matchingCase) return;
+		if (child.type === Case) {
+			const cond = child?.props?.cond;
+			if (isUseValue ? props.value === cond : cond) {
+				matchingCase = child;
+				return;
+			}
+		}
+		if (!defaultCase && child.type === Default) defaultCase = child;
+	});
+	return matchingCase ?? defaultCase ?? null;
+}
+
+//#endregion
+//#region src/components/condition/Unless.ts
 function Unless(props) {
-  const { cond, then, else: _else, tag, as: asChild, children = props.then, ...attrs } = props;
-  const elements = import_react4.Children.toArray(children);
-  const thenChild = elements.find((c) => c.type === Then);
-  const elseChild = elements.find((c) => c.type === Else);
-  const child = thenChild || elseChild ? !cond ? elseChild : thenChild : !cond ? children : _else;
-  return wrapper(tag || asChild, attrs, child);
+	const { cond, then, else: _else, tag, as: asChild, children = props.then, ...attrs } = props;
+	const elements = react.Children.toArray(children);
+	const thenChild = elements.find((c) => c.type === Then);
+	const elseChild = elements.find((c) => c.type === Else);
+	return wrapper(tag || asChild, attrs, thenChild || elseChild ? !cond ? elseChild : thenChild : !cond ? children : _else);
 }
 
-// src/components/utils/Injector.ts
-var import_react5 = require("react");
+//#endregion
+//#region src/components/utils/Injector.ts
 function Injector(props) {
-  const installs = (0, import_react5.useMemo)(
-    () => props.install.map(repack).reverse(),
-    [props.install]
-  );
-  return installs.reduce(
-    (child, { component: Component, props: props2 }) => (0, import_react5.createElement)(Component, props2, child),
-    props.children
-  );
+	return (0, react.useMemo)(() => props.install.map(repack).reverse(), [props.install]).reduce((child, { component: Component, props }) => (0, react.createElement)(Component, props, child), props.children);
 }
 function repack(c) {
-  return c.component ? c : { component: c };
+	return c.component ? c : { component: c };
 }
 
-// src/components/utils/Trigger.ts
-var import_react6 = require("react");
-var import_valtio2 = require("valtio");
-var import_utils8 = require("valtio/utils");
-var pendingTasks = (0, import_utils8.proxyMap)();
+//#endregion
+//#region src/components/utils/Trigger.ts
+const pendingTasks = (0, valtio_utils.proxyMap)();
 function createTracker(exposer) {
-  const Component = () => {
-    try {
-      exposer.deferred.resolve(exposer.fn(...exposer.args));
-    } catch (error) {
-      exposer.deferred.reject(error);
-    }
-    return null;
-  };
-  Component.key = exposer.id;
-  return Component;
+	const Component = () => {
+		try {
+			exposer.deferred.resolve(exposer.fn(...exposer.args));
+		} catch (error) {
+			exposer.deferred.reject(error);
+		}
+		return null;
+	};
+	Component.key = exposer.id;
+	return Component;
 }
 function renderTracker(Tracker) {
-  return (0, import_react6.createElement)(Tracker, { key: Tracker.key });
-}
+	return (0, react.createElement)(Tracker, { key: Tracker.key });
+}
+/**
+* @example
+* ```tsx
+* import { Trigger } from '@hairy/lib-react'
+*
+* // Use triggers to capture context
+* function App() {
+*  return (
+*   <YourContext.Provider>
+*    <Trigger />
+*   </YourContext.Provider>
+*  )
+* }
+*
+* // Obtain externally
+* import { track } from '@hairy/lib-react'
+* const context = await track(() => useContext(YourContext))
+* console.log(context) // { ... }
+* ```
+*/
 function Trigger() {
-  const values = [...(0, import_valtio2.useSnapshot)(pendingTasks).values()];
-  return values.map(createTracker).map(renderTracker);
+	return [...(0, valtio.useSnapshot)(pendingTasks).values()].map(createTracker).map(renderTracker);
 }
 Trigger.id = 0;
 Trigger.tasks = pendingTasks;
 
-// src/hooks/tryUseCallback.ts
-var import_react7 = require("react");
-var tryUseCallback = (callback, deps) => {
-  try {
-    return (0, import_react7.useCallback)(callback, deps);
-  } catch {
-    return callback;
-  }
+//#endregion
+//#region src/hooks/tryUseCallback.ts
+const tryUseCallback = (callback, deps) => {
+	try {
+		return (0, react.useCallback)(callback, deps);
+	} catch {
+		return callback;
+	}
 };
 
-// src/hooks/tryUseEffect.ts
-var import_react8 = require("react");
-var tryUseEffect = (effect, deps) => {
-  try {
-    (0, import_react8.useEffect)(effect, deps);
-  } catch {
-  }
+//#endregion
+//#region src/hooks/tryUseEffect.ts
+const tryUseEffect = (effect, deps) => {
+	try {
+		(0, react.useEffect)(effect, deps);
+	} catch {}
 };
 
-// src/hooks/tryUseInsertionEffect.ts
-var import_react9 = require("react");
-var tryUseInsertionEffect = (callback, deps) => {
-  try {
-    (0, import_react9.useInsertionEffect)(callback, deps);
-  } catch {
-  }
+//#endregion
+//#region src/hooks/tryUseInsertionEffect.ts
+const tryUseInsertionEffect = (callback, deps) => {
+	try {
+		(0, react.useInsertionEffect)(callback, deps);
+	} catch {}
 };
 
-// src/hooks/tryUseReducer.ts
-var import_react10 = require("react");
-var tryUseReducer = (reducer, initializerArg, initializer) => {
-  try {
-    return (0, import_react10.useReducer)(reducer, initializerArg, initializer);
-  } catch {
-    return [initializerArg, () => {
-    }];
-  }
+//#endregion
+//#region src/hooks/tryUseReducer.ts
+const tryUseReducer = (reducer, initializerArg, initializer) => {
+	try {
+		return (0, react.useReducer)(reducer, initializerArg, initializer);
+	} catch {
+		return [initializerArg, () => {}];
+	}
 };
 
-// src/hooks/tryUseRef.ts
-var import_react11 = require("react");
-var tryUseRef = (initialValue) => {
-  try {
-    return (0, import_react11.useRef)(initialValue);
-  } catch {
-    return { current: initialValue };
-  }
+//#endregion
+//#region src/hooks/tryUseRef.ts
+const tryUseRef = (initialValue) => {
+	try {
+		return (0, react.useRef)(initialValue);
+	} catch {
+		return { current: initialValue };
+	}
 };
 
-// src/hooks/tryUseState.ts
-var import_react12 = require("react");
-var tryUseState = (initialState) => {
-  try {
-    return (0, import_react12.useState)(initialState);
-  } catch {
-    return [isFunction_default(initialState) ? initialState() : initialState, noop];
-  }
+//#endregion
+//#region src/hooks/tryUseState.ts
+const tryUseState = (initialState) => {
+	try {
+		return (0, react.useState)(initialState);
+	} catch {
+		return [(0, _hairy_utils.isFunction)(initialState) ? initialState() : initialState, _hairy_utils.noop];
+	}
 };
 
-// src/hooks/useUpdate.ts
-var updateReducer = (num) => (num + 1) % 1e6;
+//#endregion
+//#region src/hooks/useUpdate.ts
+const updateReducer = (num) => (num + 1) % 1e6;
 function useUpdate() {
-  const [, update] = tryUseReducer(updateReducer, 0);
-  return update;
+	const [, update] = tryUseReducer(updateReducer, 0);
+	return update;
 }
 
-// src/hooks/tryUseUpdate.ts
+//#endregion
+//#region src/hooks/tryUseUpdate.ts
 function tryUseUpdate() {
-  try {
-    return useUpdate();
-  } catch {
-    return () => {
-    };
-  }
+	try {
+		return useUpdate();
+	} catch {
+		return () => {};
+	}
 }
 
-// src/hooks/useAsyncCallback.ts
-var import_react13 = require("react");
+//#endregion
+//#region src/hooks/useAsyncCallback.ts
 function useAsyncCallback(fun) {
-  const [state, set] = (0, import_react13.useState)({ loading: false });
-  async function refetch(...args) {
-    set({ loading: true });
-    return fun(...args).then((value) => {
-      set({ loading: false });
-      return value;
-    }).catch((err) => {
-      set({ loading: false, error: err });
-      return Promise.reject(err);
-    });
-  }
-  return [state.loading, refetch, state.error];
-}
-
-// src/hooks/useAsyncState.ts
-var import_react14 = require("react");
+	const [state, set] = (0, react.useState)({ loading: false });
+	async function refetch(...args) {
+		set({ loading: true });
+		return fun(...args).then((value) => {
+			set({ loading: false });
+			return value;
+		}).catch((err) => {
+			set({
+				loading: false,
+				error: err
+			});
+			return Promise.reject(err);
+		});
+	}
+	return [
+		state.loading,
+		refetch,
+		state.error
+	];
+}
+
+//#endregion
+//#region src/hooks/useAsyncState.ts
 function useAsyncState(fun, deps = [], options) {
-  const [value, set] = (0, import_react14.useState)(options?.initial);
-  const [loading, refetch, error] = useAsyncCallback(async (...args) => fun(...args).then(set));
-  (0, import_react14.useEffect)(
-    () => {
-      refetch();
-    },
-    deps
-  );
-  return [{ value, loading, error }, refetch];
-}
-
-// src/hooks/useDebounce.ts
-var import_react15 = require("react");
+	const [value, set] = (0, react.useState)(options?.initial);
+	const [loading, refetch, error] = useAsyncCallback(async (...args) => fun(...args).then(set));
+	(0, react.useEffect)(() => {
+		refetch();
+	}, deps);
+	return [{
+		value,
+		loading,
+		error
+	}, refetch];
+}
+
+//#endregion
+//#region src/hooks/useDebounce.ts
 function useDebounce(value, delay) {
-  const [debouncedValue, setDebouncedValue] = (0, import_react15.useState)(value);
-  (0, import_react15.useEffect)(() => {
-    const handler = setTimeout(() => setDebouncedValue(value), delay);
-    return () => clearTimeout(handler);
-  }, [value, delay]);
-  return debouncedValue;
+	const [debouncedValue, setDebouncedValue] = (0, react.useState)(value);
+	(0, react.useEffect)(() => {
+		const handler = setTimeout(() => setDebouncedValue(value), delay);
+		return () => clearTimeout(handler);
+	}, [value, delay]);
+	return debouncedValue;
 }
 
-// src/hooks/useEventBus.ts
-var import_mitt = __toESM(require("mitt"), 1);
-var import_react16 = require("react");
-var emitter = (0, import_mitt.default)();
+//#endregion
+//#region src/hooks/useEventBus.ts
+const emitter = (0, mitt.default)();
 function useEventBus(key) {
-  const onRef = (0, import_react16.useRef)(void 0);
-  function on(listener) {
-    emitter.on(key, listener);
-    onRef.current = listener;
-    (0, import_react16.useEffect)(() => {
-      if (!onRef.current)
-        return;
-      emitter.off(key, onRef.current);
-      emitter.on(key, listener);
-      onRef.current = listener;
-      return () => emitter.off(key, listener);
-    }, [listener]);
-  }
-  function emit(event) {
-    emitter.emit(key, event);
-  }
-  function off(listener) {
-    emitter.off(key, listener);
-  }
-  return {
-    on,
-    emit,
-    off
-  };
-}
-
-// ../../node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/react-use/esm/useEffectOnce.js
-var import_react17 = require("react");
-var useEffectOnce = function(effect) {
-  (0, import_react17.useEffect)(effect, []);
-};
-var useEffectOnce_default = useEffectOnce;
-
-// ../../node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/react-use/esm/useMount.js
-var useMount = function(fn) {
-  useEffectOnce_default(function() {
-    fn();
-  });
-};
-var useMount_default = useMount;
-
-// src/hooks/useFetchIntercept.ts
+	const onRef = (0, react.useRef)(void 0);
+	function on(listener) {
+		emitter.on(key, listener);
+		onRef.current = listener;
+		(0, react.useEffect)(() => {
+			if (!onRef.current) return;
+			emitter.off(key, onRef.current);
+			emitter.on(key, listener);
+			onRef.current = listener;
+			return () => emitter.off(key, listener);
+		}, [listener]);
+	}
+	function emit(event) {
+		emitter.emit(key, event);
+	}
+	function off(listener) {
+		emitter.off(key, listener);
+	}
+	return {
+		on,
+		emit,
+		off
+	};
+}
+
+//#endregion
+//#region src/hooks/useFetchIntercept.ts
 function useFetchResponseIntercept(intercept) {
-  useMount_default(() => fetchResponseIntercept(intercept));
+	(0, react_use.useMount)(() => fetchResponseIntercept(intercept));
 }
 function useFetchRequestIntercept(intercept) {
-  useMount_default(() => fetchRequestIntercept(intercept));
+	(0, react_use.useMount)(() => fetchRequestIntercept(intercept));
 }
 function fetchResponseIntercept(intercept) {
-  const { fetch: originalFetch } = window;
-  window.fetch = async (...args) => {
-    const [resource, config] = args;
-    const response = await originalFetch(resource, config);
-    return intercept(response, config);
-  };
+	const { fetch: originalFetch } = window;
+	window.fetch = async (...args) => {
+		const [resource, config] = args;
+		return intercept(await originalFetch(resource, config), config);
+	};
 }
 function fetchRequestIntercept(intercept) {
-  const { fetch: originalFetch } = window;
-  window.fetch = async (...args) => {
-    const [resource, config] = args;
-    return intercept(originalFetch, resource, config);
-  };
+	const { fetch: originalFetch } = window;
+	window.fetch = async (...args) => {
+		const [resource, config] = args;
+		return intercept(originalFetch, resource, config);
+	};
 }
 
-// src/hooks/useMounted.ts
-var import_react18 = require("react");
+//#endregion
+//#region src/hooks/useMounted.ts
 function useMounted() {
-  const [mounted, setMounted] = (0, import_react18.useState)(false);
-  (0, import_react18.useEffect)(() => setMounted(true), []);
-  return mounted;
+	const [mounted, setMounted] = (0, react.useState)(false);
+	(0, react.useEffect)(() => setMounted(true), []);
+	return mounted;
 }
 
-// src/hooks/useOffsetPagination.ts
-var import_react21 = require("react");
-
-// src/hooks/useWatch.ts
-var import_react20 = require("react");
-
-// src/hooks/usePrevious.ts
-var import_react19 = require("react");
+//#endregion
+//#region src/hooks/usePrevious.ts
 function usePrevious(value) {
-  const ref2 = (0, import_react19.useRef)(void 0);
-  (0, import_react19.useEffect)(() => {
-    ref2.current = value;
-  });
-  return ref2.current;
+	const ref = (0, react.useRef)(void 0);
+	(0, react.useEffect)(() => {
+		ref.current = value;
+	});
+	return ref.current;
 }
 
-// src/hooks/useWatch.ts
+//#endregion
+//#region src/hooks/useWatch.ts
 function useWatch(source, callback, options = {}) {
-  const firstUpdate = (0, import_react20.useRef)(false);
-  const then = (0, import_react20.useRef)(void 0);
-  const oldValue = usePrevious(source);
-  const deps = (0, import_react20.useMemo)(
-    () => Array.isArray(source) ? source : [source],
-    [source]
-  );
-  (0, import_react20.useEffect)(() => {
-    if (!firstUpdate.current)
-      recordFirst();
-    else
-      callback(source, oldValue);
-  }, deps);
-  async function recordFirst() {
-    if (then.current)
-      return;
-    then.current = Promise.resolve(source);
-    then.current.then(() => firstUpdate.current = true);
-    if (options.immediate)
-      then.current.then((value) => callback(value, oldValue));
-  }
-}
-
-// src/hooks/useOffsetPagination.ts
+	const firstUpdate = (0, react.useRef)(false);
+	const then = (0, react.useRef)(void 0);
+	const oldValue = usePrevious(source);
+	(0, react.useEffect)(() => {
+		if (!firstUpdate.current) recordFirst();
+		else callback(source, oldValue);
+	}, (0, react.useMemo)(() => Array.isArray(source) ? source : [source], [source]));
+	async function recordFirst() {
+		if (then.current) return;
+		then.current = Promise.resolve(source);
+		then.current.then(() => firstUpdate.current = true);
+		if (options.immediate) then.current.then((value) => callback(value, oldValue));
+	}
+}
+
+//#endregion
+//#region src/hooks/useOffsetPagination.ts
 function useOffsetPagination(options) {
-  const [page, setPage] = (0, import_react21.useState)(options.page || 1);
-  const [pageSize, setPageSize] = (0, import_react21.useState)(options.pageSize || 10);
-  const total = options.total || 0;
-  const pageCount = (0, import_react21.useMemo)(() => Math.max(1, Math.ceil(total / pageSize)), [total, pageSize]);
-  const isFirstPage = (0, import_react21.useMemo)(() => page === 1, [page]);
-  const isLastPage = (0, import_react21.useMemo)(() => page === pageCount, [page, pageCount]);
-  function next() {
-    setPage((page2) => Math.min(pageCount, page2 + 1));
-  }
-  function prev() {
-    setPage((page2) => Math.max(1, page2 - 1));
-  }
-  function pageChange(page2) {
-    setPage(() => Math.max(1, Math.min(page2, pageCount)));
-  }
-  function pageSizeChange(limit) {
-    setPageSize(limit);
-    pageChange(1);
-  }
-  const pagination = {
-    next,
-    prev,
-    page,
-    pageSize,
-    isFirstPage,
-    pageSizeChange,
-    pageChange,
-    isLastPage,
-    pageCount,
-    total
-  };
-  useWatch(page, () => options.onChange?.(pagination));
-  useWatch(pageSize, () => options.onPageSizeChange?.(pagination));
-  useWatch(pageCount, () => options.onPageCountChange?.(pagination));
-  return pagination;
-}
-
-// src/hooks/useWhenever.ts
+	const [page, setPage] = (0, react.useState)(options.page || 1);
+	const [pageSize, setPageSize] = (0, react.useState)(options.pageSize || 10);
+	const total = options.total || 0;
+	const pageCount = (0, react.useMemo)(() => Math.max(1, Math.ceil(total / pageSize)), [total, pageSize]);
+	const isFirstPage = (0, react.useMemo)(() => page === 1, [page]);
+	const isLastPage = (0, react.useMemo)(() => page === pageCount, [page, pageCount]);
+	function next() {
+		setPage((page) => Math.min(pageCount, page + 1));
+	}
+	function prev() {
+		setPage((page) => Math.max(1, page - 1));
+	}
+	function pageChange(page) {
+		setPage(() => Math.max(1, Math.min(page, pageCount)));
+	}
+	function pageSizeChange(limit) {
+		setPageSize(limit);
+		pageChange(1);
+	}
+	const pagination = {
+		next,
+		prev,
+		page,
+		pageSize,
+		isFirstPage,
+		pageSizeChange,
+		pageChange,
+		isLastPage,
+		pageCount,
+		total
+	};
+	useWatch(page, () => options.onChange?.(pagination));
+	useWatch(pageSize, () => options.onPageSizeChange?.(pagination));
+	useWatch(pageCount, () => options.onPageCountChange?.(pagination));
+	return pagination;
+}
+
+//#endregion
+//#region src/hooks/useWhenever.ts
 function useWhenever(source, cb, options) {
-  useWatch(source, (value, oldValue) => value && cb(value, oldValue), options);
-}
-
-// src/storage/defineStore.ts
-var import_react22 = require("react");
-var import_valtio4 = require("valtio");
-
-// src/storage/persistant.ts
-var import_valtio3 = require("valtio");
-function proxyWithPersistant(keyOrOptions, initialObject) {
-  let options;
-  if (typeof keyOrOptions === "string") {
-    options = { id: keyOrOptions };
-  } else {
-    options = { ...keyOrOptions };
-  }
-  const storage = options.storage || (typeof localStorage !== "undefined" ? localStorage : void 0);
-  typeof keyOrOptions === "string" && (keyOrOptions = { id: keyOrOptions });
-  const state = (0, import_valtio3.proxy)(tryParseJson(storage?.getItem(options.id)) || initialObject);
-  (0, import_valtio3.subscribe)(state, () => {
-    const pick = options.pick || Object.keys(state);
-    const statePick = {};
-    for (const key of pick)
-      statePick[key] = state[key];
-    storage?.setItem(options.id, JSON.stringify(statePick));
-  });
-  return state;
-}
-
-// src/storage/utils/index.ts
-function track2(action, status) {
-  let loadings = 0;
-  const tracking = () => loadings++ === 0 && (status.loading = true);
-  const done = () => !--loadings && (status.loading = false);
-  const fulfilled = (value) => {
-    status.finished = true;
-    done();
-    return value;
-  };
-  const rejected = (error) => {
-    status.error = error;
-    done();
-    throw error;
-  };
-  return function(...args) {
-    tracking();
-    try {
-      const value = action(...args);
-      return value instanceof Promise ? value.then(fulfilled, rejected) : fulfilled(value);
-    } catch (error) {
-      rejected(error);
-    }
-  };
-}
-
-// src/storage/defineStore.ts
-function defineStore(store, options = {}) {
-  const state = typeof store.state === "function" ? store.state() : store.state;
-  const getters = store.getters || {};
-  const actions = store.actions || {};
-  const status = {};
-  status.finished = false;
-  status.loading = false;
-  status.error = null;
-  const $status = (0, import_valtio4.proxy)(status);
-  const $state = options.persist ? proxyWithPersistant(options.persist, state) : (0, import_valtio4.proxy)(state);
-  const $actions = {};
-  const $getters = {};
-  setupActions($state, actions, $actions, $status);
-  setupGetters(state, $state, getters, $getters);
-  setupStatus($actions, $status);
-  function $subscribe(listener) {
-    return (0, import_valtio4.subscribe)($state, () => listener($state));
-  }
-  $subscribe.status = function(listener) {
-    return (0, import_valtio4.subscribe)($status, () => listener($status));
-  };
-  function $patch(patch) {
-    if (typeof patch === "function")
-      patch($state);
-    else
-      Object.assign($state, patch);
-  }
-  function $signal(fn) {
-    return (0, import_react22.createElement)(() => fn((0, import_valtio4.useSnapshot)($state)));
-  }
-  $signal.status = function(fn) {
-    return (0, import_react22.createElement)(() => fn((0, import_valtio4.useSnapshot)($status)));
-  };
-  return {
-    $subscribe,
-    $patch,
-    $state,
-    $status,
-    $actions,
-    $getters,
-    $signal,
-    ...$actions
-  };
-}
-function setupActions($state, actions, $actions, $status) {
-  for (const key in actions) {
-    $status[key] = { finished: false, loading: false, error: null };
-    $actions[key] = track2(actions[key].bind($state), $status[key]);
-    Object.defineProperty($state, key, {
-      get: () => $actions[key]
-    });
-  }
-}
-function setupGetters(state, $state, getters, $getters) {
-  for (const key in getters) {
-    Object.defineProperty(state, key, {
-      get: () => getters[key].call($state),
-      enumerable: true
-    });
-    Object.defineProperty($getters, key, {
-      get: () => state[key],
-      enumerable: true
-    });
-  }
-}
-function setupStatus($actions, $status) {
-  Object.defineProperty($status, "loading", {
-    get: () => Object.keys($actions).some((key) => $status[key].loading),
-    enumerable: true
-  });
-  Object.defineProperty($status, "finished", {
-    get: () => Object.keys($actions).every((key) => $status[key].finished),
-    enumerable: true
-  });
-  Object.defineProperty($status, "error", {
-    get: () => Object.keys($actions).find((key) => $status[key].error),
-    enumerable: true
-  });
-}
-
-// src/storage/defineStoreAsync.ts
-var import_utils12 = require("valtio/utils");
-function defineStoreAsync(fetch, options = {}) {
-  let persist;
-  if (typeof options.persist === "string") {
-    persist = { id: options.persist, pick: ["value"] };
-  }
-  if (typeof options.persist === "object") {
-    persist = { ...options.persist, pick: ["value"] };
-  }
-  const store = defineStore(
-    {
-      state: () => ({
-        value: options.initial,
-        error: void 0,
-        loading: false,
-        finished: false
-      }),
-      actions: {
-        async refetch(...args) {
-          return this.value = await fetch(...args);
-        },
-        reset(value) {
-          this.value = value || options.initial;
-        }
-      }
-    },
-    { persist }
-  );
-  (0, import_utils12.watch)((get) => {
-    const status = get(store.$status.refetch);
-    store.$state.error = status.error;
-    store.$state.loading = status.loading;
-    store.$state.finished = status.finished;
-  });
-  options.immediate && store.refetch();
-  return store;
-}
-var defienAsyncStore = defineStoreAsync;
-
-// src/storage/useStatus.tsx
-var import_valtio5 = require("valtio");
-function useStatus(store) {
-  return (0, import_valtio5.useSnapshot)(store.$status);
-}
-
-// src/storage/useStore.ts
-var import_valtio6 = require("valtio");
-function useStore(store) {
-  return (0, import_valtio6.useSnapshot)(store.$state);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Case,
-  Default,
-  Else,
-  If,
-  Injector,
-  Switch,
-  Then,
-  Trigger,
-  Unless,
-  cls,
-  defienAsyncStore,
-  defineStore,
-  defineStoreAsync,
-  proxyWithPersistant,
-  track,
-  tryUseCallback,
-  tryUseEffect,
-  tryUseInsertionEffect,
-  tryUseReducer,
-  tryUseRef,
-  tryUseState,
-  tryUseUpdate,
-  useAsyncCallback,
-  useAsyncState,
-  useDebounce,
-  useEventBus,
-  useFetchRequestIntercept,
-  useFetchResponseIntercept,
-  useMounted,
-  useOffsetPagination,
-  useStatus,
-  useStore,
-  useUpdate,
-  useWatch,
-  useWhenever,
-  wrapper
-});
-/*! Bundled license information:
-
-lodash-es/lodash.js:
-  (**
-   * @license
-   * Lodash (Custom Build) <https://lodash.com/>
-   * Build: `lodash modularize exports="es" -o ./`
-   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
-   * Released under MIT license <https://lodash.com/license>
-   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
-   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
-   *)
-*/
+	useWatch(source, (value, oldValue) => value && cb(value, oldValue), options);
+}
+
+//#endregion
+exports.Case = Case;
+exports.Default = Default;
+exports.Else = Else;
+exports.If = If;
+exports.Injector = Injector;
+exports.Switch = Switch;
+exports.Then = Then;
+exports.Trigger = Trigger;
+exports.Unless = Unless;
+exports.cls = cls;
+exports.track = track;
+exports.tryUseCallback = tryUseCallback;
+exports.tryUseEffect = tryUseEffect;
+exports.tryUseInsertionEffect = tryUseInsertionEffect;
+exports.tryUseReducer = tryUseReducer;
+exports.tryUseRef = tryUseRef;
+exports.tryUseState = tryUseState;
+exports.tryUseUpdate = tryUseUpdate;
+exports.useAsyncCallback = useAsyncCallback;
+exports.useAsyncState = useAsyncState;
+exports.useDebounce = useDebounce;
+exports.useEventBus = useEventBus;
+exports.useFetchRequestIntercept = useFetchRequestIntercept;
+exports.useFetchResponseIntercept = useFetchResponseIntercept;
+exports.useMounted = useMounted;
+exports.useOffsetPagination = useOffsetPagination;
+exports.useUpdate = useUpdate;
+exports.useWatch = useWatch;
+exports.useWhenever = useWhenever;
+exports.wrapper = wrapper;