@ahoo-wang/fetcher-react 2.5.6 → 2.5.9

package/README.md

@@ -17,6 +17,7 @@ automatic re-rendering and loading states.
 - 🌐 **TypeScript Support**: Full TypeScript support with comprehensive type definitions
 - 🚀 **Modern**: Built with modern React patterns and best practices
 - 🧠 **Smart Caching**: Built-in caching and automatic revalidation
+- ⚡ **Promise State Management**: Hooks for managing async operations and promise states
 
 ## Installation
 
@@ -26,83 +27,127 @@ npm install @ahoo-wang/fetcher-react
 
 ## Usage
 
-### useFetcher Hook
+### usePromiseState Hook
 
-The `useFetcher` hook provides a convenient way to fetch data in React components with automatic state management for
-loading, error, and result states.
+The `usePromiseState` hook provides state management for promise operations without execution logic.
 
 ```typescript jsx
-import { useFetcher } from '@ahoo-wang/fetcher-react';
+import { usePromiseState, PromiseStatus } from '@ahoo-wang/fetcher-react';
 
 const MyComponent = () => {
-  const { loading, error, result, execute, cancel } = useFetcher({
-    url: '/api/users',
-    method: 'GET'
-  });
+  const { status, loading, result, error, setSuccess, setError, setIdle } = usePromiseState<string>();
 
-  if (loading) return <div>Loading...</div>;
-  if (error) return <div>Error: {error.message}</div>;
+  const handleSuccess = () => setSuccess('Data loaded');
+  const handleError = () => setError(new Error('Failed to load'));
 
   return (
     <div>
-      <pre>{JSON.stringify(result, null, 2)}</pre>
-      <button onClick={execute}>Refresh</button>
-      <button onClick={cancel}>Cancel</button>
+      <button onClick={handleSuccess}>Set Success</button>
+      <button onClick={handleError}>Set Error</button>
+      <button onClick={setIdle}>Reset</button>
+      <p>Status: {status}</p>
+      {loading && <p>Loading...</p>}
+      {result && <p>Result: {result}</p>}
+      {error && <p>Error: {error.message}</p>}
     </div>
   );
 };
 ```
 
-### Manual Execution
+### useExecutePromise Hook
 
-To manually control when the fetch occurs, set the `immediate` option to `false`:
+The `useExecutePromise` hook manages asynchronous operations with automatic state handling and built-in race condition
+protection.
 
 ```typescript jsx
-import { useFetcher } from '@ahoo-wang/fetcher-react';
+import { useExecutePromise } from '@ahoo-wang/fetcher-react';
 
 const MyComponent = () => {
-  const { loading, error, result, execute } = useFetcher({
-    url: '/api/users',
-    method: 'POST',
-    body: JSON.stringify({ name: 'John' })
-  }, { immediate: false });
-
-  const handleSubmit = async () => {
-    await execute();
+  const { loading, result, error, execute, reset } = useExecutePromise<string>();
+
+  const fetchData = async () => {
+    const response = await fetch('/api/data');
+    return response.text();
   };
 
-  if (loading) return <div>Submitting...</div>;
+  const handleFetch = () => {
+    execute(fetchData); // Using a promise supplier
+  };
+
+  const handleDirectPromise = () => {
+    const promise = fetch('/api/data').then(res => res.text());
+    execute(promise); // Using a direct promise
+  };
+
+  if (loading) return <div>Loading...</div>;
   if (error) return <div>Error: {error.message}</div>;
+  return (
+    <div>
+      <button onClick={handleFetch}>Fetch with Supplier</button>
+      <button onClick={handleDirectPromise}>Fetch with Promise</button>
+      <button onClick={reset}>Reset</button>
+      {result && <p>{result}</p>}
+    </div>
+  );
+};
+```
+
+### useRequestId Hook
+
+The `useRequestId` hook provides request ID management for preventing race conditions in async operations.
+
+```typescript jsx
+import { useRequestId } from '@ahoo-wang/fetcher-react';
+
+const MyComponent = () => {
+  const { generate, isLatest, invalidate } = useRequestId();
+
+  const handleFetch = async () => {
+    const requestId = generate();
+
+    try {
+      const result = await fetchData();
+
+      if (isLatest(requestId)) {
+        setData(result);
+      }
+    } catch (error) {
+      if (isLatest(requestId)) {
+        setError(error);
+      }
+    }
+  };
 
   return (
     <div>
-      {result && <pre>{JSON.stringify(result, null, 2)}</pre>}
-      <button onClick={handleSubmit}>Submit</button>
+      <button onClick={handleFetch}>Fetch Data</button>
+      <button onClick={invalidate}>Cancel Ongoing</button>
     </div>
   );
 };
 ```
 
-### Custom Dependencies
+### useFetcher Hook
 
-You can specify dependencies that will trigger a refetch when they change:
+The `useFetcher` hook provides data fetching capabilities with automatic state management.
 
 ```typescript jsx
 import { useFetcher } from '@ahoo-wang/fetcher-react';
 
-const UserProfile = ({ userId }: { userId: string }) => {
-  const { loading, error, result } = useFetcher({
-    url: `/api/users/${userId}`,
-    method: 'GET'
-  }, { deps: [userId] });
+const MyComponent = () => {
+  const { loading, error, result, execute } = useFetcher<string>();
+
+  const handleFetch = () => {
+    execute({ url: '/api/users', method: 'GET' });
+  };
 
   if (loading) return <div>Loading...</div>;
   if (error) return <div>Error: {error.message}</div>;
 
   return (
     <div>
-      <h1>{result?.name}</h1>
-      <p>{result?.email}</p>
+      <pre>{JSON.stringify(result, null, 2)}</pre>
+      <button onClick={handleFetch}>Fetch Data</button>
     </div>
   );
 };
@@ -159,36 +204,96 @@ const [user, setUser] = useKeyStorage(userStorage);
 
 ## API Reference
 
+### usePromiseState
+
+```typescript
+function usePromiseState<R = unknown>(
+  options?: UsePromiseStateOptions<R>,
+): UsePromiseStateReturn<R>;
+```
+
+A React hook for managing promise state without execution logic.
+
+**Parameters:**
+
+- `options`: Configuration options
+    - `initialStatus`: Initial status, defaults to IDLE
+    - `onSuccess`: Callback invoked on success
+    - `onError`: Callback invoked on error
+
+**Returns:**
+
+An object containing:
+
+- `status`: Current status (IDLE, LOADING, SUCCESS, ERROR)
+- `loading`: Indicates if currently loading
+- `result`: The result value
+- `error`: The error value
+- `setLoading`: Set status to LOADING
+- `setSuccess`: Set status to SUCCESS with result
+- `setError`: Set status to ERROR with error
+- `setIdle`: Set status to IDLE
+
+### useExecutePromise
+
+```typescript
+function useExecutePromise<R = unknown>(): UseExecutePromiseReturn<R>;
+```
+
+A React hook for managing asynchronous operations with proper state handling.
+
+**Returns:**
+
+An object containing:
+
+- `status`: Current status
+- `loading`: Indicates if currently loading
+- `result`: The result value
+- `error`: The error value
+- `execute`: Function to execute a promise supplier or promise
+- `reset`: Function to reset the state to initial values
+
+### useRequestId
+
+```typescript
+function useRequestId(): UseRequestIdReturn;
+```
+
+A React hook for managing request IDs and race condition protection.
+
+**Returns:**
+
+An object containing:
+
+- `generate`: Generate a new request ID and get the current one
+- `current`: Get the current request ID without generating a new one
+- `isLatest`: Check if a given request ID is the latest
+- `invalidate`: Invalidate current request ID (mark as stale)
+- `reset`: Reset request ID counter
+
 ### useFetcher
 
 ```typescript
