@aws-amplify/ui-react-core 3.4.1 → 3.4.2

package/dist/esm/Authenticator/hooks/useAuthenticator/useAuthenticator.mjs

@@ -4,7 +4,7 @@ import { getServiceFacade } from '@aws-amplify/ui';
 import 'aws-amplify/auth';
 import { AuthenticatorContext } from '../../context/AuthenticatorContext.mjs';
 import { USE_AUTHENTICATOR_ERROR } from './constants.mjs';
-import { getQRFields, getMachineFields, getComparator, defaultComparator } from './utils.mjs';
+import { getComparator, defaultComparator, getQRFields, getMachineFields } from './utils.mjs';
 
 /**
  * [📖 Docs](https://ui.docs.amplify.aws/react/connected-components/authenticator/headless#useauthenticator-hook)

package/dist/esm/Authenticator/hooks/useAuthenticator/utils.mjs

@@ -1,4 +1,4 @@
-import { getActorContext, getSortedFormFields, isString, authenticatorTextUtil, areEmptyArrays, areEmptyObjects } from '@aws-amplify/ui';
+import { getActorContext, getSortedFormFields, areEmptyArrays, areEmptyObjects, isString, authenticatorTextUtil } from '@aws-amplify/ui';
 import { isComponentRouteKey } from '../utils.mjs';
 
 const defaultComparator = () => false;

package/dist/esm/hooks/useAsyncReducer.mjs

@@ -0,0 +1,78 @@
+import React__default from 'react';
+import { isFunction } from '@aws-amplify/ui';
+
+// async state constants
+const INITIAL = { hasError: false, isLoading: false, message: undefined };
+const LOADING = { hasError: false, isLoading: true, message: undefined };
+const ERROR = { hasError: true, isLoading: false };
+/**
+ * @internal may be updated in future versions
+ *
+ * @description like `useReducer` but make it async
+ *
+ * @example
+ * ```ts
+ * import fetchData from './fetchData';
+ *
+ * type MyState = { data: string[] | undefined }
+ * const initialState: MyState = { data: undefined }
+ *
+ * type MyAction = { type: 'fetch' | 'clear' }
+ *
+ * const asyncReducer = async (state: MyState, action: MyAction): Promise<MyState> => {
+ *   switch(action.type) {
+ *     case 'fetch':
+ *       const data = await fetchData();
+ *       return { data: state.data ? state.data.concat(data) : data }
+ *     case 'clear':
+ *       return { data: undefined }
+ *   }
+ * }
+ *
+ * const FetchDataButton = () => {
+ *   const [state, dispatch] = useAsyncReducer(asyncReducer, initialState);
+ *
+ *   const { value: { data }, isLoading } = state;
+ *
+ *   return (
+ *     <button onClick={() => isLoading ? null : dispatch({ type: 'fetch'})}>
+ *       Fetch Data
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+function useAsyncReducer(reducer, initialValue, options) {
+    const [state, setAsyncState] = React__default.useState(() => ({
+        ...INITIAL,
+        value: initialValue,
+    }));
+    const prevValue = React__default.useRef(initialValue);
+    const pendingId = React__default.useRef();
+    const { onSuccess, onError } = options ?? {};
+    const dispatch = React__default.useCallback((input) => {
+        const id = Symbol();
+        pendingId.current = id;
+        setAsyncState(({ value }) => ({ ...LOADING, value }));
+        reducer(prevValue.current, input)
+            .then((value) => {
+            if (pendingId.current !== id)
+                return;
+            prevValue.current = value;
+            if (isFunction(onSuccess))
+                onSuccess(value);
+            setAsyncState({ ...INITIAL, value });
+        })
+            .catch((error) => {
+            if (pendingId.current !== id)
+                return;
+            if (isFunction(onError))
+                onError(error);
+            const { message } = error;
+            setAsyncState(({ value }) => ({ ...ERROR, value, message }));
+        });
+    }, [onError, onSuccess, reducer]);
+    return [state, dispatch];
+}
+
+export { useAsyncReducer as default };

package/dist/esm/index.mjs

@@ -9,9 +9,9 @@ export { default as useForm } from './components/FormCore/useForm.mjs';
 export { default as FormProvider } from './components/FormCore/FormProvider.mjs';
 export { default as withFormProvider } from './components/FormCore/withFormProvider.mjs';
 export { default as RenderNothing } from './components/RenderNothing/RenderNothing.mjs';
-export { default as useDataState } from './hooks/useDataState/useDataState.mjs';
 export { default as useControlledReducer } from './hooks/useControlledReducer.mjs';
 export { default as useDropZone } from './hooks/useDropZone.mjs';
+export { default as useAsyncReducer } from './hooks/useAsyncReducer.mjs';
 export { default as useDeprecationWarning } from './hooks/useDeprecationWarning.mjs';
 export { default as useGetUrl } from './hooks/useGetUrl.mjs';
 export { default as useHasValueUpdated } from './hooks/useHasValueUpdated.mjs';

package/dist/index.js

@@ -605,50 +605,6 @@ function useAuthenticatorInitMachine(data) {
     }, [initializeMachine, route, data]);
 }
 
-// default state
-const INITIAL_STATE = { hasError: false, isLoading: false, message: undefined };
-const LOADING_STATE = { hasError: false, isLoading: true, message: undefined };
-const ERROR_STATE = { hasError: true, isLoading: false };
-const resolveMaybeAsync = async (value) => {
-    const awaited = await value;
-    return awaited;
-};
-/**
- * @internal may be updated in future versions
- */
-function useDataState(action, initialData, options) {
-    const [dataState, setDataState] = React__namespace["default"].useState(() => ({
-        ...INITIAL_STATE,
-        data: initialData,
-    }));
-    const prevData = React__namespace["default"].useRef(initialData);
-    const pendingId = React__namespace["default"].useRef();
-    const { onSuccess, onError } = options ?? {};
-    const handleAction = React__namespace["default"].useCallback((input) => {
-        const id = Symbol();
-        pendingId.current = id;
-        setDataState(({ data }) => ({ ...LOADING_STATE, data }));
-        resolveMaybeAsync(action(prevData.current, input))
-            .then((data) => {
-            if (pendingId.current !== id)
-                return;
-            prevData.current = data;
-            if (ui.isFunction(onSuccess))
-                onSuccess(data);
-            setDataState({ ...INITIAL_STATE, data });
-        })
-            .catch((error) => {
-            if (pendingId.current !== id)
-                return;
-            if (ui.isFunction(onError))
-                onError(error);
-            const { message } = error;
-            setDataState(({ data }) => ({ ...ERROR_STATE, data, message }));
-        });
-    }, [action, onError, onSuccess]);
-    return [dataState, handleAction];
-}
-
 function usePreviousValue(value) {
     const previous = React.useRef(undefined);
     // update ref post render
@@ -868,6 +824,80 @@ function useDropZone({ onDropComplete, onDragEnter: _onDragEnter, onDragLeave: _
     };
 }
 
+// async state constants
+const INITIAL = { hasError: false, isLoading: false, message: undefined };
+const LOADING = { hasError: false, isLoading: true, message: undefined };
+const ERROR = { hasError: true, isLoading: false };
+/**
+ * @internal may be updated in future versions
+ *
+ * @description like `useReducer` but make it async
+ *
+ * @example
+ * ```ts
+ * import fetchData from './fetchData';
+ *
+ * type MyState = { data: string[] | undefined }
+ * const initialState: MyState = { data: undefined }
+ *
+ * type MyAction = { type: 'fetch' | 'clear' }
+ *
+ * const asyncReducer = async (state: MyState, action: MyAction): Promise<MyState> => {
+ *   switch(action.type) {
+ *     case 'fetch':
+ *       const data = await fetchData();
+ *       return { data: state.data ? state.data.concat(data) : data }
+ *     case 'clear':
+ *       return { data: undefined }
+ *   }
+ * }
+ *
+ * const FetchDataButton = () => {
+ *   const [state, dispatch] = useAsyncReducer(asyncReducer, initialState);
+ *
+ *   const { value: { data }, isLoading } = state;
+ *
+ *   return (
+ *     <button onClick={() => isLoading ? null : dispatch({ type: 'fetch'})}>
+ *       Fetch Data
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+function useAsyncReducer(reducer, initialValue, options) {
+    const [state, setAsyncState] = React__namespace["default"].useState(() => ({
+        ...INITIAL,
+        value: initialValue,
+    }));
+    const prevValue = React__namespace["default"].useRef(initialValue);
+    const pendingId = React__namespace["default"].useRef();
+    const { onSuccess, onError } = options ?? {};
+    const dispatch = React__namespace["default"].useCallback((input) => {
+        const id = Symbol();
+        pendingId.current = id;
+        setAsyncState(({ value }) => ({ ...LOADING, value }));
+        reducer(prevValue.current, input)
+            .then((value) => {
+            if (pendingId.current !== id)
+                return;
+            prevValue.current = value;
+            if (ui.isFunction(onSuccess))
+                onSuccess(value);
+            setAsyncState({ ...INITIAL, value });
+        })
+            .catch((error) => {
+            if (pendingId.current !== id)
+                return;
+            if (ui.isFunction(onError))
+                onError(error);
+            const { message } = error;
+            setAsyncState(({ value }) => ({ ...ERROR, value, message }));
+        });
+    }, [onError, onSuccess, reducer]);
+    return [state, dispatch];
+}
+
 /**
  * Logs a deprecation warning message.
  *
@@ -1031,11 +1061,11 @@ exports.RenderNothing = RenderNothing;
 exports.createContextUtilities = createContextUtilities;
 exports.isAuthenticatorComponentRouteKey = isComponentRouteKey;
 exports.resolveAuthenticatorComponents = resolveAuthenticatorComponents;
+exports.useAsyncReducer = useAsyncReducer;
 exports.useAuthenticator = useAuthenticator;
 exports.useAuthenticatorInitMachine = useAuthenticatorInitMachine;
 exports.useAuthenticatorRoute = useAuthenticatorRoute;
 exports.useControlledReducer = useControlledReducer;
-exports.useDataState = useDataState;
 exports.useDeprecationWarning = useDeprecationWarning;
 exports.useDropZone = useDropZone;
 exports.useField = useField;

package/dist/types/hooks/index.d.ts

@@ -1,6 +1,6 @@
-export { useDataState, AsyncDataAction, DataAction, DataState, } from './useDataState';
 export { default as useControlledReducer } from './useControlledReducer';
 export { default as useDropZone, UseDropZoneParams } from './useDropZone';
+export { default as useAsyncReducer, AsyncReducer, AsyncReducerState, } from './useAsyncReducer';
 export { default as useDeprecationWarning, UseDeprecationWarning, } from './useDeprecationWarning';
 export { default as useGetUrl } from './useGetUrl';
 export { default as useHasValueUpdated } from './useHasValueUpdated';

package/dist/types/hooks/useAsyncReducer.d.ts

@@ -0,0 +1,55 @@
+import React from 'react';
+export interface AsyncReducerState<T> {
+    /**
+     * current value
+     */
+    value: T;
+    hasError: boolean;
+    isLoading: boolean;
+    /**
+     * error message, if any
+     */
+    message: string | undefined;
+}
+export type AsyncReducer<S, A> = (prevValue: S, action: A) => Promise<S>;
+/**
+ * @internal may be updated in future versions
+ *
+ * @description like `useReducer` but make it async
+ *
+ * @example
+ * ```ts
+ * import fetchData from './fetchData';
+ *
+ * type MyState = { data: string[] | undefined }
+ * const initialState: MyState = { data: undefined }
+ *
+ * type MyAction = { type: 'fetch' | 'clear' }
+ *
+ * const asyncReducer = async (state: MyState, action: MyAction): Promise<MyState> => {
+ *   switch(action.type) {
+ *     case 'fetch':
+ *       const data = await fetchData();
+ *       return { data: state.data ? state.data.concat(data) : data }
+ *     case 'clear':
+ *       return { data: undefined }
+ *   }
+ * }
+ *
+ * const FetchDataButton = () => {
+ *   const [state, dispatch] = useAsyncReducer(asyncReducer, initialState);
+ *
+ *   const { value: { data }, isLoading } = state;
+ *
+ *   return (
+ *     <button onClick={() => isLoading ? null : dispatch({ type: 'fetch'})}>
+ *       Fetch Data
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+export default function useAsyncReducer<T, K>(reducer: AsyncReducer<T, K>, initialValue: T, options?: {
+    onSuccess?: (data: T) => void;
+    onError?: (error: Error) => void;
+}): [AsyncReducerState<T>, React.Dispatch<K>];

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 export { AuthenticatorComponentDefaults, AuthenticatorComponentDefaultProps, AuthenticatorComponentOverrides, AuthenticatorFooterComponent, AuthenticatorFormFieldsComponent, AuthenticatorHeaderComponent, AuthenticatorLegacyField, AuthenticatorMachineContext, AuthenticatorProvider, AuthenticatorRouteComponentKey, AuthenticatorRouteComponentName, isAuthenticatorComponentRouteKey, resolveAuthenticatorComponents, useAuthenticator, useAuthenticatorRoute, UseAuthenticator, useAuthenticatorInitMachine, UseAuthenticatorRoute, } from './Authenticator';
 export { FormProvider, FormProviderProps, RenderNothing, FormValues, FormHandle, useField, useForm, UseForm, Validate, Validator, withFormProvider, } from './components';
-export { AsyncDataAction, DataAction, useControlledReducer, useDeprecationWarning, UseDeprecationWarning, useGetUrl, useHasValueUpdated, usePreviousValue, useSetUserAgent, useTimeout, useDataState, DataState, useDropZone, UseDropZoneParams, } from './hooks';
+export { AsyncReducer, AsyncReducerState, useAsyncReducer, useControlledReducer, useDeprecationWarning, UseDeprecationWarning, useDropZone, UseDropZoneParams, useGetUrl, useHasValueUpdated, usePreviousValue, useSetUserAgent, useTimeout, } from './hooks';
 export { MergeProps } from './types';
 export { createContextUtilities } from './utils';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-amplify/ui-react-core",
-  "version": "3.4.1",
+  "version": "3.4.2",
   "main": "dist/index.js",
   "module": "dist/esm/index.mjs",
   "react-native": "src/index.ts",
@@ -40,14 +40,14 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@aws-amplify/ui": "6.10.1",
+    "@aws-amplify/ui": "6.10.2",
     "@xstate/react": "^3.2.2",
     "lodash": "4.17.21",
     "react-hook-form": "^7.53.2",
     "xstate": "^4.33.6"
   },
   "peerDependencies": {
-    "aws-amplify": "^6.9.0",
+    "aws-amplify": "^6.14.3",
     "react": "^16.14 || ^17 || ^18 || ^19"
   },
   "sideEffects": false

package/src/hooks/index.ts

@@ -1,12 +1,10 @@
-export {
-  useDataState,
-  AsyncDataAction,
-  DataAction,
-  DataState,
-} from './useDataState';
-
 export { default as useControlledReducer } from './useControlledReducer';
 export { default as useDropZone, UseDropZoneParams } from './useDropZone';
+export {
+  default as useAsyncReducer,
+  AsyncReducer,
+  AsyncReducerState,
+} from './useAsyncReducer';
 export {
   default as useDeprecationWarning,
   UseDeprecationWarning,

package/src/hooks/useAsyncReducer.ts

@@ -0,0 +1,111 @@
+import React from 'react';
+
+import { isFunction } from '@aws-amplify/ui';
+
+// async state constants
+const INITIAL = { hasError: false, isLoading: false, message: undefined };
+const LOADING = { hasError: false, isLoading: true, message: undefined };
+const ERROR = { hasError: true, isLoading: false };
+
+export interface AsyncReducerState<T> {
+  /**
+   * current value
+   */
+  value: T;
+  hasError: boolean;
+  isLoading: boolean;
+  /**
+   * error message, if any
+   */
+  message: string | undefined;
+}
+
+export type AsyncReducer<S, A> = (prevValue: S, action: A) => Promise<S>;
+
+/**
+ * @internal may be updated in future versions
+ *
+ * @description like `useReducer` but make it async
+ *
+ * @example
+ * ```ts
+ * import fetchData from './fetchData';
+ *
+ * type MyState = { data: string[] | undefined }
+ * const initialState: MyState = { data: undefined }
+ *
+ * type MyAction = { type: 'fetch' | 'clear' }
+ *
+ * const asyncReducer = async (state: MyState, action: MyAction): Promise<MyState> => {
+ *   switch(action.type) {
+ *     case 'fetch':
+ *       const data = await fetchData();
+ *       return { data: state.data ? state.data.concat(data) : data }
+ *     case 'clear':
+ *       return { data: undefined }
+ *   }
+ * }
+ *
+ * const FetchDataButton = () => {
+ *   const [state, dispatch] = useAsyncReducer(asyncReducer, initialState);
+ *
+ *   const { value: { data }, isLoading } = state;
+ *
+ *   return (
+ *     <button onClick={() => isLoading ? null : dispatch({ type: 'fetch'})}>
+ *       Fetch Data
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+export default function useAsyncReducer<T, K>(
+  reducer: AsyncReducer<T, K>,
+  initialValue: T,
+  options?: {
+    onSuccess?: (data: T) => void;
+    onError?: (error: Error) => void;
+  }
+): [AsyncReducerState<T>, React.Dispatch<K>] {
+  const [state, setAsyncState] = React.useState<AsyncReducerState<T>>(() => ({
+    ...INITIAL,
+    value: initialValue,
+  }));
+
+  const prevValue = React.useRef(initialValue);
+  const pendingId = React.useRef<Symbol | undefined>();
+
+  const { onSuccess, onError } = options ?? {};
+
+  const dispatch: React.Dispatch<K> = React.useCallback(
+    (input) => {
+      const id = Symbol();
+      pendingId.current = id;
+
+      setAsyncState(({ value }) => ({ ...LOADING, value }));
+
+      reducer(prevValue.current, input)
+        .then((value: T) => {
+          if (pendingId.current !== id) return;
+
+          prevValue.current = value;
+
+          if (isFunction(onSuccess)) onSuccess(value);
+
+          setAsyncState({ ...INITIAL, value });
+        })
+        .catch((error: Error) => {
+          if (pendingId.current !== id) return;
+
+          if (isFunction(onError)) onError(error);
+
+          const { message } = error;
+
+          setAsyncState(({ value }) => ({ ...ERROR, value, message }));
+        });
+    },
+    [onError, onSuccess, reducer]
+  );
+
+  return [state, dispatch];
+}

package/src/index.ts

@@ -35,20 +35,19 @@ export {
 } from './components';
 
 export {
-  AsyncDataAction,
-  DataAction,
+  AsyncReducer,
+  AsyncReducerState,
+  useAsyncReducer,
   useControlledReducer,
   useDeprecationWarning,
   UseDeprecationWarning,
+  useDropZone,
+  UseDropZoneParams,
   useGetUrl,
   useHasValueUpdated,
   usePreviousValue,
   useSetUserAgent,
   useTimeout,
-  useDataState,
-  DataState,
-  useDropZone,
-  UseDropZoneParams,
 } from './hooks';
 
 export { MergeProps } from './types';

package/dist/esm/hooks/useDataState/useDataState.mjs

@@ -1,48 +0,0 @@
-import React__default from 'react';
-import { isFunction } from '@aws-amplify/ui';
-
-// default state
-const INITIAL_STATE = { hasError: false, isLoading: false, message: undefined };
-const LOADING_STATE = { hasError: false, isLoading: true, message: undefined };
-const ERROR_STATE = { hasError: true, isLoading: false };
-const resolveMaybeAsync = async (value) => {
-    const awaited = await value;
-    return awaited;
-};
-/**
- * @internal may be updated in future versions
- */
-function useDataState(action, initialData, options) {
-    const [dataState, setDataState] = React__default.useState(() => ({
-        ...INITIAL_STATE,
-        data: initialData,
-    }));
-    const prevData = React__default.useRef(initialData);
-    const pendingId = React__default.useRef();
-    const { onSuccess, onError } = options ?? {};
-    const handleAction = React__default.useCallback((input) => {
-        const id = Symbol();
-        pendingId.current = id;
-        setDataState(({ data }) => ({ ...LOADING_STATE, data }));
-        resolveMaybeAsync(action(prevData.current, input))
-            .then((data) => {
-            if (pendingId.current !== id)
-                return;
-            prevData.current = data;
-            if (isFunction(onSuccess))
-                onSuccess(data);
-            setDataState({ ...INITIAL_STATE, data });
-        })
-            .catch((error) => {
-            if (pendingId.current !== id)
-                return;
-            if (isFunction(onError))
-                onError(error);
-            const { message } = error;
-            setDataState(({ data }) => ({ ...ERROR_STATE, data, message }));
-        });
-    }, [action, onError, onSuccess]);
-    return [dataState, handleAction];
-}
-
-export { useDataState as default };

