Function useAsync

packages/react-async/src/useAsync.tsx:44–236

(arg1: AsyncOptions<T> | PromiseFn<T>, arg2?: AsyncOptions<T>)

function useAsync<T>(promiseFn: PromiseFn<T>, options?: AsyncOptions<T>): AsyncState<T>

function useAsync<T>(arg1: AsyncOptions<T> | PromiseFn<T>, arg2?: AsyncOptions<T>): AsyncState<T> {
  const options: AsyncOptions<T> =
    typeof arg1 === "function"
      ? {
          ...arg2,
          promiseFn: arg1,
        }
      : arg1

  const counter = useRef(0)
  const isMounted = useRef(true)
  const lastArgs = useRef<any[] | undefined>(undefined)
  const lastOptions = useRef<AsyncOptions<T>>(options)
  const lastPromise = useRef<Promise<T>>(neverSettle)
  const abortController = useRef<AbortController>(new MockAbortController())

  const { devToolsDispatcher } = globalScope.__REACT_ASYNC__
  const { reducer, dispatcher = devToolsDispatcher } = options
  const [state, _dispatch] = useReducer(
    reducer ? (state, action) => reducer(state, action, asyncReducer) : asyncReducer,
    options,
    init
  )
  const dispatch = useCallback(
    dispatcher
      ? action => dispatcher(action, dispatchMiddleware(_dispatch), lastOptions.current)
      : dispatchMiddleware(_dispatch),
    [dispatcher]
  )

  const { debugLabel } = options
  const getMeta: <M extends Meta = Meta>(meta?: M) => M = useCallback(
    (meta?) =>
      ({
        counter: counter.current,
        promise: lastPromise.current,
        debugLabel,
        ...meta,
      } as any),
    [debugLabel]
  )

  const setData = useCallback(
    (data, callback = noop) => {
      if (isMounted.current) {
        dispatch({
          type: ActionTypes.fulfill,
          payload: data,
          meta: getMeta(),
        })
        callback()
      }
      return data
    },
    [dispatch, getMeta]
  )

  const setError = useCallback(