@intlayer/design-system 2.0.13 → 3.0.1

package/dist/hooks/useAsync/useAsync.d.ts

@@ -0,0 +1,93 @@
+type UseAsyncResultBase<T extends (...args: any[]) => Promise<any>> = {
+    isFetched: boolean;
+    isLoading: boolean;
+    isInvalidated: boolean;
+    isSuccess: boolean;
+    isDisabled: boolean;
+    error: string | null;
+    data: Awaited<ReturnType<T>> | null;
+    retryCount: number;
+    revalidate: T;
+    setData: (data: Awaited<ReturnType<T> | null>) => void;
+};
+export type UseAsyncOptions<T extends (...args: any[]) => Promise<any>> = {
+    retryLimit?: number;
+    retryTime?: number;
+    cache?: boolean;
+    store?: boolean;
+    enable?: boolean;
+    autoFetch?: boolean;
+    revalidation?: boolean;
+    revalidateTime?: number;
+    isInvalidated?: boolean;
+    invalidateQueries?: string[];
+    updateQueries?: string[];
+    onSuccess?: (data: Awaited<ReturnType<T>>) => void;
+    onError?: (error: string) => void;
+    args?: Parameters<T>;
+};
+export type UseAsyncResult<U extends string, T extends (...args: any[]) => Promise<any>> = UseAsyncResultBase<T> & Record<U, T>;
+/**
+ * A custom React hook that manages asynchronous operations, providing easy-to-use states and controls over fetching, caching, and retry mechanisms.
+ * This hook abstracts away the complexity of handling loading, error, and success states for any asynchronous function.
+ *
+ * @template U - A string type that extends the keys of the async function, used as a key to store and retrieve state.
+ * @template T - A function type that must return a Promise, representing the asynchronous operation to be managed.
+ *
+ * @param {U} key - A unique identifier for the async operation, used to handle state internally and avoid conflicts.
+ * @param {T} asyncFunction - The asynchronous function that will be managed by this hook. This function should return a Promise.
+ * @param {UseAsyncOptions<T>} [options] - Optional configuration options to customize the behavior of the hook.
+ * @returns {UseAsyncResult<U, T>} The states and controls related to the managed async function. Includes states like isLoading, isSuccess, and provides control methods like revalidate and setData.
+ *
+ * @typedef {Object} UseAsyncOptions
+ * @property {number} [retryTime=300000] - Time in milliseconds for retrying the data after an error occurs.
+ * @property {number} [retryLimit=1] - The number of times the hook should retry the asynchronous function on failure before giving up.
+ * @property {boolean} [revalidation=false] - Enable revalidation.
+ * @property {number} [revalidateTime=300000] - Time in milliseconds after which the cached data is considered stale and the async function is re-invoked, if caching is enabled.
+ * @property {boolean} [cache=false] - Whether to cache the result of the async function. When enabled, revalidation is controlled by `revalidateTime`.
+ * @property {boolean} [store=false] - Store the result of the function in session storage.
+ * @property {boolean} [autoFetch=false] - Whether the hook should automatically invoke the asynchronous function on mount.
+ * @property {number} [revalidateTime=300000] - Time in milliseconds after which the cached data is considered stale and the async function is re-invoked, if caching is enabled.
+ * @property {boolean} [isInvalidated=false] - Determine if the data is invalidated and should be refetched.
+ * @property {string[]} [updateQueries=[]] - Update other queries when the data is updated.
+ * @property {string[]} [invalidateQueries=[]] - Invalidate other queries when the data is updated.
+ * @property {(data: Awaited<ReturnType<T>>) => void} [onSuccess] - Callback function that is called when the asynchronous function resolves successfully.
+ * @property {(error: string) => void} [onError] - Callback function that is called when the asynchronous function rejects or encounters an error.
+ * @property {Parameters<T>} [args=[]] - Arguments to pass to the asynchronous function.
+ *
+ *
+ * @example
+ * // Example of using useAsync to manage fetching user data from an API.
+ * const fetchUserData = async (userId) => {
+ *   const response = await fetch(`/api/users/${userId}`);
+ *   if (!response.ok) throw new Error('Failed to fetch');
+ *   return await response.json();
+ * };
+ *
+ * const UserDetails = ({ userId }) => {
+ *   const {
+ *     isLoading,
+ *     data,
+ *     error,
+ *     revalidate,
+ *   } = useAsync('userDetails', fetchUserData, {
+ *     cache: true,
+ *     revalidateTime: 60000, // 1 minute
+ *     autoFetch: true,
+ *     onSuccess: (data) => console.log('User data fetched successfully:', data),
+ *     onError: (error) => console.error('Error fetching user data:', error),
+ *   });
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *   return (
+ *     <div>
+ *       <h1>{data.name}</h1>
+ *       <button onClick={() => revalidate()}>Refresh</button>
+ *     </div>
+ *   );
+ * };
+ */
+export declare const useAsync: <U extends string, T extends (...args: any[]) => Promise<any>>(key: U, asyncFunction: T, options?: UseAsyncOptions<T>) => UseAsyncResult<U, T>;
+export {};
+//# sourceMappingURL=useAsync.d.ts.map

package/dist/hooks/useAsync/useAsync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAsync.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAsync/useAsync.ts"],"names":[],"mappings":"AAaA,KAAK,kBAAkB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,IAAI;IACpE,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,CAAC,CAAC;IACd,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,IAAI,CAAC;CACxD,CAAC;AAGF,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,IAAI;IACxE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IACnD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,IAAI,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;CACtB,CAAC;AAaF,MAAM,MAAM,cAAc,CACxB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,IACxC,kBAAkB,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAKzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,eAAO,MAAM,QAAQ,GACnB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,OAErC,CAAC,iBACS,CAAC,YACN,eAAe,CAAC,CAAC,CAAC,KAC3B,cAAc,CAAC,CAAC,EAAE,CAAC,CAuRrB,CAAC"}

package/dist/hooks/useAsync/useAsync.mjs