package/dist/types/hooks/useDataState/index.d.ts

@@ -1,2 +0,0 @@
-export { default as useDataState } from './useDataState';
-export { AsyncDataAction, DataAction, DataState } from './types';

package/dist/types/hooks/useDataState/types.d.ts

@@ -1,8 +0,0 @@
-export interface DataState<T> {
-    data: T;
-    hasError: boolean;
-    isLoading: boolean;
-    message: string | undefined;
-}
-export type DataAction<T = any, K = any> = (prevData: T, input: K) => T;
-export type AsyncDataAction<T = any, K = any> = (prevData: T, input: K) => Promise<T>;

package/dist/types/hooks/useDataState/useDataState.d.ts

@@ -1,8 +0,0 @@
-import { AsyncDataAction, DataAction, DataState } from './types';
-/**
- * @internal may be updated in future versions
- */
-export default function useDataState<T, K>(action: DataAction<T, K> | AsyncDataAction<T, K>, initialData: T, options?: {
-    onSuccess?: (data: T) => void;
-    onError?: (error: Error) => void;
-}): [state: DataState<T>, handleAction: (input: K) => void];

package/src/hooks/useDataState/index.ts

@@ -1,2 +0,0 @@
-export { default as useDataState } from './useDataState';
-export { AsyncDataAction, DataAction, DataState } from './types';

