@hairy/react-lib 1.1.2 → 1.6.0

package/{LICENSE → LICENSE.md}

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019-PRESENT Hairyf<https://github.com/hairyf>
+Copyright (c) 2025-PRESENT Hairyf <https://github.com/antfu>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,5 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-
-

package/README.md

@@ -0,0 +1,36 @@
+# @hairy/react-lib
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![bundle][bundle-src]][bundle-href]
+[![JSDocs][jsdocs-src]][jsdocs-href]
+[![License][license-src]][license-href]
+
+## Install
+
+```
+ni @hairy/react-lib
+```
+
+## CDN
+
+```html
+<script src="https://unpkg.com/@hairy/react-lib"></script>
+```
+
+## License
+
+[MIT](./LICENSE) License © [Hairyf](https://github.com/hairyf)
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/@hairy/react-lib?style=flat&colorA=080f12&colorB=1fa669
+[npm-version-href]: https://npmjs.com/package/@hairy/react-lib
+[npm-downloads-src]: https://img.shields.io/npm/dm/@hairy/react-lib?style=flat&colorA=080f12&colorB=1fa669
+[npm-downloads-href]: https://npmjs.com/package/@hairy/react-lib
+[bundle-src]: https://img.shields.io/bundlephobia/minzip/@hairy/react-lib?style=flat&colorA=080f12&colorB=1fa669&label=minzip
+[bundle-href]: https://bundlephobia.com/result?p=@hairy/react-lib
+[license-src]: https://img.shields.io/github/license/hairyf/hairylib.svg?style=flat&colorA=080f12&colorB=1fa669
+[license-href]: https://github.com/hairyf/hairylib/blob/main/LICENSE
+[jsdocs-src]: https://img.shields.io/badge/jsdocs-reference-080f12?style=flat&colorA=080f12&colorB=1fa669
+[jsdocs-href]: https://www.jsdocs.io/package/@hairy/react-lib

package/dist/index.cjs

@@ -28,8 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   Case: () => Case,
   Default: () => Default,
   Else: () => Else,
@@ -40,11 +40,6 @@ __export(src_exports, {
   Trans: () => Trans,
   Unless: () => Unless,
   cls: () => cls,
-  defineAsyncStorage: () => defineAsyncStorage,
-  defineStore: () => defineStore,
-  proxyWithPersistant: () => proxyWithPersistant,
-  storeToState: () => storeToState,
-  storeToStates: () => storeToStates,
   useAsyncCallback: () => useAsyncCallback,
   useAsyncState: () => useAsyncState,
   useDebounce: () => useDebounce,
@@ -52,11 +47,10 @@ __export(src_exports, {
   useFetchRequestIntercept: () => useFetchRequestIntercept,
   useFetchResponseIntercept: () => useFetchResponseIntercept,
   useMounted: () => useMounted,
-  useStore: () => useStore,
   useWatch: () => useWatch,
   useWhenever: () => useWhenever
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/components/condition/Case.ts
 function Case(props) {
@@ -93,7 +87,6 @@ function If(props) {
 // src/components/condition/Switch.ts
 var import_react2 = require("react");
 function Switch(props) {
-  var _a;
   const isUseValue = props.value !== void 0;
   let matchingCase;
   let defaultCase;
@@ -110,7 +103,7 @@ function Switch(props) {
     if (!defaultCase && child.type === Default)
       defaultCase = child;
   });
-  return (_a = matchingCase != null ? matchingCase : defaultCase) != null ? _a : null;
+  return matchingCase ?? defaultCase ?? null;
 }
 
 // src/components/condition/Unless.ts
@@ -140,15 +133,15 @@ function repack(c) {
 }
 
 // src/components/utils/Trans.ts
-var import_react_i18next = require("react-i18next");
+var import_html_parse_stringify = __toESM(require("html-parse-stringify"), 1);
 var import_react5 = require("react");
-var import_html_parse_stringify = __toESM(require("html-parse-stringify"));
+var import_react_i18next = require("react-i18next");
 function Trans({ i18nKey, ...additionalProps }) {
   const translation = (0, import_react_i18next.useTranslation)().t(i18nKey, additionalProps);
   return renderNodes(import_html_parse_stringify.default.parse(translation), additionalProps);
 }
-var index = 0;
 function renderNodes(tokens, values) {
+  let index = 0;
   return tokens.map((token) => {
     if (token.type === "text")
       return token.content;
@@ -158,11 +151,39 @@ function renderNodes(tokens, values) {
   });
 }
 
-// src/hooks/useDebounce.ts
+// src/hooks/useAsyncCallback.ts
 var import_react6 = require("react");
+function useAsyncCallback(fun) {
+  const [error, setError] = (0, import_react6.useState)();
+  const [loading, setLoading] = (0, import_react6.useState)(false);
+  async function execute(...args) {
+    try {
+      setLoading(true);
+      const result = await fun(...args);
+      setLoading(false);
+      return result;
+    } catch (error2) {
+      setLoading(false);
+      setError(error2);
+      throw error2;
+    }
+  }
+  return [loading, execute, error];
+}
+
+// src/hooks/useAsyncState.ts
+var import_react_use = require("react-use");
+function useAsyncState(fn, deps, options) {
+  const [state, _fn] = (0, import_react_use.useAsyncFn)(fn, deps, options?.initial);
+  (0, import_react_use.useMount)(() => options?.immediate && _fn());
+  return [state, _fn];
+}
+
+// src/hooks/useDebounce.ts
+var import_react7 = require("react");
 function useDebounce(value, delay) {
-  const [debouncedValue, setDebouncedValue] = (0, import_react6.useState)(value);
-  (0, import_react6.useEffect)(() => {
+  const [debouncedValue, setDebouncedValue] = (0, import_react7.useState)(value);
+  (0, import_react7.useEffect)(() => {
     const handler = setTimeout(() => setDebouncedValue(value), delay);
     return () => clearTimeout(handler);
   }, [value, delay]);
@@ -170,15 +191,15 @@ function useDebounce(value, delay) {
 }
 
 // src/hooks/useEventBus.ts
-var import_react7 = require("react");
-var import_mitt = __toESM(require("mitt"));
+var import_mitt = __toESM(require("mitt"), 1);
+var import_react8 = require("react");
 var emitter = (0, import_mitt.default)();
 function useEventBus(key) {
-  const onRef = (0, import_react7.useRef)();
+  const onRef = (0, import_react8.useRef)();
   function on(listener) {
     emitter.on(key, listener);
     onRef.current = listener;
-    (0, import_react7.useEffect)(() => {
+    (0, import_react8.useEffect)(() => {
       if (!onRef.current)
         return;
       emitter.off(key, onRef.current);
@@ -200,72 +221,6 @@ function useEventBus(key) {
   };
 }
 
-// src/hooks/useMounted.ts
-var import_react8 = require("react");
-function useMounted() {
-  const [mounted, setMounted] = (0, import_react8.useState)(false);
-  (0, import_react8.useEffect)(() => setMounted(true), []);
-  return mounted;
-}
-
-// src/hooks/useWatch.ts
-var import_react9 = require("react");
-function useWatch(source, callback, options = {}) {
-  const firstUpdate = (0, import_react9.useRef)(false);
-  const then = (0, import_react9.useRef)();
-  const deps = (0, import_react9.useMemo)(
-    () => Array.isArray(source) ? source : [source],
-    [source]
-  );
-  (0, import_react9.useEffect)(() => {
-    if (!firstUpdate.current)
-      recordFirst();
-    else
-      callback(source);
-  }, 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));
-  }
-}
-
-// src/hooks/useWhenever.ts
-function useWhenever(source, cb, options) {
-  useWatch(source, () => source && cb(source), options);
-}
-
-// src/hooks/useAsyncCallback.ts
-var import_react10 = require("react");
-function useAsyncCallback(fun) {
-  const [error, setError] = (0, import_react10.useState)();
-  const [loading, setLoading] = (0, import_react10.useState)(false);
-  async function execute(...args) {
-    try {
-      setLoading(true);
-      const result = await fun(...args);
-      setLoading(false);
-      return result;
-    } catch (error2) {
-      setLoading(false);
-      setError(error2);
-      throw error2;
-    }
-  }
-  return [loading, execute, error];
-}
-
-// src/hooks/useAsyncState.ts
-var import_react_use = require("react-use");
-function useAsyncState(fn, deps, options) {
-  const [state, _fn] = (0, import_react_use.useAsyncFn)(fn, deps, options == null ? void 0 : options.initial);
-  (0, import_react_use.useMount)(() => (options == null ? void 0 : options.immediate) && _fn());
-  return [state, _fn];
-}
-
 // src/hooks/useFetchIntercept.ts
 var import_react_use2 = require("react-use");
 function useFetchResponseIntercept(intercept) {
@@ -290,102 +245,42 @@ function fetchRequestIntercept(intercept) {
   };
 }
 
-// src/storage/storeToState.ts
-var import_valtio = require("valtio");
-function storeToState(store, key) {
-  const snapshot = (0, import_valtio.useSnapshot)(store);
-  function get() {
-    return snapshot[key];
-  }
-  function set(value) {
-    store[key] = value;
-  }
-  return [get(), set];
-}
-
-// src/storage/proxyWithPersistant.ts
-var import_valtio2 = require("valtio");
-function proxyWithPersistant(key, initialObject, options = {}) {
-  const storage = options.storage || (typeof localStorage !== "undefined" ? localStorage : void 0);
-  const state = (0, import_valtio2.proxy)(parse(storage == null ? void 0 : storage.getItem(key)) || initialObject);
-  (0, import_valtio2.subscribe)(state, () => {
-    storage == null ? void 0 : storage.setItem(key, JSON.stringify(state));
-  });
-  return state;
-}
-function parse(text) {
-  try {
-    return JSON.parse(text || "");
-  } catch (e) {
-  }
+// src/hooks/useMounted.ts
+var import_react9 = require("react");
+function useMounted() {
+  const [mounted, setMounted] = (0, import_react9.useState)(false);
+  (0, import_react9.useEffect)(() => setMounted(true), []);
+  return mounted;
 }
 
-// src/storage/storeToStates.ts
-var import_valtio3 = require("valtio");
-function storeToStates(store) {
-  const snapshot = (0, import_valtio3.useSnapshot)(store);
-  const states = {};
-  function toState(key) {
-    const get = () => snapshot[key];
-    const set = (value) => {
-      store[key] = value;
-    };
-    return [get(), set];
+// src/hooks/useWatch.ts
+var import_react10 = require("react");
+function useWatch(source, callback, options = {}) {
+  const firstUpdate = (0, import_react10.useRef)(false);
+  const then = (0, import_react10.useRef)();
+  const deps = (0, import_react10.useMemo)(
+    () => Array.isArray(source) ? source : [source],
+    [source]
+  );
+  (0, import_react10.useEffect)(() => {
+    if (!firstUpdate.current)
+      recordFirst();
+    else
+      callback(source);
+  }, 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));
   }
-  for (const key of Object.keys(snapshot))
-    states[key] = toState(key);
-  return states;
-}
-
-// src/storage/defineStore.ts
-var import_valtio4 = require("valtio");
-function defineStore(store, options = {}) {
-  const state = typeof store.state === "function" ? store.state() : store.state;
-  const actions = store.actions || {};
-  const $state = options.persistant ? proxyWithPersistant(options.persistant, state) : (0, import_valtio4.proxy)(state);
-  const $actions = {};
-  for (const key in actions)
-    $actions[key] = actions[key].bind($state);
-  return {
-    $state: state,
-    $actions: actions,
-    ...actions
-  };
-}
-function useStore(store) {
-  return (0, import_valtio4.useSnapshot)(store.$state);
 }
 
-// src/hooks/defineAsyncStorage.ts
-function defineAsyncStorage(options) {
-  const store = defineStore(
-    {
-      state: () => ({
-        promise: void 0,
-        value: options.initial,
-        loading: false,
-        error: void 0
-      })
-    },
-    { persistant: options.persistant }
-  );
-  function use() {
-    const fn = options.setup();
-    const state = useStore(store);
-    function fetch(...args) {
-      if (state.loading)
-        return;
-      store.$state.loading = true;
-      store.$state.promise = fn(...args);
-      store.$state.promise.then((value) => store.$state.value = value).finally(() => store.$state.loading = false).catch((error) => {
-        store.$state.error = error;
-        throw error;
-      });
-      return store.$state.promise;
-    }
-    return [state, fetch];
-  }
-  return use;
+// src/hooks/useWhenever.ts
+function useWhenever(source, cb, options) {
+  useWatch(source, () => source && cb(source), options);
 }
 
 // src/utils/index.ts
@@ -432,11 +327,6 @@ function appendClass(value, newClass) {
   Trans,
   Unless,
   cls,
-  defineAsyncStorage,
-  defineStore,
-  proxyWithPersistant,
-  storeToState,
-  storeToStates,
   useAsyncCallback,
   useAsyncState,
   useDebounce,
@@ -444,7 +334,6 @@ function appendClass(value, newClass) {
   useFetchRequestIntercept,
   useFetchResponseIntercept,
   useMounted,
-  useStore,
   useWatch,
   useWhenever
 });

package/dist/index.d.ts

@@ -1,173 +1,111 @@
+import { BooleanLike } from '@hairy/utils';
 import * as react from 'react';
-import { DetailedHTMLProps as DetailedHTMLProps$1, HTMLAttributes, ReactNode, PropsWithChildren, ReactElement, FC, ComponentClass, DependencyList } from 'react';
+import { ReactNode, PropsWithChildren, ReactElement, FC, ComponentClass, DependencyList, DetailedHTMLProps, HTMLAttributes } from 'react';
 import { FunctionReturningPromise, PromiseType } from 'react-use/lib/misc/types';
 import { AsyncState, AsyncFnReturn } from 'react-use/lib/useAsyncFn';
-import { INTERNAL_Snapshot } from 'valtio';
 
-type DetailedHTMLProps<T = HTMLDivElement> = DetailedHTMLProps$1<HTMLAttributes<T>, T>;
-type BooleanLike = any;
-
-interface CaseProps {
-    cond?: BooleanLike;
-    children?: ReactNode;
-}
+interface CaseProps {
+    cond?: BooleanLike;
+    children?: ReactNode;
+}
 declare function Case(props: CaseProps): ReactNode;
 
 declare function Default(props: PropsWithChildren): react.ReactNode;
 
 declare function Else(props: PropsWithChildren): react.ReactNode;
 
-interface IfProps {
-    cond?: BooleanLike;
-    then?: ReactNode;
-    else?: ReactNode;
-    children?: ReactNode;
-}
+interface IfProps {
+    cond?: BooleanLike;
+    then?: ReactNode;
+    else?: ReactNode;
+    children?: ReactNode;
+}
 declare function If(props: IfProps): ReactNode;
 
-interface SwitchProps extends PropsWithChildren {
-    value?: BooleanLike;
-}
+interface SwitchProps extends PropsWithChildren {
+    value?: BooleanLike;
+}
 declare function Switch(props: SwitchProps): ReactElement<any, string | react.JSXElementConstructor<any>> | null;
 
 declare function Then(props: PropsWithChildren): react.ReactNode;
 
-interface UnlessProps {
-    cond?: BooleanLike;
-    then?: ReactNode;
-    else?: ReactNode;
-    children?: ReactNode;
-}
+interface UnlessProps {
+    cond?: BooleanLike;
+    then?: ReactNode;
+    else?: ReactNode;
+    children?: ReactNode;
+}
 declare function Unless(props: UnlessProps): ReactNode;
 
-interface InjectComponent<P> {
-    component: FC<P> | ComponentClass<P>;
-    props?: P;
-}
-interface InjectorProps {
-    install: (FC<any> | InjectComponent<any> | ComponentClass<any>)[];
-    children?: ReactNode;
-}
+interface InjectComponent<P> {
+    component: FC<P> | ComponentClass<P>;
+    props?: P;
+}
+interface InjectorProps {
+    install: (FC<any> | InjectComponent<any> | ComponentClass<any>)[];
+    children?: ReactNode;
+}
 declare function Injector(props: InjectorProps): ReactNode;
 
-interface TransProps {
-    i18nKey: string;
-    [key: string]: ReactNode;
-}
+interface TransProps {
+    i18nKey: string;
+    [key: string]: ReactNode;
+}
 declare function Trans({ i18nKey, ...additionalProps }: TransProps): ReactNode[];
 
+declare function useAsyncCallback<T extends (...args: any[]) => any>(fun: T): readonly [boolean, T, Error | undefined];
+
+type StateFromFunctionReturningPromise<T extends FunctionReturningPromise> = AsyncState<PromiseType<ReturnType<T>>>;
+interface UseAsyncStateOptions<T extends FunctionReturningPromise> {
+    immediate?: boolean;
+    initial?: StateFromFunctionReturningPromise<T>;
+}
+declare function useAsyncState<T extends FunctionReturningPromise>(fn: T, deps?: DependencyList, options?: UseAsyncStateOptions<T>): AsyncFnReturn<T>;
+
 declare function useDebounce<T>(value: T, delay: number): T;
 
-interface EventBusListener<T = any> {
-    (event: T): void;
-}
-declare function useEventBus<T>(key: string): {
-    on: (listener: EventBusListener<T>) => void;
-    emit: (event?: T) => void;
-    off: (listener: EventBusListener) => void;
+interface EventBusListener<T = any> {
+    (event: T): void;
+}
+declare function useEventBus<T>(key: string): {
+    on: (listener: EventBusListener<T>) => void;
+    emit: (event?: T) => void;
+    off: (listener: EventBusListener) => void;
 };
 
+interface FetchResponseInterceptCallback {
+    (response: Response): Response | Promise<Response>;
+}
+interface FetchRequestInterceptCallback {
+    (fetch: typeof window.fetch, input: RequestInfo | URL, init?: RequestInit | undefined): Response | Promise<Response>;
+}
+declare function useFetchResponseIntercept(intercept: FetchResponseInterceptCallback): void;
+declare function useFetchRequestIntercept(intercept: FetchRequestInterceptCallback): void;
+
 declare function useMounted(): boolean;
 
-interface WatchCallback<T> {
-    (value: T): void;
-}
-interface WatchOptions {
-    immediate?: boolean;
-}
+interface WatchCallback<T> {
+    (value: T): void;
+}
+interface WatchOptions {
+    immediate?: boolean;
+}
 declare function useWatch<T>(source: T, callback: WatchCallback<T>, options?: WatchOptions): void;
 
 declare function useWhenever<T>(source: T, cb: WatchCallback<Exclude<T, null | undefined>>, options?: WatchOptions): void;
 
-declare function useAsyncCallback<T extends (...args: any[]) => any>(fun: T): readonly [boolean, T, Error | undefined];
-
-type StateFromFunctionReturningPromise<T extends FunctionReturningPromise> = AsyncState<PromiseType<ReturnType<T>>>;
-interface UseAsyncStateOptions<T extends FunctionReturningPromise> {
-    immediate?: boolean;
-    initial?: StateFromFunctionReturningPromise<T>;
-}
-declare function useAsyncState<T extends FunctionReturningPromise>(fn: T, deps?: DependencyList, options?: UseAsyncStateOptions<T>): AsyncFnReturn<T>;
-
-interface FetchResponseInterceptCallback {
-    (response: Response): Response | Promise<Response>;
-}
-interface FetchRequestInterceptCallback {
-    (fetch: typeof window.fetch, input: RequestInfo | URL, init?: RequestInit | undefined): Response | Promise<Response>;
-}
-declare function useFetchResponseIntercept(intercept: FetchResponseInterceptCallback): void;
-declare function useFetchRequestIntercept(intercept: FetchRequestInterceptCallback): void;
-
-interface AsyncStorageOptions<T extends FunctionReturningPromise> {
-    initial?: ReturnType<T> extends Promise<infer U> ? U : undefined;
-    setup: () => T;
-    persistant?: string;
-}
-declare function defineAsyncStorage<T extends FunctionReturningPromise>(options: AsyncStorageOptions<T>): () => readonly [{
-    readonly promise: any;
-    readonly value: ((ReturnType<T> extends Promise<infer U> ? U : undefined) extends infer T_1 ? T_1 extends (ReturnType<T> extends Promise<infer U> ? U : undefined) ? T_1 extends {
-        $$valtioSnapshot: infer S;
-    } ? S : T_1 extends RegExp | Error | Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | ((...args: any[]) => any) | (string | number | bigint | boolean | symbol | null | undefined) ? T_1 : T_1 extends Promise<unknown> ? Awaited<T_1> : T_1 extends object ? T_1 extends infer T_2 extends object ? { readonly [K in keyof T_2]: T_1[K] extends infer T_3 ? T_3 extends T_1[K] ? T_3 extends {
-        $$valtioSnapshot: infer S;
-    } ? S : T_3 extends RegExp | Error | Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | ((...args: any[]) => any) | (string | number | bigint | boolean | symbol | null | undefined) ? T_3 : T_3 extends Promise<unknown> ? Awaited<T_3> : T_3 extends object ? T_3 extends infer T_4 extends object ? { readonly [K_1 in keyof T_4]: T_3[K_1] extends infer T_5 ? T_5 extends T_3[K_1] ? T_5 extends {
-        $$valtioSnapshot: infer S;
-    } ? S : T_5 extends RegExp | Error | Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | ((...args: any[]) => any) | (string | number | bigint | boolean | symbol | null | undefined) ? T_5 : T_5 extends Promise<unknown> ? Awaited<T_5> : T_5 extends object ? T_5 extends infer T_6 extends object ? { readonly [K_2 in keyof T_6]: T_5[K_2] extends infer T_7 ? T_7 extends T_5[K_2] ? T_7 extends {
-        $$valtioSnapshot: infer S;
-    } ? S : T_7 extends RegExp | Error | Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | ((...args: any[]) => any) | (string | number | bigint | boolean | symbol | null | undefined) ? T_7 : T_7 extends Promise<unknown> ? Awaited<T_7> : T_7 extends object ? T_7 extends infer T_8 extends object ? { readonly [K_3 in keyof T_8]: T_7[K_3] extends infer T_9 ? T_9 extends T_7[K_3] ? T_9 extends {
-        $$valtioSnapshot: infer S;
-    } ? S : T_9 extends RegExp | Error | Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | ((...args: any[]) => any) | (string | number | bigint | boolean | symbol | null | undefined) ? T_9 : T_9 extends Promise<unknown> ? Awaited<T_9> : T_9 extends object ? T_9 extends infer T_10 extends object ? { readonly [K_4 in keyof T_10]: T_9[K_4] extends infer T_11 ? T_11 extends T_9[K_4] ? T_11 extends {
-        $$valtioSnapshot: infer S;
-    } ? S : T_11 extends RegExp | Error | Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | ((...args: any[]) => any) | (string | number | bigint | boolean | symbol | null | undefined) ? T_11 : T_11 extends Promise<unknown> ? Awaited<T_11> : T_11 extends object ? T_11 extends infer T_12 extends object ? { readonly [K_5 in keyof T_12]: T_11[K_5] extends infer T_13 ? T_13 extends T_11[K_5] ? T_13 extends {
-        $$valtioSnapshot: infer S;
-    } ? S : T_13 extends RegExp | Error | Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | ((...args: any[]) => any) | (string | number | bigint | boolean | symbol | null | undefined) ? T_13 : T_13 extends Promise<unknown> ? Awaited<T_13> : T_13 extends object ? T_13 extends infer T_14 extends object ? { readonly [K_6 in keyof T_14]: T_13[K_6] extends infer T_15 ? T_15 extends T_13[K_6] ? T_15 extends {
-        $$valtioSnapshot: infer S;
-    } ? S : T_15 extends RegExp | Error | Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | ((...args: any[]) => any) | (string | number | bigint | boolean | symbol | null | undefined) ? T_15 : T_15 extends Promise<unknown> ? Awaited<T_15> : T_15 extends object ? T_15 extends infer T_16 extends object ? { readonly [K_7 in keyof T_16]: T_15[K_7] extends infer T_17 ? T_17 extends T_15[K_7] ? T_17 extends {
-        $$valtioSnapshot: infer S;
-    } ? S : T_17 extends RegExp | Error | Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | ((...args: any[]) => any) | (string | number | bigint | boolean | symbol | null | undefined) ? T_17 : T_17 extends Promise<unknown> ? Awaited<T_17> : T_17 extends object ? T_17 extends infer T_18 extends object ? { readonly [K_8 in keyof T_18]: T_17[K_8] extends infer T_19 ? T_19 extends T_17[K_8] ? T_19 extends {
-        $$valtioSnapshot: infer S;
-    } ? S : T_19 extends RegExp | Error | Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | ((...args: any[]) => any) | (string | number | bigint | boolean | symbol | null | undefined) ? T_19 : T_19 extends Promise<unknown> ? Awaited<T_19> : T_19 extends object ? T_19 extends infer T_20 extends object ? { readonly [K_9 in keyof T_20]: T_19[K_9] extends infer T_21 ? T_21 extends T_19[K_9] ? T_21 extends {
-        $$valtioSnapshot: infer S;
-    } ? S : T_21 extends RegExp | Error | Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | ((...args: any[]) => any) | (string | number | bigint | boolean | symbol | null | undefined) ? T_21 : T_21 extends Promise<unknown> ? Awaited<T_21> : T_21 extends object ? any : T_21 : never : never; } : never : T_19 : never : never; } : never : T_17 : never : never; } : never : T_15 : never : never; } : never : T_13 : never : never; } : never : T_11 : never : never; } : never : T_9 : never : never; } : never : T_7 : never : never; } : never : T_5 : never : never; } : never : T_3 : never : never; } : never : T_1 : never : never) | undefined;
-    readonly loading: boolean;
-    readonly error: Error | undefined;
-}, T];
-
-declare function storeToState<T extends object, K extends keyof T>(store: T, key: K): readonly [T[K], (value: T[K]) => void];
-
-interface PersistantOptions {
-    storage?: Storage;
-}
-declare function proxyWithPersistant<T extends object>(key: string, initialObject?: T, options?: PersistantOptions): T;
-
-type StoreToStates<S> = {
-    [K in keyof S]: [S[K], (value: S[K]) => void];
-};
-declare function storeToStates<S extends object>(store: S): StoreToStates<S>;
-
-interface StoreDefine<S extends object, A extends Actions<S> = Record<string, any>> {
-    state: (() => S) | S;
-    actions?: A;
-}
-interface StoreOptions {
-    persistant?: string;
-}
-type Actions<S> = Record<string, (this: S) => void>;
-type Store<S, A> = {
-    $state: S;
-    $actions: A;
-} & A;
-declare function defineStore<S extends object, A extends Actions<S>>(store: StoreDefine<S, A>, options?: StoreOptions): Store<S, A>;
-declare function useStore<S extends object, A extends Actions<S>>(store: Store<S, A>): INTERNAL_Snapshot<S>;
-
-type Value = string | boolean | undefined | null;
-type Mapping = Record<string, any>;
-interface ArgumentArray extends Array<Argument> {
-}
-interface ReadonlyArgumentArray extends ReadonlyArray<Argument> {
-}
-type Argument = Value | Mapping | ArgumentArray | ReadonlyArgumentArray;
-/**
- * A simple JavaScript utility for conditionally joining classNames together.
- */
+type PropWithHtmlProps<T = HTMLDivElement> = DetailedHTMLProps<HTMLAttributes<T>, T>;
+
+type Value = string | boolean | undefined | null;
+type Mapping = Record<string, any>;
+interface ArgumentArray extends Array<Argument> {
+}
+interface ReadonlyArgumentArray extends ReadonlyArray<Argument> {
+}
+type Argument = Value | Mapping | ArgumentArray | ReadonlyArgumentArray;
+/**
+ * A simple JavaScript utility for conditionally joining classNames together.
+ */
 declare function cls(...args: ArgumentArray): string;
 
-export { Argument, ArgumentArray, AsyncStorageOptions, BooleanLike, Case, CaseProps, Default, DetailedHTMLProps, Else, EventBusListener, FetchRequestInterceptCallback, FetchResponseInterceptCallback, If, IfProps, InjectComponent, Injector, InjectorProps, Mapping, PersistantOptions, ReadonlyArgumentArray, StateFromFunctionReturningPromise, StoreToStates, Switch, SwitchProps, Then, Trans, TransProps, Unless, UnlessProps, UseAsyncStateOptions, Value, WatchCallback, WatchOptions, cls, defineAsyncStorage, defineStore, proxyWithPersistant, storeToState, storeToStates, useAsyncCallback, useAsyncState, useDebounce, useEventBus, useFetchRequestIntercept, useFetchResponseIntercept, useMounted, useStore, useWatch, useWhenever };
+export { type Argument, type ArgumentArray, Case, type CaseProps, Default, Else, type EventBusListener, type FetchRequestInterceptCallback, type FetchResponseInterceptCallback, If, type IfProps, type InjectComponent, Injector, type InjectorProps, type Mapping, type PropWithHtmlProps, type ReadonlyArgumentArray, type StateFromFunctionReturningPromise, Switch, type SwitchProps, Then, Trans, type TransProps, Unless, type UnlessProps, type UseAsyncStateOptions, type Value, type WatchCallback, type WatchOptions, cls, useAsyncCallback, useAsyncState, useDebounce, useEventBus, useFetchRequestIntercept, useFetchResponseIntercept, useMounted, useWatch, useWhenever };