@@ -0,0 +1,275 @@
+"use client";
+import require$$0, { useRef as useRef$1, useCallback, useEffect } from "react";
+import { useAsyncStateStore } from "./useAsyncStateStore.mjs";
+function shallow(objA, objB) {
+  if (Object.is(objA, objB)) {
+    return true;
+  }
+  if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
+    return false;
+  }
+  if (objA instanceof Map && objB instanceof Map) {
+    if (objA.size !== objB.size) return false;
+    for (const [key, value] of objA) {
+      if (!Object.is(value, objB.get(key))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (objA instanceof Set && objB instanceof Set) {
+    if (objA.size !== objB.size) return false;
+    for (const value of objA) {
+      if (!objB.has(value)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  const keysA = Object.keys(objA);
+  if (keysA.length !== Object.keys(objB).length) {
+    return false;
+  }
+  for (const keyA of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(objB, keyA) || !Object.is(objA[keyA], objB[keyA])) {
+      return false;
+    }
+  }
+  return true;
+}
+const { useRef } = require$$0;
+function useShallow(selector) {
+  const prev = useRef();
+  return (state) => {
+    const next = selector(state);
+    return shallow(prev.current, next) ? prev.current : prev.current = next;
+  };
+}
+const pendingPromises = /* @__PURE__ */ new Map();
+const DEFAULT_CACHE_ENABLED = false;
+const DEFAULT_STORE_ENABLED = false;
+const DEFAULT_ENABLED = true;
+const DEFAULT_AUTO_FETCH = false;
+const DEFAULT_RETRY_LIMIT = 1;
+const DEFAULT_REVALIDATION_ENABLED = false;
+const DEFAULT_REVALIDATE_TIME = 5 * 60 * 1e3;
+const DEFAULT_RETRY_TIME = 5 * 60 * 1e3;
+const getKeyWithArgs = (key, args) => args.length > 0 ? `${key}/${JSON.stringify(args)}` : key;
+const useAsync = (key, asyncFunction, options) => {
+  const retryLimit = options?.retryLimit ?? DEFAULT_RETRY_LIMIT;
+  const autoFetch = options?.autoFetch ?? DEFAULT_AUTO_FETCH;
+  const retryTime = options?.retryTime ?? DEFAULT_RETRY_TIME;
+  const cacheEnabled = options?.cache ?? DEFAULT_CACHE_ENABLED;
+  const storeEnabled = options?.store ?? DEFAULT_STORE_ENABLED;
+  const enabled = options?.enable ?? DEFAULT_ENABLED;
+  const revalidationEnabled = options?.revalidation ?? DEFAULT_REVALIDATION_ENABLED;
+  const revalidateTime = options?.revalidateTime ?? DEFAULT_REVALIDATE_TIME;
+  const isInvalidatedProps = options?.isInvalidated ?? false;
+  const updateQueries = options?.updateQueries ?? [];
+  const invalidateQueries = options?.invalidateQueries ?? [];
+  const onSuccess = options?.onSuccess;
+  const onError = options?.onError;
+  const args = options?.args ?? [];
+  const {
+    setIsFetched,
+    setIsLoading,
+    setError,
+    setIsSuccess,
+    setData,
+    setIsInvalidated,
+    setIsEnabled,
+    incrementRetryCount,
+    resetRetryCount
+  } = useAsyncStateStore(
+    useShallow((state) => ({
+      setIsFetched: state.setIsFetched,
+      setIsLoading: state.setIsLoading,
+      setError: state.setError,
+      setIsSuccess: state.setIsSuccess,
+      setIsInvalidated: state.setIsInvalidated,
+      setIsEnabled: state.setIsEnabled,
+      setData: state.setData,
+      incrementRetryCount: state.incrementRetryCount,
+      resetRetryCount: state.resetRetryCount
+    }))
+  );
+  const storedArgsRef = useRef$1(args ?? []);
+  const keyWithArgs = getKeyWithArgs(key, storedArgsRef.current);
+  const {
+    isFetched,
+    fetchedDateTime,
+    isLoading,
+    isEnabled: isEnabledState,
+    error,
+    isSuccess,
+    isInvalidated,
+    data,
+    retryCount: errorCount
+  } = useAsyncStateStore((state) => state.getStates(keyWithArgs));
+  const isEnabled = isEnabledState || enabled;
+  const isDisabled = !isEnabled;
+  const fetch = useCallback(
+    async (...args2) => {
+      const keyWithArgs2 = getKeyWithArgs(key, args2);
+      if (pendingPromises.has(keyWithArgs2)) {
+        return pendingPromises.get(keyWithArgs2);
+      }
+      const promise = (async () => {
+        setIsLoading(keyWithArgs2, true);
+        let response = null;
+        let errorResponse = null;
+        await asyncFunction(...args2).then((result) => {
+          const isResultChanged = JSON.stringify(result) !== JSON.stringify(data);
+          response = result;
+          if (isResultChanged) {
+            setData(keyWithArgs2, result);
+          }
+          setIsSuccess(keyWithArgs2, true);
+          onSuccess?.(result);
+          resetRetryCount(keyWithArgs2);
+          if (storeEnabled) {
+            sessionStorage.setItem(keyWithArgs2, JSON.stringify(result));
+          }
+          if (isResultChanged && updateQueries.length > 0) {
+            updateQueries.forEach((key2) => {
+              setData(key2, result);
+            });
+          }
+          if (isResultChanged && invalidateQueries.length > 0) {
+            invalidateQueries.forEach((key2) => {
+              setIsInvalidated(key2, true);
+            });
+          }
+        }).catch((error2) => {
+          const errorMessage = error2.message ?? "An error occurred";
+          setData(keyWithArgs2, null);
+          setError(keyWithArgs2, errorMessage);
+          incrementRetryCount(keyWithArgs2);
+          onError?.(errorMessage);
+          errorResponse = error2;
+        }).finally(() => {
+          setIsLoading(keyWithArgs2, false);
+          setIsFetched(keyWithArgs2, true);
+          setIsInvalidated(keyWithArgs2, false);
+          pendingPromises.delete(keyWithArgs2);
+        });
+        if (errorResponse) {
+          throw new Error(errorResponse);
+        }
+        return response;
+      })();
+      pendingPromises.set(keyWithArgs2, promise);
+    },
+    [asyncFunction, keyWithArgs]
+  );
+  const execute = useCallback(
+    async (...args2) => {
+      if (isDisabled) return;
+      if (isLoading) return;
+      if (isSuccess && cacheEnabled && data) return data;
+      if (args2) {
+        storedArgsRef.current = args2;
+      }
+      await fetch(...args2);
+    },
+    [isDisabled, cacheEnabled, isSuccess, data, isLoading]
+  );
+  const revalidate = useCallback(
+    async (...args2) => {
+      if (isDisabled) return;
+      if (isSuccess) return;
+      if (isLoading) return;
+      if (args2) {
+        storedArgsRef.current = args2;
+      }
+      await fetch(...storedArgsRef.current);
+    },
+    [isDisabled, storedArgsRef, isSuccess, isLoading]
+  );
+  const autoRevalidate = useCallback(() => {
+    if (isDisabled) return;
+    if (isLoading || !(cacheEnabled || storeEnabled)) return;
+    if (!revalidationEnabled || revalidateTime <= 0 || !isSuccess) return;
+    if (!fetchedDateTime) return;
+    const now = (/* @__PURE__ */ new Date()).getTime();
+    const lastFetchedTime = new Date(fetchedDateTime).getTime();
+    const shouldRevalidate = now - lastFetchedTime >= revalidateTime;
+    if (shouldRevalidate) {
+      fetch(...storedArgsRef.current);
+    }
+  }, [
+    cacheEnabled,
+    revalidationEnabled,
+    revalidateTime,
+    isSuccess,
+    fetchedDateTime,
+    isLoading,
+    isDisabled
+  ]);
+  useEffect(() => {
+    setIsEnabled(keyWithArgs, enabled);
+  }, [enabled]);
+  useEffect(() => {
+    if (!autoFetch) return;
+    if (isDisabled) return;
+    if (isFetched || isLoading) return;
+    fetch(...storedArgsRef.current);
+  }, [autoFetch, isFetched, isDisabled, isLoading]);
+  useEffect(() => {
+    const isRetryEnabled = errorCount > 0 && retryLimit > 0;
+    const isRetryLimitReached = errorCount >= retryLimit;
+    if (isDisabled) return;
+    if (!(cacheEnabled || storeEnabled)) return;
+    if (!isRetryEnabled || isRetryLimitReached) return;
+    if (isSuccess) return;
+    if (isLoading) return;
+    const timeOut = setTimeout(() => {
+      if (isRetryEnabled && !isRetryLimitReached && !isSuccess) {
+        execute(...storedArgsRef.current);
+      }
+    }, retryTime);
+    return () => clearTimeout(timeOut);
+  }, [execute, errorCount, retryLimit, retryTime, isSuccess]);
+  useEffect(() => {
+    const interval = setInterval(autoRevalidate, revalidateTime);
+    return () => clearInterval(interval);
+  }, [autoRevalidate, revalidateTime]);
+  useEffect(() => {
+    if (isDisabled) return;
+    if (!storeEnabled) return;
+    if (isInvalidated) return;
+    if (isFetched) return;
+    const storedData = sessionStorage.getItem(keyWithArgs);
+    if (storedData) {
+      setData(keyWithArgs, JSON.parse(storedData));
+    }
+  }, [storeEnabled, keyWithArgs, isFetched, isInvalidated, isDisabled]);
+  useEffect(() => {
+    if (!isInvalidatedProps) return;
+    setIsInvalidated(keyWithArgs, isInvalidatedProps);
+  }, [isInvalidatedProps]);
+  const setDataMemo = useCallback(
+    (data2) => {
+      setData(keyWithArgs, data2);
+    },
+    [keyWithArgs]
+  );
+  return {
+    isFetched,
+    isLoading,
+    isInvalidated,
+    error,
+    isSuccess,
+    data,
+    retryCount: errorCount,
+    isDisabled,
+    isEnabled,
+    [key]: execute,
+    revalidate,
+    setData: setDataMemo
+  };
+};
+export {
+  useAsync
+};
+//# sourceMappingURL=useAsync.mjs.map

package/dist/hooks/useAsync/useAsync.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAsync.mjs","sources":["../../../../../../node_modules/.pnpm/zustand@4.5.5_@types+react@18.3.11_react@18.3.1/node_modules/zustand/esm/react/shallow.mjs","../../../src/hooks/useAsync/useAsync.ts"],"sourcesContent":["import ReactExports from 'react';\n\nfunction shallow(objA, objB) {\n  if (Object.is(objA, objB)) {\n    return true;\n  }\n  if (typeof objA !== \"object\" || objA === null || typeof objB !== \"object\" || objB === null) {\n    return false;\n  }\n  if (objA instanceof Map && objB instanceof Map) {\n    if (objA.size !== objB.size) return false;\n    for (const [key, value] of objA) {\n      if (!Object.is(value, objB.get(key))) {\n        return false;\n      }\n    }\n    return true;\n  }\n  if (objA instanceof Set && objB instanceof Set) {\n    if (objA.size !== objB.size) return false;\n    for (const value of objA) {\n      if (!objB.has(value)) {\n        return false;\n      }\n    }\n    return true;\n  }\n  const keysA = Object.keys(objA);\n  if (keysA.length !== Object.keys(objB).length) {\n    return false;\n  }\n  for (const keyA of keysA) {\n    if (!Object.prototype.hasOwnProperty.call(objB, keyA) || !Object.is(objA[keyA], objB[keyA])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nconst { useRef } = ReactExports;\nfunction useShallow(selector) {\n  const prev = useRef();\n  return (state) => {\n    const next = selector(state);\n    return shallow(prev.current, next) ? prev.current : prev.current = next;\n  };\n}\n\nexport { useShallow };\n","'use client';\n\n// This is an ESLint directive to disable specific rules.\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport { useCallback, useEffect, useRef } from 'react';\nimport { useShallow } from 'zustand/react/shallow';\nimport { useAsyncStateStore } from './useAsyncStateStore';\n\n// Pending promises cache to prevent parallel requests when multiple components use the hook\nconst pendingPromises = new Map();\n\n// Defines the base structure for the result of the custom hook.\ntype UseAsyncResultBase<T extends (...args: any[]) => Promise<any>> = {\n  isFetched: boolean;\n  isLoading: boolean;\n  isInvalidated: boolean;\n  isSuccess: boolean;\n  isDisabled: boolean;\n  error: string | null;\n  data: Awaited<ReturnType<T>> | null;\n  retryCount: number;\n  revalidate: T;\n  setData: (data: Awaited<ReturnType<T> | null>) => void;\n};\n\n// Options type for the hook, allowing customization of behavior.\nexport type UseAsyncOptions<T extends (...args: any[]) => Promise<any>> = {\n  retryLimit?: number; // The number of times the hook should retry the function on failure before giving up\n  retryTime?: number; // Time in milliseconds for retrying the data\n  cache?: boolean; // Cache the result of the function using zustand\n  store?: boolean; // Store the result of the function in session storage\n  enable?: boolean; // Enable the hook\n  autoFetch?: boolean; // Automatically fetch the data when the hook is mounted\n  revalidation?: boolean; // Enable revalidation\n  revalidateTime?: number; // Time in milliseconds for revalidating the data\n  isInvalidated?: boolean; // Determine if the data is invalidated and should be refetched\n  invalidateQueries?: string[]; // Invalidate other queries when the data is updated\n  updateQueries?: string[]; // Update other queries when the data is updated\n  onSuccess?: (data: Awaited<ReturnType<T>>) => void; // Callback function that is called when the asynchronous function resolves successfully\n  onError?: (error: string) => void; // Callback function that is called when the asynchronous function rejects or encounters an error\n  args?: Parameters<T>; // Arguments to pass to the asynchronous function\n};\n\n// Default values for the hook's options\nconst DEFAULT_CACHE_ENABLED = false;\nconst DEFAULT_STORE_ENABLED = false;\nconst DEFAULT_ENABLED = true;\nconst DEFAULT_AUTO_FETCH = false;\nconst DEFAULT_RETRY_LIMIT = 1;\nconst DEFAULT_REVALIDATION_ENABLED = false;\nconst DEFAULT_REVALIDATE_TIME = 5 * 60 * 1000; // 5 minutes\nconst DEFAULT_RETRY_TIME = 5 * 60 * 1000; // 5 minutes\n\n// The main hook type that includes the async function along with its additional properties.\nexport type UseAsyncResult<\n  U extends string,\n  T extends (...args: any[]) => Promise<any>,\n> = UseAsyncResultBase<T> & Record<U, T>;\n\nconst getKeyWithArgs = (key: string, args: any[]) =>\n  args.length > 0 ? `${key}/${JSON.stringify(args)}` : key;\n\n/**\n * A custom React hook that manages asynchronous operations, providing easy-to-use states and controls over fetching, caching, and retry mechanisms.\n * This hook abstracts away the complexity of handling loading, error, and success states for any asynchronous function.\n *\n * @template U - A string type that extends the keys of the async function, used as a key to store and retrieve state.\n * @template T - A function type that must return a Promise, representing the asynchronous operation to be managed.\n *\n * @param {U} key - A unique identifier for the async operation, used to handle state internally and avoid conflicts.\n * @param {T} asyncFunction - The asynchronous function that will be managed by this hook. This function should return a Promise.\n * @param {UseAsyncOptions<T>} [options] - Optional configuration options to customize the behavior of the hook.\n * @returns {UseAsyncResult<U, T>} The states and controls related to the managed async function. Includes states like isLoading, isSuccess, and provides control methods like revalidate and setData.\n *\n * @typedef {Object} UseAsyncOptions\n * @property {number} [retryTime=300000] - Time in milliseconds for retrying the data after an error occurs.\n * @property {number} [retryLimit=1] - The number of times the hook should retry the asynchronous function on failure before giving up.\n * @property {boolean} [revalidation=false] - Enable revalidation.\n * @property {number} [revalidateTime=300000] - Time in milliseconds after which the cached data is considered stale and the async function is re-invoked, if caching is enabled.\n * @property {boolean} [cache=false] - Whether to cache the result of the async function. When enabled, revalidation is controlled by `revalidateTime`.\n * @property {boolean} [store=false] - Store the result of the function in session storage.\n * @property {boolean} [autoFetch=false] - Whether the hook should automatically invoke the asynchronous function on mount.\n * @property {number} [revalidateTime=300000] - Time in milliseconds after which the cached data is considered stale and the async function is re-invoked, if caching is enabled.\n * @property {boolean} [isInvalidated=false] - Determine if the data is invalidated and should be refetched.\n * @property {string[]} [updateQueries=[]] - Update other queries when the data is updated.\n * @property {string[]} [invalidateQueries=[]] - Invalidate other queries when the data is updated.\n * @property {(data: Awaited<ReturnType<T>>) => void} [onSuccess] - Callback function that is called when the asynchronous function resolves successfully.\n * @property {(error: string) => void} [onError] - Callback function that is called when the asynchronous function rejects or encounters an error.\n * @property {Parameters<T>} [args=[]] - Arguments to pass to the asynchronous function.\n *\n *\n * @example\n * // Example of using useAsync to manage fetching user data from an API.\n * const fetchUserData = async (userId) => {\n *   const response = await fetch(`/api/users/${userId}`);\n *   if (!response.ok) throw new Error('Failed to fetch');\n *   return await response.json();\n * };\n *\n * const UserDetails = ({ userId }) => {\n *   const {\n *     isLoading,\n *     data,\n *     error,\n *     revalidate,\n *   } = useAsync('userDetails', fetchUserData, {\n *     cache: true,\n *     revalidateTime: 60000, // 1 minute\n *     autoFetch: true,\n *     onSuccess: (data) => console.log('User data fetched successfully:', data),\n *     onError: (error) => console.error('Error fetching user data:', error),\n *   });\n *\n *   if (isLoading) return <div>Loading...</div>;\n *   if (error) return <div>Error: {error}</div>;\n *   return (\n *     <div>\n *       <h1>{data.name}</h1>\n *       <button onClick={() => revalidate()}>Refresh</button>\n *     </div>\n *   );\n * };\n */\nexport const useAsync = <\n  U extends string,\n  T extends (...args: any[]) => Promise<any>,\n>(\n  key: U,\n  asyncFunction: T,\n  options?: UseAsyncOptions<T>\n): UseAsyncResult<U, T> => {\n  // Resolving optional parameters with default values\n  const retryLimit = options?.retryLimit ?? DEFAULT_RETRY_LIMIT;\n  const autoFetch = options?.autoFetch ?? DEFAULT_AUTO_FETCH;\n  const retryTime = options?.retryTime ?? DEFAULT_RETRY_TIME;\n  const cacheEnabled = options?.cache ?? DEFAULT_CACHE_ENABLED;\n  const storeEnabled = options?.store ?? DEFAULT_STORE_ENABLED;\n  const enabled = options?.enable ?? DEFAULT_ENABLED;\n  const revalidationEnabled =\n    options?.revalidation ?? DEFAULT_REVALIDATION_ENABLED;\n  const revalidateTime = options?.revalidateTime ?? DEFAULT_REVALIDATE_TIME;\n  const isInvalidatedProps = options?.isInvalidated ?? false;\n  const updateQueries = options?.updateQueries ?? [];\n  const invalidateQueries = options?.invalidateQueries ?? [];\n  const onSuccess = options?.onSuccess;\n  const onError = options?.onError;\n  const args = options?.args ?? [];\n\n  // Using a custom hook to manage state specific to asynchronous operations\n  const {\n    setIsFetched,\n    setIsLoading,\n    setError,\n    setIsSuccess,\n    setData,\n    setIsInvalidated,\n    setIsEnabled,\n    incrementRetryCount,\n    resetRetryCount,\n  } = useAsyncStateStore(\n    useShallow((state) => ({\n      setIsFetched: state.setIsFetched,\n      setIsLoading: state.setIsLoading,\n      setError: state.setError,\n      setIsSuccess: state.setIsSuccess,\n      setIsInvalidated: state.setIsInvalidated,\n      setIsEnabled: state.setIsEnabled,\n      setData: state.setData,\n      incrementRetryCount: state.incrementRetryCount,\n      resetRetryCount: state.resetRetryCount,\n    }))\n  );\n\n  // Storing the last arguments used to call the async function\n  const storedArgsRef = useRef<any>(args ?? []);\n\n  // Apply different key for different requests\n  const keyWithArgs = getKeyWithArgs(key, storedArgsRef.current);\n\n  // Retrieving the current state of async operations using the same custom hook\n  const {\n    isFetched,\n    fetchedDateTime,\n    isLoading,\n    isEnabled: isEnabledState,\n    error,\n    isSuccess,\n    isInvalidated,\n    data,\n    retryCount: errorCount,\n  } = useAsyncStateStore((state) => state.getStates(keyWithArgs));\n\n  const isEnabled = isEnabledState || enabled;\n  const isDisabled = !isEnabled;\n\n  // The core fetching function, designed to be called directly or automatically based on configuration\n  const fetch: T = useCallback<T>(\n    (async (...args) => {\n      const keyWithArgs = getKeyWithArgs(key, args);\n\n      if (pendingPromises.has(keyWithArgs)) {\n        // Return the existing pending promise\n        return pendingPromises.get(keyWithArgs);\n      }\n\n      const promise = (async () => {\n        setIsLoading(keyWithArgs, true);\n        let response = null;\n        let errorResponse = null;\n\n        await asyncFunction(...args)\n          .then((result) => {\n            const isResultChanged =\n              JSON.stringify(result) !== JSON.stringify(data);\n\n            response = result;\n            if (isResultChanged) {\n              setData(keyWithArgs, result);\n            }\n            setIsSuccess(keyWithArgs, true);\n            onSuccess?.(result);\n            resetRetryCount(keyWithArgs);\n\n            // Store the result in session storage\n            if (storeEnabled) {\n              sessionStorage.setItem(keyWithArgs, JSON.stringify(result));\n            }\n\n            // Update other queries if necessary\n            if (isResultChanged && updateQueries.length > 0) {\n              updateQueries.forEach((key) => {\n                setData(key, result);\n              });\n            }\n\n            // Invalidate other queries if necessary\n            if (isResultChanged && invalidateQueries.length > 0) {\n              invalidateQueries.forEach((key) => {\n                setIsInvalidated(key, true);\n              });\n            }\n          })\n          .catch((error) => {\n            const errorMessage = error.message ?? 'An error occurred';\n\n            setData(keyWithArgs, null);\n            setError(keyWithArgs, errorMessage);\n            incrementRetryCount(keyWithArgs);\n            onError?.(errorMessage);\n            errorResponse = error;\n          })\n          .finally(() => {\n            setIsLoading(keyWithArgs, false);\n            setIsFetched(keyWithArgs, true);\n            setIsInvalidated(keyWithArgs, false);\n\n            // Remove the pending promise from the cache\n            pendingPromises.delete(keyWithArgs);\n          });\n\n        if (errorResponse) {\n          throw new Error(errorResponse);\n        }\n\n        return response;\n      })();\n\n      // Store the pending promise in the cache\n      pendingPromises.set(keyWithArgs, promise);\n    }) as T,\n    [asyncFunction, keyWithArgs]\n  );\n\n  // Wrapped execution function to handle disabled state and check for success before re-fetching\n  const execute: T = useCallback<T>(\n    (async (...args) => {\n      if (isDisabled) return;\n      if (isLoading) return;\n      if (isSuccess && cacheEnabled && data) return data;\n\n      if (args) {\n        storedArgsRef.current = args;\n      }\n\n      await fetch(...args);\n    }) as T,\n    [isDisabled, cacheEnabled, isSuccess, data, isLoading]\n  );\n\n  // Function to revalidate the data when necessary\n  const revalidate: T = useCallback<T>(\n    (async (...args) => {\n      if (isDisabled) return;\n      if (isSuccess) return;\n      if (isLoading) return;\n\n      if (args) {\n        storedArgsRef.current = args;\n      }\n\n      await fetch(...storedArgsRef.current);\n    }) as T,\n    [isDisabled, storedArgsRef, isSuccess, isLoading]\n  );\n\n  const autoRevalidate = useCallback(() => {\n    if (isDisabled) return;\n    if (isLoading || !(cacheEnabled || storeEnabled)) return;\n    if (!revalidationEnabled || revalidateTime <= 0 || !isSuccess) return;\n    if (!fetchedDateTime) return;\n\n    const now = new Date().getTime();\n    const lastFetchedTime = new Date(fetchedDateTime).getTime();\n    const shouldRevalidate = now - lastFetchedTime >= revalidateTime;\n    if (shouldRevalidate) {\n      fetch(...storedArgsRef.current);\n    }\n  }, [\n    cacheEnabled,\n    revalidationEnabled,\n    revalidateTime,\n    isSuccess,\n    fetchedDateTime,\n    isLoading,\n    isDisabled,\n  ]);\n\n  useEffect(() => {\n    setIsEnabled(keyWithArgs, enabled);\n  }, [enabled]);\n\n  // Auto-fetch data on hook mount if autoFetch is true\n  useEffect(() => {\n    if (!autoFetch) return;\n    if (isDisabled) return;\n    if (isFetched || isLoading) return;\n\n    fetch(...storedArgsRef.current);\n  }, [autoFetch, isFetched, isDisabled, isLoading]);\n\n  // Handle retry based on conditions set in options\n  useEffect(() => {\n    const isRetryEnabled = errorCount > 0 && retryLimit > 0;\n    const isRetryLimitReached = errorCount >= retryLimit;\n    if (isDisabled) return;\n    if (!(cacheEnabled || storeEnabled)) return;\n    if (!isRetryEnabled || isRetryLimitReached) return;\n    if (isSuccess) return;\n    if (isLoading) return;\n\n    const timeOut = setTimeout(() => {\n      if (isRetryEnabled && !isRetryLimitReached && !isSuccess) {\n        execute(...storedArgsRef.current);\n      }\n    }, retryTime);\n\n    return () => clearTimeout(timeOut);\n  }, [execute, errorCount, retryLimit, retryTime, isSuccess]);\n\n  // Handle periodic revalidation if caching is enabled\n  useEffect(() => {\n    const interval = setInterval(autoRevalidate, revalidateTime);\n\n    return () => clearInterval(interval);\n  }, [autoRevalidate, revalidateTime]);\n\n  // Load data from session storage if storeEnabled is true\n  useEffect(() => {\n    if (isDisabled) return;\n    if (!storeEnabled) return;\n    if (isInvalidated) return;\n    if (isFetched) return;\n\n    const storedData = sessionStorage.getItem(keyWithArgs);\n\n    if (storedData) {\n      setData(keyWithArgs, JSON.parse(storedData));\n    }\n  }, [storeEnabled, keyWithArgs, isFetched, isInvalidated, isDisabled]);\n\n  // Handle invalidation if props are changed\n  useEffect(() => {\n    if (!isInvalidatedProps) return;\n    setIsInvalidated(keyWithArgs, isInvalidatedProps);\n  }, [isInvalidatedProps]);\n\n  // Memoization of the setData function to prevent unnecessary re-renders\n  const setDataMemo = useCallback(\n    (data: Awaited<ReturnType<T> | null>) => {\n      setData(keyWithArgs, data);\n    },\n    [keyWithArgs]\n  );\n\n  // Return the hook's result, including all state and control functions\n  return {\n    isFetched,\n    isLoading,\n    isInvalidated,\n    error,\n    isSuccess,\n    data,\n    retryCount: errorCount,\n    isDisabled,\n    isEnabled,\n    [key]: execute,\n    revalidate,\n    setData: setDataMemo,\n  } as UseAsyncResultBase<T> & Record<U, T>;\n};\n"],"names":["ReactExports","useRef","args","keyWithArgs","key","error","data"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/hooks/useAsync/useAsyncStateStore.cjs

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const zustand = require("zustand");
+const createDefaultStates = () => ({
+  isFetched: false,
+  fetchedDateTime: null,
+  isLoading: false,
+  isInvalidated: false,
+  error: null,
+  isSuccess: false,
+  data: null,
+  retryCount: 0,
+  isEnabled: true
+});
+const ensureArray = (value) => {
+  if (!value) {
+    return [];
+  } else if (Array.isArray(value)) {
+    return value;
+  }
+  return [value];
+};
+const getMatchKeys = (selectorsKeys, keysWithArgs) => {
+  const matchedKeys = keysWithArgs.filter(
+    (key) => selectorsKeys.includes(key.split("/")[0])
+  );
+  return matchedKeys;
+};
+const useAsyncStateStore = zustand.create((set, get) => ({
+  states: {},
+  getStates: (key) => get().states[key] ?? createDefaultStates(),
+  setIsFetched: (key, value) => set((state) => ({
+    states: {
+      ...state.states,
+      [key]: {
+        ...state.states[key] ?? createDefaultStates(),
+        isFetched: value,
+        fetchedDateTime: /* @__PURE__ */ new Date()
+      }
+    }
+  })),
+  setIsLoading: (key, value) => set((state) => ({
+    states: {
+      ...state.states,
+      [key]: {
+        ...state.states[key] ?? createDefaultStates(),
+        isLoading: value
+      }
+    }
+  })),
+  setError: (key, value) => set((state) => ({
+    states: {
+      ...state.states,
+      [key]: {
+        ...state.states[key] ?? createDefaultStates(),
+        error: value
+      }
+    }
+  })),
+  setIsSuccess: (key, value) => set((state) => ({
+    states: {
+      ...state.states,
+      [key]: {
+        ...state.states[key] ?? createDefaultStates(),
+        isSuccess: value
+      }
+    }
+  })),
+  setIsInvalidated: (key, value) => set((state) => {
+    if (value === true) {
+      const allKeys = Object.keys(state.states);
+      const matchedKeys = getMatchKeys([key], allKeys);
+      matchedKeys.forEach((key2) => {
+        sessionStorage.removeItem(key2);
+      });
+      return {
+        states: {
+          ...state.states,
+          [key]: {
+            ...createDefaultStates(),
+            isInvalidated: true
+          }
+        }
+      };
+    }
+    return {
+      states: {
+        ...state.states,
+        [key]: {
+          ...state.states[key] ?? createDefaultStates(),
+          isInvalidated: false
+        }
+      }
+    };
+  }),
+  setData: (key, value) => set((state) => ({
+    states: {
+      ...state.states,
+      [key]: {
+        ...state.states[key] ?? createDefaultStates(),
+        data: value
+      }
+    }
+  })),
+  incrementRetryCount: (key) => set((state) => {
+    const prevState = state.states[key] ?? createDefaultStates();
+    return {
+      states: {
+        ...state.states,
+        [key]: {
+          ...prevState,
+          retryCount: prevState.retryCount + 1
+        }
+      }
+    };
+  }),
+  resetRetryCount: (key) => set((state) => {
+    const prevState = state.states[key] ?? createDefaultStates();
+    return {
+      states: {
+        ...state.states,
+        [key]: {
+          ...prevState,
+          retryCount: 0
+        }
+      }
+    };
+  }),
+  setIsEnabled: (key, value) => set((state) => ({
+    states: {
+      ...state.states,
+      [key]: {
+        ...state.states[key] ?? createDefaultStates(),
+        isEnabled: value
+      }
+    }
+  })),
+  resetKeyState: (key) => set((state) => {
+    const keys = ensureArray(key);
+    const allKeys = Object.keys(state.states);
+    const matchedKeys = getMatchKeys(keys, allKeys);
+    const newStates = { ...state.states };
+    matchedKeys.forEach((k) => {
+      newStates[k] = createDefaultStates();
+    });
+    return {
+      states: newStates
+    };
+  }),
+  resetState: (excludedKey) => set((state) => {
+    const excludedKeys = ensureArray(excludedKey);
+    const allKeys = Object.keys(state.states);
+    const matchedKeys = getMatchKeys(excludedKeys, allKeys);
+    const newStates = Object.keys(state.states).reduce((acc, key) => {
+      if (matchedKeys.includes(key)) {
+        acc[key] = state.states[key];
+      } else {
+        acc[key] = createDefaultStates();
+      }
+      return acc;
+    }, {});
+    return {
+      states: newStates
+    };
+  })
+}));
+exports.useAsyncStateStore = useAsyncStateStore;
+//# sourceMappingURL=useAsyncStateStore.cjs.map

package/dist/hooks/useAsync/useAsyncStateStore.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAsyncStateStore.cjs","sources":["../../../src/hooks/useAsync/useAsyncStateStore.ts"],"sourcesContent":["import { create } from 'zustand';\n\ntype States<T> = {\n  isLoading: boolean;\n  isFetched: boolean;\n  isInvalidated: boolean;\n  fetchedDateTime: null | Date;\n  error: string | null;\n  isSuccess: boolean;\n  data: T | null;\n  retryCount: number;\n  isEnabled: boolean;\n};\n\ntype StateSlice<T> = {\n  [key: string]: States<T>;\n};\n\ntype Actions<T> = {\n  getStates: (key: string) => States<T>;\n  setIsFetched: (key: string, value: boolean) => void;\n  setIsLoading: (key: string, value: boolean) => void;\n  setIsInvalidated: (key: string, value: boolean) => void;\n  setError: (key: string, value: string | null) => void;\n  setIsSuccess: (key: string, value: boolean) => void;\n  setData: (key: string, value: T | null) => void;\n  incrementRetryCount: (key: string) => void;\n  resetRetryCount: (key: string) => void;\n  setIsEnabled: (key: string, value: boolean) => void;\n  resetKeyState: (key: string[]) => void;\n  resetState: (excludedKey: string[]) => void;\n};\n\ntype AsyncState<T> = {\n  states: StateSlice<T>;\n} & Actions<T>;\n\nconst createDefaultStates = <T>(): States<T> => ({\n  isFetched: false,\n  fetchedDateTime: null,\n  isLoading: false,\n  isInvalidated: false,\n  error: null,\n  isSuccess: false,\n  data: null,\n  retryCount: 0,\n  isEnabled: true,\n});\n\n/**\n * If the value is not an array. Transform it en array\n *\n * @param value value to transform en array if not array\n * @returns array\n */\nconst ensureArray = <T>(value?: T | T[]): T[] => {\n  if (!value) {\n    return [];\n  } else if (Array.isArray(value)) {\n    return value;\n  }\n\n  return [value];\n};\n\n/**\n * Return all keys that match\n *\n * @param {string[]} selectorsKeys - List of key to check - example: ['getProducts']\n * @param {string[]} keysWithArgs - List of keys that can includes args - example: [\"getProducts\", \"getProducts/{'ids':['id1','id2']}\", \"getUsers\", \"getUsers/{'ids':['id1','id2']}\" ]\n * @returns {string[]} - key that match the selectors - example: [\"getProducts\", \"getProducts/{'ids':['id1','id2']}\" ]\n */\nconst getMatchKeys = (\n  selectorsKeys: string[],\n  keysWithArgs: string[]\n): string[] => {\n  const matchedKeys: string[] = keysWithArgs.filter((key) =>\n    selectorsKeys.includes(key.split('/')[0])\n  );\n\n  return matchedKeys;\n};\n\nexport const useAsyncStateStore = create<AsyncState<unknown>>((set, get) => ({\n  states: {} as StateSlice<unknown>,\n\n  getStates: (key) =>\n    (get().states[key] as States<unknown>) ?? createDefaultStates<unknown>(),\n\n  setIsFetched: (key, value) =>\n    set((state) => ({\n      states: {\n        ...state.states,\n        [key]: {\n          ...((state.states[key] as States<unknown>) ??\n            createDefaultStates<unknown>()),\n          isFetched: value,\n          fetchedDateTime: new Date(),\n        },\n      },\n    })),\n\n  setIsLoading: (key, value) =>\n    set((state) => ({\n      states: {\n        ...state.states,\n        [key]: {\n          ...((state.states[key] as States<unknown>) ??\n            createDefaultStates<unknown>()),\n          isLoading: value,\n        },\n      },\n    })),\n\n  setError: (key, value) =>\n    set((state) => ({\n      states: {\n        ...state.states,\n        [key]: {\n          ...((state.states[key] as States<unknown>) ??\n            createDefaultStates<unknown>()),\n          error: value,\n        },\n      },\n    })),\n\n  setIsSuccess: (key, value) =>\n    set((state) => ({\n      states: {\n        ...state.states,\n        [key]: {\n          ...((state.states[key] as States<unknown>) ??\n            createDefaultStates<unknown>()),\n          isSuccess: value,\n        },\n      },\n    })),\n\n  setIsInvalidated: (key, value) =>\n    set((state) => {\n      if (value === true) {\n        const allKeys = Object.keys(state.states);\n        const matchedKeys = getMatchKeys([key], allKeys);\n\n        matchedKeys.forEach((key) => {\n          sessionStorage.removeItem(key);\n        });\n\n        return {\n          states: {\n            ...state.states,\n            [key]: {\n              ...createDefaultStates<unknown>(),\n              isInvalidated: true,\n            },\n          },\n        };\n      }\n\n      return {\n        states: {\n          ...state.states,\n          [key]: {\n            ...((state.states[key] as States<unknown>) ??\n              createDefaultStates<unknown>()),\n            isInvalidated: false,\n          },\n        },\n      };\n    }),\n\n  setData: (key, value) =>\n    set((state) => ({\n      states: {\n        ...state.states,\n        [key]: {\n          ...((state.states[key] as States<unknown>) ??\n            createDefaultStates<unknown>()),\n          data: value,\n        },\n      },\n    })),\n\n  incrementRetryCount: (key) =>\n    set((state) => {\n      const prevState =\n        (state.states[key] as States<unknown>) ??\n        createDefaultStates<unknown>();\n      return {\n        states: {\n          ...state.states,\n          [key]: {\n            ...prevState,\n            retryCount: prevState.retryCount + 1,\n          },\n        },\n      };\n    }),\n\n  resetRetryCount: (key) =>\n    set((state) => {\n      const prevState =\n        (state.states[key] as States<unknown>) ??\n        createDefaultStates<unknown>();\n      return {\n        states: {\n          ...state.states,\n          [key]: {\n            ...prevState,\n            retryCount: 0,\n          },\n        },\n      };\n    }),\n\n  setIsEnabled: (key, value) =>\n    set((state) => ({\n      states: {\n        ...state.states,\n        [key]: {\n          ...((state.states[key] as States<unknown>) ??\n            createDefaultStates<unknown>()),\n          isEnabled: value,\n        },\n      },\n    })),\n\n  resetKeyState: (key: string | string[]) =>\n    set((state) => {\n      const keys = ensureArray(key);\n\n      const allKeys = Object.keys(state.states);\n      const matchedKeys = getMatchKeys(keys, allKeys);\n\n      const newStates = { ...state.states };\n      matchedKeys.forEach((k) => {\n        newStates[k] = createDefaultStates<unknown>();\n      });\n      return {\n        states: newStates,\n      };\n    }),\n\n  resetState: (excludedKey?: string | string[]) =>\n    set((state) => {\n      const excludedKeys = ensureArray(excludedKey);\n\n      const allKeys = Object.keys(state.states);\n      const matchedKeys = getMatchKeys(excludedKeys, allKeys);\n\n      const newStates = Object.keys(state.states).reduce((acc, key) => {\n        if (matchedKeys.includes(key)) {\n          acc[key] = state.states[key];\n        } else {\n          acc[key] = createDefaultStates<unknown>();\n        }\n        return acc;\n      }, {} as StateSlice<unknown>);\n\n      return {\n        states: newStates,\n      };\n    }),\n}));\n"],"names":["create","key"],"mappings":"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"}

package/dist/hooks/useAsync/useAsyncStateStore.d.ts

@@ -0,0 +1,34 @@
+type States<T> = {
+    isLoading: boolean;
+    isFetched: boolean;
+    isInvalidated: boolean;
+    fetchedDateTime: null | Date;
+    error: string | null;
+    isSuccess: boolean;
+    data: T | null;
+    retryCount: number;
+    isEnabled: boolean;
+};
+type StateSlice<T> = {
+    [key: string]: States<T>;
+};
+type Actions<T> = {
+    getStates: (key: string) => States<T>;
+    setIsFetched: (key: string, value: boolean) => void;
+    setIsLoading: (key: string, value: boolean) => void;
+    setIsInvalidated: (key: string, value: boolean) => void;
+    setError: (key: string, value: string | null) => void;
+    setIsSuccess: (key: string, value: boolean) => void;
+    setData: (key: string, value: T | null) => void;
+    incrementRetryCount: (key: string) => void;
+    resetRetryCount: (key: string) => void;
+    setIsEnabled: (key: string, value: boolean) => void;
+    resetKeyState: (key: string[]) => void;
+    resetState: (excludedKey: string[]) => void;
+};
+type AsyncState<T> = {
+    states: StateSlice<T>;
+} & Actions<T>;
+export declare const useAsyncStateStore: import('zustand').UseBoundStore<import('zustand').StoreApi<AsyncState<unknown>>>;
+export {};
+//# sourceMappingURL=useAsyncStateStore.d.ts.map

package/dist/hooks/useAsync/useAsyncStateStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAsyncStateStore.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAsync/useAsyncStateStore.ts"],"names":[],"mappings":"AAEA,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,IAAI,GAAG,IAAI,CAAC;IAC7B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,KAAK,UAAU,CAAC,CAAC,IAAI;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;CAC1B,CAAC;AAEF,KAAK,OAAO,CAAC,CAAC,IAAI;IAChB,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC;IACtC,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACpD,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACpD,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACxD,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IACtD,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACpD,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,KAAK,IAAI,CAAC;IAChD,mBAAmB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,eAAe,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACpD,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IACvC,UAAU,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CAC7C,CAAC;AAEF,KAAK,UAAU,CAAC,CAAC,IAAI;IACnB,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;CACvB,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAgDf,eAAO,MAAM,kBAAkB,kFAoL5B,CAAC"}