@ahoo-wang/fetcher-react 2.6.2 → 2.6.3

package/README.md

@@ -92,6 +92,32 @@ const MyComponent = () => {
 };
 ```
 
+### useLatest Hook
+
+The `useLatest` hook returns the latest value, useful for accessing the current value in async callbacks.
+
+```typescript jsx
+import { useLatest } from '@ahoo-wang/fetcher-react';
+
+const MyComponent = () => {
+  const [count, setCount] = useState(0);
+  const latestCount = useLatest(count);
+
+  const handleAsync = async () => {
+    await someAsyncOperation();
+    console.log('Latest count:', latestCount.current); // Always the latest
+  };
+
+  return (
+    <div>
+      <p>Count: {count}</p>
+      <button onClick={() => setCount(c => c + 1)}>Increment</button>
+      <button onClick={handleAsync}>Async Log</button>
+    </div>
+  );
+};
+```
+
 ### useRequestId Hook
 
 The `useRequestId` hook provides request ID management for preventing race conditions in async operations.
@@ -253,6 +279,26 @@ An object containing:
 - `execute`: Function to execute a promise supplier or promise
 - `reset`: Function to reset the state to initial values
 
+### useLatest
+
+```typescript
+function useLatest<T>(value: T): T;
+```
+
+A React hook that returns the latest value, useful for accessing the current value in async callbacks.
+
+**Type Parameters:**
+
+- `T`: The type of the value
+
+**Parameters:**
+
+- `value`: The value to track
+
+**Returns:**
+
+The latest value
+
 ### useRequestId
 
 ```typescript

package/dist/core/index.d.ts

@@ -1,4 +1,5 @@
 export * from './useExecutePromise';
 export * from './usePromiseState';
 export * from './useRequestId';
+export * from './useLatest';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAaA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAaA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC"}

package/dist/core/useLatest.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A React hook that returns a ref containing the latest value, useful for accessing the current value in async callbacks.
+ *
+ * @template T - The type of the value
+ * @param value - The value to track
+ * @returns A ref object containing the latest value
+ *
+ * @example
+ * ```typescript
+ * import { useLatest } from '@ahoo-wang/fetcher-react';
+ *
+ * const MyComponent = () => {
+ *   const [count, setCount] = useState(0);
+ *   const latestCount = useLatest(count);
+ *
+ *   const handleAsync = async () => {
+ *     await someAsyncOperation();
+ *     console.log('Latest count:', latestCount.current); // Always the latest
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <p>Count: {count}</p>
+ *       <button onClick={() => setCount(c => c + 1)}>Increment</button>
+ *       <button onClick={handleAsync}>Async Log</button>
+ *     </div>
+ *   );
+ * };
+ * ```
+ */
+export declare function useLatest<T>(value: T): import('react').MutableRefObject<T>;
+//# sourceMappingURL=useLatest.d.ts.map

package/dist/core/useLatest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLatest.d.ts","sourceRoot":"","sources":["../../src/core/useLatest.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,uCAIpC"}

package/dist/core/usePromiseState.d.ts

@@ -17,6 +17,12 @@ export interface PromiseState<R, E = unknown> {
     /** The error value */
     error: E | undefined;
 }
+export interface PromiseStateCallbacks<R, E = unknown> {
+    /** Callback invoked on success */
+    onSuccess?: (result: R) => void;
+    /** Callback invoked on error */
+    onError?: (error: E) => void;
+}
 /**
  * Options for configuring usePromiseState behavior
  * @template R - The type of result
@@ -30,13 +36,9 @@ export interface PromiseState<R, E = unknown> {
  * };
  * ```
  */
