@ahoo-wang/fetcher-react 3.1.6 → 3.1.9

package/dist/index.es.js

@@ -1,444 +1,479 @@
-var k = Object.defineProperty;
-var y = (e, t) => k(e, "name", { value: t, configurable: !0 });
-import { useRef as m, useCallback as u, useEffect as C, useState as Q, useMemo as h, useReducer as A, useSyncExternalStore as U } from "react";
-import { nameGenerator as z } from "@ahoo-wang/fetcher-eventbus";
-import { fetcherRegistrar as G, getFetcher as K } from "@ahoo-wang/fetcher";
-function p() {
-  const e = m(!1), t = u(() => e.current, []);
-  return C(() => (e.current = !0, () => {
+var M = Object.defineProperty;
+var b = (e, t) => M(e, "name", { value: t, configurable: !0 });
+import { useRef as v, useCallback as c, useEffect as F, useState as Q, useMemo as h, useReducer as O, useSyncExternalStore as k } from "react";
+import { nameGenerator as q } from "@ahoo-wang/fetcher-eventbus";
+import { fetcherRegistrar as U, getFetcher as z } from "@ahoo-wang/fetcher";
+function D() {
+  const e = v(!1), t = c(() => e.current, []);
+  return F(() => (e.current = !0, () => {
     e.current = !1;
   }), []), t;
 }
-y(p, "useMounted");
-function S(e) {
-  const t = m(e);
+b(D, "useMounted");
+function C(e) {
+  const t = v(e);
   return t.current = e, t;
 }
-y(S, "useLatest");
-var T = /* @__PURE__ */ ((e) => (e.IDLE = "idle", e.LOADING = "loading", e.SUCCESS = "success", e.ERROR = "error", e))(T || {});
-function D(e) {
-  const [t, r] = Q(
+b(C, "useLatest");
+var G = /* @__PURE__ */ ((e) => (e.IDLE = "idle", e.LOADING = "loading", e.SUCCESS = "success", e.ERROR = "error", e))(G || {});
+function K(e) {
+  const [t, n] = Q(
     e?.initialStatus ?? "idle"
     /* IDLE */
-  ), [s, o] = Q(void 0), [i, n] = Q(void 0), c = p(), a = S(e), l = u(() => {
-    c() && (r(
+  ), [o, i] = Q(void 0), [l, s] = Q(void 0), u = D(), d = C(e), a = c(() => {
+    u() && (n(
       "loading"
       /* LOADING */
-    ), n(void 0));
-  }, [c]), f = u(
-    async (b) => {
-      if (c()) {
-        o(b), r(
+    ), s(void 0));
+  }, [u]), f = c(
+    async (y) => {
+      if (u()) {
+        i(y), n(
           "success"
           /* SUCCESS */
-        ), n(void 0);
+        ), s(void 0);
         try {
-          await a.current?.onSuccess?.(b);
+          await d.current?.onSuccess?.(y);
         } catch (E) {
           console.warn("PromiseState onSuccess callback error:", E);
         }
       }
     },
-    [c, a]
-  ), d = u(
-    async (b) => {
-      if (c()) {
-        n(b), r(
+    [u, d]
+  ), r = c(
+    async (y) => {
+      if (u()) {
+        s(y), n(
           "error"
           /* ERROR */
-        ), o(void 0);
+        ), i(void 0);
         try {
-          await a.current?.onError?.(b);
+          await d.current?.onError?.(y);
         } catch (E) {
           console.warn("PromiseState onError callback error:", E);
         }
       }
     },
-    [c, a]
-  ), g = u(() => {
-    c() && (r(
+    [u, d]
+  ), g = c(() => {
+    u() && (n(
       "idle"
       /* IDLE */
-    ), n(void 0), o(void 0));
-  }, [c]);
+    ), s(void 0), i(void 0));
+  }, [u]);
   return h(
     () => ({
       status: t,
       loading: t === "loading",
-      result: s,
-      error: i,
-      setLoading: l,
+      result: o,
+      error: l,
+      setLoading: a,
       setSuccess: f,
-      setError: d,
+      setError: r,
       setIdle: g
     }),
-    [t, s, i, l, f, d, g]
+    [t, o, l, a, f, r, g]
   );
 }
-y(D, "usePromiseState");
-function P() {
-  const e = m(0), t = u(() => ++e.current, []), r = u(() => e.current, []), s = u((n) => n === e.current, []), o = u(() => {
+b(K, "usePromiseState");
+function T() {
+  const e = v(0), t = c(() => ++e.current, []), n = c(() => e.current, []), o = c((s) => s === e.current, []), i = c(() => {
     e.current++;
-  }, []), i = u(() => {
+  }, []), l = c(() => {
     e.current = 0;
   }, []);
   return h(() => ({
     generate: t,
-    current: r,
-    isLatest: s,
-    invalidate: o,
-    reset: i
-  }), [t, r, s, o, i]);
+    current: n,
+    isLatest: o,
+    invalidate: i,
+    reset: l
+  }), [t, n, o, i, l]);
 }
-y(P, "useRequestId");
-function O(e) {
+b(T, "useRequestId");
+function P(e) {
   const {
     loading: t,
-    result: r,
-    error: s,
-    status: o,
-    setLoading: i,
-    setSuccess: n,
-    setError: c,
-    setIdle: a
-  } = D(e), l = p(), f = P(), d = e?.propagateError, g = u(
-    async (E) => {
-      if (!l())
-        throw new Error("Component is unmounted");
-      const w = f.generate();
-      i();
+    result: n,
+    error: o,
+    status: i,
+    setLoading: l,
+    setSuccess: s,
+    setError: u,
+    setIdle: d
+  } = K(e), a = D(), f = T(), r = v(void 0), g = e?.propagateError, y = e?.onAbort, E = c(async () => {
+    try {
+      await y?.();
+    } catch (w) {
+      console.warn("useExecutePromise onAbort callback error:", w);
+    }
+  }, [y]), S = c(
+    async (w) => {
+      r.current && (r.current.abort(), await E());
+      const I = new AbortController();
+      r.current = I;
+      const A = f.generate();
+      l();
       try {
-        const R = await (typeof E == "function" ? E() : E);
-        return l() && f.isLatest(w) && await n(R), R;
-      } catch (x) {
-        if (l() && f.isLatest(w) && await c(x), d)
-          throw x;
-        return x;
+        const R = await w(I);
+        a() && f.isLatest(A) && await s(R);
+      } catch (R) {
+        if (R instanceof Error && R.name === "AbortError") {
+          a() && d();
+          return;
+        }
+        if (a() && f.isLatest(A) && await u(R), g)
+          throw R;
+      } finally {
+        r.current === I && (r.current = void 0);
       }
     },
-    [i, n, c, l, f, d]
-  ), b = u(() => {
-    l() && a();
-  }, [a, l]);
-  return h(
+    [
+      l,
+      s,
+      u,
+      d,
+      a,
+      f,
+      g,
+      E
+    ]
+  ), m = c(() => {
+    a() && d();
+  }, [d, a]), x = c(async () => {
+    m(), r.current && (r.current.abort(), r.current = void 0, await E());
+  }, [m, E]);
+  return F(() => () => {
+    x();
+  }, [x]), h(
     () => ({
       loading: t,
-      result: r,
-      error: s,
-      status: o,
-      execute: g,
-      reset: b
+      result: n,
+      error: o,
+      status: i,
+      execute: S,
+      reset: m,
+      abort: x
     }),
-    [t, r, s, o, g, b]
+    [t, n, o, i, S, m, x]
   );
 }
-y(O, "useExecutePromise");
+b(P, "useExecutePromise");
 function J() {
-  const e = m(/* @__PURE__ */ new Map()), t = u((d) => e.current.get(d), []), r = u(
-    (d, g) => e.current.set(d, g),
+  const e = v(/* @__PURE__ */ new Map()), t = c((r) => e.current.get(r), []), n = c(
+    (r, g) => e.current.set(r, g),
     []
-  ), s = u((d) => e.current.has(d), []), o = u((d) => e.current.delete(d), []), i = u(() => e.current.clear(), []), n = u(() => e.current.keys(), []), c = u(() => e.current.values(), []), a = u(() => e.current.entries(), []), l = u(() => e.current[Symbol.iterator](), []), f = u((d) => (g) => {
-    g ? e.current.set(d, g) : e.current.delete(d);
+  ), o = c((r) => e.current.has(r), []), i = c((r) => e.current.delete(r), []), l = c(() => e.current.clear(), []), s = c(() => e.current.keys(), []), u = c(() => e.current.values(), []), d = c(() => e.current.entries(), []), a = c(() => e.current[Symbol.iterator](), []), f = c((r) => (g) => {
+    g ? e.current.set(r, g) : e.current.delete(r);
   }, []);
-  return C(() => () => {
+  return F(() => () => {
     e.current.clear();
   }, []), h(
     () => ({
       register: f,
       get: t,
-      set: r,
-      has: s,
-      delete: o,
-      clear: i,
-      keys: n,
-      values: c,
-      entries: a,
+      set: n,
+      has: o,
+      delete: i,
+      clear: l,
+      keys: s,
+      values: u,
+      entries: d,
       get size() {
         return e.current.size;
       },
-      [Symbol.iterator]: l
+      [Symbol.iterator]: a
     }),
-    [f, t, r, s, o, i, n, c, a, l]
+    [f, t, n, o, i, l, s, u, d, a]
   );
 }
-y(J, "useRefs");
-function M(e, t) {
+b(J, "useRefs");
+function p(e, t) {
   if (t.leading === !1 && t.trailing === !1)
     throw new Error(
       "useDebouncedCallback: at least one of leading or trailing must be true"
     );
-  const r = m(
+  const n = v(
     void 0
-  ), s = m(!1), o = S(e), i = S(t), n = u(() => r.current !== void 0, []), c = u(() => {
-    r.current !== void 0 && (clearTimeout(r.current), r.current = void 0);
+  ), o = v(!1), i = C(e), l = C(t), s = c(() => n.current !== void 0, []), u = c(() => {
+    n.current !== void 0 && (clearTimeout(n.current), n.current = void 0);
   }, []);
-  C(() => () => {
-    c();
-  }, [c]);
-  const a = u(
-    (...l) => {
-      const { leading: f = !1, trailing: d = !0, delay: g } = i.current;
-      c(), f && !s.current && (o.current(...l), s.current = !0), d && (r.current = setTimeout(() => {
-        s.current || o.current(...l), s.current = !1, r.current = void 0;
+  F(() => () => {
+    u();
+  }, [u]);
+  const d = c(
+    (...a) => {
+      const { leading: f = !1, trailing: r = !0, delay: g } = l.current;
+      u(), f && !o.current && (i.current(...a), o.current = !0), r && (n.current = setTimeout(() => {
+        o.current || i.current(...a), o.current = !1, n.current = void 0;
       }, g));
     },
-    [o, i, c]
+    [i, l, u]
   );
   return h(
     () => ({
-      run: a,
-      cancel: c,
-      isPending: n
+      run: d,
+      cancel: u,
+      isPending: s
     }),
-    [a, c, n]
+    [d, u, s]
   );
 }
-y(M, "useDebouncedCallback");
+b(p, "useDebouncedCallback");
 function W(e) {
-  const { loading: t, result: r, error: s, execute: o, reset: i, status: n } = O(e), { run: c, cancel: a, isPending: l } = M(
-    o,
+  const { loading: t, result: n, error: o, execute: i, reset: l, abort: s, status: u } = P(e), { run: d, cancel: a, isPending: f } = p(
+    i,
     e.debounce
   );
   return h(
     () => ({
       loading: t,
-      result: r,
-      error: s,
-      status: n,
-      run: c,
+      result: n,
+      error: o,
+      status: u,
+      reset: l,
+      abort: s,
+      run: d,
       cancel: a,
-      isPending: l,
-      reset: i
+      isPending: f
     }),
-    [t, r, s, n, c, a, l, i]
+    [t, n, o, u, l, s, d, a, f]
   );
 }
-y(W, "useDebouncedExecutePromise");
+b(W, "useDebouncedExecutePromise");
 function X() {
-  const [, e] = A((t) => t + 1, 0);
+  const [, e] = O((t) => t + 1, 0);
   return e;
 }
-y(X, "useForceUpdate");
+b(X, "useForceUpdate");
 function Y(e, t) {
-  const r = u(
-    (n) => e.addListener({
-      name: z.generate("useKeyStorage"),
+  const n = c(
+    (s) => e.addListener({
+      name: q.generate("useKeyStorage"),
       // Generate unique listener name
-      handle: n
+      handle: s
       // Callback to trigger React re-render on storage changes
     }),
     [e]
     // Recreate subscription only if keyStorage changes
-  ), s = u(() => {
-    const n = e.get();
-    return n !== null ? n : t ?? null;
-  }, [e, t]), o = U(r, s, s), i = u(
-    (n) => e.set(n),
+  ), o = c(() => {
+    const s = e.get();
+    return s !== null ? s : t ?? null;
+  }, [e, t]), i = k(n, o, o), l = c(
+    (s) => e.set(s),
     [e]
     // Recreate setter only if keyStorage changes
   );
-  return [o, i];
+  return [i, l];
 }
-y(Y, "useKeyStorage");
+b(Y, "useKeyStorage");
 function N(e) {
-  const { fetcher: t = G.default } = e || {}, {
-    loading: r,
-    result: s,
-    error: o,
-    status: i,
-    setLoading: n,
-    setSuccess: c,
-    setError: a,
-    setIdle: l
-  } = D(e), [f, d] = Q(
+  const { fetcher: t = U.default } = e || {}, {
+    loading: n,
+    result: o,
+    error: i,
+    status: l,
+    execute: s,
+    reset: u,
+    abort: d
+  } = P(e), [a, f] = Q(
     void 0
-  ), g = p(), b = m(void 0), E = P(), w = S(e), x = K(t), R = u(
-    async (I) => {
-      b.current && b.current.abort(), b.current = I.abortController ?? new AbortController(), I.abortController = b.current;
-      const F = E.generate();
-      n();
+  ), r = C(e), g = z(t), y = c(
+    async (m) => {
       try {
-        const v = await x.exchange(
-          I,
-          w.current
-        );
-        g() && E.isLatest(F) && d(v);
-        const q = await v.extractResult();
-        g() && E.isLatest(F) && await c(q);
-      } catch (v) {
-        if (v instanceof Error && v.name === "AbortError") {
-          g() && l();
-          return;
-        }
-        g() && E.isLatest(F) && await a(v);
-      } finally {
-        b.current === I.abortController && (b.current = void 0);
+        await s(async (x) => {
+          m.abortController = x;
+          const w = await g.exchange(
+            m,
+            r.current
+          );
+          return f(w), await w.extractResult();
+        });
+      } catch (x) {
+        throw f(void 0), x;
       }
     },
-    [
-      x,
-      g,
-      w,
-      n,
-      c,
-      l,
-      a,
-      E
-    ]
-  );
-  return C(() => () => {
-    b.current?.abort(), b.current = void 0;
-  }, []), h(
+    [s, g, r]
+  ), E = c(() => {
+    u(), f(void 0);
+  }, [u]), S = c(() => {
+    d(), f(void 0);
+  }, [d]);
+  return h(
     () => ({
-      loading: r,
-      result: s,
-      error: o,
-      status: i,
-      exchange: f,
-      execute: R
+      loading: n,
+      result: o,
+      error: i,
+      status: l,
+      exchange: a,
+      execute: y,
+      reset: E,
+      abort: S
     }),
-    [r, s, o, i, f, R]
+    [n, o, i, l, a, y, E, S]
   );
 }
-y(N, "useFetcher");
+b(N, "useFetcher");
 function Z(e) {
-  const { loading: t, result: r, error: s, status: o, exchange: i, execute: n } = N(e), { run: c, cancel: a, isPending: l } = M(
-    n,
+  const { loading: t, result: n, error: o, status: i, exchange: l, execute: s, reset: u, abort: d } = N(e), { run: a, cancel: f, isPending: r } = p(
+    s,
     e.debounce
   );
   return h(
     () => ({
       loading: t,
-      result: r,
-      error: s,
-      status: o,
-      exchange: i,
-      run: c,
-      cancel: a,
-      isPending: l
-    }),
-    [t, r, s, o, i, c, a, l]
-  );
-}
-y(Z, "useDebouncedFetcher");
-function L(e) {
-  const t = S(e), {
-    loading: r,
-    result: s,
-    error: o,
-    status: i,
-    execute: n,
-    reset: c
-  } = O(t.current), a = m(e.initialQuery), l = u(async () => t.current.execute(
-    a.current,
-    t.current.attributes
-  ), [a, t]), f = u(() => n(l), [n, l]), d = u(() => a.current, [a]), g = u(
-    (b) => {
-      a.current = b, t.current.autoExecute && f();
-    },
-    [a, t, f]
-  );
-  return C(() => {
-    t.current.autoExecute && f();
-  }, [t, f]), h(
-    () => ({
-      loading: r,
-      result: s,
+      result: n,
       error: o,
       status: i,
-      execute: f,
-      reset: c,
-      getQuery: d,
-      setQuery: g
+      exchange: l,
+      reset: u,
+      abort: d,
+      run: a,
+      cancel: f,
+      isPending: r
     }),
     [
-      r,
-      s,
+      t,
+      n,
       o,
       i,
-      f,
-      c,
+      l,
+      u,
       d,
-      g
+      a,
+      f,
+      r
     ]
   );
 }
-y(L, "useQuery");
+b(Z, "useDebouncedFetcher");
+function L(e) {
+  const t = C(e), {
+    loading: n,
+    result: o,
+    error: i,
+    status: l,
+    execute: s,
+    reset: u,
+    abort: d
+  } = P(t.current), a = v(e.initialQuery), f = c(
+    async (E) => t.current.execute(
+      a.current,
+      t.current.attributes,
+      E
+    ),
+    [a, t]
+  ), r = c(() => s(f), [s, f]), g = c(() => a.current, [a]), y = c(
+    (E) => {
+      a.current = E, t.current.autoExecute && r();
+    },
+    [a, t, r]
+  );
+  return F(() => {
+    t.current.autoExecute && r();
+  }, [t, r]), h(
+    () => ({
+      loading: n,
+      result: o,
+      error: i,
+      status: l,
+      execute: r,
+      reset: u,
+      abort: d,
+      getQuery: g,
+      setQuery: y
+    }),
+    [n, o, i, l, r, u, d, g, y]
+  );
+}
+b(L, "useQuery");
 function _(e) {
   return L(e);
 }
-y(_, "usePagedQuery");
+b(_, "usePagedQuery");
 function $(e) {
   return L(e);
 }
-y($, "useSingleQuery");
+b($, "useSingleQuery");
 function ee(e) {
   return L(e);
 }
-y(ee, "useCountQuery");
+b(ee, "useCountQuery");
 function te(e) {
   return L(e);
 }
-y(te, "useListQuery");
+b(te, "useListQuery");
 function re(e) {
   return L(
     e
   );
 }
-y(re, "useListStreamQuery");
+b(re, "useListStreamQuery");
 function ne(e) {
-  const { loading: t, result: r, error: s, status: o, execute: i, reset: n, getQuery: c, setQuery: a } = L(e), { run: l, cancel: f, isPending: d } = M(
-    i,
+  const {
+    loading: t,
+    result: n,
+    error: o,
+    status: i,
+    execute: l,
+    reset: s,
+    abort: u,
+    getQuery: d,
+    setQuery: a
+  } = L(e), { run: f, cancel: r, isPending: g } = p(
+    l,
     e.debounce
   );
   return h(
     () => ({
       loading: t,
-      result: r,
-      error: s,
-      status: o,
-      reset: n,
-      getQuery: c,
+      result: n,
+      error: o,
+      status: i,
+      reset: s,
+      abort: u,
+      getQuery: d,
       setQuery: a,
-      run: l,
-      cancel: f,
-      isPending: d
+      run: f,
+      cancel: r,
+      isPending: g
     }),
     [
       t,
-      r,
-      s,
-      o,
       n,
-      c,
+      o,
+      i,
+      s,
+      u,
+      d,
       a,
-      l,
       f,
-      d
+      r,
+      g
     ]
   );
 }
-y(ne, "useDebouncedQuery");
+b(ne, "useDebouncedQuery");
 export {
-  T as PromiseStatus,
+  G as PromiseStatus,
   ee as useCountQuery,
-  M as useDebouncedCallback,
+  p as useDebouncedCallback,
   W as useDebouncedExecutePromise,
   Z as useDebouncedFetcher,
   ne as useDebouncedQuery,
-  O as useExecutePromise,
+  P as useExecutePromise,
   N as useFetcher,
   X as useForceUpdate,
   Y as useKeyStorage,
-  S as useLatest,
+  C as useLatest,
   te as useListQuery,
   re as useListStreamQuery,
-  p as useMounted,
+  D as useMounted,
   _ as usePagedQuery,
-  D as usePromiseState,
+  K as usePromiseState,
   L as useQuery,
   J as useRefs,
-  P as useRequestId,
+  T as useRequestId,
   $ as useSingleQuery
 };
 //# sourceMappingURL=index.es.js.map