-function useFetcher<R>(
-  request: FetchRequest,
-  options?: UseFetcherOptions,
-): UseFetcherResult<R>;
+function useFetcher<R>(options?: UseFetcherOptions): UseFetcherReturn<R>;
 ```
 
-A React hook that provides data fetching capabilities with automatic state management.
+A React hook for managing asynchronous fetch operations with proper state handling.
 
 **Parameters:**
 
-- `request`: The fetch request configuration
-- `options`: Configuration options for the fetch operation
-    - `deps`: Dependencies list for the fetch operation. When provided, the hook will re-fetch when any of these values
-      change.
-    - `immediate`: Whether the fetch operation should execute immediately upon component mount. Defaults to `true`.
+- `options`: Configuration options
     - `fetcher`: Custom fetcher instance to use. Defaults to the default fetcher.
 
 **Returns:**
 
 An object containing:
 
-- `loading`: Indicates if the fetch operation is currently in progress
-- `exchange`: The FetchExchange object representing the ongoing fetch operation
-- `result`: The data returned by the fetch operation
-- `error`: Any error that occurred during the fetch operation
-- `execute`: Function to manually trigger the fetch operation
-- `cancel`: Function to cancel the ongoing fetch operation
+- `status`: Current status
+- `loading`: Indicates if currently loading
+- `result`: The result value
+- `error`: The error value
+- `exchange`: The FetchExchange object
+- `execute`: Function to execute a fetch request
 
 ### useKeyStorage
 

package/README.zh-CN.md

@@ -16,6 +16,7 @@ Fetcher 生态的 React 集成包。提供 React Hooks 和组件，实现无缝
 - 🌐 **TypeScript 支持**: 完整的 TypeScript 支持和全面的类型定义
 - 🚀 **现代化**: 使用现代 React 模式和最佳实践构建
 - 🧠 **智能缓存**: 内置缓存和自动重新验证
+- ⚡ **Promise 状态管理**: 用于管理异步操作和 promise 状态的 hooks
 
 ## 安装
 
@@ -25,82 +26,126 @@ npm install @ahoo-wang/fetcher-react
 
 ## 使用方法
 
-### useFetcher Hook
+### usePromiseState Hook
 
-`useFetcher` hook 提供了一种在 React 组件中获取数据的便捷方式，具有自动管理加载、错误和结果状态的功能。
+`usePromiseState` hook 提供 promise 操作的状态管理，无执行逻辑。
 
 ```typescript jsx
-import { useFetcher } from '@ahoo-wang/fetcher-react';
+import { usePromiseState, PromiseStatus } from '@ahoo-wang/fetcher-react';
 
 const MyComponent = () => {
-  const { loading, error, result, execute, cancel } = useFetcher({
-    url: '/api/users',
-    method: 'GET'
-  });
+  const { status, loading, result, error, setSuccess, setError, setIdle } = usePromiseState<string>();
 
-  if (loading) return <div>加载中...</div>;
-  if (error) return <div>错误: {error.message}</div>;
+  const handleSuccess = () => setSuccess('数据加载成功');
+  const handleError = () => setError(new Error('加载失败'));
 
   return (
     <div>
-      <pre>{JSON.stringify(result, null, 2)}</pre>
-      <button onClick={execute}>刷新</button>
-      <button onClick={cancel}>取消</button>
+      <button onClick={handleSuccess}>设置成功</button>
+      <button onClick={handleError}>设置错误</button>
+      <button onClick={setIdle}>重置</button>
+      <p>状态: {status}</p>
+      {loading && <p>加载中...</p>}
+      {result && <p>结果: {result}</p>}
+      {error && <p>错误: {error.message}</p>}
     </div>
   );
 };
 ```
 
-### 手动执行
+### useExecutePromise Hook
 
-要手动控制获取数据的时机，请将 `immediate` 选项设置为 `false`：
+`useExecutePromise` hook 管理异步操作，具有自动状态处理和内置竞态条件保护。
 
 ```typescript jsx