-export interface UsePromiseStateOptions<R, E = unknown> {
+export interface UsePromiseStateOptions<R, E = unknown> extends PromiseStateCallbacks<R, E> {
     /** Initial status, defaults to IDLE */
     initialStatus?: PromiseStatus;
-    /** Callback invoked on success */
-    onSuccess?: (result: R) => void;
-    /** Callback invoked on error */
-    onError?: (error: E) => void;
 }
 /**
  * Return type for usePromiseState hook

package/dist/core/usePromiseState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePromiseState.d.ts","sourceRoot":"","sources":["../../src/core/usePromiseState.ts"],"names":[],"mappings":"AAgBA;;GAEG;AACH,oBAAY,aAAa;IACvB,IAAI,SAAS;IACb,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,KAAK,UAAU;CAChB;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO;IAC1C,oCAAoC;IACpC,MAAM,EAAE,aAAa,CAAC;IACtB,qCAAqC;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,uBAAuB;IACvB,MAAM,EAAE,CAAC,GAAG,SAAS,CAAC;IACtB,sBAAsB;IACtB,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC;CACtB;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,sBAAsB,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO;IACpD,uCAAuC;IACvC,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,kCAAkC;IAClC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,CAAC;IAChC,gCAAgC;IAChC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CAAE,SAAQ,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/E,4BAA4B;IAC5B,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,wCAAwC;IACxC,UAAU,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,CAAC;IAChC,qCAAqC;IACrC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC7B,yBAAyB;IACzB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EACtD,OAAO,CAAC,EAAE,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,GACrC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAwD7B"}
+{"version":3,"file":"usePromiseState.d.ts","sourceRoot":"","sources":["../../src/core/usePromiseState.ts"],"names":[],"mappings":"AAiBA;;GAEG;AACH,oBAAY,aAAa;IACvB,IAAI,SAAS;IACb,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,KAAK,UAAU;CAChB;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO;IAC1C,oCAAoC;IACpC,MAAM,EAAE,aAAa,CAAC;IACtB,qCAAqC;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,uBAAuB;IACvB,MAAM,EAAE,CAAC,GAAG,SAAS,CAAC;IACtB,sBAAsB;IACtB,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC;CACtB;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO;IACnD,kCAAkC;IAClC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,CAAC;IAChC,gCAAgC;IAChC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CAC9B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,sBAAsB,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CAAE,SAAQ,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC;IACzF,uCAAuC;IACvC,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CACnD,SAAQ,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC;IAC1B,4BAA4B;IAC5B,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,wCAAwC;IACxC,UAAU,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,CAAC;IAChC,qCAAqC;IACrC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC7B,yBAAyB;IACzB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EACtD,OAAO,CAAC,EAAE,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,GACrC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CA2D7B"}

package/dist/core/useRequestId.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRequestId.d.ts","sourceRoot":"","sources":["../../src/core/useRequestId.ts"],"names":[],"mappings":"AAeA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,wDAAwD;IACxD,QAAQ,EAAE,MAAM,MAAM,CAAC;IACvB,8DAA8D;IAC9D,OAAO,EAAE,MAAM,MAAM,CAAC;IACtB,gDAAgD;IAChD,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IACzC,oDAAoD;IACpD,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,+BAA+B;IAC/B,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,YAAY,IAAI,kBAAkB,CA8BjD"}
+{"version":3,"file":"useRequestId.d.ts","sourceRoot":"","sources":["../../src/core/useRequestId.ts"],"names":[],"mappings":"AAeA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,wDAAwD;IACxD,QAAQ,EAAE,MAAM,MAAM,CAAC;IACvB,8DAA8D;IAC9D,OAAO,EAAE,MAAM,MAAM,CAAC;IACtB,gDAAgD;IAChD,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IACzC,oDAAoD;IACpD,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,+BAA+B;IAC/B,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,YAAY,IAAI,kBAAkB,CA+BjD"}

package/dist/fetcher/useFetcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useFetcher.d.ts","sourceRoot":"","sources":["../../src/fetcher/useFetcher.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,cAAc,EACd,aAAa,EACb,YAAY,EAEZ,cAAc,EACf,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,YAAY,EAAmB,sBAAsB,EAAgB,MAAM,SAAS,CAAC;AAE9F;;;GAGG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CAAE,SAAQ,cAAc,EAAE,cAAc,EAAE,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC;CACtH;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CAAE,SAAQ,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC;IAC1E,wEAAwE;IACxE,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,OAAO,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,EACvC,OAAO,CAAC,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAgExB"}
+{"version":3,"file":"useFetcher.d.ts","sourceRoot":"","sources":["../../src/fetcher/useFetcher.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,cAAc,EACd,aAAa,EACb,YAAY,EAEZ,cAAc,EACf,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,YAAY,EAGZ,sBAAsB,EAEvB,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CAC/C,SAAQ,cAAc,EACpB,cAAc,EACd,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CAAE,SAAQ,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC;IAC1E,wEAAwE;IACxE,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,OAAO,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,EACvC,OAAO,CAAC,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAsExB"}

package/dist/index.es.js

@@ -1,82 +1,89 @@
-import { useRef as v, useCallback as c, useEffect as R, useState as E, useMemo as h, useSyncExternalStore as x } from "react";
-import { fetcherRegistrar as S, getFetcher as C } from "@ahoo-wang/fetcher";
-function L() {
+import { useRef as v, useCallback as c, useEffect as I, useState as h, useMemo as L, useSyncExternalStore as C } from "react";
+import { fetcherRegistrar as w, getFetcher as F } from "@ahoo-wang/fetcher";
+function R() {
   var t = v(!1), e = c(function() {
     return t.current;
   }, []);
-  return R(function() {
+  return I(function() {
     return t.current = !0, function() {
       t.current = !1;
     };
   }, []), e;
 }
-var w = /* @__PURE__ */ ((t) => (t.IDLE = "idle", t.LOADING = "loading", t.SUCCESS = "success", t.ERROR = "error", t))(w || {});
-function I(t) {
-  const [e, r] = E(
+function b(t) {
+  const e = v(t);
+  return e.current = t, e;
+}
+var p = /* @__PURE__ */ ((t) => (t.IDLE = "idle", t.LOADING = "loading", t.SUCCESS = "success", t.ERROR = "error", t))(p || {});
+function m(t) {
+  const [e, r] = h(
     t?.initialStatus ?? "idle"
     /* IDLE */
-  ), [u, a] = E(void 0), [s, n] = E(void 0), o = L(), d = c(() => {
+  ), [u, i] = h(void 0), [s, n] = h(void 0), o = R(), d = b(t), f = c(() => {
     o() && (r(
       "loading"
       /* LOADING */
     ), n(void 0));
-  }, [o]), l = c(
-    (i) => {
-      o() && (a(i), r(
+  }, [o]), E = c(
+    (a) => {
+      o() && (i(a), r(
         "success"
         /* SUCCESS */
-      ), n(void 0), t?.onSuccess?.(i));
+      ), n(void 0), d.current?.onSuccess?.(a));
     },
-    [o, t]
-  ), f = c(
-    (i) => {
-      o() && (n(i), r(
+    [o, d]
+  ), l = c(
+    (a) => {
+      o() && (n(a), r(
         "error"
         /* ERROR */
-      ), a(void 0), t?.onError?.(i));
+      ), i(void 0), d.current?.onError?.(a));
     },
-    [o, t]
+    [o, d]
   ), g = c(() => {
     o() && (r(
       "idle"
       /* IDLE */
-    ), n(void 0), a(void 0));
+    ), n(void 0), i(void 0));
   }, [o]);
-  return h(() => ({
-    status: e,
-    loading: e === "loading",
-    result: u,
-    error: s,
-    setLoading: d,
-    setSuccess: l,
-    setError: f,
-    setIdle: g
-  }), [e, u, s, d, l, f, g]);
+  return L(
+    () => ({
+      status: e,
+      loading: e === "loading",
+      result: u,
+      error: s,
+      setLoading: f,
+      setSuccess: E,
+      setError: l,
+      setIdle: g
+    }),
+    [e, u, s, f, E, l, g]
+  );
 }
-function b() {
-  const t = v(0), e = c(() => ++t.current, []), r = c(() => t.current, []), u = c((n) => n === t.current, []), a = c(() => {
+function x() {
+  const t = v(0), e = c(() => ++t.current, []), r = c(() => t.current, []), u = c((n) => n === t.current, []), i = c(() => {
     t.current++;
   }, []), s = c(() => {
     t.current = 0;
   }, []);
-  return {
+  return L(() => ({
     generate: e,
     current: r,
     isLatest: u,
-    invalidate: a,
+    invalidate: i,
     reset: s
-  };
+  }), [e, r, u, i, s]);
 }
 function q(t) {
-  const e = I(t), r = L(), u = b(), a = c(
+  const e = m(t), r = R(), u = x(), i = c(
     async (n) => {
       if (!r())
         throw new Error("Component is unmounted");
       const o = u.generate();
       e.setLoading();
       try {
-        const l = await (typeof n == "function" ? n() : n);
-        return r() && u.isLatest(o) && e.setSuccess(l), l;
+        const f = await (typeof n == "function" ? n() : n);
+        return r() && u.isLatest(o) && e.setSuccess(f), f;
       } catch (d) {
         throw r() && u.isLatest(o) && e.setError(d), d;
       }
@@ -85,67 +92,74 @@ function q(t) {
   ), s = c(() => {
     r() && e.setIdle();
   }, [e, r]);
-  return h(
+  return L(
     () => ({
       loading: e.loading,
       result: e.result,
       error: e.error,
-      execute: a,
+      execute: i,
       reset: s,
       status: e.status
     }),
-    [e.loading, e.result, e.error, a, s, e.status]
+    [e.loading, e.result, e.error, i, s, e.status]
   );
 }
 function y(t) {
   const e = c(
     (s) => t.addListener(s),
     [t]
-  ), r = c(() => t.get(), [t]), u = x(e, r, r), a = c(
+  ), r = c(() => t.get(), [t]), u = C(e, r, r), i = c(
     (s) => t.set(s),
     [t]
   );
-  return [u, a];
+  return [u, i];
 }
 function A(t) {
-  const { fetcher: e = S.default } = t || {}, r = I(t), [u, a] = E(
+  const { fetcher: e = w.default } = t || {}, r = m(t), [u, i] = h(
     void 0
-  ), s = L(), n = v(), o = b(), d = C(e), l = c(
-    async (f) => {
-      n.current && n.current.abort(), n.current = f.abortController ?? new AbortController(), f.abortController = n.current;
+  ), s = R(), n = v(), o = x(), d = b(t), f = F(e), E = c(
+    async (l) => {
+      n.current && n.current.abort(), n.current = l.abortController ?? new AbortController(), l.abortController = n.current;
       const g = o.generate();
       r.setLoading();
       try {
-        const i = await d.exchange(f, t);
-        s() && o.isLatest(g) && a(i);
-        const m = await i.extractResult();
-        s() && o.isLatest(g) && r.setSuccess(m);
-      } catch (i) {
-        if (i instanceof Error && i.name === "AbortError") {
+        const a = await f.exchange(
+          l,
+          d.current
+        );
+        s() && o.isLatest(g) && i(a);
+        const S = await a.extractResult();
+        s() && o.isLatest(g) && r.setSuccess(S);
+      } catch (a) {
+        if (a instanceof Error && a.name === "AbortError") {
           s() && r.setIdle();
           return;
         }
-        s() && o.isLatest(g) && r.setError(i);
+        s() && o.isLatest(g) && r.setError(a);
       } finally {
-        n.current === f.abortController && (n.current = void 0);
+        n.current === l.abortController && (n.current = void 0);
       }
     },
-    [d, s, t, r, o]
+    [f, s, d, r, o]
   );
-  return R(() => () => {
+  return I(() => () => {
     n.current?.abort(), n.current = void 0;
-  }, []), h(() => ({
-    ...r,
-    exchange: u,
-    execute: l
-  }), [r, u, l]);
+  }, []), L(
+    () => ({
+      ...r,
+      exchange: u,
+      execute: E
+    }),
+    [r, u, E]
+  );
 }
 export {
-  w as PromiseStatus,
+  p as PromiseStatus,
   q as useExecutePromise,
   A as useFetcher,
   y as useKeyStorage,
-  I as usePromiseState,
-  b as useRequestId
+  b as useLatest,
+  m as usePromiseState,
+  x as useRequestId
 };
 //# sourceMappingURL=index.es.js.map

package/dist/index.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es.js","sources":["../../../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","../src/core/usePromiseState.ts","../src/core/useRequestId.ts","../src/core/useExecutePromise.ts","../src/storage/useKeyStorage.ts","../src/fetcher/useFetcher.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from 'react';\nexport default function useMountedState() {\n    var mountedRef = useRef(false);\n    var get = useCallback(function () { return mountedRef.current; }, []);\n    useEffect(function () {\n        mountedRef.current = true;\n        return function () {\n            mountedRef.current = false;\n        };\n    }, []);\n    return get;\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useCallback, useMemo, useState } from 'react';\nimport { useMountedState } from 'react-use';\n\n/**\n * Enumeration of possible promise execution states\n */\nexport enum PromiseStatus {\n  IDLE = 'idle',\n  LOADING = 'loading',\n  SUCCESS = 'success',\n  ERROR = 'error',\n}\n\nexport interface PromiseState<R, E = unknown> {\n  /** Current status of the promise */\n  status: PromiseStatus;\n  /** Indicates if currently loading */\n  loading: boolean;\n  /** The result value */\n  result: R | undefined;\n  /** The error value */\n  error: E | undefined;\n}\n\n/**\n * Options for configuring usePromiseState behavior\n * @template R - The type of result\n *\n * @example\n * ```typescript\n * const options: UsePromiseStateOptions<string> = {\n *   initialStatus: PromiseStatus.IDLE,\n *   onSuccess: (result) => console.log('Success:', result),\n *   onError: (error) => console.error('Error:', error),\n * };\n * ```\n */\nexport interface UsePromiseStateOptions<R, E = unknown> {\n  /** Initial status, defaults to IDLE */\n  initialStatus?: PromiseStatus;\n  /** Callback invoked on success */\n  onSuccess?: (result: R) => void;\n  /** Callback invoked on error */\n  onError?: (error: E) => void;\n}\n\n/**\n * Return type for usePromiseState hook\n * @template R - The type of result\n */\nexport interface UsePromiseStateReturn<R, E = unknown> extends PromiseState<R, E> {\n  /** Set status to LOADING */\n  setLoading: () => void;\n  /** Set status to SUCCESS with result */\n  setSuccess: (result: R) => void;\n  /** Set status to ERROR with error */\n  setError: (error: E) => void;\n  /** Set status to IDLE */\n  setIdle: () => void;\n}\n\n/**\n * A React hook for managing promise state without execution logic\n * @template R - The type of result\n * @param options - Configuration options\n * @returns State management object\n *\n * @example\n * ```typescript\n * import { usePromiseState, PromiseStatus } from '@ahoo-wang/fetcher-react';\n *\n * function MyComponent() {\n *   const { status, loading, result, error, setSuccess, setError, setIdle } = usePromiseState<string>();\n *\n *   const handleSuccess = () => setSuccess('Data loaded');\n *   const handleError = () => setError(new Error('Failed to load'));\n *\n *   return (\n *     <div>\n *       <button onClick={handleSuccess}>Set Success</button>\n *       <button onClick={handleError}>Set Error</button>\n *       <button onClick={setIdle}>Reset</button>\n *       <p>Status: {status}</p>\n *       {loading && <p>Loading...</p>}\n *       {result && <p>Result: {result}</p>}\n *       {error && <p>Error: {error.message}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function usePromiseState<R = unknown, E = unknown>(\n  options?: UsePromiseStateOptions<R, E>,\n): UsePromiseStateReturn<R, E> {\n  const [status, setStatus] = useState<PromiseStatus>(\n    options?.initialStatus ?? PromiseStatus.IDLE,\n  );\n  const [result, setResult] = useState<R | undefined>(undefined);\n  const [error, setErrorState] = useState<E | undefined>(undefined);\n  const isMounted = useMountedState();\n\n  const setLoadingFn = useCallback(() => {\n    if (isMounted()) {\n      setStatus(PromiseStatus.LOADING);\n      setErrorState(undefined);\n    }\n  }, [isMounted]);\n\n  const setSuccessFn = useCallback(\n    (result: R) => {\n      if (isMounted()) {\n        setResult(result);\n        setStatus(PromiseStatus.SUCCESS);\n        setErrorState(undefined);\n        options?.onSuccess?.(result);\n      }\n    },\n    [isMounted, options],\n  );\n\n  const setErrorFn = useCallback(\n    (error: E) => {\n      if (isMounted()) {\n        setErrorState(error);\n        setStatus(PromiseStatus.ERROR);\n        setResult(undefined);\n        options?.onError?.(error);\n      }\n    },\n    [isMounted, options],\n  );\n\n  const setIdleFn = useCallback(() => {\n    if (isMounted()) {\n      setStatus(PromiseStatus.IDLE);\n      setErrorState(undefined);\n      setResult(undefined);\n    }\n  }, [isMounted]);\n  return useMemo(() => ({\n    status,\n    loading: status === PromiseStatus.LOADING,\n    result,\n    error,\n    setLoading: setLoadingFn,\n    setSuccess: setSuccessFn,\n    setError: setErrorFn,\n    setIdle: setIdleFn,\n  }), [status, result, error, setLoadingFn, setSuccessFn, setErrorFn, setIdleFn]);\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useRef, useCallback } from 'react';\n\n/**\n * Return type for useRequestId hook\n */\nexport interface UseRequestIdReturn {\n  /** Generate a new request ID and get the current one */\n  generate: () => number;\n  /** Get the current request ID without generating a new one */\n  current: () => number;\n  /** Check if a given request ID is the latest */\n  isLatest: (requestId: number) => boolean;\n  /** Invalidate current request ID (mark as stale) */\n  invalidate: () => void;\n  /** Reset request ID counter */\n  reset: () => void;\n}\n\n/**\n * A React hook for managing request IDs and race condition protection\n *\n * @example\n * ```typescript\n * // Basic usage\n * const requestId = useRequestId();\n *\n * const execute = async () => {\n *   const id = requestId.generate();\n *\n *   try {\n *     const result = await someAsyncOperation();\n *\n *     // Check if this is still the latest request\n *     if (requestId.isLatest(id)) {\n *       setState(result);\n *     }\n *   } catch (error) {\n *     if (requestId.isLatest(id)) {\n *       setError(error);\n *     }\n *   }\n * };\n *\n * // Manual cancellation\n * const handleCancel = () => {\n *   requestId.invalidate(); // All ongoing requests will be ignored\n * };\n * ```\n *\n * @example\n * ```typescript\n * // With async operation wrapper\n * const { execute, cancel } = useAsyncOperation(async (data) => {\n *   return await apiCall(data);\n * }, [requestId]);\n * ```\n */\nexport function useRequestId(): UseRequestIdReturn {\n  const requestIdRef = useRef<number>(0);\n\n  const generate = useCallback((): number => {\n    return ++requestIdRef.current;\n  }, []);\n\n  const current = useCallback((): number => {\n    return requestIdRef.current;\n  }, []);\n\n  const isLatest = useCallback((requestId: number): boolean => {\n    return requestId === requestIdRef.current;\n  }, []);\n\n  const invalidate = useCallback((): void => {\n    requestIdRef.current++;\n  }, []);\n\n  const reset = useCallback((): void => {\n    requestIdRef.current = 0;\n  }, []);\n\n  return {\n    generate,\n    current,\n    isLatest,\n    invalidate,\n    reset,\n  };\n}","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useCallback, useMemo } from 'react';\nimport { useMountedState } from 'react-use';\nimport { usePromiseState, PromiseState, UsePromiseStateOptions } from './usePromiseState';\nimport { useRequestId } from './useRequestId';\n\n/**\n * Type definition for a function that returns a Promise\n * @template R - The type of value the promise will resolve to\n */\nexport type PromiseSupplier<R> = () => Promise<R>;\n\n/**\n * Interface defining the return type of useExecutePromise hook\n * @template R - The type of the result value\n */\nexport interface UseExecutePromiseReturn<R, E = unknown>\n  extends PromiseState<R, E> {\n  /** Function to execute a promise supplier or promise */\n  execute: (input: PromiseSupplier<R> | Promise<R>) => Promise<R>;\n  /** Function to reset the state to initial values */\n  reset: () => void;\n}\n\n/**\n * A React hook for managing asynchronous operations with proper state handling\n * @template R - The type of the result value\n * @returns An object containing the current state and control functions\n *\n * @example\n * ```typescript\n * import { useExecutePromise } from '@ahoo-wang/fetcher-react';\n *\n * function MyComponent() {\n *   const { loading, result, error, execute, reset } = useExecutePromise<string>();\n *\n *   const fetchData = async () => {\n *     const response = await fetch('/api/data');\n *     return response.text();\n *   };\n *\n *   const handleFetch = () => {\n *     execute(fetchData);\n *   };\n *\n *   const handleReset = () => {\n *     reset();\n *   };\n *\n *   if (loading) return <div>Loading...</div>;\n *   if (error) return <div>Error: {error.message}</div>;\n *   return (\n *     <div>\n *       <button onClick={handleFetch}>Fetch Data</button>\n *       <button onClick={handleReset}>Reset</button>\n *       {result && <p>{result}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useExecutePromise<R = unknown, E = unknown>(options?: UsePromiseStateOptions<R, E>): UseExecutePromiseReturn<R, E> {\n  const state = usePromiseState<R, E>(options);\n  const isMounted = useMountedState();\n  const requestId = useRequestId();\n\n  /**\n   * Execute a promise supplier or promise and manage its state\n   * @param input - A function that returns a Promise or a Promise to be executed\n   * @returns A Promise that resolves with the result of the executed promise\n   */\n  const execute = useCallback(\n    async (input: PromiseSupplier<R> | Promise<R>): Promise<R> => {\n      if (!isMounted()) {\n        throw new Error('Component is unmounted');\n      }\n      const currentRequestId = requestId.generate();\n      state.setLoading();\n      try {\n        const promise = typeof input === 'function' ? input() : input;\n        const data = await promise;\n\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setSuccess(data);\n        }\n        return data;\n      } catch (err) {\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setError(err as E);\n        }\n        throw err;\n      }\n    },\n    [state, isMounted, requestId],\n  );\n\n  /**\n   * Reset the state to initial values\n   */\n  const reset = useCallback(() => {\n    if (isMounted()) {\n      state.setIdle();\n    }\n  }, [state, isMounted]);\n\n  return useMemo(\n    () => ({\n      loading: state.loading,\n      result: state.result,\n      error: state.error,\n      execute,\n      reset,\n      status: state.status,\n    }),\n    [state.loading, state.result, state.error, execute, reset, state.status],\n  );\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useCallback, useSyncExternalStore } from 'react';\nimport { KeyStorage } from '@ahoo-wang/fetcher-storage';\n\n/**\n * A React hook that provides state management for a KeyStorage instance.\n * Subscribes to storage changes and returns the current value along with a setter function.\n *\n * @template T - The type of value stored in the key storage\n * @param keyStorage - The KeyStorage instance to subscribe to and manage\n * @returns A tuple containing the current stored value and a function to update it\n */\nexport function useKeyStorage<T>(\n  keyStorage: KeyStorage<T>,\n): [T | null, (value: T) => void] {\n  const subscribe = useCallback(\n    (callback: () => void) => keyStorage.addListener(callback),\n    [keyStorage],\n  );\n  const getSnapshot = useCallback(() => keyStorage.get(), [keyStorage]);\n  const value = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n  const setValue = useCallback(\n    (value: T) => keyStorage.set(value),\n    [keyStorage],\n  );\n  return [value, setValue];\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  fetcherRegistrar,\n  FetcherCapable,\n  FetchExchange,\n  FetchRequest,\n  getFetcher,\n  RequestOptions,\n} from '@ahoo-wang/fetcher';\nimport { useRef, useCallback, useEffect, useState, useMemo } from 'react';\nimport { useMountedState } from 'react-use';\nimport { PromiseState, usePromiseState, UsePromiseStateOptions, useRequestId } from '../core';\n\n/**\n * Configuration options for the useFetcher hook.\n * Extends RequestOptions and FetcherCapable interfaces.\n */\nexport interface UseFetcherOptions<R, E = unknown> extends RequestOptions, FetcherCapable, UsePromiseStateOptions<R, E> {\n}\n\nexport interface UseFetcherReturn<R, E = unknown> extends PromiseState<R, E> {\n  /** The FetchExchange object representing the ongoing fetch operation */\n  exchange?: FetchExchange;\n  execute: (request: FetchRequest) => Promise<void>;\n}\n\n/**\n * A React hook for managing asynchronous operations with proper state handling\n * @param options - Configuration options for the fetcher\n * @returns An object containing the current state and control functions\n *\n * @example\n * ```typescript\n * import { useFetcher } from '@ahoo-wang/fetcher-react';\n *\n * function MyComponent() {\n *   const { loading, result, error, execute } = useFetcher<string>();\n *\n *   const handleFetch = () => {\n *     execute({ url: '/api/data', method: 'GET' });\n *   };\n *\n *   if (loading) return <div>Loading...</div>;\n *   if (error) return <div>Error: {error.message}</div>;\n *   return (\n *     <div>\n *       <button onClick={handleFetch}>Fetch Data</button>\n *       {result && <p>{result}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useFetcher<R, E = unknown>(\n  options?: UseFetcherOptions<R, E>,\n): UseFetcherReturn<R, E> {\n  const { fetcher = fetcherRegistrar.default } = options || {};\n  const state = usePromiseState<R, E>(options);\n  const [exchange, setExchange] = useState<FetchExchange | undefined>(\n    undefined,\n  );\n  const isMounted = useMountedState();\n  const abortControllerRef = useRef<AbortController | undefined>();\n  const requestId = useRequestId();\n\n  const currentFetcher = getFetcher(fetcher);\n  /**\n   * Execute the fetch operation.\n   * Cancels any ongoing fetch before starting a new one.\n   */\n  const execute = useCallback(\n    async (request: FetchRequest) => {\n      if (abortControllerRef.current) {\n        abortControllerRef.current.abort();\n      }\n      abortControllerRef.current =\n        request.abortController ?? new AbortController();\n      request.abortController = abortControllerRef.current;\n      const currentRequestId = requestId.generate();\n      state.setLoading();\n      try {\n        const exchange = await currentFetcher.exchange(request, options);\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          setExchange(exchange);\n        }\n        const result = await exchange.extractResult<R>();\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setSuccess(result);\n        }\n      } catch (error) {\n        if (error instanceof Error && error.name === 'AbortError') {\n          if (isMounted()) {\n            state.setIdle();\n          }\n          return;\n        }\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setError(error as E);\n        }\n      } finally {\n        if (abortControllerRef.current === request.abortController) {\n          abortControllerRef.current = undefined;\n        }\n      }\n    },\n    [currentFetcher, isMounted, options, state, requestId],\n  );\n\n  useEffect(() => {\n    return () => {\n      abortControllerRef.current?.abort();\n      abortControllerRef.current = undefined;\n    };\n  }, []);\n  return useMemo(() => ({\n    ...state,\n    exchange,\n    execute,\n  }), [state, exchange, execute]);\n}\n"],"names":["useMountedState","mountedRef","useRef","get","useCallback","useEffect","PromiseStatus","usePromiseState","options","status","setStatus","useState","result","setResult","error","setErrorState","isMounted","setLoadingFn","setSuccessFn","setErrorFn","setIdleFn","useMemo","useRequestId","requestIdRef","generate","current","isLatest","requestId","invalidate","reset","useExecutePromise","state","execute","input","currentRequestId","data","err","useKeyStorage","keyStorage","subscribe","callback","getSnapshot","value","useSyncExternalStore","setValue","useFetcher","fetcher","fetcherRegistrar","exchange","setExchange","abortControllerRef","currentFetcher","getFetcher","request"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es.js","sources":["../../../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","../src/core/useLatest.ts","../src/core/usePromiseState.ts","../src/core/useRequestId.ts","../src/core/useExecutePromise.ts","../src/storage/useKeyStorage.ts","../src/fetcher/useFetcher.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from 'react';\nexport default function useMountedState() {\n    var mountedRef = useRef(false);\n    var get = useCallback(function () { return mountedRef.current; }, []);\n    useEffect(function () {\n        mountedRef.current = true;\n        return function () {\n            mountedRef.current = false;\n        };\n    }, []);\n    return get;\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useRef } from 'react';\n\n/**\n * A React hook that returns a ref containing the latest value, useful for accessing the current value in async callbacks.\n *\n * @template T - The type of the value\n * @param value - The value to track\n * @returns A ref object containing the latest value\n *\n * @example\n * ```typescript\n * import { useLatest } from '@ahoo-wang/fetcher-react';\n *\n * const MyComponent = () => {\n *   const [count, setCount] = useState(0);\n *   const latestCount = useLatest(count);\n *\n *   const handleAsync = async () => {\n *     await someAsyncOperation();\n *     console.log('Latest count:', latestCount.current); // Always the latest\n *   };\n *\n *   return (\n *     <div>\n *       <p>Count: {count}</p>\n *       <button onClick={() => setCount(c => c + 1)}>Increment</button>\n *       <button onClick={handleAsync}>Async Log</button>\n *     </div>\n *   );\n * };\n * ```\n */\nexport function useLatest<T>(value: T) {\n  const ref = useRef(value);\n  ref.current = value;\n  return ref;\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useCallback, useMemo, useState } from 'react';\nimport { useMountedState } from 'react-use';\nimport { useLatest } from './useLatest';\n\n/**\n * Enumeration of possible promise execution states\n */\nexport enum PromiseStatus {\n  IDLE = 'idle',\n  LOADING = 'loading',\n  SUCCESS = 'success',\n  ERROR = 'error',\n}\n\nexport interface PromiseState<R, E = unknown> {\n  /** Current status of the promise */\n  status: PromiseStatus;\n  /** Indicates if currently loading */\n  loading: boolean;\n  /** The result value */\n  result: R | undefined;\n  /** The error value */\n  error: E | undefined;\n}\n\nexport interface PromiseStateCallbacks<R, E = unknown> {\n  /** Callback invoked on success */\n  onSuccess?: (result: R) => void;\n  /** Callback invoked on error */\n  onError?: (error: E) => void;\n}\n\n/**\n * Options for configuring usePromiseState behavior\n * @template R - The type of result\n *\n * @example\n * ```typescript\n * const options: UsePromiseStateOptions<string> = {\n *   initialStatus: PromiseStatus.IDLE,\n *   onSuccess: (result) => console.log('Success:', result),\n *   onError: (error) => console.error('Error:', error),\n * };\n * ```\n */\nexport interface UsePromiseStateOptions<R, E = unknown> extends PromiseStateCallbacks<R, E> {\n  /** Initial status, defaults to IDLE */\n  initialStatus?: PromiseStatus;\n}\n\n/**\n * Return type for usePromiseState hook\n * @template R - The type of result\n */\nexport interface UsePromiseStateReturn<R, E = unknown>\n  extends PromiseState<R, E> {\n  /** Set status to LOADING */\n  setLoading: () => void;\n  /** Set status to SUCCESS with result */\n  setSuccess: (result: R) => void;\n  /** Set status to ERROR with error */\n  setError: (error: E) => void;\n  /** Set status to IDLE */\n  setIdle: () => void;\n}\n\n/**\n * A React hook for managing promise state without execution logic\n * @template R - The type of result\n * @param options - Configuration options\n * @returns State management object\n *\n * @example\n * ```typescript\n * import { usePromiseState, PromiseStatus } from '@ahoo-wang/fetcher-react';\n *\n * function MyComponent() {\n *   const { status, loading, result, error, setSuccess, setError, setIdle } = usePromiseState<string>();\n *\n *   const handleSuccess = () => setSuccess('Data loaded');\n *   const handleError = () => setError(new Error('Failed to load'));\n *\n *   return (\n *     <div>\n *       <button onClick={handleSuccess}>Set Success</button>\n *       <button onClick={handleError}>Set Error</button>\n *       <button onClick={setIdle}>Reset</button>\n *       <p>Status: {status}</p>\n *       {loading && <p>Loading...</p>}\n *       {result && <p>Result: {result}</p>}\n *       {error && <p>Error: {error.message}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function usePromiseState<R = unknown, E = unknown>(\n  options?: UsePromiseStateOptions<R, E>,\n): UsePromiseStateReturn<R, E> {\n  const [status, setStatus] = useState<PromiseStatus>(\n    options?.initialStatus ?? PromiseStatus.IDLE,\n  );\n  const [result, setResult] = useState<R | undefined>(undefined);\n  const [error, setErrorState] = useState<E | undefined>(undefined);\n  const isMounted = useMountedState();\n  const latestOptions = useLatest(options);\n  const setLoadingFn = useCallback(() => {\n    if (isMounted()) {\n      setStatus(PromiseStatus.LOADING);\n      setErrorState(undefined);\n    }\n  }, [isMounted]);\n\n  const setSuccessFn = useCallback(\n    (result: R) => {\n      if (isMounted()) {\n        setResult(result);\n        setStatus(PromiseStatus.SUCCESS);\n        setErrorState(undefined);\n        latestOptions.current?.onSuccess?.(result);\n      }\n    },\n    [isMounted, latestOptions],\n  );\n\n  const setErrorFn = useCallback(\n    (error: E) => {\n      if (isMounted()) {\n        setErrorState(error);\n        setStatus(PromiseStatus.ERROR);\n        setResult(undefined);\n        latestOptions.current?.onError?.(error);\n      }\n    },\n    [isMounted, latestOptions],\n  );\n\n  const setIdleFn = useCallback(() => {\n    if (isMounted()) {\n      setStatus(PromiseStatus.IDLE);\n      setErrorState(undefined);\n      setResult(undefined);\n    }\n  }, [isMounted]);\n  return useMemo(\n    () => ({\n      status,\n      loading: status === PromiseStatus.LOADING,\n      result,\n      error,\n      setLoading: setLoadingFn,\n      setSuccess: setSuccessFn,\n      setError: setErrorFn,\n      setIdle: setIdleFn,\n    }),\n    [status, result, error, setLoadingFn, setSuccessFn, setErrorFn, setIdleFn],\n  );\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useRef, useCallback, useMemo } from 'react';\n\n/**\n * Return type for useRequestId hook\n */\nexport interface UseRequestIdReturn {\n  /** Generate a new request ID and get the current one */\n  generate: () => number;\n  /** Get the current request ID without generating a new one */\n  current: () => number;\n  /** Check if a given request ID is the latest */\n  isLatest: (requestId: number) => boolean;\n  /** Invalidate current request ID (mark as stale) */\n  invalidate: () => void;\n  /** Reset request ID counter */\n  reset: () => void;\n}\n\n/**\n * A React hook for managing request IDs and race condition protection\n *\n * @example\n * ```typescript\n * // Basic usage\n * const requestId = useRequestId();\n *\n * const execute = async () => {\n *   const id = requestId.generate();\n *\n *   try {\n *     const result = await someAsyncOperation();\n *\n *     // Check if this is still the latest request\n *     if (requestId.isLatest(id)) {\n *       setState(result);\n *     }\n *   } catch (error) {\n *     if (requestId.isLatest(id)) {\n *       setError(error);\n *     }\n *   }\n * };\n *\n * // Manual cancellation\n * const handleCancel = () => {\n *   requestId.invalidate(); // All ongoing requests will be ignored\n * };\n * ```\n *\n * @example\n * ```typescript\n * // With async operation wrapper\n * const { execute, cancel } = useAsyncOperation(async (data) => {\n *   return await apiCall(data);\n * }, [requestId]);\n * ```\n */\nexport function useRequestId(): UseRequestIdReturn {\n  const requestIdRef = useRef<number>(0);\n\n  const generate = useCallback((): number => {\n    return ++requestIdRef.current;\n  }, []);\n\n  const current = useCallback((): number => {\n    return requestIdRef.current;\n  }, []);\n\n  const isLatest = useCallback((requestId: number): boolean => {\n    return requestId === requestIdRef.current;\n  }, []);\n\n  const invalidate = useCallback((): void => {\n    requestIdRef.current++;\n  }, []);\n\n  const reset = useCallback((): void => {\n    requestIdRef.current = 0;\n  }, []);\n  return useMemo(() => {\n    return {\n      generate,\n      current,\n      isLatest,\n      invalidate,\n      reset,\n    };\n  }, [generate, current, isLatest, invalidate, reset]);\n}","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useCallback, useMemo } from 'react';\nimport { useMountedState } from 'react-use';\nimport { usePromiseState, PromiseState, UsePromiseStateOptions } from './usePromiseState';\nimport { useRequestId } from './useRequestId';\n\n/**\n * Type definition for a function that returns a Promise\n * @template R - The type of value the promise will resolve to\n */\nexport type PromiseSupplier<R> = () => Promise<R>;\n\n/**\n * Interface defining the return type of useExecutePromise hook\n * @template R - The type of the result value\n */\nexport interface UseExecutePromiseReturn<R, E = unknown>\n  extends PromiseState<R, E> {\n  /** Function to execute a promise supplier or promise */\n  execute: (input: PromiseSupplier<R> | Promise<R>) => Promise<R>;\n  /** Function to reset the state to initial values */\n  reset: () => void;\n}\n\n/**\n * A React hook for managing asynchronous operations with proper state handling\n * @template R - The type of the result value\n * @returns An object containing the current state and control functions\n *\n * @example\n * ```typescript\n * import { useExecutePromise } from '@ahoo-wang/fetcher-react';\n *\n * function MyComponent() {\n *   const { loading, result, error, execute, reset } = useExecutePromise<string>();\n *\n *   const fetchData = async () => {\n *     const response = await fetch('/api/data');\n *     return response.text();\n *   };\n *\n *   const handleFetch = () => {\n *     execute(fetchData);\n *   };\n *\n *   const handleReset = () => {\n *     reset();\n *   };\n *\n *   if (loading) return <div>Loading...</div>;\n *   if (error) return <div>Error: {error.message}</div>;\n *   return (\n *     <div>\n *       <button onClick={handleFetch}>Fetch Data</button>\n *       <button onClick={handleReset}>Reset</button>\n *       {result && <p>{result}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useExecutePromise<R = unknown, E = unknown>(options?: UsePromiseStateOptions<R, E>): UseExecutePromiseReturn<R, E> {\n  const state = usePromiseState<R, E>(options);\n  const isMounted = useMountedState();\n  const requestId = useRequestId();\n\n  /**\n   * Execute a promise supplier or promise and manage its state\n   * @param input - A function that returns a Promise or a Promise to be executed\n   * @returns A Promise that resolves with the result of the executed promise\n   */\n  const execute = useCallback(\n    async (input: PromiseSupplier<R> | Promise<R>): Promise<R> => {\n      if (!isMounted()) {\n        throw new Error('Component is unmounted');\n      }\n      const currentRequestId = requestId.generate();\n      state.setLoading();\n      try {\n        const promise = typeof input === 'function' ? input() : input;\n        const data = await promise;\n\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setSuccess(data);\n        }\n        return data;\n      } catch (err) {\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setError(err as E);\n        }\n        throw err;\n      }\n    },\n    [state, isMounted, requestId],\n  );\n\n  /**\n   * Reset the state to initial values\n   */\n  const reset = useCallback(() => {\n    if (isMounted()) {\n      state.setIdle();\n    }\n  }, [state, isMounted]);\n\n  return useMemo(\n    () => ({\n      loading: state.loading,\n      result: state.result,\n      error: state.error,\n      execute,\n      reset,\n      status: state.status,\n    }),\n    [state.loading, state.result, state.error, execute, reset, state.status],\n  );\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useCallback, useSyncExternalStore } from 'react';\nimport { KeyStorage } from '@ahoo-wang/fetcher-storage';\n\n/**\n * A React hook that provides state management for a KeyStorage instance.\n * Subscribes to storage changes and returns the current value along with a setter function.\n *\n * @template T - The type of value stored in the key storage\n * @param keyStorage - The KeyStorage instance to subscribe to and manage\n * @returns A tuple containing the current stored value and a function to update it\n */\nexport function useKeyStorage<T>(\n  keyStorage: KeyStorage<T>,\n): [T | null, (value: T) => void] {\n  const subscribe = useCallback(\n    (callback: () => void) => keyStorage.addListener(callback),\n    [keyStorage],\n  );\n  const getSnapshot = useCallback(() => keyStorage.get(), [keyStorage]);\n  const value = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n  const setValue = useCallback(\n    (value: T) => keyStorage.set(value),\n    [keyStorage],\n  );\n  return [value, setValue];\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  fetcherRegistrar,\n  FetcherCapable,\n  FetchExchange,\n  FetchRequest,\n  getFetcher,\n  RequestOptions,\n} from '@ahoo-wang/fetcher';\nimport { useRef, useCallback, useEffect, useState, useMemo } from 'react';\nimport { useMountedState } from 'react-use';\nimport {\n  PromiseState,\n  useLatest,\n  usePromiseState,\n  UsePromiseStateOptions,\n  useRequestId,\n} from '../core';\n\n/**\n * Configuration options for the useFetcher hook.\n * Extends RequestOptions and FetcherCapable interfaces.\n */\nexport interface UseFetcherOptions<R, E = unknown>\n  extends RequestOptions,\n    FetcherCapable,\n    UsePromiseStateOptions<R, E> {\n}\n\nexport interface UseFetcherReturn<R, E = unknown> extends PromiseState<R, E> {\n  /** The FetchExchange object representing the ongoing fetch operation */\n  exchange?: FetchExchange;\n  execute: (request: FetchRequest) => Promise<void>;\n}\n\n/**\n * A React hook for managing asynchronous operations with proper state handling\n * @param options - Configuration options for the fetcher\n * @returns An object containing the current state and control functions\n *\n * @example\n * ```typescript\n * import { useFetcher } from '@ahoo-wang/fetcher-react';\n *\n * function MyComponent() {\n *   const { loading, result, error, execute } = useFetcher<string>();\n *\n *   const handleFetch = () => {\n *     execute({ url: '/api/data', method: 'GET' });\n *   };\n *\n *   if (loading) return <div>Loading...</div>;\n *   if (error) return <div>Error: {error.message}</div>;\n *   return (\n *     <div>\n *       <button onClick={handleFetch}>Fetch Data</button>\n *       {result && <p>{result}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useFetcher<R, E = unknown>(\n  options?: UseFetcherOptions<R, E>,\n): UseFetcherReturn<R, E> {\n  const { fetcher = fetcherRegistrar.default } = options || {};\n  const state = usePromiseState<R, E>(options);\n  const [exchange, setExchange] = useState<FetchExchange | undefined>(\n    undefined,\n  );\n  const isMounted = useMountedState();\n  const abortControllerRef = useRef<AbortController | undefined>();\n  const requestId = useRequestId();\n  const latestOptions = useLatest(options);\n  const currentFetcher = getFetcher(fetcher);\n  /**\n   * Execute the fetch operation.\n   * Cancels any ongoing fetch before starting a new one.\n   */\n  const execute = useCallback(\n    async (request: FetchRequest) => {\n      if (abortControllerRef.current) {\n        abortControllerRef.current.abort();\n      }\n      abortControllerRef.current =\n        request.abortController ?? new AbortController();\n      request.abortController = abortControllerRef.current;\n      const currentRequestId = requestId.generate();\n      state.setLoading();\n      try {\n        const exchange = await currentFetcher.exchange(\n          request,\n          latestOptions.current,\n        );\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          setExchange(exchange);\n        }\n        const result = await exchange.extractResult<R>();\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setSuccess(result);\n        }\n      } catch (error) {\n        if (error instanceof Error && error.name === 'AbortError') {\n          if (isMounted()) {\n            state.setIdle();\n          }\n          return;\n        }\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setError(error as E);\n        }\n      } finally {\n        if (abortControllerRef.current === request.abortController) {\n          abortControllerRef.current = undefined;\n        }\n      }\n    },\n    [currentFetcher, isMounted, latestOptions, state, requestId],\n  );\n\n  useEffect(() => {\n    return () => {\n      abortControllerRef.current?.abort();\n      abortControllerRef.current = undefined;\n    };\n  }, []);\n  return useMemo(\n    () => ({\n      ...state,\n      exchange,\n      execute,\n    }),\n    [state, exchange, execute],\n  );\n}\n"],"names":["useMountedState","mountedRef","useRef","get","useCallback","useEffect","useLatest","value","ref","PromiseStatus","usePromiseState","options","status","setStatus","useState","result","setResult","error","setErrorState","isMounted","latestOptions","setLoadingFn","setSuccessFn","setErrorFn","setIdleFn","useMemo","useRequestId","requestIdRef","generate","current","isLatest","requestId","invalidate","reset","useExecutePromise","state","execute","input","currentRequestId","data","err","useKeyStorage","keyStorage","subscribe","callback","getSnapshot","useSyncExternalStore","setValue","useFetcher","fetcher","fetcherRegistrar","exchange","setExchange","abortControllerRef","currentFetcher","getFetcher","request"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.umd.js

@@ -1,2 +1,2 @@
-(function(a,t){typeof exports=="object"&&typeof module<"u"?t(exports,require("react"),require("@ahoo-wang/fetcher")):typeof define=="function"&&define.amd?define(["exports","react","@ahoo-wang/fetcher"],t):(a=typeof globalThis<"u"?globalThis:a||self,t(a.FetcherReact={},a.React,a.Fetcher))})(this,(function(a,t,S){"use strict";function C(){var e=t.useRef(!1),r=t.useCallback(function(){return e.current},[]);return t.useEffect(function(){return e.current=!0,function(){e.current=!1}},[]),r}var v=(e=>(e.IDLE="idle",e.LOADING="loading",e.SUCCESS="success",e.ERROR="error",e))(v||{});function g(e){const[r,s]=t.useState(e?.initialStatus??"idle"),[c,i]=t.useState(void 0),[u,n]=t.useState(void 0),o=C(),d=t.useCallback(()=>{o()&&(s("loading"),n(void 0))},[o]),f=t.useCallback(l=>{o()&&(i(l),s("success"),n(void 0),e?.onSuccess?.(l))},[o,e]),b=t.useCallback(l=>{o()&&(n(l),s("error"),i(void 0),e?.onError?.(l))},[o,e]),h=t.useCallback(()=>{o()&&(s("idle"),n(void 0),i(void 0))},[o]);return t.useMemo(()=>({status:r,loading:r==="loading",result:c,error:u,setLoading:d,setSuccess:f,setError:b,setIdle:h}),[r,c,u,d,f,b,h])}function E(){const e=t.useRef(0),r=t.useCallback(()=>++e.current,[]),s=t.useCallback(()=>e.current,[]),c=t.useCallback(n=>n===e.current,[]),i=t.useCallback(()=>{e.current++},[]),u=t.useCallback(()=>{e.current=0},[]);return{generate:r,current:s,isLatest:c,invalidate:i,reset:u}}function m(e){const r=g(e),s=C(),c=E(),i=t.useCallback(async n=>{if(!s())throw new Error("Component is unmounted");const o=c.generate();r.setLoading();try{const f=await(typeof n=="function"?n():n);return s()&&c.isLatest(o)&&r.setSuccess(f),f}catch(d){throw s()&&c.isLatest(o)&&r.setError(d),d}},[r,s,c]),u=t.useCallback(()=>{s()&&r.setIdle()},[r,s]);return t.useMemo(()=>({loading:r.loading,result:r.result,error:r.error,execute:i,reset:u,status:r.status}),[r.loading,r.result,r.error,i,u,r.status])}function I(e){const r=t.useCallback(u=>e.addListener(u),[e]),s=t.useCallback(()=>e.get(),[e]),c=t.useSyncExternalStore(r,s,s),i=t.useCallback(u=>e.set(u),[e]);return[c,i]}function L(e){const{fetcher:r=S.fetcherRegistrar.default}=e||{},s=g(e),[c,i]=t.useState(void 0),u=C(),n=t.useRef(),o=E(),d=S.getFetcher(r),f=t.useCallback(async b=>{n.current&&n.current.abort(),n.current=b.abortController??new AbortController,b.abortController=n.current;const h=o.generate();s.setLoading();try{const l=await d.exchange(b,e);u()&&o.isLatest(h)&&i(l);const k=await l.extractResult();u()&&o.isLatest(h)&&s.setSuccess(k)}catch(l){if(l instanceof Error&&l.name==="AbortError"){u()&&s.setIdle();return}u()&&o.isLatest(h)&&s.setError(l)}finally{n.current===b.abortController&&(n.current=void 0)}},[d,u,e,s,o]);return t.useEffect(()=>()=>{n.current?.abort(),n.current=void 0},[]),t.useMemo(()=>({...s,exchange:c,execute:f}),[s,c,f])}a.PromiseStatus=v,a.useExecutePromise=m,a.useFetcher=L,a.useKeyStorage=I,a.usePromiseState=g,a.useRequestId=E,Object.defineProperty(a,Symbol.toStringTag,{value:"Module"})}));
+(function(i,e){typeof exports=="object"&&typeof module<"u"?e(exports,require("react"),require("@ahoo-wang/fetcher")):typeof define=="function"&&define.amd?define(["exports","react","@ahoo-wang/fetcher"],e):(i=typeof globalThis<"u"?globalThis:i||self,e(i.FetcherReact={},i.React,i.Fetcher))})(this,(function(i,e,v){"use strict";function g(){var t=e.useRef(!1),r=e.useCallback(function(){return t.current},[]);return e.useEffect(function(){return t.current=!0,function(){t.current=!1}},[]),r}function E(t){const r=e.useRef(t);return r.current=t,r}var L=(t=>(t.IDLE="idle",t.LOADING="loading",t.SUCCESS="success",t.ERROR="error",t))(L||{});function S(t){const[r,s]=e.useState(t?.initialStatus??"idle"),[c,a]=e.useState(void 0),[u,n]=e.useState(void 0),o=g(),f=E(t),d=e.useCallback(()=>{o()&&(s("loading"),n(void 0))},[o]),C=e.useCallback(l=>{o()&&(a(l),s("success"),n(void 0),f.current?.onSuccess?.(l))},[o,f]),b=e.useCallback(l=>{o()&&(n(l),s("error"),a(void 0),f.current?.onError?.(l))},[o,f]),h=e.useCallback(()=>{o()&&(s("idle"),n(void 0),a(void 0))},[o]);return e.useMemo(()=>({status:r,loading:r==="loading",result:c,error:u,setLoading:d,setSuccess:C,setError:b,setIdle:h}),[r,c,u,d,C,b,h])}function m(){const t=e.useRef(0),r=e.useCallback(()=>++t.current,[]),s=e.useCallback(()=>t.current,[]),c=e.useCallback(n=>n===t.current,[]),a=e.useCallback(()=>{t.current++},[]),u=e.useCallback(()=>{t.current=0},[]);return e.useMemo(()=>({generate:r,current:s,isLatest:c,invalidate:a,reset:u}),[r,s,c,a,u])}function I(t){const r=S(t),s=g(),c=m(),a=e.useCallback(async n=>{if(!s())throw new Error("Component is unmounted");const o=c.generate();r.setLoading();try{const d=await(typeof n=="function"?n():n);return s()&&c.isLatest(o)&&r.setSuccess(d),d}catch(f){throw s()&&c.isLatest(o)&&r.setError(f),f}},[r,s,c]),u=e.useCallback(()=>{s()&&r.setIdle()},[r,s]);return e.useMemo(()=>({loading:r.loading,result:r.result,error:r.error,execute:a,reset:u,status:r.status}),[r.loading,r.result,r.error,a,u,r.status])}function k(t){const r=e.useCallback(u=>t.addListener(u),[t]),s=e.useCallback(()=>t.get(),[t]),c=e.useSyncExternalStore(r,s,s),a=e.useCallback(u=>t.set(u),[t]);return[c,a]}function F(t){const{fetcher:r=v.fetcherRegistrar.default}=t||{},s=S(t),[c,a]=e.useState(void 0),u=g(),n=e.useRef(),o=m(),f=E(t),d=v.getFetcher(r),C=e.useCallback(async b=>{n.current&&n.current.abort(),n.current=b.abortController??new AbortController,b.abortController=n.current;const h=o.generate();s.setLoading();try{const l=await d.exchange(b,f.current);u()&&o.isLatest(h)&&a(l);const w=await l.extractResult();u()&&o.isLatest(h)&&s.setSuccess(w)}catch(l){if(l instanceof Error&&l.name==="AbortError"){u()&&s.setIdle();return}u()&&o.isLatest(h)&&s.setError(l)}finally{n.current===b.abortController&&(n.current=void 0)}},[d,u,f,s,o]);return e.useEffect(()=>()=>{n.current?.abort(),n.current=void 0},[]),e.useMemo(()=>({...s,exchange:c,execute:C}),[s,c,C])}i.PromiseStatus=L,i.useExecutePromise=I,i.useFetcher=F,i.useKeyStorage=k,i.useLatest=E,i.usePromiseState=S,i.useRequestId=m,Object.defineProperty(i,Symbol.toStringTag,{value:"Module"})}));
 //# sourceMappingURL=index.umd.js.map

package/dist/index.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.umd.js","sources":["../../../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","../src/core/usePromiseState.ts","../src/core/useRequestId.ts","../src/core/useExecutePromise.ts","../src/storage/useKeyStorage.ts","../src/fetcher/useFetcher.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from 'react';\nexport default function useMountedState() {\n    var mountedRef = useRef(false);\n    var get = useCallback(function () { return mountedRef.current; }, []);\n    useEffect(function () {\n        mountedRef.current = true;\n        return function () {\n            mountedRef.current = false;\n        };\n    }, []);\n    return get;\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useCallback, useMemo, useState } from 'react';\nimport { useMountedState } from 'react-use';\n\n/**\n * Enumeration of possible promise execution states\n */\nexport enum PromiseStatus {\n  IDLE = 'idle',\n  LOADING = 'loading',\n  SUCCESS = 'success',\n  ERROR = 'error',\n}\n\nexport interface PromiseState<R, E = unknown> {\n  /** Current status of the promise */\n  status: PromiseStatus;\n  /** Indicates if currently loading */\n  loading: boolean;\n  /** The result value */\n  result: R | undefined;\n  /** The error value */\n  error: E | undefined;\n}\n\n/**\n * Options for configuring usePromiseState behavior\n * @template R - The type of result\n *\n * @example\n * ```typescript\n * const options: UsePromiseStateOptions<string> = {\n *   initialStatus: PromiseStatus.IDLE,\n *   onSuccess: (result) => console.log('Success:', result),\n *   onError: (error) => console.error('Error:', error),\n * };\n * ```\n */\nexport interface UsePromiseStateOptions<R, E = unknown> {\n  /** Initial status, defaults to IDLE */\n  initialStatus?: PromiseStatus;\n  /** Callback invoked on success */\n  onSuccess?: (result: R) => void;\n  /** Callback invoked on error */\n  onError?: (error: E) => void;\n}\n\n/**\n * Return type for usePromiseState hook\n * @template R - The type of result\n */\nexport interface UsePromiseStateReturn<R, E = unknown> extends PromiseState<R, E> {\n  /** Set status to LOADING */\n  setLoading: () => void;\n  /** Set status to SUCCESS with result */\n  setSuccess: (result: R) => void;\n  /** Set status to ERROR with error */\n  setError: (error: E) => void;\n  /** Set status to IDLE */\n  setIdle: () => void;\n}\n\n/**\n * A React hook for managing promise state without execution logic\n * @template R - The type of result\n * @param options - Configuration options\n * @returns State management object\n *\n * @example\n * ```typescript\n * import { usePromiseState, PromiseStatus } from '@ahoo-wang/fetcher-react';\n *\n * function MyComponent() {\n *   const { status, loading, result, error, setSuccess, setError, setIdle } = usePromiseState<string>();\n *\n *   const handleSuccess = () => setSuccess('Data loaded');\n *   const handleError = () => setError(new Error('Failed to load'));\n *\n *   return (\n *     <div>\n *       <button onClick={handleSuccess}>Set Success</button>\n *       <button onClick={handleError}>Set Error</button>\n *       <button onClick={setIdle}>Reset</button>\n *       <p>Status: {status}</p>\n *       {loading && <p>Loading...</p>}\n *       {result && <p>Result: {result}</p>}\n *       {error && <p>Error: {error.message}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function usePromiseState<R = unknown, E = unknown>(\n  options?: UsePromiseStateOptions<R, E>,\n): UsePromiseStateReturn<R, E> {\n  const [status, setStatus] = useState<PromiseStatus>(\n    options?.initialStatus ?? PromiseStatus.IDLE,\n  );\n  const [result, setResult] = useState<R | undefined>(undefined);\n  const [error, setErrorState] = useState<E | undefined>(undefined);\n  const isMounted = useMountedState();\n\n  const setLoadingFn = useCallback(() => {\n    if (isMounted()) {\n      setStatus(PromiseStatus.LOADING);\n      setErrorState(undefined);\n    }\n  }, [isMounted]);\n\n  const setSuccessFn = useCallback(\n    (result: R) => {\n      if (isMounted()) {\n        setResult(result);\n        setStatus(PromiseStatus.SUCCESS);\n        setErrorState(undefined);\n        options?.onSuccess?.(result);\n      }\n    },\n    [isMounted, options],\n  );\n\n  const setErrorFn = useCallback(\n    (error: E) => {\n      if (isMounted()) {\n        setErrorState(error);\n        setStatus(PromiseStatus.ERROR);\n        setResult(undefined);\n        options?.onError?.(error);\n      }\n    },\n    [isMounted, options],\n  );\n\n  const setIdleFn = useCallback(() => {\n    if (isMounted()) {\n      setStatus(PromiseStatus.IDLE);\n      setErrorState(undefined);\n      setResult(undefined);\n    }\n  }, [isMounted]);\n  return useMemo(() => ({\n    status,\n    loading: status === PromiseStatus.LOADING,\n    result,\n    error,\n    setLoading: setLoadingFn,\n    setSuccess: setSuccessFn,\n    setError: setErrorFn,\n    setIdle: setIdleFn,\n  }), [status, result, error, setLoadingFn, setSuccessFn, setErrorFn, setIdleFn]);\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useRef, useCallback } from 'react';\n\n/**\n * Return type for useRequestId hook\n */\nexport interface UseRequestIdReturn {\n  /** Generate a new request ID and get the current one */\n  generate: () => number;\n  /** Get the current request ID without generating a new one */\n  current: () => number;\n  /** Check if a given request ID is the latest */\n  isLatest: (requestId: number) => boolean;\n  /** Invalidate current request ID (mark as stale) */\n  invalidate: () => void;\n  /** Reset request ID counter */\n  reset: () => void;\n}\n\n/**\n * A React hook for managing request IDs and race condition protection\n *\n * @example\n * ```typescript\n * // Basic usage\n * const requestId = useRequestId();\n *\n * const execute = async () => {\n *   const id = requestId.generate();\n *\n *   try {\n *     const result = await someAsyncOperation();\n *\n *     // Check if this is still the latest request\n *     if (requestId.isLatest(id)) {\n *       setState(result);\n *     }\n *   } catch (error) {\n *     if (requestId.isLatest(id)) {\n *       setError(error);\n *     }\n *   }\n * };\n *\n * // Manual cancellation\n * const handleCancel = () => {\n *   requestId.invalidate(); // All ongoing requests will be ignored\n * };\n * ```\n *\n * @example\n * ```typescript\n * // With async operation wrapper\n * const { execute, cancel } = useAsyncOperation(async (data) => {\n *   return await apiCall(data);\n * }, [requestId]);\n * ```\n */\nexport function useRequestId(): UseRequestIdReturn {\n  const requestIdRef = useRef<number>(0);\n\n  const generate = useCallback((): number => {\n    return ++requestIdRef.current;\n  }, []);\n\n  const current = useCallback((): number => {\n    return requestIdRef.current;\n  }, []);\n\n  const isLatest = useCallback((requestId: number): boolean => {\n    return requestId === requestIdRef.current;\n  }, []);\n\n  const invalidate = useCallback((): void => {\n    requestIdRef.current++;\n  }, []);\n\n  const reset = useCallback((): void => {\n    requestIdRef.current = 0;\n  }, []);\n\n  return {\n    generate,\n    current,\n    isLatest,\n    invalidate,\n    reset,\n  };\n}","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useCallback, useMemo } from 'react';\nimport { useMountedState } from 'react-use';\nimport { usePromiseState, PromiseState, UsePromiseStateOptions } from './usePromiseState';\nimport { useRequestId } from './useRequestId';\n\n/**\n * Type definition for a function that returns a Promise\n * @template R - The type of value the promise will resolve to\n */\nexport type PromiseSupplier<R> = () => Promise<R>;\n\n/**\n * Interface defining the return type of useExecutePromise hook\n * @template R - The type of the result value\n */\nexport interface UseExecutePromiseReturn<R, E = unknown>\n  extends PromiseState<R, E> {\n  /** Function to execute a promise supplier or promise */\n  execute: (input: PromiseSupplier<R> | Promise<R>) => Promise<R>;\n  /** Function to reset the state to initial values */\n  reset: () => void;\n}\n\n/**\n * A React hook for managing asynchronous operations with proper state handling\n * @template R - The type of the result value\n * @returns An object containing the current state and control functions\n *\n * @example\n * ```typescript\n * import { useExecutePromise } from '@ahoo-wang/fetcher-react';\n *\n * function MyComponent() {\n *   const { loading, result, error, execute, reset } = useExecutePromise<string>();\n *\n *   const fetchData = async () => {\n *     const response = await fetch('/api/data');\n *     return response.text();\n *   };\n *\n *   const handleFetch = () => {\n *     execute(fetchData);\n *   };\n *\n *   const handleReset = () => {\n *     reset();\n *   };\n *\n *   if (loading) return <div>Loading...</div>;\n *   if (error) return <div>Error: {error.message}</div>;\n *   return (\n *     <div>\n *       <button onClick={handleFetch}>Fetch Data</button>\n *       <button onClick={handleReset}>Reset</button>\n *       {result && <p>{result}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useExecutePromise<R = unknown, E = unknown>(options?: UsePromiseStateOptions<R, E>): UseExecutePromiseReturn<R, E> {\n  const state = usePromiseState<R, E>(options);\n  const isMounted = useMountedState();\n  const requestId = useRequestId();\n\n  /**\n   * Execute a promise supplier or promise and manage its state\n   * @param input - A function that returns a Promise or a Promise to be executed\n   * @returns A Promise that resolves with the result of the executed promise\n   */\n  const execute = useCallback(\n    async (input: PromiseSupplier<R> | Promise<R>): Promise<R> => {\n      if (!isMounted()) {\n        throw new Error('Component is unmounted');\n      }\n      const currentRequestId = requestId.generate();\n      state.setLoading();\n      try {\n        const promise = typeof input === 'function' ? input() : input;\n        const data = await promise;\n\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setSuccess(data);\n        }\n        return data;\n      } catch (err) {\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setError(err as E);\n        }\n        throw err;\n      }\n    },\n    [state, isMounted, requestId],\n  );\n\n  /**\n   * Reset the state to initial values\n   */\n  const reset = useCallback(() => {\n    if (isMounted()) {\n      state.setIdle();\n    }\n  }, [state, isMounted]);\n\n  return useMemo(\n    () => ({\n      loading: state.loading,\n      result: state.result,\n      error: state.error,\n      execute,\n      reset,\n      status: state.status,\n    }),\n    [state.loading, state.result, state.error, execute, reset, state.status],\n  );\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useCallback, useSyncExternalStore } from 'react';\nimport { KeyStorage } from '@ahoo-wang/fetcher-storage';\n\n/**\n * A React hook that provides state management for a KeyStorage instance.\n * Subscribes to storage changes and returns the current value along with a setter function.\n *\n * @template T - The type of value stored in the key storage\n * @param keyStorage - The KeyStorage instance to subscribe to and manage\n * @returns A tuple containing the current stored value and a function to update it\n */\nexport function useKeyStorage<T>(\n  keyStorage: KeyStorage<T>,\n): [T | null, (value: T) => void] {\n  const subscribe = useCallback(\n    (callback: () => void) => keyStorage.addListener(callback),\n    [keyStorage],\n  );\n  const getSnapshot = useCallback(() => keyStorage.get(), [keyStorage]);\n  const value = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n  const setValue = useCallback(\n    (value: T) => keyStorage.set(value),\n    [keyStorage],\n  );\n  return [value, setValue];\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  fetcherRegistrar,\n  FetcherCapable,\n  FetchExchange,\n  FetchRequest,\n  getFetcher,\n  RequestOptions,\n} from '@ahoo-wang/fetcher';\nimport { useRef, useCallback, useEffect, useState, useMemo } from 'react';\nimport { useMountedState } from 'react-use';\nimport { PromiseState, usePromiseState, UsePromiseStateOptions, useRequestId } from '../core';\n\n/**\n * Configuration options for the useFetcher hook.\n * Extends RequestOptions and FetcherCapable interfaces.\n */\nexport interface UseFetcherOptions<R, E = unknown> extends RequestOptions, FetcherCapable, UsePromiseStateOptions<R, E> {\n}\n\nexport interface UseFetcherReturn<R, E = unknown> extends PromiseState<R, E> {\n  /** The FetchExchange object representing the ongoing fetch operation */\n  exchange?: FetchExchange;\n  execute: (request: FetchRequest) => Promise<void>;\n}\n\n/**\n * A React hook for managing asynchronous operations with proper state handling\n * @param options - Configuration options for the fetcher\n * @returns An object containing the current state and control functions\n *\n * @example\n * ```typescript\n * import { useFetcher } from '@ahoo-wang/fetcher-react';\n *\n * function MyComponent() {\n *   const { loading, result, error, execute } = useFetcher<string>();\n *\n *   const handleFetch = () => {\n *     execute({ url: '/api/data', method: 'GET' });\n *   };\n *\n *   if (loading) return <div>Loading...</div>;\n *   if (error) return <div>Error: {error.message}</div>;\n *   return (\n *     <div>\n *       <button onClick={handleFetch}>Fetch Data</button>\n *       {result && <p>{result}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useFetcher<R, E = unknown>(\n  options?: UseFetcherOptions<R, E>,\n): UseFetcherReturn<R, E> {\n  const { fetcher = fetcherRegistrar.default } = options || {};\n  const state = usePromiseState<R, E>(options);\n  const [exchange, setExchange] = useState<FetchExchange | undefined>(\n    undefined,\n  );\n  const isMounted = useMountedState();\n  const abortControllerRef = useRef<AbortController | undefined>();\n  const requestId = useRequestId();\n\n  const currentFetcher = getFetcher(fetcher);\n  /**\n   * Execute the fetch operation.\n   * Cancels any ongoing fetch before starting a new one.\n   */\n  const execute = useCallback(\n    async (request: FetchRequest) => {\n      if (abortControllerRef.current) {\n        abortControllerRef.current.abort();\n      }\n      abortControllerRef.current =\n        request.abortController ?? new AbortController();\n      request.abortController = abortControllerRef.current;\n      const currentRequestId = requestId.generate();\n      state.setLoading();\n      try {\n        const exchange = await currentFetcher.exchange(request, options);\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          setExchange(exchange);\n        }\n        const result = await exchange.extractResult<R>();\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setSuccess(result);\n        }\n      } catch (error) {\n        if (error instanceof Error && error.name === 'AbortError') {\n          if (isMounted()) {\n            state.setIdle();\n          }\n          return;\n        }\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setError(error as E);\n        }\n      } finally {\n        if (abortControllerRef.current === request.abortController) {\n          abortControllerRef.current = undefined;\n        }\n      }\n    },\n    [currentFetcher, isMounted, options, state, requestId],\n  );\n\n  useEffect(() => {\n    return () => {\n      abortControllerRef.current?.abort();\n      abortControllerRef.current = undefined;\n    };\n  }, []);\n  return useMemo(() => ({\n    ...state,\n    exchange,\n    execute,\n  }), [state, exchange, execute]);\n}\n"],"names":["useMountedState","mountedRef","useRef","get","useCallback","useEffect","PromiseStatus","usePromiseState","options","status","setStatus","useState","result","setResult","error","setErrorState","isMounted","setLoadingFn","setSuccessFn","setErrorFn","setIdleFn","useMemo","useRequestId","requestIdRef","generate","current","isLatest","requestId","invalidate","reset","useExecutePromise","state","execute","input","currentRequestId","data","err","useKeyStorage","keyStorage","subscribe","callback","getSnapshot","value","useSyncExternalStore","setValue","useFetcher","fetcher","fetcherRegistrar","exchange","setExchange","abortControllerRef","currentFetcher","getFetcher","request"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"index.umd.js","sources":["../../../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","../src/core/useLatest.ts","../src/core/usePromiseState.ts","../src/core/useRequestId.ts","../src/core/useExecutePromise.ts","../src/storage/useKeyStorage.ts","../src/fetcher/useFetcher.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from 'react';\nexport default function useMountedState() {\n    var mountedRef = useRef(false);\n    var get = useCallback(function () { return mountedRef.current; }, []);\n    useEffect(function () {\n        mountedRef.current = true;\n        return function () {\n            mountedRef.current = false;\n        };\n    }, []);\n    return get;\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useRef } from 'react';\n\n/**\n * A React hook that returns a ref containing the latest value, useful for accessing the current value in async callbacks.\n *\n * @template T - The type of the value\n * @param value - The value to track\n * @returns A ref object containing the latest value\n *\n * @example\n * ```typescript\n * import { useLatest } from '@ahoo-wang/fetcher-react';\n *\n * const MyComponent = () => {\n *   const [count, setCount] = useState(0);\n *   const latestCount = useLatest(count);\n *\n *   const handleAsync = async () => {\n *     await someAsyncOperation();\n *     console.log('Latest count:', latestCount.current); // Always the latest\n *   };\n *\n *   return (\n *     <div>\n *       <p>Count: {count}</p>\n *       <button onClick={() => setCount(c => c + 1)}>Increment</button>\n *       <button onClick={handleAsync}>Async Log</button>\n *     </div>\n *   );\n * };\n * ```\n */\nexport function useLatest<T>(value: T) {\n  const ref = useRef(value);\n  ref.current = value;\n  return ref;\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useCallback, useMemo, useState } from 'react';\nimport { useMountedState } from 'react-use';\nimport { useLatest } from './useLatest';\n\n/**\n * Enumeration of possible promise execution states\n */\nexport enum PromiseStatus {\n  IDLE = 'idle',\n  LOADING = 'loading',\n  SUCCESS = 'success',\n  ERROR = 'error',\n}\n\nexport interface PromiseState<R, E = unknown> {\n  /** Current status of the promise */\n  status: PromiseStatus;\n  /** Indicates if currently loading */\n  loading: boolean;\n  /** The result value */\n  result: R | undefined;\n  /** The error value */\n  error: E | undefined;\n}\n\nexport interface PromiseStateCallbacks<R, E = unknown> {\n  /** Callback invoked on success */\n  onSuccess?: (result: R) => void;\n  /** Callback invoked on error */\n  onError?: (error: E) => void;\n}\n\n/**\n * Options for configuring usePromiseState behavior\n * @template R - The type of result\n *\n * @example\n * ```typescript\n * const options: UsePromiseStateOptions<string> = {\n *   initialStatus: PromiseStatus.IDLE,\n *   onSuccess: (result) => console.log('Success:', result),\n *   onError: (error) => console.error('Error:', error),\n * };\n * ```\n */\nexport interface UsePromiseStateOptions<R, E = unknown> extends PromiseStateCallbacks<R, E> {\n  /** Initial status, defaults to IDLE */\n  initialStatus?: PromiseStatus;\n}\n\n/**\n * Return type for usePromiseState hook\n * @template R - The type of result\n */\nexport interface UsePromiseStateReturn<R, E = unknown>\n  extends PromiseState<R, E> {\n  /** Set status to LOADING */\n  setLoading: () => void;\n  /** Set status to SUCCESS with result */\n  setSuccess: (result: R) => void;\n  /** Set status to ERROR with error */\n  setError: (error: E) => void;\n  /** Set status to IDLE */\n  setIdle: () => void;\n}\n\n/**\n * A React hook for managing promise state without execution logic\n * @template R - The type of result\n * @param options - Configuration options\n * @returns State management object\n *\n * @example\n * ```typescript\n * import { usePromiseState, PromiseStatus } from '@ahoo-wang/fetcher-react';\n *\n * function MyComponent() {\n *   const { status, loading, result, error, setSuccess, setError, setIdle } = usePromiseState<string>();\n *\n *   const handleSuccess = () => setSuccess('Data loaded');\n *   const handleError = () => setError(new Error('Failed to load'));\n *\n *   return (\n *     <div>\n *       <button onClick={handleSuccess}>Set Success</button>\n *       <button onClick={handleError}>Set Error</button>\n *       <button onClick={setIdle}>Reset</button>\n *       <p>Status: {status}</p>\n *       {loading && <p>Loading...</p>}\n *       {result && <p>Result: {result}</p>}\n *       {error && <p>Error: {error.message}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function usePromiseState<R = unknown, E = unknown>(\n  options?: UsePromiseStateOptions<R, E>,\n): UsePromiseStateReturn<R, E> {\n  const [status, setStatus] = useState<PromiseStatus>(\n    options?.initialStatus ?? PromiseStatus.IDLE,\n  );\n  const [result, setResult] = useState<R | undefined>(undefined);\n  const [error, setErrorState] = useState<E | undefined>(undefined);\n  const isMounted = useMountedState();\n  const latestOptions = useLatest(options);\n  const setLoadingFn = useCallback(() => {\n    if (isMounted()) {\n      setStatus(PromiseStatus.LOADING);\n      setErrorState(undefined);\n    }\n  }, [isMounted]);\n\n  const setSuccessFn = useCallback(\n    (result: R) => {\n      if (isMounted()) {\n        setResult(result);\n        setStatus(PromiseStatus.SUCCESS);\n        setErrorState(undefined);\n        latestOptions.current?.onSuccess?.(result);\n      }\n    },\n    [isMounted, latestOptions],\n  );\n\n  const setErrorFn = useCallback(\n    (error: E) => {\n      if (isMounted()) {\n        setErrorState(error);\n        setStatus(PromiseStatus.ERROR);\n        setResult(undefined);\n        latestOptions.current?.onError?.(error);\n      }\n    },\n    [isMounted, latestOptions],\n  );\n\n  const setIdleFn = useCallback(() => {\n    if (isMounted()) {\n      setStatus(PromiseStatus.IDLE);\n      setErrorState(undefined);\n      setResult(undefined);\n    }\n  }, [isMounted]);\n  return useMemo(\n    () => ({\n      status,\n      loading: status === PromiseStatus.LOADING,\n      result,\n      error,\n      setLoading: setLoadingFn,\n      setSuccess: setSuccessFn,\n      setError: setErrorFn,\n      setIdle: setIdleFn,\n    }),\n    [status, result, error, setLoadingFn, setSuccessFn, setErrorFn, setIdleFn],\n  );\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useRef, useCallback, useMemo } from 'react';\n\n/**\n * Return type for useRequestId hook\n */\nexport interface UseRequestIdReturn {\n  /** Generate a new request ID and get the current one */\n  generate: () => number;\n  /** Get the current request ID without generating a new one */\n  current: () => number;\n  /** Check if a given request ID is the latest */\n  isLatest: (requestId: number) => boolean;\n  /** Invalidate current request ID (mark as stale) */\n  invalidate: () => void;\n  /** Reset request ID counter */\n  reset: () => void;\n}\n\n/**\n * A React hook for managing request IDs and race condition protection\n *\n * @example\n * ```typescript\n * // Basic usage\n * const requestId = useRequestId();\n *\n * const execute = async () => {\n *   const id = requestId.generate();\n *\n *   try {\n *     const result = await someAsyncOperation();\n *\n *     // Check if this is still the latest request\n *     if (requestId.isLatest(id)) {\n *       setState(result);\n *     }\n *   } catch (error) {\n *     if (requestId.isLatest(id)) {\n *       setError(error);\n *     }\n *   }\n * };\n *\n * // Manual cancellation\n * const handleCancel = () => {\n *   requestId.invalidate(); // All ongoing requests will be ignored\n * };\n * ```\n *\n * @example\n * ```typescript\n * // With async operation wrapper\n * const { execute, cancel } = useAsyncOperation(async (data) => {\n *   return await apiCall(data);\n * }, [requestId]);\n * ```\n */\nexport function useRequestId(): UseRequestIdReturn {\n  const requestIdRef = useRef<number>(0);\n\n  const generate = useCallback((): number => {\n    return ++requestIdRef.current;\n  }, []);\n\n  const current = useCallback((): number => {\n    return requestIdRef.current;\n  }, []);\n\n  const isLatest = useCallback((requestId: number): boolean => {\n    return requestId === requestIdRef.current;\n  }, []);\n\n  const invalidate = useCallback((): void => {\n    requestIdRef.current++;\n  }, []);\n\n  const reset = useCallback((): void => {\n    requestIdRef.current = 0;\n  }, []);\n  return useMemo(() => {\n    return {\n      generate,\n      current,\n      isLatest,\n      invalidate,\n      reset,\n    };\n  }, [generate, current, isLatest, invalidate, reset]);\n}","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useCallback, useMemo } from 'react';\nimport { useMountedState } from 'react-use';\nimport { usePromiseState, PromiseState, UsePromiseStateOptions } from './usePromiseState';\nimport { useRequestId } from './useRequestId';\n\n/**\n * Type definition for a function that returns a Promise\n * @template R - The type of value the promise will resolve to\n */\nexport type PromiseSupplier<R> = () => Promise<R>;\n\n/**\n * Interface defining the return type of useExecutePromise hook\n * @template R - The type of the result value\n */\nexport interface UseExecutePromiseReturn<R, E = unknown>\n  extends PromiseState<R, E> {\n  /** Function to execute a promise supplier or promise */\n  execute: (input: PromiseSupplier<R> | Promise<R>) => Promise<R>;\n  /** Function to reset the state to initial values */\n  reset: () => void;\n}\n\n/**\n * A React hook for managing asynchronous operations with proper state handling\n * @template R - The type of the result value\n * @returns An object containing the current state and control functions\n *\n * @example\n * ```typescript\n * import { useExecutePromise } from '@ahoo-wang/fetcher-react';\n *\n * function MyComponent() {\n *   const { loading, result, error, execute, reset } = useExecutePromise<string>();\n *\n *   const fetchData = async () => {\n *     const response = await fetch('/api/data');\n *     return response.text();\n *   };\n *\n *   const handleFetch = () => {\n *     execute(fetchData);\n *   };\n *\n *   const handleReset = () => {\n *     reset();\n *   };\n *\n *   if (loading) return <div>Loading...</div>;\n *   if (error) return <div>Error: {error.message}</div>;\n *   return (\n *     <div>\n *       <button onClick={handleFetch}>Fetch Data</button>\n *       <button onClick={handleReset}>Reset</button>\n *       {result && <p>{result}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useExecutePromise<R = unknown, E = unknown>(options?: UsePromiseStateOptions<R, E>): UseExecutePromiseReturn<R, E> {\n  const state = usePromiseState<R, E>(options);\n  const isMounted = useMountedState();\n  const requestId = useRequestId();\n\n  /**\n   * Execute a promise supplier or promise and manage its state\n   * @param input - A function that returns a Promise or a Promise to be executed\n   * @returns A Promise that resolves with the result of the executed promise\n   */\n  const execute = useCallback(\n    async (input: PromiseSupplier<R> | Promise<R>): Promise<R> => {\n      if (!isMounted()) {\n        throw new Error('Component is unmounted');\n      }\n      const currentRequestId = requestId.generate();\n      state.setLoading();\n      try {\n        const promise = typeof input === 'function' ? input() : input;\n        const data = await promise;\n\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setSuccess(data);\n        }\n        return data;\n      } catch (err) {\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setError(err as E);\n        }\n        throw err;\n      }\n    },\n    [state, isMounted, requestId],\n  );\n\n  /**\n   * Reset the state to initial values\n   */\n  const reset = useCallback(() => {\n    if (isMounted()) {\n      state.setIdle();\n    }\n  }, [state, isMounted]);\n\n  return useMemo(\n    () => ({\n      loading: state.loading,\n      result: state.result,\n      error: state.error,\n      execute,\n      reset,\n      status: state.status,\n    }),\n    [state.loading, state.result, state.error, execute, reset, state.status],\n  );\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { useCallback, useSyncExternalStore } from 'react';\nimport { KeyStorage } from '@ahoo-wang/fetcher-storage';\n\n/**\n * A React hook that provides state management for a KeyStorage instance.\n * Subscribes to storage changes and returns the current value along with a setter function.\n *\n * @template T - The type of value stored in the key storage\n * @param keyStorage - The KeyStorage instance to subscribe to and manage\n * @returns A tuple containing the current stored value and a function to update it\n */\nexport function useKeyStorage<T>(\n  keyStorage: KeyStorage<T>,\n): [T | null, (value: T) => void] {\n  const subscribe = useCallback(\n    (callback: () => void) => keyStorage.addListener(callback),\n    [keyStorage],\n  );\n  const getSnapshot = useCallback(() => keyStorage.get(), [keyStorage]);\n  const value = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n  const setValue = useCallback(\n    (value: T) => keyStorage.set(value),\n    [keyStorage],\n  );\n  return [value, setValue];\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  fetcherRegistrar,\n  FetcherCapable,\n  FetchExchange,\n  FetchRequest,\n  getFetcher,\n  RequestOptions,\n} from '@ahoo-wang/fetcher';\nimport { useRef, useCallback, useEffect, useState, useMemo } from 'react';\nimport { useMountedState } from 'react-use';\nimport {\n  PromiseState,\n  useLatest,\n  usePromiseState,\n  UsePromiseStateOptions,\n  useRequestId,\n} from '../core';\n\n/**\n * Configuration options for the useFetcher hook.\n * Extends RequestOptions and FetcherCapable interfaces.\n */\nexport interface UseFetcherOptions<R, E = unknown>\n  extends RequestOptions,\n    FetcherCapable,\n    UsePromiseStateOptions<R, E> {\n}\n\nexport interface UseFetcherReturn<R, E = unknown> extends PromiseState<R, E> {\n  /** The FetchExchange object representing the ongoing fetch operation */\n  exchange?: FetchExchange;\n  execute: (request: FetchRequest) => Promise<void>;\n}\n\n/**\n * A React hook for managing asynchronous operations with proper state handling\n * @param options - Configuration options for the fetcher\n * @returns An object containing the current state and control functions\n *\n * @example\n * ```typescript\n * import { useFetcher } from '@ahoo-wang/fetcher-react';\n *\n * function MyComponent() {\n *   const { loading, result, error, execute } = useFetcher<string>();\n *\n *   const handleFetch = () => {\n *     execute({ url: '/api/data', method: 'GET' });\n *   };\n *\n *   if (loading) return <div>Loading...</div>;\n *   if (error) return <div>Error: {error.message}</div>;\n *   return (\n *     <div>\n *       <button onClick={handleFetch}>Fetch Data</button>\n *       {result && <p>{result}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useFetcher<R, E = unknown>(\n  options?: UseFetcherOptions<R, E>,\n): UseFetcherReturn<R, E> {\n  const { fetcher = fetcherRegistrar.default } = options || {};\n  const state = usePromiseState<R, E>(options);\n  const [exchange, setExchange] = useState<FetchExchange | undefined>(\n    undefined,\n  );\n  const isMounted = useMountedState();\n  const abortControllerRef = useRef<AbortController | undefined>();\n  const requestId = useRequestId();\n  const latestOptions = useLatest(options);\n  const currentFetcher = getFetcher(fetcher);\n  /**\n   * Execute the fetch operation.\n   * Cancels any ongoing fetch before starting a new one.\n   */\n  const execute = useCallback(\n    async (request: FetchRequest) => {\n      if (abortControllerRef.current) {\n        abortControllerRef.current.abort();\n      }\n      abortControllerRef.current =\n        request.abortController ?? new AbortController();\n      request.abortController = abortControllerRef.current;\n      const currentRequestId = requestId.generate();\n      state.setLoading();\n      try {\n        const exchange = await currentFetcher.exchange(\n          request,\n          latestOptions.current,\n        );\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          setExchange(exchange);\n        }\n        const result = await exchange.extractResult<R>();\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setSuccess(result);\n        }\n      } catch (error) {\n        if (error instanceof Error && error.name === 'AbortError') {\n          if (isMounted()) {\n            state.setIdle();\n          }\n          return;\n        }\n        if (isMounted() && requestId.isLatest(currentRequestId)) {\n          state.setError(error as E);\n        }\n      } finally {\n        if (abortControllerRef.current === request.abortController) {\n          abortControllerRef.current = undefined;\n        }\n      }\n    },\n    [currentFetcher, isMounted, latestOptions, state, requestId],\n  );\n\n  useEffect(() => {\n    return () => {\n      abortControllerRef.current?.abort();\n      abortControllerRef.current = undefined;\n    };\n  }, []);\n  return useMemo(\n    () => ({\n      ...state,\n      exchange,\n      execute,\n    }),\n    [state, exchange, execute],\n  );\n}\n"],"names":["useMountedState","mountedRef","useRef","get","useCallback","useEffect","useLatest","value","ref","PromiseStatus","usePromiseState","options","status","setStatus","useState","result","setResult","error","setErrorState","isMounted","latestOptions","setLoadingFn","setSuccessFn","setErrorFn","setIdleFn","useMemo","useRequestId","requestIdRef","generate","current","isLatest","requestId","invalidate","reset","useExecutePromise","state","execute","input","currentRequestId","data","err","useKeyStorage","keyStorage","subscribe","callback","getSnapshot","useSyncExternalStore","setValue","useFetcher","fetcher","fetcherRegistrar","exchange","setExchange","abortControllerRef","currentFetcher","getFetcher","request"],"mappings":"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","x_google_ignoreList":[0]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ahoo-wang/fetcher-react",
-  "version": "2.6.2",
+  "version": "2.6.3",
   "description": "React integration for Fetcher HTTP client. Provides React Hooks and components for seamless data fetching with automatic re-rendering and loading states.",
   "keywords": [
     "fetch",