@hairy/react-lib 1.14.0 → 1.15.0

package/dist/index.cjs

@@ -62,7 +62,7 @@ __export(index_exports, {
   Unless: () => Unless,
   cls: () => cls,
   defineAsyncStore: () => defineAsyncStore,
-  defineAsyncStorePlain: () => defineAsyncStorePlain,
+  defineAsyncStoreLayered: () => defineAsyncStoreLayered,
   defineStore: () => defineStore,
   proxyWithPersistant: () => proxyWithPersistant,
   useAsyncCallback: () => useAsyncCallback,
@@ -72,6 +72,7 @@ __export(index_exports, {
   useFetchRequestIntercept: () => useFetchRequestIntercept,
   useFetchResponseIntercept: () => useFetchResponseIntercept,
   useMounted: () => useMounted,
+  useStatus: () => useStatus,
   useStore: () => useStore,
   useWatch: () => useWatch,
   useWhenever: () => useWhenever,
@@ -422,6 +423,7 @@ function useWhenever(source, cb, options) {
 }
 
 // src/storage/defineStore.ts
+var import_react15 = require("react");
 var import_valtio2 = require("valtio");
 
 // ../util-core/src/util/json.ts
@@ -458,11 +460,19 @@ 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 = {};
+  markActions($state, actions, $actions);
+  markGetters(state, $state, getters, $getters);
+  markStatus($actions, $status);
   function $subscribe(listener) {
     return (0, import_valtio2.subscribe)($state, () => listener($state));
   }
@@ -472,14 +482,84 @@ function defineStore(store, options = {}) {
     else
       Object.assign($state, patch);
   }
+  function $signal(fn) {
+    return (0, import_react15.createElement)(() => fn((0, import_valtio2.useSnapshot)($state)));
+  }
+  $signal.status = function(fn) {
+    return (0, import_react15.createElement)(() => fn((0, import_valtio2.useSnapshot)($status)));
+  };
   return {
     $subscribe,
     $patch,
     $state,
+    $status,
     $actions,
-    ...$actions
+    $getters,
+    $signal,
+    ...$actions,
+    ...$state
   };
 }
+function markActions($state, actions, $actions) {
+  for (const key in actions)
+    $actions[key] = actions[key].bind($state);
+}
+function markGetters(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 markStatus($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
+  });
+  for (const key in $actions) {
+    let subscribe4 = function() {
+      if (subscribers === 0)
+        $status[key].loading = true;
+      subscribers++;
+    }, done2 = function() {
+      subscribers--;
+      if (!subscribers)
+        $status[key].loading = false;
+    };
+    var subscribe3 = subscribe4, done = done2;
+    const action = $actions[key];
+    $status[key] = { finished: false, loading: false, error: null };
+    let subscribers = 0;
+    $actions[key] = function(...args) {
+      subscribe4();
+      try {
+        const result = action(...args);
+        if (result instanceof Promise) {
+          result.then(() => $status[key].finished = true).catch((error) => $status[key].error = error).finally(done2);
+        } else {
+          $status[key].finished = true;
+          done2();
+        }
+      } catch (error) {
+        $status[key].error = error;
+        done2();
+      }
+    };
+  }
+}
 
 // src/storage/useStore.ts
 var import_valtio3 = require("valtio");
@@ -498,7 +578,7 @@ function defineAsyncStore(options) {
         error: void 0
       })
     },
