@hairy/react-lib 1.14.0 → 1.16.0

package/dist/index.cjs

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -30,24 +27,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
-var __assign;
-var init_tslib_es6 = __esm({
-  "../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs"() {
-    "use strict";
-    __assign = function() {
-      __assign = Object.assign || function __assign2(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-          s = arguments[i];
-          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-      };
-      return __assign.apply(this, arguments);
-    };
-  }
-});
-
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -62,7 +41,6 @@ __export(index_exports, {
   Unless: () => Unless,
   cls: () => cls,
   defineAsyncStore: () => defineAsyncStore,
-  defineAsyncStorePlain: () => defineAsyncStorePlain,
   defineStore: () => defineStore,
   proxyWithPersistant: () => proxyWithPersistant,
   useAsyncCallback: () => useAsyncCallback,
@@ -72,6 +50,7 @@ __export(index_exports, {
   useFetchRequestIntercept: () => useFetchRequestIntercept,
   useFetchResponseIntercept: () => useFetchResponseIntercept,
   useMounted: () => useMounted,
+  useStatus: () => useStatus,
   useStore: () => useStore,
   useWatch: () => useWatch,
   useWhenever: () => useWhenever,
@@ -226,80 +205,26 @@ function renderNodes(tokens, values) {
 // src/hooks/useAsyncCallback.ts
 var import_react7 = require("react");
 function useAsyncCallback(fun) {
-  const [error, setError] = (0, import_react7.useState)();
-  const [loading, setLoading] = (0, import_react7.useState)(false);
+  const [state, set] = (0, import_react7.useState)({ loading: 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 fun(...args).then((value) => {
+      set({ loading: false });
+      return value;
+    }).catch((err) => {
+      set({ loading: false, error: err });
+      return Promise.reject(err);
+    });
   }
-  return [loading, execute, error];
+  return [state.loading, execute, state.error];
 }
 
-// ../../node_modules/.pnpm/react-use@17.6.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-use/esm/useAsyncFn.js
-init_tslib_es6();
+// src/hooks/useAsyncState.ts
 var import_react9 = require("react");
 
-// ../../node_modules/.pnpm/react-use@17.6.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-use/esm/useMountedState.js
-var import_react8 = require("react");
-function useMountedState() {
-  var mountedRef = (0, import_react8.useRef)(false);
-  var get = (0, import_react8.useCallback)(function() {
-    return mountedRef.current;
-  }, []);
-  (0, import_react8.useEffect)(function() {
-    mountedRef.current = true;
-    return function() {
-      mountedRef.current = false;
-    };
-  }, []);
-  return get;
-}
-
-// ../../node_modules/.pnpm/react-use@17.6.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-use/esm/useAsyncFn.js
-function useAsyncFn(fn, deps, initialState) {
-  if (deps === void 0) {
-    deps = [];
-  }
-  if (initialState === void 0) {
-    initialState = { loading: false };
-  }
-  var lastCallId = (0, import_react9.useRef)(0);
-  var isMounted = useMountedState();
-  var _a = (0, import_react9.useState)(initialState), state = _a[0], set = _a[1];
-  var callback = (0, import_react9.useCallback)(function() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-      args[_i] = arguments[_i];
-    }
-    var callId = ++lastCallId.current;
-    if (!state.loading) {
-      set(function(prevState) {
-        return __assign(__assign({}, prevState), { loading: true });
-      });
-    }
-    return fn.apply(void 0, args).then(function(value) {
-      isMounted() && callId === lastCallId.current && set({ value, loading: false });
-      return value;
-    }, function(error) {
-      isMounted() && callId === lastCallId.current && set({ error, loading: false });
-      return error;
-    });
-  }, deps);
-  return [state, callback];
-}
-
 // ../../node_modules/.pnpm/react-use@17.6.0_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-use/esm/useEffectOnce.js
-var import_react10 = require("react");
+var import_react8 = require("react");
 var useEffectOnce = function(effect) {
-  (0, import_react10.useEffect)(effect, []);
+  (0, import_react8.useEffect)(effect, []);
 };
 var useEffectOnce_default = useEffectOnce;
 
@@ -312,17 +237,21 @@ var useMount = function(fn) {
 var useMount_default = useMount;
 
 // src/hooks/useAsyncState.ts
-function useAsyncState(fn, deps, options) {
-  const [state, _fn] = useAsyncFn(fn, deps, options?.initial);
-  useMount_default(() => options?.immediate && _fn());
-  return [state, _fn];
+function useAsyncState(fun, options) {
+  const [value, set] = (0, import_react9.useState)(options?.initial);
+  const [loading, execute, error] = useAsyncCallback(async (...args) => fun(...args).then(set));
+  useMount_default(() => options?.immediate && execute());
+  (0, import_react9.useEffect)(() => {
+    execute();
+  }, [execute]);
+  return [{ value, loading, error }, execute];
 }
 
 // src/hooks/useDebounce.ts
-var import_react11 = require("react");
+var import_react10 = require("react");
 function useDebounce(value, delay) {
-  const [debouncedValue, setDebouncedValue] = (0, import_react11.useState)(value);
-  (0, import_react11.useEffect)(() => {
+  const [debouncedValue, setDebouncedValue] = (0, import_react10.useState)(value);
+  (0, import_react10.useEffect)(() => {
     const handler = setTimeout(() => setDebouncedValue(value), delay);
     return () => clearTimeout(handler);
   }, [value, delay]);
@@ -331,14 +260,14 @@ function useDebounce(value, delay) {
 
 // src/hooks/useEventBus.ts
 var import_mitt = __toESM(require("mitt"), 1);
-var import_react12 = require("react");
+var import_react11 = require("react");
 var emitter = (0, import_mitt.default)();
 function useEventBus(key) {
-  const onRef = (0, import_react12.useRef)();
+  const onRef = (0, import_react11.useRef)();
   function on(listener) {
     emitter.on(key, listener);
     onRef.current = listener;
-    (0, import_react12.useEffect)(() => {
+    (0, import_react11.useEffect)(() => {
       if (!onRef.current)
         return;
       emitter.off(key, onRef.current);
@@ -384,23 +313,23 @@ function fetchRequestIntercept(intercept) {
 }
 
 // src/hooks/useMounted.ts
-var import_react13 = require("react");
+var import_react12 = require("react");
 function useMounted() {
-  const [mounted, setMounted] = (0, import_react13.useState)(false);
-  (0, import_react13.useEffect)(() => setMounted(true), []);
+  const [mounted, setMounted] = (0, import_react12.useState)(false);
+  (0, import_react12.useEffect)(() => setMounted(true), []);
   return mounted;
 }
 
 // src/hooks/useWatch.ts
-var import_react14 = require("react");
+var import_react13 = require("react");
 function useWatch(source, callback, options = {}) {
-  const firstUpdate = (0, import_react14.useRef)(false);
-  const then = (0, import_react14.useRef)();
-  const deps = (0, import_react14.useMemo)(
+  const firstUpdate = (0, import_react13.useRef)(false);
+  const then = (0, import_react13.useRef)();
+  const deps = (0, import_react13.useMemo)(
     () => Array.isArray(source) ? source : [source],
     [source]
   );
-  (0, import_react14.useEffect)(() => {
+  (0, import_react13.useEffect)(() => {
     if (!firstUpdate.current)
       recordFirst();
     else
@@ -422,6 +351,7 @@ function useWhenever(source, cb, options) {
 }
 
 // src/storage/defineStore.ts
+var import_react14 = require("react");
 var import_valtio2 = require("valtio");
 
 // ../util-core/src/util/json.ts
@@ -433,7 +363,7 @@ function jsonTryParse(text) {
   }
 }
 
-// src/storage/proxyWithPersistant.ts
+// src/storage/persistant.ts
 var import_valtio = require("valtio");
 function proxyWithPersistant(keyOrOptions, initialObject) {
   let options;
@@ -458,77 +388,133 @@ function proxyWithPersistant(keyOrOptions, initialObject) {
 // 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 $state = options.persistant ? proxyWithPersistant(options.persistant, state) : (0, import_valtio2.proxy)(state);
+  const status = {};
+  status.finished = false;
+  status.loading = false;
+  status.error = null;
+  const $state = options.persist ? proxyWithPersistant(options.persist, state) : (0, import_valtio2.proxy)(state);
+  const $status = (0, import_valtio2.proxy)(status);
   const $actions = {};
-  for (const key in actions)
-    $actions[key] = actions[key].bind($state);
+  const $getters = {};
+  setupActions($state, actions, $actions, $status);
+  setupGetters(state, $state, getters, $getters);
+  setupStatus($actions, $status);
   function $subscribe(listener) {
     return (0, import_valtio2.subscribe)($state, () => listener($state));
   }
+  $subscribe.status = function(listener) {
+    return (0, import_valtio2.subscribe)($status, () => listener($status));
+  };
   function $patch(patch) {
     if (typeof patch === "function")
       patch($state);
     else
       Object.assign($state, patch);
   }
+  function $signal(fn) {
+    return (0, import_react14.createElement)(() => fn((0, import_valtio2.useSnapshot)($state)));
+  }
+  $signal.status = function(fn) {
+    return (0, import_react14.createElement)(() => fn((0, import_valtio2.useSnapshot)($status)));
+  };
   return {
     $subscribe,
     $patch,
     $state,
+    $status,
     $actions,
+    $getters,
+    $signal,
     ...$actions
   };
 }
-
-// src/storage/useStore.ts
-var import_valtio3 = require("valtio");
-function useStore(store) {
-  return (0, import_valtio3.useSnapshot)(store.$state);
+function track(action, status) {
+  let loadings = 0;
+  const tracking = () => loadings++ === 0 && (status.loading = true);
+  const done = () => !--loadings && (status.loading = false);
+  const fulfilled = () => {
+    status.finished = true;
+    done();
+  };
+  const rejected = (error) => {
+    status.error = error;
+    done();
+  };
+  return function(...args) {
+    tracking();
+    try {
+      const result = action(...args);
+      if (result instanceof Promise)
+        result.then(fulfilled).catch(rejected);
+      else
+        fulfilled();
+    } catch (error) {
+      rejected(error);
+    }
+  };
+}
+function setupActions($state, actions, $actions, $status) {
+  for (const key in actions) {
+    $status[key] = { finished: false, loading: false, error: null };
+    $actions[key] = track(actions[key].bind($state), $status[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/defineAsyncStore.ts
-function defineAsyncStore(options) {
+function defineAsyncStore(fetch, options = {}) {
   const store = defineStore(
     {
-      state: () => ({
-        promise: void 0,
-        value: options.initial,
-        loading: false,
-        error: void 0
-      })
+      state: () => ({ value: options.initial }),
+      actions: {
+        fetch,
+        refresh(value) {
+          this.value = value || options.initial;
+        }
+      }
     },
-    { persistant: options.persistant ? { id: options.persistant, pick: ["value"] } : void 0 }
+    { persist: options.persist }
   );
-  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;
-    }
-    function refresh(value) {
-      store.$state.value = value || options.initial;
-    }
-    return [state, fetch, refresh];
-  }
-  return use;
+  return store;
 }
 
-// src/storage/defineAsyncStorePlain.ts
-function defineAsyncStorePlain(fn, options = {}) {
-  return defineAsyncStore({
-    setup: () => fn,
-    initial: options.initial,
-    persistant: options.persistant
-  });
+// src/storage/useStatus.tsx
+var import_valtio3 = require("valtio");
+function useStatus(store) {
+  return (0, import_valtio3.useSnapshot)(store.$status);
+}
+
+// src/storage/useStore.ts
+var import_valtio4 = require("valtio");
+function useStore(store) {
+  return (0, import_valtio4.useSnapshot)(store.$state);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -543,7 +529,6 @@ function defineAsyncStorePlain(fn, options = {}) {
   Unless,
   cls,
   defineAsyncStore,
-  defineAsyncStorePlain,
   defineStore,
   proxyWithPersistant,
   useAsyncCallback,
@@ -553,6 +538,7 @@ function defineAsyncStorePlain(fn, options = {}) {
   useFetchRequestIntercept,
   useFetchResponseIntercept,
   useMounted,
+  useStatus,
   useStore,
   useWatch,
   useWhenever,

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-import { BooleanLike } from '@hairy/utils';
+import { BooleanLike, PromiseFn, PromiseType, AnyFn } from '@hairy/utils';
 import * as react from 'react';
-import { JSX, ReactNode, PropsWithChildren, ReactElement, FC, ComponentClass, DependencyList, DetailedHTMLProps, HTMLAttributes } from 'react';
-import { FunctionReturningPromise as FunctionReturningPromise$1, PromiseType as PromiseType$1 } from './misc/types';
+import { JSX, ReactNode, PropsWithChildren, ReactElement, FC, ComponentClass, DetailedHTMLProps, HTMLAttributes } from 'react';
 import * as valtio from 'valtio';
 
 type Value = string | boolean | undefined | null;
@@ -80,12 +79,9 @@ interface TransProps {
 }
 declare function Trans({ i18nKey, ...additionalProps }: TransProps): ReactNode[];
 
-declare function useAsyncCallback<T extends (...args: any[]) => any>(fun: T): readonly [boolean, T, Error | undefined];
+declare function useAsyncCallback<T extends PromiseFn>(fun: T): readonly [boolean, T, Error | undefined];
 
-declare type PromiseType<P extends Promise<any>> = P extends Promise<infer T> ? T : never;
-declare type FunctionReturningPromise = (...args: any[]) => Promise<any>;
-
-declare type AsyncState<T> = {
+type AsyncState<T> = {
     loading: boolean;
     error?: undefined;
     value?: undefined;
@@ -102,18 +98,20 @@ declare type AsyncState<T> = {
     error?: undefined;
     value: T;
 };
-declare type StateFromFunctionReturningPromise$1<T extends FunctionReturningPromise$1> = AsyncState<PromiseType$1<ReturnType<T>>>;
-declare type AsyncFnReturn<T extends FunctionReturningPromise$1 = FunctionReturningPromise$1> = [
-    StateFromFunctionReturningPromise$1<T>,
+type StateFromFnReturningPromise<T extends PromiseFn = PromiseFn> = AsyncState<PromiseType<ReturnType<T>>>;
+declare type AsyncStateReturn<T extends PromiseFn = PromiseFn> = [
+    StateFromFnReturningPromise<T>,
     T
 ];
 
-type StateFromFunctionReturningPromise<T extends FunctionReturningPromise> = AsyncState<PromiseType<ReturnType<T>>>;
-interface UseAsyncStateOptions<T extends FunctionReturningPromise> {
+type UseAsyncStateOptions<T extends AnyFn> = {
     immediate?: boolean;
-    initial?: StateFromFunctionReturningPromise<T>;
-}
-declare function useAsyncState<T extends FunctionReturningPromise>(fn: T, deps?: DependencyList, options?: UseAsyncStateOptions<T>): AsyncFnReturn<T>;
+    initial?: PromiseType<ReturnType<T>>;
+} | {
+    immediate?: boolean;
+    initial: PromiseType<ReturnType<T>>;
+};
+declare function useAsyncState<T extends PromiseFn>(fun: T, options?: UseAsyncStateOptions<T>): AsyncStateReturn<T>;
 
 declare function useDebounce<T>(value: T, delay: number): T;
 
@@ -147,37 +145,6 @@ declare function useWatch<T>(source: T, callback: WatchCallback<T>, options?: Wa
 
 declare function useWhenever<T>(source: T, cb: WatchCallback<Exclude<T, null | undefined>>, options?: WatchOptions): void;
 
-interface AsyncStoreOptions<T extends FunctionReturningPromise> {
-    initial?: ReturnType<T> extends Promise<infer U> ? U : undefined;
-    setup: () => T;
-    persistant?: string;
-}
-declare function defineAsyncStore<T extends FunctionReturningPromise>(options: AsyncStoreOptions<T>): () => readonly [{
-    readonly promise: {
-        readonly then: <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
-        readonly catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>;
-        readonly finally: (onfinally?: (() => void) | null | undefined) => Promise<any>;
-        readonly [Symbol.toStringTag]: string;
-    } | undefined;
-    readonly value: valtio.Snapshot<ReturnType<T> extends Promise<infer U> ? U : undefined> | undefined;
-    readonly loading: boolean;
-    readonly error: Error | undefined;
-}, T, (value?: (ReturnType<T> extends Promise<infer U_1> ? U_1 : undefined)) => void];
-
-interface AsyncStorePlainOptions<T extends FunctionReturningPromise> extends Omit<AsyncStoreOptions<T>, 'setup'> {
-}
-declare function defineAsyncStorePlain<T extends FunctionReturningPromise>(fn: T, options?: AsyncStorePlainOptions<T>): () => readonly [{
-    readonly promise: {
-        readonly then: <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
-        readonly catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>;
-        readonly finally: (onfinally?: (() => void) | null | undefined) => Promise<any>;
-        readonly [Symbol.toStringTag]: string;
-    } | undefined;
-    readonly value: valtio.Snapshot<ReturnType<T> extends Promise<infer U> ? U : undefined> | undefined;
-    readonly loading: boolean;
-    readonly error: Error | undefined;
-}, T, (value?: (ReturnType<T> extends Promise<infer U_1> ? U_1 : undefined) | undefined) => void];
-
 interface PersistantOptions {
     id: string;
     storage?: Storage;
@@ -186,27 +153,72 @@ interface PersistantOptions {
 declare function proxyWithPersistant<T extends object>(key: string, initialObject?: T, options?: Omit<PersistantOptions, 'key'>): T;
 declare function proxyWithPersistant<T extends object>(options: PersistantOptions, initialObject?: T): T;
 
-interface StoreDefine<S extends object, A extends Actions<S>> {
+type Actions<S> = Record<string, (this: S, ...args: any) => any>;
+type Getters<S> = Record<string, (this: S) => any>;
+type ActionsOmitThisParameter<A extends Actions<any>> = {
+    [K in keyof A]: (...args: Parameters<A[K]>) => ReturnType<A[K]>;
+};
+interface Status {
+    finished: boolean;
+    loading: boolean;
+    error: Error | null;
+}
+type ActionsStatus<A extends Actions<any>> = Status & {
+    [K in keyof A]: Status;
+};
+type GettersReturnType<G extends Getters<any>> = {
+    [K in keyof G]: ReturnType<G[K]>;
+};
+interface StoreDefine<S extends object, A extends Actions<S>, G extends Getters<S>> {
     state: (() => S) | S;
     actions?: A;
+    getters?: G;
 }
 interface StoreOptions {
-    persistant?: string | PersistantOptions;
+    persist?: string | PersistantOptions;
 }
-type Actions<S> = Record<string, (this: S, ...args: any) => any>;
-type ActionsOmitThisParameter<A extends Actions<any>> = {
-    [K in keyof A]: (...args: Parameters<A[K]>) => ReturnType<A[K]>;
-};
-type Store<S, A extends Actions<S>> = {
-    $subscribe: (listener: (state: S) => void) => () => void;
-    $patch: (patch: Partial<S> | ((state: S) => void)) => void;
-    $state: S;
+interface StoreSignal<S, A extends Actions<S>, G extends Getters<S>> {
+    <T>(fn: (state: S & GettersReturnType<G>) => T): T;
+    status: <T>(fn: (status: ActionsStatus<A>) => T) => T;
+}
+interface StoreSubscribe<S, A extends Actions<S>, G extends Getters<S>> {
+    (listener: (state: S & GettersReturnType<G>) => void): () => void;
+    status: (listener: (status: ActionsStatus<A>) => void) => () => void;
+}
+interface StorePatch<S, G extends Getters<S>> {
+    (patch: Partial<S> | ((state: S & GettersReturnType<G>) => void)): void;
+}
+type Store<S, A extends Actions<S>, G extends Getters<S>> = {
+    $subscribe: StoreSubscribe<S, A, G>;
+    $patch: StorePatch<S, G>;
+    $state: S & GettersReturnType<G>;
     $actions: ActionsOmitThisParameter<A>;
+    $getters: GettersReturnType<G>;
+    $status: ActionsStatus<A>;
+    $signal: StoreSignal<S, A, G>;
 } & ActionsOmitThisParameter<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>): valtio.Snapshot<S>;
+interface AsyncStoreOptions<T extends AnyFn> {
+    initial?: ReturnType<T> extends Promise<infer U> ? U : undefined;
+    persist?: string;
+}
+declare function defineAsyncStore<T extends AnyFn>(fetch: AnyFn, options?: AsyncStoreOptions<T>): Store<{
+    value: (ReturnType<T> extends Promise<infer U> ? U : undefined) | undefined;
+}, {
+    fetch: AnyFn;
+    refresh(this: {
+        value: (ReturnType<T> extends Promise<infer U> ? U : undefined) | undefined;
+    }, value?: (ReturnType<T> extends Promise<infer U_1> ? U_1 : undefined)): void;
+}, Getters<{
+    value: (ReturnType<T> extends Promise<infer U> ? U : undefined) | undefined;
+}>>;
+
+declare function defineStore<S extends object, A extends Actions<S>, G extends Getters<S>>(store: StoreDefine<S, A, G>, options?: StoreOptions): Store<S, A, G>;
+
+declare function useStatus<S extends object, A extends Actions<S>, G extends Getters<S>>(store: Store<S, A, G>): valtio.Snapshot<ActionsStatus<A>>;
+
+declare function useStore<S extends object, A extends Actions<S>, G extends Getters<S>>(store: Store<S, A, G>): valtio.Snapshot<S & GettersReturnType<G>>;
 
 type PropsWithDetailedHTML<T = HTMLDivElement> = DetailedHTMLProps<HTMLAttributes<T>, T>;
 
-export { type Actions, type ActionsOmitThisParameter, type Argument, type ArgumentArray, type AsyncStoreOptions, type AsyncStorePlainOptions, Case, type CaseProps, Default, type DefaultProps, Else, type ElseProps, type EventBusListener, type FetchRequestInterceptCallback, type FetchResponseInterceptCallback, If, type IfProps, type InjectComponent, Injector, type InjectorProps, type Mapping, type PersistantOptions, type PropsWithDetailedHTML, type ReadonlyArgumentArray, type StateFromFunctionReturningPromise, type Store, type StoreDefine, type StoreOptions, Switch, type SwitchProps, Then, type ThenProps, Trans, type TransProps, Unless, type UnlessProps, type UseAsyncStateOptions, type Value, type WatchCallback, type WatchOptions, type WrapperProps, type WrapperTag, cls, defineAsyncStore, defineAsyncStorePlain, defineStore, proxyWithPersistant, useAsyncCallback, useAsyncState, useDebounce, useEventBus, useFetchRequestIntercept, useFetchResponseIntercept, useMounted, useStore, useWatch, useWhenever, wrapper };
+export { type Argument, type ArgumentArray, type AsyncStoreOptions, Case, type CaseProps, Default, type DefaultProps, Else, type ElseProps, type EventBusListener, type FetchRequestInterceptCallback, type FetchResponseInterceptCallback, If, type IfProps, type InjectComponent, Injector, type InjectorProps, type Mapping, type PersistantOptions, type PropsWithDetailedHTML, type ReadonlyArgumentArray, Switch, type SwitchProps, Then, type ThenProps, Trans, type TransProps, Unless, type UnlessProps, type UseAsyncStateOptions, type Value, type WatchCallback, type WatchOptions, type WrapperProps, type WrapperTag, cls, defineAsyncStore, defineStore, proxyWithPersistant, useAsyncCallback, useAsyncState, useDebounce, useEventBus, useFetchRequestIntercept, useFetchResponseIntercept, useMounted, useStatus, useStore, useWatch, useWhenever, wrapper };