fix(useWorkerLoad): group error and retry into an optional attr

Author: fjcaetano

src/__tests__/useWorkerLoad.ts

@@ -92,7 +92,8 @@ it('stops loading on failure and returns the error', async () => {
 
   await waitForNextUpdate();
 
-  expect(result.current.error).toBe(thrownError);
+  expect(result.current.error?.value).toBe(thrownError);
+  expect(result.current.error?.retry).not.toBeUndefined();
   expect(result.current.isLoading).toEqual(false);
 });
 
@@ -119,7 +120,8 @@ it('can set error', async () => {
     result.current.setError(thrownError);
   });
 
-  expect(result.current.error).toEqual(thrownError);
+  expect(result.current.error?.value).toEqual(thrownError);
+  expect(result.current.error?.retry).not.toBeUndefined();
 });
 
 it('can set isLoading', async () => {
@@ -138,6 +140,7 @@ it('can set isLoading', async () => {
 
 describe('retry', () => {
   it('sets loading true', async () => {
+    callbackFn.mockRejectedValue(thrownError);
     const { result, waitForNextUpdate } = renderHook(useHookHelper, {
       initialProps,
     });
@@ -146,7 +149,7 @@ describe('retry', () => {
     expect(result.current.isLoading).toBe(false);
 
     act(() => {
-      result.current.retry();
+      result.current.error!.retry();
     });
 
     expect(result.current.isLoading).toBe(true);
@@ -162,9 +165,9 @@ describe('retry', () => {
     });
 
     await waitForNextUpdate();
-    expect(result.current.error).toBe(thrownError);
+    expect(result.current.error?.value).toBe(thrownError);
 
-    await act(result.current.retry);
+    await act(result.current.error!.retry);
 
     expect(result.current.error).toBeUndefined();
   });
@@ -179,19 +182,22 @@ describe('retry', () => {
     });
 
     await waitForNextUpdate();
-    expect(result.current.error).toBe(thrownError);
+    expect(result.current.error?.value).toBe(thrownError);
     expect(result.current.data).toBeUndefined();
 
-    await act(result.current.retry);
+    await act(result.current.error!.retry);
 
     expect(result.current.data).toBe(val);
+    expect(result.current.error).toBeUndefined();
   });
 });
 
 /// These tests won't fail their execution, but the type-checking instead.
 describe('test types', () => {
   type Assert<T, Expected> = T extends Expected
-    ? (Expected extends T ? true : never)
+    ? Expected extends T
+      ? true
+      : never
     : never;
 
   describe('`initialValue` is unset', () => {

src/index.tsx

@@ -7,6 +7,41 @@ import {
   MutableRefObject,
 } from 'react';
 
+/**
+ * The return of a [[useWorkerLoad]] call.
+ *
+ * See [[RetryWorkerError]] for errors.
+ *
+ * @typeparam Data The worker's return type
+ */
+interface WorkerLoad<Data> {
+  /** Indicates if the worker is running */
+  isLoading: boolean;
+
+  /** The worker's returned value stored in a state */
+  data: Data;
+
+  /** An optional object that contains any thrown errors, if any, and a retry function */
+  error?: RetryWorkerError;
+
+  /** Sets [[isLoading]] state manually */
+  setIsLoading: (_: boolean) => void;
+
+  /** Sets [[error]] state manually */
+  setError: (_: Error | undefined) => void;
+}
+
+/**
+ * Encapsulates [[useWorkerLoad]]'s errors and retry function
+ */
+interface RetryWorkerError {
+  /** The error thrown by the worker's call */
+  value: Error;
+
+  /** Calls the worker again */
+  retry: () => Promise<void>;
+}
+
 /**
  * Executes an asynchronous effect
  *
@@ -44,6 +79,7 @@ export const useAsyncLayoutEffect = (
  *
  * @param worker The callback function that runs a promise.
  * @param dependencies The callback dependencies.
+ * @category Workers
  */
 export const useWorker = <TArgs extends readonly any[], TRet>(
   worker: (...args: TArgs) => Promise<TRet>,
@@ -180,15 +216,6 @@ export const useLazyRef = <T extends any>(
   return ref as MutableRefObject<T>;
 };
 
-type WorkerLoad<Data> = {
-  isLoading: boolean;
-  setIsLoading: (_: boolean) => void;
-  setError: (_: Error | undefined) => void;
-  error: Error | undefined;
-  data: Data;
-  retry: () => Promise<void>;
-};
-
 export function useWorkerLoad<Data>(
   worker: () => Promise<Data | undefined>,
 ): WorkerLoad<Data | undefined>;
@@ -205,6 +232,8 @@ export function useWorkerLoad<Data>(
  *
  * @param worker An asynchronous function that returns data, which is saved into a state
  * @param initialValue The data's initial value
+ * @typeparam Data The worker's return type
+ * @category Workers
  */
 export function useWorkerLoad<Data>(
   worker: () => Promise<typeof initialValue>,
@@ -227,9 +256,11 @@ export function useWorkerLoad<Data>(
   return {
     data,
     isLoading,
-    error,
     setIsLoading,
     setError,
-    retry: callback,
+    error: error && {
+      value: error,
+      retry: callback,
+    },
   };
 }