{"version":3,"sources":["../../src/use-query/index.ts"],"sourcesContent":["import { useEffect } from 'react'\nimport { resolveMutateActions } from '../use-async-fn'\nimport { useDebouncedFn } from '../use-debounced-fn'\nimport { useIntervalFn } from '../use-interval-fn'\nimport { useLatest } from '../use-latest'\nimport { useLoadingSlowFn } from '../use-loading-slow-fn'\nimport { usePausable } from '../use-pausable'\nimport { useReConnect } from '../use-re-connect'\nimport { useReFocus } from '../use-re-focus'\nimport { useRetryFn } from '../use-retry-fn'\nimport { useStableFn } from '../use-stable-fn'\nimport { useThrottledFn } from '../use-throttled-fn'\nimport { useUpdateEffect } from '../use-update-effect'\nimport { isDefined, isNumber } from '../utils/basic'\nimport { shallowEqual } from '../utils/equal'\nimport { useQueryCache } from './use-query-cache'\n\nimport type { DependencyList } from 'react'\nimport type { UseAsyncFnMutateAction } from '../use-async-fn'\nimport type { UseDebouncedFnOptions } from '../use-debounced-fn'\nimport type { UseIntervalFnInterval } from '../use-interval-fn'\nimport type { UseLoadingSlowFnOptions, UseLoadingSlowFnReturns } from '../use-loading-slow-fn'\nimport type { Pausable } from '../use-pausable'\nimport type { UseReConnectOptions } from '../use-re-connect'\nimport type { UseReFocusOptions } from '../use-re-focus'\nimport type { UseRetryFnOptions } from '../use-retry-fn'\nimport type { UseThrottledFnOptions } from '../use-throttled-fn'\nimport type { AnyFunc, Gettable, Promisable } from '../utils/basic'\nimport type { UseQueryCacheLike } from './use-query-cache'\n\nexport const defaultIsVisible: () => boolean = () => !document.hidden\nexport const defaultIsOnline: () => boolean = () => navigator.onLine\n\nexport { mutate } from './use-query-cache'\n\nexport type { UseQueryMutate, UseQueryCacheLike } from './use-query-cache'\n\nexport interface UseQueryOptions<T extends AnyFunc, D = Awaited<ReturnType<T>>, E = any>\n  extends Omit<UseLoadingSlowFnOptions<T, D, E>, 'initialValue'>,\n    Pick<UseReConnectOptions, 'registerReConnect'>,\n    Pick<UseReFocusOptions, 'registerReFocus'> {\n  /**\n   * Disable all automatic refresh behaviors, default is off\n   *\n   * @defaultValue false\n   */\n  manual?: boolean\n  /**\n   * Initial data passed to fetcher when first mount\n   *\n   * @defaultValue undefined\n   */\n  initialData?: D | undefined\n  /**\n   * Cache key, can be a string or a function that returns a string\n   *\n   * @defaultValue undefined\n   */\n  cacheKey?: string | ((...args: Parameters<T> | []) => string)\n  /**\n   * Max cache time, will clear the cache after the specified time\n   *\n   * default is 5_000 ms, set `false` to disable\n   */\n  cacheExpirationTime?: number | false\n  /**\n   * Cache provider, it can be set to an external store (reactive), localStorage, etc.\n   *\n   * Needs to comply with the UseQueryCacheLike interface definition, defaults to a globally shared `new Map()`\n   *\n   * @defaultValue global shared `new Map()`\n   */\n  provider?: Gettable<UseQueryCacheLike<D>>\n  /**\n   * ThrottleOptions => only affects the frequency of manually executing the run method\n   *\n   * @defaultValue undefined\n   */\n  throttle?: UseThrottledFnOptions['wait'] | UseThrottledFnOptions\n  /**\n   * DebounceOptions => only affects the frequency of manually executing the run method\n   *\n   * @defaultValue undefined\n   */\n  debounce?: UseDebouncedFnOptions['wait'] | UseDebouncedFnOptions\n  /**\n   * Whether to reload when focus is obtained, default is off\n   *\n   * @defaultValue false\n   */\n  refreshOnFocus?: boolean\n  /**\n   * Throttle time when obtaining focus, default 5_000 (ms), only valid when `refreshOnFocus` is true\n   *\n   * @defaultValue 5_000\n   */\n  refreshOnFocusThrottleWait?: number\n  /**\n   * Custom visibility judgment function\n   *\n   * @defaultValue defaultIsVisible\n   */\n  isVisible?: () => Promisable<boolean>\n  /**\n   * Whether to reload when network reconnects, default is off\n   *\n   * @defaultValue false\n   */\n  refreshOnReconnect?: boolean\n  /**\n   * Custom online judgment function\n   *\n   * @defaultValue defaultIsOnline\n   */\n  isOnline?: () => Promisable<boolean>\n  /**\n   * Interval time for automatic refresh, default is 0, off\n   *\n   * @defaultValue 0\n   */\n  refreshInterval?: Exclude<UseIntervalFnInterval, 'requestAnimationFrame'>\n  /**\n   * Whether to reload when hidden, default is off\n   *\n   * @defaultValue false\n   */\n  refreshWhenHidden?: boolean\n  /**\n   * Whether to reload when offline, default is off\n   *\n   * @defaultValue false\n   */\n  refreshWhenOffline?: boolean\n  /**\n   * The dependencies of the refresh operation, when the dependencies change, the refresh operation will be triggered\n   *\n   * @defaultValue []\n   */\n  refreshDependencies?: DependencyList\n  /**\n   * Error retry count\n   *\n   * @defaultValue 0\n   */\n  errorRetryCount?: UseRetryFnOptions<E>['count']\n  /**\n   * Error retry interval\n   *\n   * @defaultValue `defaultRetryInterval` in `useRetryFn`\n   */\n  errorRetryInterval?: UseRetryFnOptions<E>['interval']\n  /**\n   * Whether to clear the cache before each request\n   *\n   * @defaultValue undefined\n   */\n  onErrorRetry?: UseRetryFnOptions<E>['onErrorRetry']\n  /**\n   * Callback executed when the request is canceled\n   *\n   * @defaultValue undefined\n   */\n  onErrorRetryFailed?: UseRetryFnOptions<E>['onRetryFailed']\n}\n\nexport interface UseQueryReturns<T extends AnyFunc, D = Awaited<ReturnType<T>>, E = any>\n  extends Pausable,\n    Omit<UseLoadingSlowFnReturns<T, D, E>, 'value'> {\n  /**\n   * The data returned by the request\n   */\n  data: D | undefined\n  /**\n   * Whether the request is in the initialization state (no data + loading, initializing => !data && loading)\n   */\n  initializing: boolean\n  /**\n   * Whether the request is refreshing data (has data + loading, refreshing => data && loading)\n   */\n  refreshing: boolean\n}\n\n/**\n * A basic React Hook for data fetching, supports cache, automatic refresh, and many awesome features.\n *\n * @since 1.5.0\n */\nexport function useQuery<T extends AnyFunc, D = Awaited<ReturnType<T>>, E = any>(\n  fetcher: T,\n  options: UseQueryOptions<T, D, E> = {},\n): UseQueryReturns<T, D, E> {\n  const [cache, cacheActions] = useQueryCache<T, D>(options)\n\n  const debounceOptions = isNumber(options.debounce) ? { wait: options.debounce } : options.debounce\n  const throttleOptions = isNumber(options.throttle) ? { wait: options.throttle } : options.throttle\n\n  const enableRateControl = Boolean(debounceOptions || throttleOptions)\n\n  const latest = useLatest({ fetcher, cache, enableRateControl, ...options })\n\n  const service = useLoadingSlowFn<T, D, E>(\n    useRetryFn<T, E>(\n      ((...args: Parameters<T>) => {\n        // no cache, directly fetch\n        if (!cacheActions.isCacheEnabled) return latest.current.fetcher(...args)\n\n        // prevent multiple call in different components with the same cacheKey, reuse the promise\n        const prePromise = cacheActions.getPromiseCache()\n        if (prePromise) return prePromise\n\n        // SWR: stale-while-revalidate\n        const { data, params, stale } = latest.current.cache\n        const isMeetSWR = isDefined(data) && !stale && shallowEqual(args, params)\n        if (isMeetSWR) return Promise.resolve(data)\n\n        // if not meet SWR, fetch new data and update promise cache\n        const promise = latest.current.fetcher(...args)\n        cacheActions.setPromiseCache(promise)\n\n        return promise\n      }) as T,\n      {\n        count: options.errorRetryCount ?? 0,\n        interval: options.errorRetryInterval,\n        onErrorRetry: options.onErrorRetry,\n        onRetryFailed(...args) {\n          latest.current.onErrorRetryFailed?.(...args)\n          throw args[0]\n        },\n        onError(..._args) {\n          cacheActions.clearPromiseCache()\n        },\n      },\n    ),\n    {\n      immediate: options.immediate ?? !options.manual,\n      initialParams: options.initialParams,\n      initialValue: options.initialData ?? cache.data,\n      clearBeforeRun: options.clearBeforeRun,\n      loadingTimeout: options.loadingTimeout,\n      onBefore(...args) {\n        if (latest.current.clearBeforeRun) cacheActions.setCache(undefined, [])\n        intervalPausable.resume()\n        return latest.current.onBefore?.(...args)\n      },\n      onLoadingSlow: options.onLoadingSlow,\n      onCancel(...args) {\n        cacheActions.clearPromiseCache()\n        return latest.current.onCancel?.(...args)\n      },\n      onSuccess(nextData, params, ...rest) {\n        cacheActions.setCache(nextData, params)\n        return latest.current.onSuccess?.(nextData, params, ...rest)\n      },\n      onError: options.onError,\n      onFinally(...args) {\n        cacheActions.clearPromiseCache()\n        return latest.current.onFinally?.(...args)\n      },\n      onMutate(nextData, params, ...rest) {\n        cacheActions.setCache(nextData, params)\n        return latest.current.onMutate?.(nextData, params, ...rest)\n      },\n      onRefresh: options.onRefresh,\n    },\n  )\n\n  const refreshWithStatusCheck = useStableFn(async () => {\n    if (!pausable.isActive() || latest.current.manual) return\n\n    const {\n      refreshWhenHidden = false,\n      refreshWhenOffline = false,\n      isVisible = defaultIsVisible,\n      isOnline = defaultIsOnline,\n    } = latest.current\n\n    const isVisibleMatch = (await isVisible()) || refreshWhenHidden\n    const isOnlineMatch = (await isOnline()) || refreshWhenOffline\n\n    const params = cacheActions.isCacheEnabled ? latest.current.cache.params : service.params\n\n    if (isVisibleMatch && isOnlineMatch) return service.refresh(params)\n  })\n\n  const serviceWithRateControl = useThrottledFn(useDebouncedFn(service.run, debounceOptions), throttleOptions)\n  const refreshWithRateControl = useThrottledFn(useDebouncedFn(service.refresh, debounceOptions), throttleOptions)\n\n  const intervalPausable = useIntervalFn(refreshWithStatusCheck, options.refreshInterval ?? 0, {\n    immediate: Boolean(options.refreshInterval && !options.manual),\n  })\n\n  useReConnect(() => options.refreshOnReconnect && refreshWithStatusCheck(), {\n    registerReConnect: options.registerReConnect,\n  })\n\n  useReFocus(() => options.refreshOnFocus && refreshWithStatusCheck(), {\n    registerReFocus: options.registerReFocus,\n    wait: options.refreshOnFocusThrottleWait ?? 5_000,\n  })\n\n  const pausable = usePausable(\n    true,\n    () => {\n      intervalPausable.pause()\n      service.cancel()\n    },\n    () => intervalPausable.resume(),\n  )\n\n  useUpdateEffect(() => void refreshWithStatusCheck(), [...(options.refreshDependencies ?? [])])\n\n  // revalidate when cache becomes stale\n  // install of `useUpdateEffect`: cover the case when cache is enabled and stale at the first time mount\n  useEffect(() => {\n    if (!cacheActions.isCacheEnabled || !cache.stale || latest.current.manual) return\n    if (service.loading || cacheActions.getPromiseCache()) return\n    refreshWithStatusCheck()\n  }, [cache.stale, cacheActions.isCacheEnabled])\n\n  const mutateWithCache = useStableFn((...actions: UseAsyncFnMutateAction<D | undefined, Parameters<T> | []>) => {\n    const data = cacheActions.isCacheEnabled ? latest.current.cache.data : service.value\n    const params = cacheActions.isCacheEnabled ? latest.current.cache.params : service.params\n    const [nextData, nextParams] = resolveMutateActions<D | undefined, Parameters<T> | []>(actions, data, params)\n    return service.mutate(nextData, nextParams)\n  })\n\n  const refreshWithCache = useStableFn(async (params?: Parameters<T> | []) => {\n    const outerParams = cacheActions.isCacheEnabled ? latest.current.cache.params : service.params\n    const actualParams = params ?? outerParams\n    return latest.current.enableRateControl ? refreshWithRateControl(actualParams) : service.refresh(actualParams)\n  })\n\n  return {\n    ...pausable,\n    mutate: mutateWithCache,\n    refresh: refreshWithCache,\n    run: (enableRateControl ? serviceWithRateControl : service.run) as T,\n    cancel: service.cancel,\n    get params() {\n      return cacheActions.isCacheEnabled ? cache.params : service.params\n    },\n    get loadingSlow() {\n      return service.loadingSlow\n    },\n    get data() {\n      return cacheActions.isCacheEnabled ? cache.data : service.value\n    },\n    get error() {\n      return service.error\n    },\n    get loading() {\n      return service.loading\n    },\n    get refreshing() {\n      const data = cacheActions.isCacheEnabled ? cache.data : service.value\n      return Boolean(data && service.loading)\n    },\n    get initializing() {\n      const data = cacheActions.isCacheEnabled ? cache.data : service.value\n      return Boolean(!data && service.loading)\n    },\n  }\n}\n"],"names":["defaultIsOnline","defaultIsVisible","mutate","useQuery","document","hidden","navigator","onLine","fetcher","options","useQueryCache","cache","cacheActions","debounceOptions","isNumber","debounce","wait","throttleOptions","throttle","enableRateControl","Boolean","latest","useLatest","service","useLoadingSlowFn","useRetryFn","args","isCacheEnabled","current","prePromise","getPromiseCache","data","params","stale","isMeetSWR","isDefined","shallowEqual","Promise","resolve","promise","setPromiseCache","count","errorRetryCount","interval","errorRetryInterval","onErrorRetry","onRetryFailed","onErrorRetryFailed","onError","_args","clearPromiseCache","immediate","manual","initialParams","initialValue","initialData","clearBeforeRun","loadingTimeout","onBefore","setCache","undefined","intervalPausable","resume","onLoadingSlow","onCancel","onSuccess","nextData","rest","onFinally","onMutate","onRefresh","refreshWithStatusCheck","useStableFn","refreshWhenHidden","refreshWhenOffline","isVisible","isOnline","isVisibleMatch","isOnlineMatch","pausable","isActive","refresh","serviceWithRateControl","useThrottledFn","useDebouncedFn","run","refreshWithRateControl","useIntervalFn","refreshInterval","useReConnect","refreshOnReconnect","registerReConnect","useReFocus","refreshOnFocus","registerReFocus","refreshOnFocusThrottleWait","usePausable","pause","cancel","useUpdateEffect","refreshDependencies","useEffect","loading","mutateWithCache","actions","value","resolveMutateActions","nextParams","refreshWithCache","outerParams","actualParams","loadingSlow","error","refreshing","initializing"],"mappings":"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"}