-import { useFetcher } from '@ahoo-wang/fetcher-react';
+import { useExecutePromise } from '@ahoo-wang/fetcher-react';
 
 const MyComponent = () => {
-  const { loading, error, result, execute } = useFetcher({
-    url: '/api/users',
-    method: 'POST',
-    body: JSON.stringify({ name: 'John' })
-  }, { immediate: false });
-
-  const handleSubmit = async () => {
-    await execute();
+  const { loading, result, error, execute, reset } = useExecutePromise<string>();
+
+  const fetchData = async () => {
+    const response = await fetch('/api/data');
+    return response.text();
   };
 
-  if (loading) return <div>提交中...</div>;
+  const handleFetch = () => {
+    execute(fetchData); // 使用 promise supplier
+  };
+
+  const handleDirectPromise = () => {
+    const promise = fetch('/api/data').then(res => res.text());
+    execute(promise); // 使用直接 promise
+  };
+
+  if (loading) return <div>加载中...</div>;
   if (error) return <div>错误: {error.message}</div>;
+  return (
+    <div>
+      <button onClick={handleFetch}>使用 Supplier 获取</button>
+      <button onClick={handleDirectPromise}>使用 Promise 获取</button>
+      <button onClick={reset}>重置</button>
+      {result && <p>{result}</p>}
+    </div>
+  );
+};
+```
+
+### useRequestId Hook
+
+`useRequestId` hook 提供请求ID管理，用于防止异步操作中的竞态条件。
+
+```typescript jsx
+import { useRequestId } from '@ahoo-wang/fetcher-react';
+
+const MyComponent = () => {
+  const { generate, isLatest, invalidate } = useRequestId();
+
+  const handleFetch = async () => {
+    const requestId = generate();
+
+    try {
+      const result = await fetchData();
+
+      if (isLatest(requestId)) {
+        setData(result);
+      }
+    } catch (error) {
+      if (isLatest(requestId)) {
+        setError(error);
+      }
+    }
+  };
 
   return (
     <div>
-      {result && <pre>{JSON.stringify(result, null, 2)}</pre>}
-      <button onClick={handleSubmit}>提交</button>
+      <button onClick={handleFetch}>获取数据</button>
+      <button onClick={invalidate}>取消进行中</button>
     </div>
   );
 };
 ```
 
-### 自定义依赖项
+### useFetcher Hook
 
-您可以指定依赖项，当它们发生变化时会触发重新获取：
+`useFetcher` hook 提供数据获取功能，具有自动状态管理。
 
 ```typescript jsx
 import { useFetcher } from '@ahoo-wang/fetcher-react';
 
-const UserProfile = ({ userId }: { userId: string }) => {
-  const { loading, error, result } = useFetcher({
-    url: `/api/users/${userId}`,
-    method: 'GET'
-  }, { deps: [userId] });
+const MyComponent = () => {
+  const { loading, error, result, execute } = useFetcher<string>();
+
+  const handleFetch = () => {
+    execute({ url: '/api/users', method: 'GET' });
+  };
 
   if (loading) return <div>加载中...</div>;
   if (error) return <div>错误: {error.message}</div>;
 
   return (
     <div>
-      <h1>{result?.name}</h1>
-      <p>{result?.email}</p>
+      <pre>{JSON.stringify(result, null, 2)}</pre>
+      <button onClick={handleFetch}>获取数据</button>
     </div>
   );
 };
@@ -153,35 +198,96 @@ const [user, setUser] = useKeyStorage(userStorage);
 
 ## API 参考
 
+### usePromiseState
+
+```typescript
+function usePromiseState<R = unknown>(
+  options?: UsePromiseStateOptions<R>,
+): UsePromiseStateReturn<R>;
+```
+
+用于管理 promise 状态的 React hook，无执行逻辑。
+
+**参数:**
+
+- `options`: 配置选项
+    - `initialStatus`: 初始状态，默认为 IDLE
+    - `onSuccess`: 成功时调用的回调
+    - `onError`: 错误时调用的回调
+
+**返回值:**
+
+包含以下属性的对象：
+
+- `status`: 当前状态 (IDLE, LOADING, SUCCESS, ERROR)
+- `loading`: 指示当前是否加载中
+- `result`: 结果值
+- `error`: 错误值
+- `setLoading`: 设置状态为 LOADING
+- `setSuccess`: 设置状态为 SUCCESS 并提供结果
+- `setError`: 设置状态为 ERROR 并提供错误
+- `setIdle`: 设置状态为 IDLE
+
+### useExecutePromise
+
+```typescript
+function useExecutePromise<R = unknown>(): UseExecutePromiseReturn<R>;
+```
+
+用于管理异步操作的 React hook，具有适当的状态处理。
+
+**返回值:**
+
+包含以下属性的对象：
+
+- `status`: 当前状态
+- `loading`: 指示当前是否加载中
+- `result`: 结果值
+- `error`: 错误值
+- `execute`: 执行 promise supplier 或 promise 的函数
+- `reset`: 重置状态到初始值的函数
+
+### useRequestId
+
+```typescript
+function useRequestId(): UseRequestIdReturn;
+```
+
+用于管理请求ID和竞态条件保护的 React hook。
+
+**返回值:**
+
+包含以下属性的对象：
+
+- `generate`: 生成新请求ID并获取当前ID
+- `current`: 获取当前请求ID而不生成新ID
+- `isLatest`: 检查给定请求ID是否为最新
+- `invalidate`: 使当前请求ID失效（标记为过时）
+- `reset`: 重置请求ID计数器
+
 ### useFetcher
 
 ```typescript
-function useFetcher<R>(
-  request: FetchRequest,
-  options?: UseFetcherOptions,
-): UseFetcherResult<R>;
+function useFetcher<R>(options?: UseFetcherOptions): UseFetcherReturn<R>;
 ```
 
-提供数据获取功能并自动管理状态的 React hook。
+用于管理异步获取操作的 React hook，具有适当的状态处理。
 
 **参数:**
 
-- `request`: 获取数据的请求配置
-- `options`: 获取数据操作的配置选项
-    - `deps`: 获取数据操作的依赖项列表。提供时，当这些值中的任何一个发生变化时，hook 将重新获取数据。
-    - `immediate`: 获取数据操作是否应在组件挂载时立即执行。默认为 `true`。
+- `options`: 配置选项
     - `fetcher`: 要使用的自定义获取器实例。默认为默认获取器。
 
 **返回值:**
 
 包含以下属性的对象：
 
-- `loading`: 指示获取数据操作当前是否正在进行中
-- `exchange`: 代表正在进行的获取数据操作的 FetchExchange 对象
-- `result`: 获取数据操作返回的数据
-- `error`: 获取数据操作期间发生的任何错误
-- `execute`: 手动触发获取数据操作的函数
-- `cancel`: 取消正在进行的获取数据操作的函数
+- `status`: 当前状态
+- `loading`: 指示当前是否加载中
+- `result`: 结果值
+- `error`: 错误值
+- `exchange`: FetchExchange 对象
+- `execute`: 执行获取请求的函数
 
 ### useKeyStorage
 

package/dist/core/index.d.ts

@@ -1,3 +1,4 @@
 export * from './useExecutePromise';
 export * from './usePromiseState';
+export * from './useRequestId';
 //# 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"}
+{"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"}

package/dist/core/useExecutePromise.d.ts

@@ -7,15 +7,10 @@ export type PromiseSupplier<R> = () => Promise<R>;
 /**
  * Interface defining the return type of useExecutePromise hook
  * @template R - The type of the result value
- *
- * @example
- * ```typescript
- * const { loading, result, error, execute, reset } = useExecutePromise<string>();
- * ```
  */
-export interface UseExecutePromiseReturn<R> extends PromiseState<R> {
-    /** Function to execute a promise supplier */
-    execute: (provider: PromiseSupplier<R>) => Promise<R>;
+export interface UseExecutePromiseReturn<R, E = unknown> extends PromiseState<R, E> {
+    /** Function to execute a promise supplier or promise */
+    execute: (input: PromiseSupplier<R> | Promise<R>) => Promise<R>;
     /** Function to reset the state to initial values */
     reset: () => void;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"useExecutePromise.d.ts","sourceRoot":"","sources":["../../src/core/useExecutePromise.ts"],"names":[],"mappings":"AAeA,OAAO,EAAmB,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAElE;;;GAGG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;AAElD;;;;;;;;GAQG;AACH,MAAM,WAAW,uBAAuB,CAAC,CAAC,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IACjE,6CAA6C;IAC7C,OAAO,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACtD,oDAAoD;IACpD,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,GAAG,OAAO,KAAK,uBAAuB,CAAC,CAAC,CAAC,CAiD3E"}
+{"version":3,"file":"useExecutePromise.d.ts","sourceRoot":"","sources":["../../src/core/useExecutePromise.ts"],"names":[],"mappings":"AAeA,OAAO,EAAmB,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGlE;;;GAGG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;AAElD;;;GAGG;AACH,MAAM,WAAW,uBAAuB,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CACrD,SAAQ,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC;IAC1B,wDAAwD;IACxD,OAAO,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IAChE,oDAAoD;IACpD,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,GAAG,OAAO,KAAK,uBAAuB,CAAC,CAAC,CAAC,CAuD3E"}

package/dist/core/usePromiseState.d.ts

@@ -7,7 +7,7 @@ export declare enum PromiseStatus {
     SUCCESS = "success",
     ERROR = "error"
 }
-export interface PromiseState<R> {
+export interface PromiseState<R, E = unknown> {
     /** Current status of the promise */
     status: PromiseStatus;
     /** Indicates if currently loading */
@@ -15,7 +15,7 @@ export interface PromiseState<R> {
     /** The result value */
     result: R | undefined;
     /** The error value */
-    error: unknown | undefined;
+    error: E | undefined;
 }
 /**
  * Options for configuring usePromiseState behavior
@@ -30,25 +30,25 @@ export interface PromiseState<R> {
  * };
  * ```
  */
-export interface UsePromiseStateOptions<R> {
+export interface UsePromiseStateOptions<R, E = unknown> {
     /** Initial status, defaults to IDLE */
     initialStatus?: PromiseStatus;
     /** Callback invoked on success */
     onSuccess?: (result: R) => void;
     /** Callback invoked on error */
-    onError?: (error: unknown) => void;
+    onError?: (error: E) => void;
 }
 /**
  * Return type for usePromiseState hook
  * @template R - The type of result
  */
-export interface UsePromiseStateReturn<R> extends PromiseState<R> {
+export interface UsePromiseStateReturn<R, E = unknown> extends PromiseState<R, E> {
     /** Set status to LOADING */
     setLoading: () => void;
     /** Set status to SUCCESS with result */
     setSuccess: (result: R) => void;
     /** Set status to ERROR with error */
-    setError: (error: unknown) => void;
+    setError: (error: E) => void;
     /** Set status to IDLE */
     setIdle: () => void;
 }
@@ -82,5 +82,5 @@ export interface UsePromiseStateReturn<R> extends PromiseState<R> {
  * }
  * ```
  */
-export declare function usePromiseState<R = unknown>(options?: UsePromiseStateOptions<R>): UsePromiseStateReturn<R>;
+export declare function usePromiseState<R = unknown, E = unknown>(options?: UsePromiseStateOptions<R, E>): UsePromiseStateReturn<R, E>;
 //# sourceMappingURL=usePromiseState.d.ts.map

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;IAC7B,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,OAAO,GAAG,SAAS,CAAC;CAC5B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,sBAAsB,CAAC,CAAC;IACvC,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,OAAO,KAAK,IAAI,CAAC;CACpC;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB,CAAC,CAAC,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IAC/D,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,OAAO,KAAK,IAAI,CAAC;IACnC,yBAAyB;IACzB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,eAAe,CAAC,CAAC,GAAG,OAAO,EACzC,OAAO,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAClC,qBAAqB,CAAC,CAAC,CAAC,CAyD1B"}
+{"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"}

package/dist/core/useRequestId.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Return type for useRequestId hook
+ */
+export interface UseRequestIdReturn {
+    /** Generate a new request ID and get the current one */
+    generate: () => number;
+    /** Get the current request ID without generating a new one */
+    current: () => number;
+    /** Check if a given request ID is the latest */
+    isLatest: (requestId: number) => boolean;
+    /** Invalidate current request ID (mark as stale) */
+    invalidate: () => void;
+    /** Reset request ID counter */
+    reset: () => void;
+}
+/**
+ * A React hook for managing request IDs and race condition protection
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const requestId = useRequestId();
+ *
+ * const execute = async () => {
+ *   const id = requestId.generate();
+ *
+ *   try {
+ *     const result = await someAsyncOperation();
+ *
+ *     // Check if this is still the latest request
+ *     if (requestId.isLatest(id)) {
+ *       setState(result);
+ *     }
+ *   } catch (error) {
+ *     if (requestId.isLatest(id)) {
+ *       setError(error);
+ *     }
+ *   }
+ * };
+ *
+ * // Manual cancellation
+ * const handleCancel = () => {
+ *   requestId.invalidate(); // All ongoing requests will be ignored
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With async operation wrapper
+ * const { execute, cancel } = useAsyncOperation(async (data) => {
+ *   return await apiCall(data);
+ * }, [requestId]);
+ * ```
+ */
+export declare function useRequestId(): UseRequestIdReturn;
+//# sourceMappingURL=useRequestId.d.ts.map

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

@@ -0,0 +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"}

package/dist/fetcher/useFetcher.d.ts

@@ -6,7 +6,7 @@ import { PromiseState } from '../core';
  */
 export interface UseFetcherOptions extends RequestOptions, FetcherCapable {
 }
-export interface UseFetcherReturn<R> extends PromiseState<R> {
+export interface UseFetcherReturn<R, E = unknown> extends PromiseState<R, E> {
     /** The FetchExchange object representing the ongoing fetch operation */
     exchange?: FetchExchange;
     execute: (request: FetchRequest) => Promise<void>;
@@ -38,5 +38,5 @@ export interface UseFetcherReturn<R> extends PromiseState<R> {
  * }
  * ```
  */
-export declare function useFetcher<R>(options?: UseFetcherOptions): UseFetcherReturn<R>;
+export declare function useFetcher<R, E = unknown>(options?: UseFetcherOptions): UseFetcherReturn<R, E>;
 //# sourceMappingURL=useFetcher.d.ts.map

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,EACL,YAAY,EAEb,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,MAAM,WAAW,iBAAkB,SAAQ,cAAc,EAAE,cAAc;CACxE;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IAC1D,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,EAC1B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,gBAAgB,CAAC,CAAC,CAAC,CA8DrB"}
+{"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,EAAiC,MAAM,SAAS,CAAC;AAEtE;;;GAGG;AACH,MAAM,WAAW,iBAAkB,SAAQ,cAAc,EAAE,cAAc;CACxE;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,GAC1B,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAgExB"}

package/dist/index.es.js

@@ -1,130 +1,151 @@
-import { useRef as v, useCallback as c, useEffect as b, useState as d, useSyncExternalStore as S } from "react";
-import { fetcher as C, getFetcher as R } from "@ahoo-wang/fetcher";
-function g() {
-  var t = v(!1), n = c(function() {
+import { useRef as h, useCallback as c, useEffect as L, useState as E, useMemo as I, useSyncExternalStore as x } from "react";
+import { fetcher as S, getFetcher as C } from "@ahoo-wang/fetcher";
+function v() {
+  var t = h(!1), r = c(function() {
     return t.current;
   }, []);
-  return b(function() {
+  return L(function() {
     return t.current = !0, function() {
       t.current = !1;
     };
-  }, []), n;
+  }, []), r;
 }
-var m = /* @__PURE__ */ ((t) => (t.IDLE = "idle", t.LOADING = "loading", t.SUCCESS = "success", t.ERROR = "error", t))(m || {});
-function x(t) {
-  const [n, r] = d(
+var w = /* @__PURE__ */ ((t) => (t.IDLE = "idle", t.LOADING = "loading", t.SUCCESS = "success", t.ERROR = "error", t))(w || {});
+function R(t) {
+  const [r, e] = E(
     t?.initialStatus ?? "idle"
     /* IDLE */
-  ), [a, u] = d(void 0), [e, s] = d(void 0), o = g(), E = c(() => {
-    o() && (r(
+  ), [i, u] = E(void 0), [n, s] = E(void 0), o = v(), d = c(() => {
+    o() && (e(
       "loading"
       /* LOADING */
     ), s(void 0));
-  }, [o]), l = c(
-    (f) => {
-      o() && (u(f), r(
+  }, [o]), g = c(
+    (a) => {
+      o() && (u(a), e(
         "success"
         /* SUCCESS */
-      ), s(void 0), t?.onSuccess?.(f));
+      ), s(void 0), t?.onSuccess?.(a));
     },
     [o, t]
-  ), i = c(
-    (f) => {
-      o() && (s(f), r(
+  ), f = c(
+    (a) => {
+      o() && (s(a), e(
         "error"
         /* ERROR */
-      ), u(void 0), t?.onError?.(f));
+      ), u(void 0), t?.onError?.(a));
     },
     [o, t]
-  ), h = c(() => {
-    o() && (r(
+  ), l = c(() => {
+    o() && (e(
       "idle"
       /* IDLE */
     ), s(void 0), u(void 0));
   }, [o]);
+  return I(() => ({
+    status: r,
+    loading: r === "loading",
+    result: i,
+    error: n,
+    setLoading: d,
+    setSuccess: g,
+    setError: f,
+    setIdle: l
+  }), [r, i, n, d, g, f, l]);
+}
+function b() {
+  const t = h(0), r = c(() => ++t.current, []), e = c(() => t.current, []), i = c((s) => s === t.current, []), u = c(() => {
+    t.current++;
+  }, []), n = c(() => {
+    t.current = 0;
+  }, []);
   return {
-    status: n,
-    loading: n === "loading",
-    result: a,
-    error: e,
-    setLoading: E,
-    setSuccess: l,
-    setError: i,
-    setIdle: h
+    generate: r,
+    current: e,
+    isLatest: i,
+    invalidate: u,
+    reset: n
   };
 }
-function L() {
-  const t = x(), n = g(), r = c(
-    async (u) => {
-      if (!n())
+function q() {
+  const t = R(), r = v(), e = b(), i = c(
+    async (n) => {
+      if (!r())
         throw new Error("Component is unmounted");
+      const s = e.generate();
       t.setLoading();
       try {
-        const e = await u();
-        return n() && t.setSuccess(e), e;
-      } catch (e) {
-        throw n() && t.setError(e), e;
+        const d = await (typeof n == "function" ? n() : n);
+        return r() && e.isLatest(s) && t.setSuccess(d), d;
+      } catch (o) {
+        throw r() && e.isLatest(s) && t.setError(o), o;
       }
     },
-    [t, n]
-  ), a = c(() => {
-    n() && t.setIdle();
-  }, [t, n]);
-  return {
-    loading: t.loading,
-    result: t.result,
-    error: t.error,
-    execute: r,
-    reset: a,
-    status: t.status
-  };
+    [t, r, e]
+  ), u = c(() => {
+    r() && t.setIdle();
+  }, [t, r]);
+  return I(
+    () => ({
+      loading: t.loading,
+      result: t.result,
+      error: t.error,
+      execute: i,
+      reset: u,
+      status: t.status
+    }),
+    [t.loading, t.result, t.error, i, u, t.status]
+  );
 }
-function I(t) {
-  const n = c(
-    (e) => t.addListener(e),
+function y(t) {
+  const r = c(
+    (n) => t.addListener(n),
     [t]
-  ), r = c(() => t.get(), [t]), a = S(n, r, r), u = c(
-    (e) => t.set(e),
+  ), e = c(() => t.get(), [t]), i = x(r, e, e), u = c(
+    (n) => t.set(n),
     [t]
   );
-  return [a, u];
+  return [i, u];
 }
-function M(t) {
-  const { fetcher: n = C } = t || {}, r = x(), [a, u] = d(
+function A(t) {
+  const { fetcher: r = S } = t || {}, e = R(), [i, u] = E(
     void 0
-  ), e = g(), s = v(), o = R(n), E = c(
-    async (l) => {
-      s.current && s.current.abort(), s.current = l.abortController ?? new AbortController(), l.abortController = s.current, r.setLoading();
+  ), n = v(), s = h(), o = b(), d = C(r), g = c(
+    async (f) => {
+      s.current && s.current.abort(), s.current = f.abortController ?? new AbortController(), f.abortController = s.current;
+      const l = o.generate();
+      e.setLoading();
       try {
-        const i = await o.exchange(l, t);
-        e() && u(i);
-        const h = await i.extractResult();
-        e() && r.setSuccess(h);
-      } catch (i) {
-        if (i instanceof Error && i.name === "AbortError") {
-          e() && r.setIdle();
+        const a = await d.exchange(f, t);
+        n() && o.isLatest(l) && u(a);
+        const m = await a.extractResult();
+        n() && o.isLatest(l) && e.setSuccess(m);
+      } catch (a) {
+        if (a instanceof Error && a.name === "AbortError") {
+          n() && e.setIdle();
           return;
         }
-        e() && r.setError(i);
+        n() && o.isLatest(l) && e.setError(a);
       } finally {
-        s.current === l.abortController && (s.current = void 0);
+        s.current === f.abortController && (s.current = void 0);
       }
     },
-    [o, e, t, r]
+    [d, n, t, e, o]
   );
-  return b(() => () => {
+  return L(() => () => {
     s.current?.abort(), s.current = void 0;
   }, []), {
-    ...r,
-    exchange: a,
-    execute: E
+    ...e,
+    exchange: i,
+    execute: g
   };
 }
 export {
-  m as PromiseStatus,
-  L as useExecutePromise,
-  M as useFetcher,
-  I as useKeyStorage,
-  x as usePromiseState
+  w as PromiseStatus,
+  q as useExecutePromise,
+  A as useFetcher,
+  y as useKeyStorage,
+  R as usePromiseState,
+  b 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/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, 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> {\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: unknown | 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> {\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: unknown) => void;\n}\n\n/**\n * Return type for usePromiseState hook\n * @template R - The type of result\n */\nexport interface UsePromiseStateReturn<R> extends PromiseState<R> {\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: unknown) => 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>(\n  options?: UsePromiseStateOptions<R>,\n): UsePromiseStateReturn<R> {\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<unknown | 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: unknown) => {\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\n  return {\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}\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 } from 'react';\nimport { useMountedState } from 'react-use';\nimport { usePromiseState, PromiseState } from './usePromiseState';\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 *\n * @example\n * ```typescript\n * const { loading, result, error, execute, reset } = useExecutePromise<string>();\n * ```\n */\nexport interface UseExecutePromiseReturn<R> extends PromiseState<R> {\n  /** Function to execute a promise supplier */\n  execute: (provider: PromiseSupplier<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>(): UseExecutePromiseReturn<R> {\n  const state = usePromiseState<R>();\n  const isMounted = useMountedState();\n\n  /**\n   * Execute a promise supplier and manage its state\n   * @param provider - A function that returns 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 (provider: PromiseSupplier<R>): Promise<R> => {\n      if (!isMounted()) {\n        throw new Error('Component is unmounted');\n      }\n      state.setLoading();\n      try {\n        const data = await provider();\n\n        if (isMounted()) {\n          state.setSuccess(data);\n        }\n        return data;\n      } catch (err) {\n        if (isMounted()) {\n          state.setError(err);\n        }\n        throw err;\n      }\n    },\n    [state, isMounted],\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 {\n    loading: state.loading,\n    result: state.result,\n    error: state.error,\n    execute,\n    reset,\n    status: 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  fetcher as defaultFetcher,\n  FetcherCapable,\n  FetchExchange,\n  FetchRequest,\n  getFetcher,\n  RequestOptions,\n} from '@ahoo-wang/fetcher';\nimport { useRef, useCallback, useEffect, useState } from 'react';\nimport { useMountedState } from 'react-use';\nimport {\n  PromiseState,\n  usePromiseState,\n} from '../core';\n\n/**\n * Configuration options for the useFetcher hook.\n * Extends RequestOptions and FetcherCapable interfaces.\n */\nexport interface UseFetcherOptions extends RequestOptions, FetcherCapable {\n}\n\nexport interface UseFetcherReturn<R> extends PromiseState<R> {\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>(\n  options?: UseFetcherOptions,\n): UseFetcherReturn<R> {\n  const { fetcher = defaultFetcher } = options || {};\n  const state = usePromiseState<R>();\n  const [exchange, setExchange] = useState<FetchExchange | undefined>(\n    undefined,\n  );\n  const isMounted = useMountedState();\n  const abortControllerRef = useRef<AbortController | undefined>();\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      state.setLoading();\n      try {\n        const exchange = await currentFetcher.exchange(request, options);\n        if (isMounted()) {\n          setExchange(exchange);\n        }\n        const result = await exchange.extractResult<R>();\n        if (isMounted()) {\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()) {\n          state.setError(error);\n        }\n      } finally {\n        if (abortControllerRef.current === request.abortController) {\n          abortControllerRef.current = undefined;\n        }\n      }\n    },\n    [currentFetcher, isMounted, options, state],\n  );\n\n  useEffect(() => {\n    return () => {\n      abortControllerRef.current?.abort();\n      abortControllerRef.current = undefined;\n    };\n  }, []);\n  return {\n    ...state,\n    exchange,\n    execute,\n  };\n}\n"],"names":["useMountedState","mountedRef","useRef","get","useCallback","useEffect","PromiseStatus","usePromiseState","options","status","setStatus","useState","result","setResult","error","setErrorState","isMounted","setLoadingFn","setSuccessFn","setErrorFn","setIdleFn","useExecutePromise","state","execute","provider","data","err","reset","useKeyStorage","keyStorage","subscribe","callback","getSnapshot","value","useSyncExternalStore","setValue","useFetcher","fetcher","defaultFetcher","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/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 } 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>(): UseExecutePromiseReturn<R> {\n  const state = usePromiseState<R>();\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);\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  fetcher as defaultFetcher,\n  FetcherCapable,\n  FetchExchange,\n  FetchRequest,\n  getFetcher,\n  RequestOptions,\n} from '@ahoo-wang/fetcher';\nimport { useRef, useCallback, useEffect, useState } from 'react';\nimport { useMountedState } from 'react-use';\nimport { PromiseState, usePromiseState, useRequestId } from '../core';\n\n/**\n * Configuration options for the useFetcher hook.\n * Extends RequestOptions and FetcherCapable interfaces.\n */\nexport interface UseFetcherOptions extends RequestOptions, FetcherCapable {\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,\n): UseFetcherReturn<R, E> {\n  const { fetcher = defaultFetcher } = options || {};\n  const state = usePromiseState<R, E>();\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 {\n    ...state,\n    exchange,\n    execute,\n  };\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","defaultFetcher","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(u,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):(u=typeof globalThis<"u"?globalThis:u||self,t(u.FetcherReact={},u.React,u.Fetcher))})(this,(function(u,t,S){"use strict";function h(){var e=t.useRef(!1),s=t.useCallback(function(){return e.current},[]);return t.useEffect(function(){return e.current=!0,function(){e.current=!1}},[]),s}var g=(e=>(e.IDLE="idle",e.LOADING="loading",e.SUCCESS="success",e.ERROR="error",e))(g||{});function b(e){const[s,n]=t.useState(e?.initialStatus??"idle"),[l,i]=t.useState(void 0),[r,o]=t.useState(void 0),c=h(),C=t.useCallback(()=>{c()&&(n("loading"),o(void 0))},[c]),f=t.useCallback(d=>{c()&&(i(d),n("success"),o(void 0),e?.onSuccess?.(d))},[c,e]),a=t.useCallback(d=>{c()&&(o(d),n("error"),i(void 0),e?.onError?.(d))},[c,e]),E=t.useCallback(()=>{c()&&(n("idle"),o(void 0),i(void 0))},[c]);return{status:s,loading:s==="loading",result:l,error:r,setLoading:C,setSuccess:f,setError:a,setIdle:E}}function v(){const e=b(),s=h(),n=t.useCallback(async i=>{if(!s())throw new Error("Component is unmounted");e.setLoading();try{const r=await i();return s()&&e.setSuccess(r),r}catch(r){throw s()&&e.setError(r),r}},[e,s]),l=t.useCallback(()=>{s()&&e.setIdle()},[e,s]);return{loading:e.loading,result:e.result,error:e.error,execute:n,reset:l,status:e.status}}function F(e){const s=t.useCallback(r=>e.addListener(r),[e]),n=t.useCallback(()=>e.get(),[e]),l=t.useSyncExternalStore(s,n,n),i=t.useCallback(r=>e.set(r),[e]);return[l,i]}function m(e){const{fetcher:s=S.fetcher}=e||{},n=b(),[l,i]=t.useState(void 0),r=h(),o=t.useRef(),c=S.getFetcher(s),C=t.useCallback(async f=>{o.current&&o.current.abort(),o.current=f.abortController??new AbortController,f.abortController=o.current,n.setLoading();try{const a=await c.exchange(f,e);r()&&i(a);const E=await a.extractResult();r()&&n.setSuccess(E)}catch(a){if(a instanceof Error&&a.name==="AbortError"){r()&&n.setIdle();return}r()&&n.setError(a)}finally{o.current===f.abortController&&(o.current=void 0)}},[c,r,e,n]);return t.useEffect(()=>()=>{o.current?.abort(),o.current=void 0},[]),{...n,exchange:l,execute:C}}u.PromiseStatus=g,u.useExecutePromise=v,u.useFetcher=m,u.useKeyStorage=F,u.usePromiseState=b,Object.defineProperty(u,Symbol.toStringTag,{value:"Module"})}));
+(function(c,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):(c=typeof globalThis<"u"?globalThis:c||self,t(c.FetcherReact={},c.React,c.Fetcher))})(this,(function(c,t,S){"use strict";function C(){var e=t.useRef(!1),s=t.useCallback(function(){return e.current},[]);return t.useEffect(function(){return e.current=!0,function(){e.current=!1}},[]),s}var v=(e=>(e.IDLE="idle",e.LOADING="loading",e.SUCCESS="success",e.ERROR="error",e))(v||{});function g(e){const[s,r]=t.useState(e?.initialStatus??"idle"),[l,i]=t.useState(void 0),[n,u]=t.useState(void 0),o=C(),d=t.useCallback(()=>{o()&&(r("loading"),u(void 0))},[o]),h=t.useCallback(a=>{o()&&(i(a),r("success"),u(void 0),e?.onSuccess?.(a))},[o,e]),f=t.useCallback(a=>{o()&&(u(a),r("error"),i(void 0),e?.onError?.(a))},[o,e]),b=t.useCallback(()=>{o()&&(r("idle"),u(void 0),i(void 0))},[o]);return t.useMemo(()=>({status:s,loading:s==="loading",result:l,error:n,setLoading:d,setSuccess:h,setError:f,setIdle:b}),[s,l,n,d,h,f,b])}function E(){const e=t.useRef(0),s=t.useCallback(()=>++e.current,[]),r=t.useCallback(()=>e.current,[]),l=t.useCallback(u=>u===e.current,[]),i=t.useCallback(()=>{e.current++},[]),n=t.useCallback(()=>{e.current=0},[]);return{generate:s,current:r,isLatest:l,invalidate:i,reset:n}}function m(){const e=g(),s=C(),r=E(),l=t.useCallback(async n=>{if(!s())throw new Error("Component is unmounted");const u=r.generate();e.setLoading();try{const d=await(typeof n=="function"?n():n);return s()&&r.isLatest(u)&&e.setSuccess(d),d}catch(o){throw s()&&r.isLatest(u)&&e.setError(o),o}},[e,s,r]),i=t.useCallback(()=>{s()&&e.setIdle()},[e,s]);return t.useMemo(()=>({loading:e.loading,result:e.result,error:e.error,execute:l,reset:i,status:e.status}),[e.loading,e.result,e.error,l,i,e.status])}function I(e){const s=t.useCallback(n=>e.addListener(n),[e]),r=t.useCallback(()=>e.get(),[e]),l=t.useSyncExternalStore(s,r,r),i=t.useCallback(n=>e.set(n),[e]);return[l,i]}function L(e){const{fetcher:s=S.fetcher}=e||{},r=g(),[l,i]=t.useState(void 0),n=C(),u=t.useRef(),o=E(),d=S.getFetcher(s),h=t.useCallback(async f=>{u.current&&u.current.abort(),u.current=f.abortController??new AbortController,f.abortController=u.current;const b=o.generate();r.setLoading();try{const a=await d.exchange(f,e);n()&&o.isLatest(b)&&i(a);const k=await a.extractResult();n()&&o.isLatest(b)&&r.setSuccess(k)}catch(a){if(a instanceof Error&&a.name==="AbortError"){n()&&r.setIdle();return}n()&&o.isLatest(b)&&r.setError(a)}finally{u.current===f.abortController&&(u.current=void 0)}},[d,n,e,r,o]);return t.useEffect(()=>()=>{u.current?.abort(),u.current=void 0},[]),{...r,exchange:l,execute:h}}c.PromiseStatus=v,c.useExecutePromise=m,c.useFetcher=L,c.useKeyStorage=I,c.usePromiseState=g,c.useRequestId=E,Object.defineProperty(c,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/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, 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> {\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: unknown | 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> {\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: unknown) => void;\n}\n\n/**\n * Return type for usePromiseState hook\n * @template R - The type of result\n */\nexport interface UsePromiseStateReturn<R> extends PromiseState<R> {\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: unknown) => 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>(\n  options?: UsePromiseStateOptions<R>,\n): UsePromiseStateReturn<R> {\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<unknown | 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: unknown) => {\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\n  return {\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}\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 } from 'react';\nimport { useMountedState } from 'react-use';\nimport { usePromiseState, PromiseState } from './usePromiseState';\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 *\n * @example\n * ```typescript\n * const { loading, result, error, execute, reset } = useExecutePromise<string>();\n * ```\n */\nexport interface UseExecutePromiseReturn<R> extends PromiseState<R> {\n  /** Function to execute a promise supplier */\n  execute: (provider: PromiseSupplier<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>(): UseExecutePromiseReturn<R> {\n  const state = usePromiseState<R>();\n  const isMounted = useMountedState();\n\n  /**\n   * Execute a promise supplier and manage its state\n   * @param provider - A function that returns 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 (provider: PromiseSupplier<R>): Promise<R> => {\n      if (!isMounted()) {\n        throw new Error('Component is unmounted');\n      }\n      state.setLoading();\n      try {\n        const data = await provider();\n\n        if (isMounted()) {\n          state.setSuccess(data);\n        }\n        return data;\n      } catch (err) {\n        if (isMounted()) {\n          state.setError(err);\n        }\n        throw err;\n      }\n    },\n    [state, isMounted],\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 {\n    loading: state.loading,\n    result: state.result,\n    error: state.error,\n    execute,\n    reset,\n    status: 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  fetcher as defaultFetcher,\n  FetcherCapable,\n  FetchExchange,\n  FetchRequest,\n  getFetcher,\n  RequestOptions,\n} from '@ahoo-wang/fetcher';\nimport { useRef, useCallback, useEffect, useState } from 'react';\nimport { useMountedState } from 'react-use';\nimport {\n  PromiseState,\n  usePromiseState,\n} from '../core';\n\n/**\n * Configuration options for the useFetcher hook.\n * Extends RequestOptions and FetcherCapable interfaces.\n */\nexport interface UseFetcherOptions extends RequestOptions, FetcherCapable {\n}\n\nexport interface UseFetcherReturn<R> extends PromiseState<R> {\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>(\n  options?: UseFetcherOptions,\n): UseFetcherReturn<R> {\n  const { fetcher = defaultFetcher } = options || {};\n  const state = usePromiseState<R>();\n  const [exchange, setExchange] = useState<FetchExchange | undefined>(\n    undefined,\n  );\n  const isMounted = useMountedState();\n  const abortControllerRef = useRef<AbortController | undefined>();\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      state.setLoading();\n      try {\n        const exchange = await currentFetcher.exchange(request, options);\n        if (isMounted()) {\n          setExchange(exchange);\n        }\n        const result = await exchange.extractResult<R>();\n        if (isMounted()) {\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()) {\n          state.setError(error);\n        }\n      } finally {\n        if (abortControllerRef.current === request.abortController) {\n          abortControllerRef.current = undefined;\n        }\n      }\n    },\n    [currentFetcher, isMounted, options, state],\n  );\n\n  useEffect(() => {\n    return () => {\n      abortControllerRef.current?.abort();\n      abortControllerRef.current = undefined;\n    };\n  }, []);\n  return {\n    ...state,\n    exchange,\n    execute,\n  };\n}\n"],"names":["useMountedState","mountedRef","useRef","get","useCallback","useEffect","PromiseStatus","usePromiseState","options","status","setStatus","useState","result","setResult","error","setErrorState","isMounted","setLoadingFn","setSuccessFn","setErrorFn","setIdleFn","useExecutePromise","state","execute","provider","data","err","reset","useKeyStorage","keyStorage","subscribe","callback","getSnapshot","value","useSyncExternalStore","setValue","useFetcher","fetcher","defaultFetcher","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/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 } 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>(): UseExecutePromiseReturn<R> {\n  const state = usePromiseState<R>();\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);\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  fetcher as defaultFetcher,\n  FetcherCapable,\n  FetchExchange,\n  FetchRequest,\n  getFetcher,\n  RequestOptions,\n} from '@ahoo-wang/fetcher';\nimport { useRef, useCallback, useEffect, useState } from 'react';\nimport { useMountedState } from 'react-use';\nimport { PromiseState, usePromiseState, useRequestId } from '../core';\n\n/**\n * Configuration options for the useFetcher hook.\n * Extends RequestOptions and FetcherCapable interfaces.\n */\nexport interface UseFetcherOptions extends RequestOptions, FetcherCapable {\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,\n): UseFetcherReturn<R, E> {\n  const { fetcher = defaultFetcher } = options || {};\n  const state = usePromiseState<R, E>();\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 {\n    ...state,\n    exchange,\n    execute,\n  };\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","defaultFetcher","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.5.6",
+  "version": "2.5.9",
   "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",