@ahoo-wang/fetcher-react 2.5.5 → 2.5.8

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,91 @@ 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.
 
 ```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>;
-  if (error) return <div>Error: {error.message}</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>
-      {result && <pre>{JSON.stringify(result, null, 2)}</pre>}
-      <button onClick={handleSubmit}>Submit</button>
+      <button onClick={handleFetch}>Fetch with Supplier</button>
+      <button onClick={handleDirectPromise}>Fetch with Promise</button>
+      <button onClick={reset}>Reset</button>
+      {result && <p>{result}</p>}
     </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 +168,78 @@ 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
+- `reset`: Function to reset the state to initial values
+
 ### 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,91 @@ 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>;
-  if (error) return <div>错误: {error.message}</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>
-      {result && <pre>{JSON.stringify(result, null, 2)}</pre>}
-      <button onClick={handleSubmit}>提交</button>
+      <button onClick={handleFetch}>使用 Supplier 获取</button>
+      <button onClick={handleDirectPromise}>使用 Promise 获取</button>
+      <button onClick={reset}>重置</button>
+      {result && <p>{result}</p>}
     </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 +163,78 @@ 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 提供者的函数
+- `reset`: 重置状态到初始值的函数
+
 ### 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

@@ -0,0 +1,3 @@
+export * from './useExecutePromise';
+export * from './usePromiseState';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/core/useExecutePromise.d.ts

@@ -0,0 +1,55 @@
+import { PromiseState } from './usePromiseState';
+/**
+ * Type definition for a function that returns a Promise
+ * @template R - The type of value the promise will resolve to
+ */
+export type PromiseSupplier<R> = () => Promise<R>;
+/**
+ * Interface defining the return type of useExecutePromise hook
+ * @template R - The type of the result value
+ */
+export interface UseExecutePromiseReturn<R> extends PromiseState<R> {
+    /** 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;
+}
+/**
+ * A React hook for managing asynchronous operations with proper state handling
+ * @template R - The type of the result value
+ * @returns An object containing the current state and control functions
+ *
+ * @example
+ * ```typescript
+ * import { useExecutePromise } from '@ahoo-wang/fetcher-react';
+ *
+ * function MyComponent() {
+ *   const { loading, result, error, execute, reset } = useExecutePromise<string>();
+ *
+ *   const fetchData = async () => {
+ *     const response = await fetch('/api/data');
+ *     return response.text();
+ *   };
+ *
+ *   const handleFetch = () => {
+ *     execute(fetchData);
+ *   };
+ *
+ *   const handleReset = () => {
+ *     reset();
+ *   };
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *   return (
+ *     <div>
+ *       <button onClick={handleFetch}>Fetch Data</button>
+ *       <button onClick={handleReset}>Reset</button>
+ *       {result && <p>{result}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useExecutePromise<R = unknown>(): UseExecutePromiseReturn<R>;
+//# sourceMappingURL=useExecutePromise.d.ts.map

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

@@ -0,0 +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;;;GAGG;AACH,MAAM,WAAW,uBAAuB,CAAC,CAAC,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IACjE,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,CAkD3E"}

package/dist/core/usePromiseState.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Enumeration of possible promise execution states
+ */
+export declare enum PromiseStatus {
+    IDLE = "idle",
+    LOADING = "loading",
+    SUCCESS = "success",
+    ERROR = "error"
+}
+export interface PromiseState<R> {
+    /** Current status of the promise */
+    status: PromiseStatus;
+    /** Indicates if currently loading */
+    loading: boolean;
+    /** The result value */
+    result: R | undefined;
+    /** The error value */
+    error: unknown | undefined;
+}
+/**
+ * Options for configuring usePromiseState behavior
+ * @template R - The type of result
+ *
+ * @example
+ * ```typescript
+ * const options: UsePromiseStateOptions<string> = {
+ *   initialStatus: PromiseStatus.IDLE,
+ *   onSuccess: (result) => console.log('Success:', result),
+ *   onError: (error) => console.error('Error:', error),
+ * };
+ * ```
+ */
+export interface UsePromiseStateOptions<R> {
+    /** Initial status, defaults to IDLE */
+    initialStatus?: PromiseStatus;
+    /** Callback invoked on success */
+    onSuccess?: (result: R) => void;
+    /** Callback invoked on error */
+    onError?: (error: unknown) => void;
+}
+/**
+ * Return type for usePromiseState hook
+ * @template R - The type of result
+ */
+export interface UsePromiseStateReturn<R> extends PromiseState<R> {
+    /** 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;
+    /** Set status to IDLE */
+    setIdle: () => void;
+}
+/**
+ * A React hook for managing promise state without execution logic
+ * @template R - The type of result
+ * @param options - Configuration options
+ * @returns State management object
+ *
+ * @example
+ * ```typescript
+ * import { usePromiseState, PromiseStatus } from '@ahoo-wang/fetcher-react';
+ *
+ * function MyComponent() {
+ *   const { status, loading, result, error, setSuccess, setError, setIdle } = usePromiseState<string>();
+ *
+ *   const handleSuccess = () => setSuccess('Data loaded');
+ *   const handleError = () => setError(new Error('Failed to load'));
+ *
+ *   return (
+ *     <div>
+ *       <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>
+ *   );
+ * }
+ * ```
+ */
+export declare function usePromiseState<R = unknown>(options?: UsePromiseStateOptions<R>): UsePromiseStateReturn<R>;
+//# sourceMappingURL=usePromiseState.d.ts.map

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

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

package/dist/fetcher/useFetcher.d.ts

@@ -1,35 +1,42 @@
 import { FetcherCapable, FetchExchange, FetchRequest, RequestOptions } from '@ahoo-wang/fetcher';
+import { PromiseState } from '../core';
 /**
  * Configuration options for the useFetcher hook.
  * Extends RequestOptions and FetcherCapable interfaces.
  */
 export interface UseFetcherOptions extends RequestOptions, FetcherCapable {
-    /**
-     * Whether the fetch operation should execute immediately upon component mount.
-     * Defaults to true.
-     */
-    readonly immediate?: boolean;
 }
-/**
- * The result object returned by the useFetcher hook.
- * @template R - The type of the data returned by the fetch operation
- */
-export interface UseFetcherResult<R> {
-    /** Indicates if the fetch operation is currently in progress */
-    loading: boolean;
+export interface UseFetcherReturn<R> extends PromiseState<R> {
     /** The FetchExchange object representing the ongoing fetch operation */
     exchange?: FetchExchange;
-    /** The data returned by the fetch operation, or undefined if not yet loaded or an error occurred */
-    result?: R;
-    /** Any error that occurred during the fetch operation, or undefined if no error */
-    error?: unknown;
-    /**
-     * Function to manually trigger the fetch operation.
-     * Useful for fetching data on demand rather than automatically.
-     */
-    execute: () => Promise<void>;
-    /** Function to cancel the ongoing fetch operation */
-    cancel: () => void;
+    execute: (request: FetchRequest) => Promise<void>;
 }
-export declare function useFetcher<R>(request: FetchRequest, options?: UseFetcherOptions): UseFetcherResult<R>;
+/**
+ * A React hook for managing asynchronous operations with proper state handling
+ * @param options - Configuration options for the fetcher
+ * @returns An object containing the current state and control functions
+ *
+ * @example
+ * ```typescript
+ * import { useFetcher } from '@ahoo-wang/fetcher-react';
+ *
+ * function MyComponent() {
+ *   const { loading, result, error, execute } = useFetcher<string>();
+ *
+ *   const handleFetch = () => {
+ *     execute({ url: '/api/data', method: 'GET' });
+ *   };
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *   return (
+ *     <div>
+ *       <button onClick={handleFetch}>Fetch Data</button>
+ *       {result && <p>{result}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useFetcher<R>(options?: UseFetcherOptions): UseFetcherReturn<R>;
 //# 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;AAI5B;;;GAGG;AACH,MAAM,WAAW,iBAAkB,SAAQ,cAAc,EAAE,cAAc;IACvE;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,gEAAgE;IAChE,OAAO,EAAE,OAAO,CAAC;IAEjB,wEAAwE;IACxE,QAAQ,CAAC,EAAE,aAAa,CAAC;IAEzB,oGAAoG;IACpG,MAAM,CAAC,EAAE,CAAC,CAAC;IAEX,mFAAmF;IACnF,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7B,qDAAqD;IACrD,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAED,wBAAgB,UAAU,CAAC,CAAC,EAC1B,OAAO,EAAE,YAAY,EACrB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,gBAAgB,CAAC,CAAC,CAAC,CA2ErB"}
+{"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"}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from './core';
 export * from './storage';
 export * from './fetcher';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC"}

package/dist/index.es.js

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

package/dist/index.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es.js","sources":["../src/storage/useKeyStorage.ts","../../../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/fetcher/useFetcher.ts"],"sourcesContent":["/*\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","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 {\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';\n\n/**\n * Configuration options for the useFetcher hook.\n * Extends RequestOptions and FetcherCapable interfaces.\n */\nexport interface UseFetcherOptions extends RequestOptions, FetcherCapable {\n  /**\n   * Whether the fetch operation should execute immediately upon component mount.\n   * Defaults to true.\n   */\n  readonly immediate?: boolean;\n}\n\n/**\n * The result object returned by the useFetcher hook.\n * @template R - The type of the data returned by the fetch operation\n */\nexport interface UseFetcherResult<R> {\n  /** Indicates if the fetch operation is currently in progress */\n  loading: boolean;\n\n  /** The FetchExchange object representing the ongoing fetch operation */\n  exchange?: FetchExchange;\n\n  /** The data returned by the fetch operation, or undefined if not yet loaded or an error occurred */\n  result?: R;\n\n  /** Any error that occurred during the fetch operation, or undefined if no error */\n  error?: unknown;\n\n  /**\n   * Function to manually trigger the fetch operation.\n   * Useful for fetching data on demand rather than automatically.\n   */\n  execute: () => Promise<void>;\n\n  /** Function to cancel the ongoing fetch operation */\n  cancel: () => void;\n}\n\nexport function useFetcher<R>(\n  request: FetchRequest,\n  options?: UseFetcherOptions,\n): UseFetcherResult<R> {\n  const { fetcher = defaultFetcher, immediate = true } = options || {};\n  const [loading, setLoading] = useState(false);\n  const [error, setError] = useState<unknown>(undefined);\n  const [exchange, setExchange] = useState<FetchExchange | undefined>(\n    undefined,\n  );\n  const [result, setResult] = useState<R | undefined>(undefined);\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(async () => {\n    if (abortControllerRef.current) {\n      abortControllerRef.current.abort();\n    }\n    abortControllerRef.current =\n      request.abortController ?? new AbortController();\n    request.abortController = abortControllerRef.current;\n    if (isMounted()) {\n      setLoading(true);\n      setError(undefined);\n    }\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        setResult(result);\n      }\n    } catch (error) {\n      if (error instanceof Error && error.name === 'AbortError') {\n        return;\n      }\n      if (isMounted()) {\n        setError(error);\n      }\n    } finally {\n      if (isMounted()) {\n        setLoading(false);\n      }\n      if (abortControllerRef.current === request.abortController) {\n        abortControllerRef.current = undefined;\n      }\n    }\n  }, [currentFetcher, request, isMounted, options]);\n  /**\n   * Cancel the ongoing fetch operation if one is in progress.\n   */\n  const cancel = useCallback(() => {\n    abortControllerRef.current?.abort();\n  }, []);\n  useEffect(() => {\n    if (immediate) {\n      execute();\n    }\n    return () => {\n      abortControllerRef.current?.abort();\n      abortControllerRef.current = undefined;\n    };\n  }, [execute, request, immediate]);\n  return {\n    loading,\n    exchange,\n    result,\n    error,\n    execute,\n    cancel,\n  };\n}\n"],"names":["useKeyStorage","keyStorage","subscribe","useCallback","callback","getSnapshot","value","useSyncExternalStore","setValue","useMountedState","mountedRef","useRef","get","useEffect","useFetcher","request","options","fetcher","defaultFetcher","immediate","loading","setLoading","useState","error","setError","exchange","setExchange","result","setResult","isMounted","abortControllerRef","currentFetcher","getFetcher","execute","cancel"],"mappings":";;AAwBO,SAASA,EACdC,GACgC;AAChC,QAAMC,IAAYC;AAAA,IAChB,CAACC,MAAyBH,EAAW,YAAYG,CAAQ;AAAA,IACzD,CAACH,CAAU;AAAA,EAAA,GAEPI,IAAcF,EAAY,MAAMF,EAAW,OAAO,CAACA,CAAU,CAAC,GAC9DK,IAAQC,EAAqBL,GAAWG,GAAaA,CAAW,GAChEG,IAAWL;AAAA,IACf,CAACG,MAAaL,EAAW,IAAIK,CAAK;AAAA,IAClC,CAACL,CAAU;AAAA,EAAA;AAEb,SAAO,CAACK,GAAOE,CAAQ;AACzB;ACrCe,SAASC,IAAkB;AACtC,MAAIC,IAAaC,EAAO,EAAK,GACzBC,IAAMT,EAAY,WAAY;AAAE,WAAOO,EAAW;AAAA,EAAS,GAAG,EAAE;AACpE,SAAAG,EAAU,WAAY;AAClB,WAAAH,EAAW,UAAU,IACd,WAAY;AACf,MAAAA,EAAW,UAAU;AAAA,IACzB;AAAA,EACJ,GAAG,CAAA,CAAE,GACEE;AACX;ACoDO,SAASE,EACdC,GACAC,GACqB;AACrB,QAAM,EAAA,SAAEC,IAAUC,GAAgB,WAAAC,IAAY,GAAA,IAASH,KAAW,CAAA,GAC5D,CAACI,GAASC,CAAU,IAAIC,EAAS,EAAK,GACtC,CAACC,GAAOC,CAAQ,IAAIF,EAAkB,MAAS,GAC/C,CAACG,GAAUC,CAAW,IAAIJ;AAAA,IAC9B;AAAA,EAAA,GAEI,CAACK,GAAQC,CAAS,IAAIN,EAAwB,MAAS,GACvDO,IAAYpB,EAAA,GACZqB,IAAqBnB,EAAA,GAErBoB,IAAiBC,EAAWf,CAAO,GAKnCgB,IAAU9B,EAAY,YAAY;AACtC,IAAI2B,EAAmB,WACrBA,EAAmB,QAAQ,MAAA,GAE7BA,EAAmB,UACjBf,EAAQ,mBAAmB,IAAI,gBAAA,GACjCA,EAAQ,kBAAkBe,EAAmB,SACzCD,QACFR,EAAW,EAAI,GACfG,EAAS,MAAS;AAEpB,QAAI;AACF,YAAMC,IAAW,MAAMM,EAAe,SAAShB,GAASC,CAAO;AAC/D,MAAIa,OACFH,EAAYD,CAAQ;AAEtB,YAAME,IAAS,MAAMF,EAAS,cAAA;AAC9B,MAAII,OACFD,EAAUD,CAAM;AAAA,IAEpB,SAASJ,GAAO;AACd,UAAIA,aAAiB,SAASA,EAAM,SAAS;AAC3C;AAEF,MAAIM,OACFL,EAASD,CAAK;AAAA,IAElB,UAAA;AACE,MAAIM,OACFR,EAAW,EAAK,GAEdS,EAAmB,YAAYf,EAAQ,oBACzCe,EAAmB,UAAU;AAAA,IAEjC;AAAA,EACF,GAAG,CAACC,GAAgBhB,GAASc,GAAWb,CAAO,CAAC,GAI1CkB,IAAS/B,EAAY,MAAM;AAC/B,IAAA2B,EAAmB,SAAS,MAAA;AAAA,EAC9B,GAAG,CAAA,CAAE;AACL,SAAAjB,EAAU,OACJM,KACFc,EAAA,GAEK,MAAM;AACX,IAAAH,EAAmB,SAAS,MAAA,GAC5BA,EAAmB,UAAU;AAAA,EAC/B,IACC,CAACG,GAASlB,GAASI,CAAS,CAAC,GACzB;AAAA,IACL,SAAAC;AAAA,IACA,UAAAK;AAAA,IACA,QAAAE;AAAA,IACA,OAAAJ;AAAA,IACA,SAAAU;AAAA,IACA,QAAAC;AAAA,EAAA;AAEJ;","x_google_ignoreList":[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 */\nexport interface UseExecutePromiseReturn<R> extends PromiseState<R> {\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\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      state.setLoading();\n      try {\n        const promise = typeof input === 'function' ? input() : input;\n        const data = await promise;\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","input","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]}

package/dist/index.umd.js

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

package/dist/index.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.umd.js","sources":["../src/storage/useKeyStorage.ts","../../../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/fetcher/useFetcher.ts"],"sourcesContent":["/*\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","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 {\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';\n\n/**\n * Configuration options for the useFetcher hook.\n * Extends RequestOptions and FetcherCapable interfaces.\n */\nexport interface UseFetcherOptions extends RequestOptions, FetcherCapable {\n  /**\n   * Whether the fetch operation should execute immediately upon component mount.\n   * Defaults to true.\n   */\n  readonly immediate?: boolean;\n}\n\n/**\n * The result object returned by the useFetcher hook.\n * @template R - The type of the data returned by the fetch operation\n */\nexport interface UseFetcherResult<R> {\n  /** Indicates if the fetch operation is currently in progress */\n  loading: boolean;\n\n  /** The FetchExchange object representing the ongoing fetch operation */\n  exchange?: FetchExchange;\n\n  /** The data returned by the fetch operation, or undefined if not yet loaded or an error occurred */\n  result?: R;\n\n  /** Any error that occurred during the fetch operation, or undefined if no error */\n  error?: unknown;\n\n  /**\n   * Function to manually trigger the fetch operation.\n   * Useful for fetching data on demand rather than automatically.\n   */\n  execute: () => Promise<void>;\n\n  /** Function to cancel the ongoing fetch operation */\n  cancel: () => void;\n}\n\nexport function useFetcher<R>(\n  request: FetchRequest,\n  options?: UseFetcherOptions,\n): UseFetcherResult<R> {\n  const { fetcher = defaultFetcher, immediate = true } = options || {};\n  const [loading, setLoading] = useState(false);\n  const [error, setError] = useState<unknown>(undefined);\n  const [exchange, setExchange] = useState<FetchExchange | undefined>(\n    undefined,\n  );\n  const [result, setResult] = useState<R | undefined>(undefined);\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(async () => {\n    if (abortControllerRef.current) {\n      abortControllerRef.current.abort();\n    }\n    abortControllerRef.current =\n      request.abortController ?? new AbortController();\n    request.abortController = abortControllerRef.current;\n    if (isMounted()) {\n      setLoading(true);\n      setError(undefined);\n    }\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        setResult(result);\n      }\n    } catch (error) {\n      if (error instanceof Error && error.name === 'AbortError') {\n        return;\n      }\n      if (isMounted()) {\n        setError(error);\n      }\n    } finally {\n      if (isMounted()) {\n        setLoading(false);\n      }\n      if (abortControllerRef.current === request.abortController) {\n        abortControllerRef.current = undefined;\n      }\n    }\n  }, [currentFetcher, request, isMounted, options]);\n  /**\n   * Cancel the ongoing fetch operation if one is in progress.\n   */\n  const cancel = useCallback(() => {\n    abortControllerRef.current?.abort();\n  }, []);\n  useEffect(() => {\n    if (immediate) {\n      execute();\n    }\n    return () => {\n      abortControllerRef.current?.abort();\n      abortControllerRef.current = undefined;\n    };\n  }, [execute, request, immediate]);\n  return {\n    loading,\n    exchange,\n    result,\n    error,\n    execute,\n    cancel,\n  };\n}\n"],"names":["useKeyStorage","keyStorage","subscribe","useCallback","callback","getSnapshot","value","useSyncExternalStore","setValue","useMountedState","mountedRef","useRef","get","useEffect","useFetcher","request","options","fetcher","defaultFetcher","immediate","loading","setLoading","useState","error","setError","exchange","setExchange","result","setResult","isMounted","abortControllerRef","currentFetcher","getFetcher","execute","cancel"],"mappings":"uUAwBO,SAASA,EACdC,EACgC,CAChC,MAAMC,EAAYC,EAAAA,YACfC,GAAyBH,EAAW,YAAYG,CAAQ,EACzD,CAACH,CAAU,CAAA,EAEPI,EAAcF,EAAAA,YAAY,IAAMF,EAAW,MAAO,CAACA,CAAU,CAAC,EAC9DK,EAAQC,EAAAA,qBAAqBL,EAAWG,EAAaA,CAAW,EAChEG,EAAWL,EAAAA,YACdG,GAAaL,EAAW,IAAIK,CAAK,EAClC,CAACL,CAAU,CAAA,EAEb,MAAO,CAACK,EAAOE,CAAQ,CACzB,CCrCe,SAASC,GAAkB,CACtC,IAAIC,EAAaC,EAAAA,OAAO,EAAK,EACzBC,EAAMT,EAAAA,YAAY,UAAY,CAAE,OAAOO,EAAW,OAAS,EAAG,EAAE,EACpEG,OAAAA,EAAAA,UAAU,UAAY,CAClB,OAAAH,EAAW,QAAU,GACd,UAAY,CACfA,EAAW,QAAU,EACzB,CACJ,EAAG,CAAA,CAAE,EACEE,CACX,CCoDO,SAASE,EACdC,EACAC,EACqB,CACrB,KAAM,CAAA,QAAEC,EAAUC,EAAAA,QAAgB,UAAAC,EAAY,EAAA,EAASH,GAAW,CAAA,EAC5D,CAACI,EAASC,CAAU,EAAIC,EAAAA,SAAS,EAAK,EACtC,CAACC,EAAOC,CAAQ,EAAIF,EAAAA,SAAkB,MAAS,EAC/C,CAACG,EAAUC,CAAW,EAAIJ,EAAAA,SAC9B,MAAA,EAEI,CAACK,EAAQC,CAAS,EAAIN,EAAAA,SAAwB,MAAS,EACvDO,EAAYpB,EAAA,EACZqB,EAAqBnB,EAAAA,OAAA,EAErBoB,EAAiBC,EAAAA,WAAWf,CAAO,EAKnCgB,EAAU9B,EAAAA,YAAY,SAAY,CAClC2B,EAAmB,SACrBA,EAAmB,QAAQ,MAAA,EAE7BA,EAAmB,QACjBf,EAAQ,iBAAmB,IAAI,gBACjCA,EAAQ,gBAAkBe,EAAmB,QACzCD,MACFR,EAAW,EAAI,EACfG,EAAS,MAAS,GAEpB,GAAI,CACF,MAAMC,EAAW,MAAMM,EAAe,SAAShB,EAASC,CAAO,EAC3Da,KACFH,EAAYD,CAAQ,EAEtB,MAAME,EAAS,MAAMF,EAAS,cAAA,EAC1BI,KACFD,EAAUD,CAAM,CAEpB,OAASJ,EAAO,CACd,GAAIA,aAAiB,OAASA,EAAM,OAAS,aAC3C,OAEEM,KACFL,EAASD,CAAK,CAElB,QAAA,CACMM,KACFR,EAAW,EAAK,EAEdS,EAAmB,UAAYf,EAAQ,kBACzCe,EAAmB,QAAU,OAEjC,CACF,EAAG,CAACC,EAAgBhB,EAASc,EAAWb,CAAO,CAAC,EAI1CkB,EAAS/B,EAAAA,YAAY,IAAM,CAC/B2B,EAAmB,SAAS,MAAA,CAC9B,EAAG,CAAA,CAAE,EACLjB,OAAAA,EAAAA,UAAU,KACJM,GACFc,EAAA,EAEK,IAAM,CACXH,EAAmB,SAAS,MAAA,EAC5BA,EAAmB,QAAU,MAC/B,GACC,CAACG,EAASlB,EAASI,CAAS,CAAC,EACzB,CACL,QAAAC,EACA,SAAAK,EACA,OAAAE,EACA,MAAAJ,EACA,QAAAU,EACA,OAAAC,CAAA,CAEJ","x_google_ignoreList":[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 */\nexport interface UseExecutePromiseReturn<R> extends PromiseState<R> {\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\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      state.setLoading();\n      try {\n        const promise = typeof input === 'function' ? input() : input;\n        const data = await promise;\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","input","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]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ahoo-wang/fetcher-react",
-  "version": "2.5.5",
+  "version": "2.5.8",
   "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",
@@ -44,6 +44,7 @@
   "peerDependencies": {
     "@ahoo-wang/fetcher": "^2.3.4",
     "@ahoo-wang/fetcher-storage": "^2.3.4",
+    "@ahoo-wang/fetcher-wow": "^2.3.4",
     "react": ">=16.8.0",
     "react-dom": ">=16.8.0"
   },