@hairy/react-lib 1.15.0 → 1.17.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,
-  defineAsyncStoreLayered: () => defineAsyncStoreLayered,
   defineStore: () => defineStore,
   proxyWithPersistant: () => proxyWithPersistant,
   useAsyncCallback: () => useAsyncCallback,
@@ -227,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;
 
@@ -313,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]);
@@ -332,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);
@@ -385,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
@@ -423,7 +351,7 @@ function useWhenever(source, cb, options) {
 }
 
 // src/storage/defineStore.ts
-var import_react15 = require("react");
+var import_react14 = require("react");
 var import_valtio2 = require("valtio");
 
 // ../util-core/src/util/json.ts
@@ -435,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;
@@ -470,12 +398,15 @@ function defineStore(store, options = {}) {
   const $status = (0, import_valtio2.proxy)(status);
   const $actions = {};
   const $getters = {};
-  markActions($state, actions, $actions);
-  markGetters(state, $state, getters, $getters);
-  markStatus($actions, $status);
+  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);
@@ -483,10 +414,10 @@ function defineStore(store, options = {}) {
       Object.assign($state, patch);
   }
   function $signal(fn) {
-    return (0, import_react15.createElement)(() => fn((0, import_valtio2.useSnapshot)($state)));
+    return (0, import_react14.createElement)(() => fn((0, import_valtio2.useSnapshot)($state)));
   }
   $signal.status = function(fn) {
-    return (0, import_react15.createElement)(() => fn((0, import_valtio2.useSnapshot)($status)));
+    return (0, import_react14.createElement)(() => fn((0, import_valtio2.useSnapshot)($status)));
   };
   return {
     $subscribe,
@@ -496,15 +427,41 @@ function defineStore(store, options = {}) {
     $actions,
     $getters,
     $signal,
-    ...$actions,
-    ...$state
+    ...$actions
+  };
+}
+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 markActions($state, actions, $actions) {
-  for (const key in actions)
-    $actions[key] = actions[key].bind($state);
+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 markGetters(state, $state, getters, $getters) {
+function setupGetters(state, $state, getters, $getters) {
   for (const key in getters) {
     Object.defineProperty(state, key, {
       get: () => getters[key].call($state),
@@ -516,7 +473,7 @@ function markGetters(state, $state, getters, $getters) {
     });
   }
 }
-function markStatus($actions, $status) {
+function setupStatus($actions, $status) {
   Object.defineProperty($status, "loading", {
     get: () => Object.keys($actions).some((key) => $status[key].loading),
     enumerable: true
@@ -529,92 +486,35 @@ function markStatus($actions, $status) {
     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");
-function useStore(store) {
-  return (0, import_valtio3.useSnapshot)(store.$state);
 }
 
 // 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;
+        }
+      }
     },
-    { persist: options.persist ? { id: options.persist, 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/defineAsyncStoreLayered.ts
-function defineAsyncStoreLayered(fn, options = {}) {
-  return defineAsyncStore({
-    setup: () => fn,
-    initial: options.initial,
-    persist: options.persist
-  });
+// src/storage/useStatus.tsx
+var import_valtio3 = require("valtio");
+function useStatus(store) {
+  return (0, import_valtio3.useSnapshot)(store.$status);
 }
 
-// src/storage/useStatus.tsx
+// src/storage/useStore.ts
 var import_valtio4 = require("valtio");
-function useStatus(store) {
-  return (0, import_valtio4.useSnapshot)(store.$status);
+function useStore(store) {
+  return (0, import_valtio4.useSnapshot)(store.$state);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -629,7 +529,6 @@ function useStatus(store) {
   Unless,
   cls,
   defineAsyncStore,
-  defineAsyncStoreLayered,
   defineStore,
   proxyWithPersistant,
   useAsyncCallback,

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,39 +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;
-    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>;
-        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 AsyncStoreLayeredOptions<T extends FunctionReturningPromise> extends Omit<AsyncStoreOptions<T>, 'setup'> {
-}
-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>;
-        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;
@@ -212,19 +177,41 @@ interface StoreDefine<S extends object, A extends Actions<S>, G extends Getters<
 interface StoreOptions {
     persist?: string | PersistantOptions;
 }
-interface Signal<S, A extends Actions<S>, G extends Getters<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: (listener: (state: S) => void) => () => void;
-    $patch: (patch: Partial<S> | ((state: S) => void)) => void;
+    $subscribe: StoreSubscribe<S, A, G>;
+    $patch: StorePatch<S, G>;
     $state: S & GettersReturnType<G>;
     $actions: ActionsOmitThisParameter<A>;
     $getters: GettersReturnType<G>;
     $status: ActionsStatus<A>;
-    $signal: Signal<S, A, G>;
-} & ActionsOmitThisParameter<A> & GettersReturnType<G>;
+    $signal: StoreSignal<S, A, G>;
+} & ActionsOmitThisParameter<A>;
+
+interface AsyncStoreOptions<T extends AnyFn> {
+    initial?: ReturnType<T> extends Promise<infer U> ? U : undefined;
+    persist?: string;
+}
+declare function defineAsyncStore<T extends AnyFn>(fetch: T, options?: AsyncStoreOptions<T>): Store<{
+    value: (ReturnType<T> extends Promise<infer U> ? U : undefined) | undefined;
+}, {
+    fetch: T;
+    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>;
 
@@ -234,4 +221,4 @@ declare function useStore<S extends object, A extends Actions<S>, G extends Gett
 
 type PropsWithDetailedHTML<T = HTMLDivElement> = DetailedHTMLProps<HTMLAttributes<T>, T>;
 
-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 };
+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 };