-    { persistant: options.persistant ? { id: options.persistant, pick: ["value"] } : void 0 }
+    { persist: options.persist ? { id: options.persist, pick: ["value"] } : void 0 }
   );
   function use() {
     const fn = options.setup();
@@ -522,14 +602,20 @@ function defineAsyncStore(options) {
   return use;
 }
 
-// src/storage/defineAsyncStorePlain.ts
-function defineAsyncStorePlain(fn, options = {}) {
+// src/storage/defineAsyncStoreLayered.ts
+function defineAsyncStoreLayered(fn, options = {}) {
   return defineAsyncStore({
     setup: () => fn,
     initial: options.initial,
-    persistant: options.persistant
+    persist: options.persist
   });
 }
+
+// src/storage/useStatus.tsx
+var import_valtio4 = require("valtio");
+function useStatus(store) {
+  return (0, import_valtio4.useSnapshot)(store.$status);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Case,
@@ -543,7 +629,7 @@ function defineAsyncStorePlain(fn, options = {}) {
   Unless,
   cls,
   defineAsyncStore,
-  defineAsyncStorePlain,
+  defineAsyncStoreLayered,
   defineStore,
   proxyWithPersistant,
   useAsyncCallback,
@@ -553,6 +639,7 @@ function defineAsyncStorePlain(fn, options = {}) {
   useFetchRequestIntercept,
   useFetchResponseIntercept,
   useMounted,
+  useStatus,
   useStore,
   useWatch,
   useWhenever,

package/dist/index.d.ts

@@ -150,9 +150,10 @@ declare function useWhenever<T>(source: T, cb: WatchCallback<Exclude<T, null | u
 interface AsyncStoreOptions<T extends FunctionReturningPromise> {
     initial?: ReturnType<T> extends Promise<infer U> ? U : undefined;
     setup: () => T;
-    persistant?: string;
+    persist?: string;
 }
 declare function defineAsyncStore<T extends FunctionReturningPromise>(options: AsyncStoreOptions<T>): () => readonly [{
+    readonly [x: string]: any;
     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>;
@@ -164,9 +165,10 @@ declare function defineAsyncStore<T extends FunctionReturningPromise>(options: A
     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'> {
+interface AsyncStoreLayeredOptions<T extends FunctionReturningPromise> extends Omit<AsyncStoreOptions<T>, 'setup'> {
 }
-declare function defineAsyncStorePlain<T extends FunctionReturningPromise>(fn: T, options?: AsyncStorePlainOptions<T>): () => readonly [{
+declare function defineAsyncStoreLayered<T extends FunctionReturningPromise>(fn: T, options?: AsyncStoreLayeredOptions<T>): () => readonly [{
+    readonly [x: string]: any;
     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>;
@@ -186,27 +188,50 @@ 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>> = {
+interface Signal<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;
+}
+type Store<S, A extends Actions<S>, G extends Getters<S>> = {
     $subscribe: (listener: (state: S) => void) => () => void;
     $patch: (patch: Partial<S> | ((state: S) => void)) => void;
-    $state: S;
+    $state: S & GettersReturnType<G>;
     $actions: ActionsOmitThisParameter<A>;
-} & ActionsOmitThisParameter<A>;
-declare function defineStore<S extends object, A extends Actions<S>>(store: StoreDefine<S, A>, options?: StoreOptions): Store<S, A>;
+    $getters: GettersReturnType<G>;
+    $status: ActionsStatus<A>;
+    $signal: Signal<S, A, G>;
+} & ActionsOmitThisParameter<A> & GettersReturnType<G>;
+
+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>>(store: Store<S, A>): valtio.Snapshot<S>;
+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 AsyncStoreLayeredOptions, 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, type StateFromFunctionReturningPromise, 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, defineAsyncStoreLayered, defineStore, proxyWithPersistant, useAsyncCallback, useAsyncState, useDebounce, useEventBus, useFetchRequestIntercept, useFetchResponseIntercept, useMounted, useStatus, useStore, useWatch, useWhenever, wrapper };

package/dist/index.global.js

@@ -105,7 +105,7 @@ var LibReact = (() => {
     Unless: () => Unless,
     cls: () => cls,
     defineAsyncStore: () => defineAsyncStore,
-    defineAsyncStorePlain: () => defineAsyncStorePlain,
+    defineAsyncStoreLayered: () => defineAsyncStoreLayered,
     defineStore: () => defineStore,
     proxyWithPersistant: () => proxyWithPersistant,
     useAsyncCallback: () => useAsyncCallback,
@@ -115,6 +115,7 @@ var LibReact = (() => {
     useFetchRequestIntercept: () => useFetchRequestIntercept,
     useFetchResponseIntercept: () => useFetchResponseIntercept,
     useMounted: () => useMounted,
+    useStatus: () => useStatus,
     useStore: () => useStore,
     useWatch: () => useWatch,
     useWhenever: () => useWhenever,
@@ -541,6 +542,9 @@ var LibReact = (() => {
     useWatch(source, () => source && cb(source), options);
   }
 
+  // src/storage/defineStore.ts
+  var import_react16 = __toESM(require_react(), 1);
+
   // ../../node_modules/.pnpm/proxy-compare@3.0.1/node_modules/proxy-compare/dist/index.js
   var TRACK_MEMO_SYMBOL = Symbol();
   var GET_ORIGINAL_SYMBOL = Symbol();
@@ -1067,11 +1071,19 @@ var LibReact = (() => {
   // 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) : proxy(state);
+    const status = {};
+    status.finished = false;
+    status.loading = false;
+    status.error = null;
+    const $state = options.persist ? proxyWithPersistant(options.persist, state) : proxy(state);
+    const $status = proxy(status);
     const $actions = {};
-    for (const key in actions)
-      $actions[key] = actions[key].bind($state);
+    const $getters = {};
+    markActions($state, actions, $actions);
+    markGetters(state, $state, getters, $getters);
+    markStatus($actions, $status);
     function $subscribe(listener) {
       return subscribe($state, () => listener($state));
     }
@@ -1081,14 +1093,84 @@ var LibReact = (() => {
       else
         Object.assign($state, patch);
     }
+    function $signal(fn) {
+      return (0, import_react16.createElement)(() => fn(useSnapshot($state)));
+    }
+    $signal.status = function(fn) {
+      return (0, import_react16.createElement)(() => fn(useSnapshot($status)));
+    };
     return {
       $subscribe,
       $patch,
       $state,
+      $status,
       $actions,
-      ...$actions
+      $getters,
+      $signal,
+      ...$actions,
+      ...$state
     };
   }
+  function markActions($state, actions, $actions) {
+    for (const key in actions)
+      $actions[key] = actions[key].bind($state);
+  }
+  function markGetters(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 markStatus($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
+    });
+    for (const key in $actions) {
+      let subscribe3 = function() {
+        if (subscribers === 0)
+          $status[key].loading = true;
+        subscribers++;
+      }, done2 = function() {
+        subscribers--;
+        if (!subscribers)
+          $status[key].loading = false;
+      };
+      var subscribe2 = subscribe3, done = done2;
+      const action = $actions[key];
+      $status[key] = { finished: false, loading: false, error: null };
+      let subscribers = 0;
+      $actions[key] = function(...args) {
+        subscribe3();
+        try {
+          const result = action(...args);
+          if (result instanceof Promise) {
+            result.then(() => $status[key].finished = true).catch((error) => $status[key].error = error).finally(done2);
+          } else {
+            $status[key].finished = true;
+            done2();
+          }
+        } catch (error) {
+          $status[key].error = error;
+          done2();
+        }
+      };
+    }
+  }
 
   // src/storage/useStore.ts
   function useStore(store) {
@@ -1106,7 +1188,7 @@ var LibReact = (() => {
           error: void 0
         })
       },
-      { persistant: options.persistant ? { id: options.persistant, pick: ["value"] } : void 0 }
+      { persist: options.persist ? { id: options.persist, pick: ["value"] } : void 0 }
     );
     function use() {
       const fn = options.setup();
@@ -1130,13 +1212,18 @@ var LibReact = (() => {
     return use;
   }
 
-  // src/storage/defineAsyncStorePlain.ts
-  function defineAsyncStorePlain(fn, options = {}) {
+  // src/storage/defineAsyncStoreLayered.ts
+  function defineAsyncStoreLayered(fn, options = {}) {
     return defineAsyncStore({
       setup: () => fn,
       initial: options.initial,
-      persistant: options.persistant
+      persist: options.persist
     });
   }
+
+  // src/storage/useStatus.tsx
+  function useStatus(store) {
+    return useSnapshot(store.$status);
+  }
   return __toCommonJS(index_exports);
 })();

package/dist/index.js

@@ -364,7 +364,8 @@ function useWhenever(source, cb, options) {
 }
 
 // src/storage/defineStore.ts
-import { proxy as proxy2, subscribe as subscribe2 } from "valtio";
+import { createElement as createElement4 } from "react";
+import { proxy as proxy2, subscribe as subscribe2, useSnapshot } from "valtio";
 
 // ../util-core/src/util/json.ts
 function jsonTryParse(text) {
@@ -400,11 +401,19 @@ 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) : proxy2(state);
+  const status = {};
+  status.finished = false;
+  status.loading = false;
+  status.error = null;
+  const $state = options.persist ? proxyWithPersistant(options.persist, state) : proxy2(state);
+  const $status = proxy2(status);
   const $actions = {};
-  for (const key in actions)
-    $actions[key] = actions[key].bind($state);
+  const $getters = {};
+  markActions($state, actions, $actions);
+  markGetters(state, $state, getters, $getters);
+  markStatus($actions, $status);
   function $subscribe(listener) {
     return subscribe2($state, () => listener($state));
   }
@@ -414,19 +423,89 @@ function defineStore(store, options = {}) {
     else
       Object.assign($state, patch);
   }
+  function $signal(fn) {
+    return createElement4(() => fn(useSnapshot($state)));
+  }
+  $signal.status = function(fn) {
+    return createElement4(() => fn(useSnapshot($status)));
+  };
   return {
     $subscribe,
     $patch,
     $state,
+    $status,
     $actions,
-    ...$actions
+    $getters,
+    $signal,
+    ...$actions,
+    ...$state
   };
 }
+function markActions($state, actions, $actions) {
+  for (const key in actions)
+    $actions[key] = actions[key].bind($state);
+}
+function markGetters(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 markStatus($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
+  });
+  for (const key in $actions) {
+    let subscribe4 = function() {
+      if (subscribers === 0)
+        $status[key].loading = true;
+      subscribers++;
+    }, done2 = function() {
+      subscribers--;
+      if (!subscribers)
+        $status[key].loading = false;
+    };
+    var subscribe3 = subscribe4, done = done2;
+    const action = $actions[key];
+    $status[key] = { finished: false, loading: false, error: null };
+    let subscribers = 0;
+    $actions[key] = function(...args) {
+      subscribe4();
+      try {
+        const result = action(...args);
+        if (result instanceof Promise) {
+          result.then(() => $status[key].finished = true).catch((error) => $status[key].error = error).finally(done2);
+        } else {
+          $status[key].finished = true;
+          done2();
+        }
+      } catch (error) {
+        $status[key].error = error;
+        done2();
+      }
+    };
+  }
+}
 
 // src/storage/useStore.ts
-import { useSnapshot } from "valtio";
+import { useSnapshot as useSnapshot2 } from "valtio";
 function useStore(store) {
-  return useSnapshot(store.$state);
+  return useSnapshot2(store.$state);
 }
 
 // src/storage/defineAsyncStore.ts
@@ -440,7 +519,7 @@ function defineAsyncStore(options) {
         error: void 0
       })
     },
-    { persistant: options.persistant ? { id: options.persistant, pick: ["value"] } : void 0 }
+    { persist: options.persist ? { id: options.persist, pick: ["value"] } : void 0 }
   );
   function use() {
     const fn = options.setup();
@@ -464,14 +543,20 @@ function defineAsyncStore(options) {
   return use;
 }
 
-// src/storage/defineAsyncStorePlain.ts
-function defineAsyncStorePlain(fn, options = {}) {
+// src/storage/defineAsyncStoreLayered.ts
+function defineAsyncStoreLayered(fn, options = {}) {
   return defineAsyncStore({
     setup: () => fn,
     initial: options.initial,
-    persistant: options.persistant
+    persist: options.persist
   });
 }
+
+// src/storage/useStatus.tsx
+import { useSnapshot as useSnapshot3 } from "valtio";
+function useStatus(store) {
+  return useSnapshot3(store.$status);
+}
 export {
   Case,
   Default,
@@ -484,7 +569,7 @@ export {
   Unless,
   cls,
   defineAsyncStore,
-  defineAsyncStorePlain,
+  defineAsyncStoreLayered,
   defineStore,
   proxyWithPersistant,
   useAsyncCallback,
@@ -494,6 +579,7 @@ export {
   useFetchRequestIntercept,
   useFetchResponseIntercept,
   useMounted,
+  useStatus,
   useStore,
   useWatch,
   useWhenever,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hairy/react-lib",
   "type": "module",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "Library for react",
   "author": "Hairyf <wwu710632@gmail.com>",
   "license": "MIT",
@@ -38,7 +38,7 @@
     "react-dom": "^18.2.0",
     "react-i18next": "^14.1.2",
     "react-use": "^17.6.0",
-    "@hairy/utils": "1.14.0"
+    "@hairy/utils": "1.15.0"
   },
   "scripts": {
     "build": "tsup",