package/src/hooks/useDataState/types.ts

@@ -1,13 +0,0 @@
-export interface DataState<T> {
-  data: T;
-  hasError: boolean;
-  isLoading: boolean;
-  message: string | undefined;
-}
-
-export type DataAction<T = any, K = any> = (prevData: T, input: K) => T;
-
-export type AsyncDataAction<T = any, K = any> = (
-  prevData: T,
-  input: K
-) => Promise<T>;

package/src/hooks/useDataState/useDataState.ts

@@ -1,70 +0,0 @@
-import React from 'react';
-import { isFunction } from '@aws-amplify/ui';
-
-import { AsyncDataAction, DataAction, DataState } from './types';
-
-// default state
-const INITIAL_STATE = { hasError: false, isLoading: false, message: undefined };
-const LOADING_STATE = { hasError: false, isLoading: true, message: undefined };
-const ERROR_STATE = { hasError: true, isLoading: false };
-
-const resolveMaybeAsync = async <T>(
-  value: T | Promise<T>
-): Promise<Awaited<T>> => {
-  const awaited = await value;
-  return awaited;
-};
-
-/**
- * @internal may be updated in future versions
- */
-export default function useDataState<T, K>(
-  action: DataAction<T, K> | AsyncDataAction<T, K>,
-  initialData: T,
-  options?: {
-    onSuccess?: (data: T) => void;
-    onError?: (error: Error) => void;
-  }
-): [state: DataState<T>, handleAction: (input: K) => void] {
-  const [dataState, setDataState] = React.useState<DataState<T>>(() => ({
-    ...INITIAL_STATE,
-    data: initialData,
-  }));
-
-  const prevData = React.useRef(initialData);
-  const pendingId = React.useRef<Symbol | undefined>();
-
-  const { onSuccess, onError } = options ?? {};
-
-  const handleAction: (input: K) => void = React.useCallback(
-    (input) => {
-      const id = Symbol();
-      pendingId.current = id;
-
-      setDataState(({ data }) => ({ ...LOADING_STATE, data }));
-
-      resolveMaybeAsync(action(prevData.current, input))
-        .then((data: T) => {
-          if (pendingId.current !== id) return;
-
-          prevData.current = data;
-
-          if (isFunction(onSuccess)) onSuccess(data);
-
-          setDataState({ ...INITIAL_STATE, data });
-        })
-        .catch((error: Error) => {
-          if (pendingId.current !== id) return;
-
-          if (isFunction(onError)) onError(error);
-
-          const { message } = error;
-
-          setDataState(({ data }) => ({ ...ERROR_STATE, data, message }));
-        });
-    },
-    [action, onError, onSuccess]
-  );
-
-  return [dataState, handleAction];
-}