@ahoo-wang/fetcher-react 3.1.9 → 3.2.1

package/dist/index.es.js

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