@hairy/react-lib 1.14.0 → 1.16.0

package/dist/index.global.js

@@ -6,9 +6,6 @@ var LibReact = (() => {
   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 __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
@@ -73,24 +70,6 @@ var LibReact = (() => {
     }
   });
 
-  // ../../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(t2) {
-          for (var s2, i2 = 1, n2 = arguments.length; i2 < n2; i2++) {
-            s2 = arguments[i2];
-            for (var p in s2) if (Object.prototype.hasOwnProperty.call(s2, p)) t2[p] = s2[p];
-          }
-          return t2;
-        };
-        return __assign.apply(this, arguments);
-      };
-    }
-  });
-
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
@@ -105,7 +84,6 @@ var LibReact = (() => {
     Unless: () => Unless,
     cls: () => cls,
     defineAsyncStore: () => defineAsyncStore,
-    defineAsyncStorePlain: () => defineAsyncStorePlain,
     defineStore: () => defineStore,
     proxyWithPersistant: () => proxyWithPersistant,
     useAsyncCallback: () => useAsyncCallback,
@@ -115,6 +93,7 @@ var LibReact = (() => {
     useFetchRequestIntercept: () => useFetchRequestIntercept,
     useFetchResponseIntercept: () => useFetchResponseIntercept,
     useMounted: () => useMounted,
+    useStatus: () => useStatus,
     useStore: () => useStore,
     useWatch: () => useWatch,
     useWhenever: () => useWhenever,
@@ -329,80 +308,26 @@ var LibReact = (() => {
   // src/hooks/useAsyncCallback.ts
   var import_react7 = __toESM(require_react(), 1);
   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 [loading, execute, 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();
-  var import_react9 = __toESM(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 = __toESM(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 fun(...args).then((value) => {
+        set({ loading: false });
         return value;
-      }, function(error) {
-        isMounted() && callId === lastCallId.current && set({ error, loading: false });
-        return error;
+      }).catch((err) => {
+        set({ loading: false, error: err });
+        return Promise.reject(err);
       });
-    }, deps);
-    return [state, callback];
+    }
+    return [state.loading, execute, state.error];
   }
 
+  // src/hooks/useAsyncState.ts
+  var import_react9 = __toESM(require_react(), 1);
+
   // ../../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 = __toESM(require_react());
+  var import_react8 = __toESM(require_react());
   var useEffectOnce = function(effect) {
-    (0, import_react10.useEffect)(effect, []);
+    (0, import_react8.useEffect)(effect, []);
   };
   var useEffectOnce_default = useEffectOnce;
 
@@ -415,17 +340,21 @@ var LibReact = (() => {
   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 = __toESM(require_react(), 1);
+  var import_react10 = __toESM(require_react(), 1);
   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]);
@@ -451,14 +380,14 @@ var LibReact = (() => {
   }
 
   // src/hooks/useEventBus.ts
-  var import_react12 = __toESM(require_react(), 1);
+  var import_react11 = __toESM(require_react(), 1);
   var emitter = 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);
@@ -504,23 +433,23 @@ var LibReact = (() => {
   }
 
   // src/hooks/useMounted.ts
-  var import_react13 = __toESM(require_react(), 1);
+  var import_react12 = __toESM(require_react(), 1);
   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 = __toESM(require_react(), 1);
+  var import_react13 = __toESM(require_react(), 1);
   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
@@ -541,6 +470,9 @@ var LibReact = (() => {
     useWatch(source, () => source && cb(source), options);
   }
 
+  // src/storage/defineStore.ts
+  var import_react15 = __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();
@@ -978,27 +910,27 @@ var LibReact = (() => {
   }
 
   // ../../node_modules/.pnpm/valtio@2.1.4_@types+react@18.3.18_react@18.3.1/node_modules/valtio/esm/react.mjs
-  var import_react15 = __toESM(require_react(), 1);
+  var import_react14 = __toESM(require_react(), 1);
   var import_meta2 = {};
   var useAffectedDebugValue = (state, affected) => {
-    const pathList = (0, import_react15.useRef)(void 0);
-    (0, import_react15.useEffect)(() => {
+    const pathList = (0, import_react14.useRef)(void 0);
+    (0, import_react14.useEffect)(() => {
       pathList.current = affectedToPathList(state, affected, true);
     });
-    (0, import_react15.useDebugValue)(pathList.current);
+    (0, import_react14.useDebugValue)(pathList.current);
   };
   var condUseAffectedDebugValue = useAffectedDebugValue;
   var targetCache = /* @__PURE__ */ new WeakMap();
   function useSnapshot(proxyObject, options) {
     const notifyInSync = options == null ? void 0 : options.sync;
-    const affected = (0, import_react15.useMemo)(
+    const affected = (0, import_react14.useMemo)(
       () => proxyObject && /* @__PURE__ */ new WeakMap(),
       [proxyObject]
     );
-    const lastSnapshot = (0, import_react15.useRef)(void 0);
+    const lastSnapshot = (0, import_react14.useRef)(void 0);
     let inRender = true;
-    const currSnapshot = (0, import_react15.useSyncExternalStore)(
-      (0, import_react15.useCallback)(
+    const currSnapshot = (0, import_react14.useSyncExternalStore)(
+      (0, import_react14.useCallback)(
         (callback) => {
           const unsub = subscribe(proxyObject, callback, notifyInSync);
           callback();
@@ -1024,13 +956,13 @@ var LibReact = (() => {
       () => snapshot(proxyObject)
     );
     inRender = false;
-    (0, import_react15.useLayoutEffect)(() => {
+    (0, import_react14.useLayoutEffect)(() => {
       lastSnapshot.current = currSnapshot;
     });
     if ((import_meta2.env ? import_meta2.env.MODE : void 0) !== "production") {
       condUseAffectedDebugValue(currSnapshot, affected);
     }
-    const proxyCache2 = (0, import_react15.useMemo)(() => /* @__PURE__ */ new WeakMap(), []);
+    const proxyCache2 = (0, import_react14.useMemo)(() => /* @__PURE__ */ new WeakMap(), []);
     return createProxy(currSnapshot, affected, proxyCache2, targetCache);
   }
 
@@ -1043,7 +975,7 @@ var LibReact = (() => {
     }
   }
 
-  // src/storage/proxyWithPersistant.ts
+  // src/storage/persistant.ts
   function proxyWithPersistant(keyOrOptions, initialObject) {
     let options;
     if (typeof keyOrOptions === "string") {
@@ -1067,76 +999,131 @@ 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 = {};
+    setupActions($state, actions, $actions, $status);
+    setupGetters(state, $state, getters, $getters);
+    setupStatus($actions, $status);
     function $subscribe(listener) {
       return subscribe($state, () => listener($state));
     }
+    $subscribe.status = function(listener) {
+      return subscribe($status, () => listener($status));
+    };
     function $patch(patch) {
       if (typeof patch === "function")
         patch($state);
       else
         Object.assign($state, patch);
     }
+    function $signal(fn) {
+      return (0, import_react15.createElement)(() => fn(useSnapshot($state)));
+    }
+    $signal.status = function(fn) {
+      return (0, import_react15.createElement)(() => fn(useSnapshot($status)));
+    };
     return {
       $subscribe,
       $patch,
       $state,
+      $status,
       $actions,
+      $getters,
+      $signal,
       ...$actions
     };
   }
-
-  // src/storage/useStore.ts
-  function useStore(store) {
-    return 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
+  function useStatus(store) {
+    return useSnapshot(store.$status);
+  }
+
+  // src/storage/useStore.ts
+  function useStore(store) {
+    return useSnapshot(store.$state);
   }
   return __toCommonJS(index_exports);
 })();