{"version":3,"sources":["../../src/use-async-fn/index.ts"],"sourcesContent":["import { useLatest } from '../use-latest'\nimport { useMount } from '../use-mount'\nimport { useStableFn } from '../use-stable-fn'\nimport { useTrackedRefState } from '../use-tracked-ref-state'\nimport { useUnmount } from '../use-unmount'\nimport { useVersionedAction } from '../use-versioned-action'\nimport { isFunction } from '../utils/basic'\n\nimport type { AnyFunc, Gettable, Promisable } from '../utils/basic'\n\nexport interface UseAsyncFnOptions<T extends AnyFunc, D = Awaited<ReturnType<T>>, E = any> {\n  /**\n   * Initial data to be used as the initial value\n   *\n   * @defaultValue undefined\n   *\n   * @since 1.4.0\n   */\n  initialValue?: D\n  /**\n   * Initial parameters passed to fetcher when first mount\n   *\n   * @defaultValue []\n   *\n   * @since 1.4.0\n   */\n  initialParams?: Gettable<Promisable<Parameters<T> | []>>\n  /**\n   * whether to run the async function immediately on component mount\n   *\n   * @defaultValue false\n   *\n   * @since 1.4.0\n   */\n  immediate?: boolean\n  /**\n   * whether to clear the value before running the function\n   *\n   * @defaultValue false\n   */\n  clearBeforeRun?: boolean\n  /**\n   * whether to cancel the async function when the component is unmounted\n   *\n   * @defaultValue true\n   *\n   * @since 1.4.0\n   */\n  cancelOnUnmount?: boolean\n  /**\n   * a function to run when the async function throws an error\n   *\n   * @defaultValue undefined\n   *\n   * @since 1.4.0\n   */\n  onError?: (error: E | undefined, params: Parameters<T> | []) => void\n  /**\n   * a function to run before the async function\n   *\n   * @defaultValue undefined\n   *\n   * @since 1.4.0\n   */\n  onBefore?: (value: D | undefined, params: Parameters<T> | []) => void\n  /**\n   * a function to run after the async function\n   *\n   * @defaultValue undefined\n   *\n   * @since 1.4.0\n   */\n  onSuccess?: (value: D, params: Parameters<T> | []) => void\n  /**\n   * a function to run after the async function\n   *\n   * @defaultValue undefined\n   *\n   * @since 1.4.0\n   */\n  onFinally?: (value: D | undefined, params: Parameters<T> | []) => void\n  /**\n   * a function to run when the async function is cancelled\n   *\n   * @defaultValue undefined\n   *\n   * @since 1.4.0\n   */\n  onCancel?: (value: D | undefined, params: Parameters<T> | []) => void\n  /**\n   * a function to run when the value is mutated\n   *\n   * @defaultValue undefined\n   *\n   * @since 1.4.0\n   */\n  onMutate?: (value: D | undefined, params: Parameters<T> | []) => void\n  /**\n   * a function to run when the value is refreshed\n   *\n   * @defaultValue undefined\n   *\n   * @since 1.4.0\n   */\n  onRefresh?: (value: D | undefined, params: Parameters<T> | []) => void\n  /**\n   * Custom cache comparison function, `true` means the cache is the same\n   *\n   * @defaultValue shallowEqual\n   *\n   * @since 1.4.0\n   */\n  compare?: (prevData: D | undefined, nextData: D | undefined) => boolean\n}\n\nexport type UseAsyncFnMutateAction<D, P> =\n  | [D | undefined]\n  | [D | undefined, P | undefined]\n  | [(prevData: D | undefined, preParams?: P) => [D, P | undefined]]\n\nexport interface UseAsyncFnReturns<T extends AnyFunc, D = Awaited<ReturnType<T>>, E = any> {\n  /**\n   * a function to run the async function\n   */\n  run: T\n  /**\n   * a function to refresh the async function\n   */\n  refresh: (params?: Parameters<T> | []) => Promise<D | undefined>\n  /**\n   * a function to cancel the async function\n   */\n  cancel: () => void\n  /**\n   * manually set the value\n   */\n  mutate: (...actions: UseAsyncFnMutateAction<D | undefined, Parameters<T> | []>) => void\n  /**\n   * whether the async function is loading\n   */\n  loading: boolean\n  /**\n   * the error thrown by the async function\n   */\n  error: E | undefined\n  /**\n   * the value returned by the async function\n   */\n  value: D | undefined\n  /**\n   * the parameters passed to the async function\n   */\n  params: Parameters<T> | []\n}\n\nexport function resolveMutateActions<D, P>(actions: UseAsyncFnMutateAction<D, P>, prevData: D, prevParams: P): [D, P] {\n  return (isFunction(actions[0]) ? actions[0](prevData, prevParams) : (actions as [D, P])) as [D, P]\n}\n\n/**\n * A React Hook to run **async** functions with extra **loading** state that indicates whether the promise is pending.\n *\n * @param {AnyFunc} fn - `AnyFunc`, the async function to run, see {@link AnyFunc}\n * @returns {UseAsyncFnReturns} `UseAsyncFnReturns`, see {@link UseAsyncFnReturns}\n */\nexport function useAsyncFn<T extends AnyFunc, D = Awaited<ReturnType<T>>, E = any>(\n  fn: T,\n  options: UseAsyncFnOptions<T, D, E> = {},\n): UseAsyncFnReturns<T, D, E> {\n  const { initialParams = [], immediate = false, clearBeforeRun = false, cancelOnUnmount = true } = options\n\n  const [incVersion, runVersionedAction] = useVersionedAction()\n\n  const [refState, actions, stateRef] = useTrackedRefState({\n    error: undefined as E | undefined,\n    loading: Boolean(immediate),\n    value: options.initialValue,\n    // async function could not be used as default value, so all the functions will be initialized in useEffect\n    params: (isFunction(initialParams) ? [] : initialParams) as Parameters<T> | [],\n  })\n\n  const latest = useLatest({ fn, ...options, initialParams, clearBeforeRun, cancelOnUnmount })\n\n  const cancel = useStableFn(() => {\n    incVersion()\n    actions.updateRefState('loading', false)\n    latest.current.onCancel?.(stateRef.value.value, stateRef.params.value)\n  })\n\n  const run = useStableFn(async (...args: Parameters<T> | []) => {\n    actions.updateRefState('params', args)\n\n    const version = incVersion()\n\n    let result: D | undefined = undefined\n\n    try {\n      latest.current.onBefore?.(stateRef.value.value, stateRef.params.value)\n\n      if (latest.current.clearBeforeRun) {\n        actions.updateRefState('value', undefined)\n      }\n\n      actions.updateRefState('loading', true)\n\n      result = await latest.current.fn(...args)\n\n      runVersionedAction(version, () => {\n        latest.current.onSuccess?.(result as D, stateRef.params.value)\n        actions.updateRefState('value', result, latest.current.compare)\n        actions.updateRefState('error', undefined)\n      })\n    } catch (error) {\n      runVersionedAction(version, () => {\n        latest.current.onError?.(error as E | undefined, stateRef.params.value)\n        actions.updateRefState('error', error as E | undefined)\n      })\n    } finally {\n      runVersionedAction(version, () => {\n        latest.current.onFinally?.(result, stateRef.params.value)\n        actions.updateRefState('loading', false)\n      })\n    }\n\n    return result\n  }) as T\n\n  const mutate = useStableFn((...mutateActions: UseAsyncFnMutateAction<D | undefined, Parameters<T> | []>) => {\n    const [nextValue, nextParams] = resolveMutateActions<D | undefined, Parameters<T> | []>(\n      mutateActions,\n      stateRef.value.value,\n      stateRef.params.value,\n    )\n\n    actions.updateRefState('value', nextValue)\n    actions.updateRefState('params', nextParams)\n\n    latest.current.onMutate?.(nextValue, nextParams ?? [])\n  })\n\n  const refresh = useStableFn(async (params?: Parameters<T> | []) => {\n    const actualParams = (params ?? stateRef.params.value) || []\n    const result = await run(...actualParams)\n    latest.current.onRefresh?.(result, actualParams)\n    return result\n  })\n\n  useMount(async () => {\n    if (isFunction(initialParams)) {\n      actions.updateRefState('params', await initialParams())\n    }\n\n    if (immediate) {\n      await run(...stateRef.params.value)\n    }\n  })\n\n  useUnmount(() => {\n    if (latest.current.cancelOnUnmount) {\n      cancel()\n    }\n  })\n\n  return {\n    run,\n    refresh,\n    mutate,\n    cancel,\n    get loading() {\n      return refState.loading\n    },\n    get error() {\n      return refState.error\n    },\n    get value() {\n      return refState.value\n    },\n    get params() {\n      return refState.params\n    },\n  }\n}\n"],"names":["resolveMutateActions","useAsyncFn","actions","prevData","prevParams","isFunction","fn","options","initialParams","immediate","clearBeforeRun","cancelOnUnmount","useVersionedAction","incVersion","runVersionedAction","useTrackedRefState","error","undefined","loading","Boolean","value","initialValue","params","refState","stateRef","latest","useLatest","cancel","useStableFn","updateRefState","current","onCancel","run","args","version","result","onBefore","onSuccess","compare","onError","onFinally","mutate","mutateActions","nextValue","nextParams","onMutate","refresh","actualParams","onRefresh","useMount","useUnmount"],"mappings":";;;;;;;;;;;QA2JgBA;eAAAA;;QAUAC;eAAAA;;;yBArKU;wBACD;2BACG;kCACO;0BACR;kCACQ;qBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqJpB,SAASD,qBAA2BE,OAAqC,EAAEC,QAAW,EAAEC,UAAa;IAC1G,OAAQC,IAAAA,iBAAU,EAACH,OAAO,CAAC,EAAE,IAAIA,OAAO,CAAC,EAAE,CAACC,UAAUC,cAAeF;AACvE;AAQO,SAASD,WACdK,EAAK;QACLC,UAAAA,iEAAsC,CAAC;IAEvC,6BAAkGA,QAA1FC,eAAAA,oDAAgB,EAAE,gDAAwED,QAAtEE,WAAAA,4CAAY,sDAA0DF,QAAnDG,gBAAAA,sDAAiB,4DAAkCH,QAA3BI,iBAAAA,wDAAkB;IAEzF,IAAyCC,uCAAAA,IAAAA,sCAAkB,SAApDC,aAAkCD,wBAAtBE,qBAAsBF;IAEzC,IAAsCG,uCAAAA,IAAAA,sCAAkB,EAAC;QACvDC,OAAOC;QACPC,SAASC,QAAQV;QACjBW,OAAOb,QAAQc,YAAY;QAC3B,2GAA2G;QAC3GC,QAASjB,IAAAA,iBAAU,EAACG,iBAAiB,EAAE,GAAGA;IAC5C,QANOe,WAA+BR,wBAArBb,UAAqBa,wBAAZS,WAAYT;IAQtC,IAAMU,SAASC,IAAAA,oBAAS,EAAC;QAAEpB,IAAAA;OAAOC;QAASC,eAAAA;QAAeE,gBAAAA;QAAgBC,iBAAAA;;IAE1E,IAAMgB,SAASC,IAAAA,wBAAW,EAAC;YAGzBH,0BAAAA;QAFAZ;QACAX,QAAQ2B,cAAc,CAAC,WAAW;SAClCJ,2BAAAA,CAAAA,kBAAAA,OAAOK,OAAO,EAACC,QAAQ,cAAvBN,+CAAAA,8BAAAA,iBAA0BD,SAASJ,KAAK,CAACA,KAAK,EAAEI,SAASF,MAAM,CAACF,KAAK;IACvE;IAEA,IAAMY,MAAMJ,IAAAA,wBAAW,EAAC;yCAAUK;YAAAA;;;gBAG1BC,SAEFC,QAWaV,iBARfA,0BAAAA,kBAeOT;;;;wBAtBTd,QAAQ2B,cAAc,CAAC,UAAUI;wBAE3BC,UAAUrB;wBAEZsB,SAAwBlB;;;;;;;;;yBAG1BQ,2BAAAA,CAAAA,mBAAAA,OAAOK,OAAO,EAACM,QAAQ,cAAvBX,+CAAAA,8BAAAA,kBAA0BD,SAASJ,KAAK,CAACA,KAAK,EAAEI,SAASF,MAAM,CAACF,KAAK;wBAErE,IAAIK,OAAOK,OAAO,CAACpB,cAAc,EAAE;4BACjCR,QAAQ2B,cAAc,CAAC,SAASZ;wBAClC;wBAEAf,QAAQ2B,cAAc,CAAC,WAAW;wBAEzB;;4BAAMJ,CAAAA,kBAAAA,OAAOK,OAAO,EAACxB,EAAE,OAAjBmB,iBAAkB,qBAAGQ;;;wBAApCE,SAAS;wBAETrB,mBAAmBoB,SAAS;gCAC1BT,2BAAAA;6BAAAA,4BAAAA,CAAAA,kBAAAA,OAAOK,OAAO,EAACO,SAAS,cAAxBZ,gDAAAA,+BAAAA,iBAA2BU,QAAaX,SAASF,MAAM,CAACF,KAAK;4BAC7DlB,QAAQ2B,cAAc,CAAC,SAASM,QAAQV,OAAOK,OAAO,CAACQ,OAAO;4BAC9DpC,QAAQ2B,cAAc,CAAC,SAASZ;wBAClC;;;;;;wBACOD;wBACPF,mBAAmBoB,SAAS;gCAC1BT,yBAAAA;6BAAAA,0BAAAA,CAAAA,kBAAAA,OAAOK,OAAO,EAACS,OAAO,cAAtBd,8CAAAA,6BAAAA,iBAAyBT,OAAwBQ,SAASF,MAAM,CAACF,KAAK;4BACtElB,QAAQ2B,cAAc,CAAC,SAASb;wBAClC;;;;;;wBAEAF,mBAAmBoB,SAAS;gCAC1BT,2BAAAA;6BAAAA,4BAAAA,CAAAA,kBAAAA,OAAOK,OAAO,EAACU,SAAS,cAAxBf,gDAAAA,+BAAAA,iBAA2BU,QAAQX,SAASF,MAAM,CAACF,KAAK;4BACxDlB,QAAQ2B,cAAc,CAAC,WAAW;wBACpC;;;;;wBAGF;;4BAAOM;;;;QACT;;IAEA,IAAMM,SAASb,IAAAA,wBAAW,EAAC;yCAAIc;YAAAA;;YAU7BjB,0BAAAA;QATA,IAAgCzB,yCAAAA,qBAC9B0C,eACAlB,SAASJ,KAAK,CAACA,KAAK,EACpBI,SAASF,MAAM,CAACF,KAAK,OAHhBuB,YAAyB3C,0BAAd4C,aAAc5C;QAMhCE,QAAQ2B,cAAc,CAAC,SAASc;QAChCzC,QAAQ2B,cAAc,CAAC,UAAUe;SAEjCnB,2BAAAA,CAAAA,kBAAAA,OAAOK,OAAO,EAACe,QAAQ,cAAvBpB,+CAAAA,8BAAAA,iBAA0BkB,WAAWC,uBAAAA,wBAAAA,aAAc,EAAE;IACvD;IAEA,IAAME,UAAUlB,IAAAA,wBAAW,EAAC,SAAON;;gBAGjCG,2BAAAA,iBAFMsB,cACAZ;;;;wBADAY,eAAe,AAACzB,CAAAA,mBAAAA,oBAAAA,SAAUE,SAASF,MAAM,CAACF,KAAK,AAAD;wBACrC;;4BAAMY,UAAAA,KAAAA,GAAI,qBAAGe;;;wBAAtBZ,SAAS;yBACfV,4BAAAA,CAAAA,kBAAAA,OAAOK,OAAO,EAACkB,SAAS,cAAxBvB,gDAAAA,+BAAAA,iBAA2BU,QAAQY;wBACnC;;4BAAOZ;;;;QACT;;IAEAc,IAAAA,kBAAQ,EAAC;;;;;;6BACH5C,IAAAA,iBAAU,EAACG,gBAAXH;;;;4BACFH,QAAQ2B,cAAc;;4BAAC;;wBAAU;;4BAAMrB;;;wBAAvCN,QAAAA;4BAAiC;;;;6BAG/BO,WAAAA;;;;wBACF;;4BAAMuB,UAAAA,KAAAA,GAAI,qBAAGR,SAASF,MAAM,CAACF,KAAK;;;wBAAlC;;;;;;;;QAEJ;;IAEA8B,IAAAA,sBAAU,EAAC;QACT,IAAIzB,OAAOK,OAAO,CAACnB,eAAe,EAAE;YAClCgB;QACF;IACF;IAEA,OAAO;QACLK,KAAAA;QACAc,SAAAA;QACAL,QAAAA;QACAd,QAAAA;QACA,IAAIT,WAAU;YACZ,OAAOK,SAASL,OAAO;QACzB;QACA,IAAIF,SAAQ;YACV,OAAOO,SAASP,KAAK;QACvB;QACA,IAAII,SAAQ;YACV,OAAOG,SAASH,KAAK;QACvB;QACA,IAAIE,UAAS;YACX,OAAOC,SAASD,MAAM;QACxB;IACF;AACF"}