@tanstack/query-core 5.103.1 → 5.103.3

package/build/modern/{hydration-Cq7QYAzB.d.ts → hydration-Br9VIGXa.d.cts}

@@ -1,5 +1,5 @@
-import { t as Subscribable } from "./subscribable-CbifVTKz.js";
-import { t as Removable } from "./removable-DeMjhW5M.js";
+import { t as Subscribable } from "./subscribable-CysQ0tne.cjs";
+import { t as Removable } from "./removable-0GzhW1PK.cjs";
 //#region src/queryObserver.d.ts
 type QueryObserverListener<TData, TError> = (result: QueryObserverResult<TData, TError>) => void;
 interface ObserverFetchOptions extends FetchOptions {
@@ -870,7 +870,7 @@ interface QueryFilters<TQueryKey extends QueryKey = QueryKey> {
   /**
    * Filter to active queries, inactive queries or all queries
    *
-   * Defaults to `'all'`.
+   * @defaultValue 'all'
    */
   type?: QueryTypeFilter;
   /**
@@ -1329,6 +1329,7 @@ declare class QueryClient {
    * Hint: Do not use this function inside a component, because it won't receive updates.
    * Use `useQuery` to create a `QueryObserver` that subscribes to changes.
    *
+   * @returns The cached data for the query, or `undefined` if no query with this key has been observed yet.
    * @see {@link QueryClient#getQueriesData}
    */
   getQueryData<TQueryFnData = unknown, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>>(queryKey: TTaggedQueryKey): TInferredQueryFnData | undefined;
@@ -1347,6 +1348,7 @@ declare class QueryClient {
    * every matched query holds the same shape — it is not checked against the actual cache
    * contents.
    *
+   * @returns An array of query key and data pairs. The data is `undefined` for a query with no cached data.
    * @see {@link QueryClient#getQueryData}
    * @example
    * ```ts
@@ -1366,6 +1368,9 @@ declare class QueryClient {
    * @param queryKey - The query key to set data for.
    * @param updater - Either the new data, or a function that receives the current data (which
    * may be `undefined`) and returns the new data.
+   * @param options - Set `updatedAt` to override the timestamp the written data is recorded with.
+   * @returns The data that was written, or `undefined` if the updater returned `undefined` — in that case
+   * the write is skipped and the cache is left unchanged.
    *
    * @example
    * ```ts
@@ -1382,6 +1387,8 @@ declare class QueryClient {
    * filters are updated; no new cache entries are created. Internally this calls
    * {@link QueryClient#setQueryData} for each matching query.
    *
+   * @returns One `[queryKey, data]` tuple per matched query, in the same shape and with the same
+   * `undefined` case as {@link QueryClient#setQueryData}.
    * @example
    * ```ts
    * queryClient.setQueriesData({ queryKey: ['posts'] }, (oldPosts) =>
@@ -1713,9 +1720,13 @@ interface Retryer<TData = unknown> {
   start: () => Promise<TData>;
   status: () => 'pending' | 'resolved' | 'rejected';
 }
+/** @inline */
 type RetryValue<TError> = boolean | number | ShouldRetryFunction<TError>;
+/** @inline */
 type ShouldRetryFunction<TError = DefaultError> = (failureCount: number, error: TError) => boolean;
+/** @inline */
 type RetryDelayValue<TError> = number | RetryDelayFunction<TError>;
+/** @inline */
 type RetryDelayFunction<TError = DefaultError> = (failureCount: number, error: TError) => number;
 declare function canFetch(networkMode: NetworkMode | undefined): boolean;
 /**
@@ -1750,12 +1761,39 @@ declare function createRetryer<TData = unknown, TError = DefaultError>(config: R
 //#region src/types.d.ts
 type NonUndefinedGuard<T> = T extends undefined ? never : T;
 type DistributiveOmit<TObject, TKey extends keyof TObject> = TObject extends any ? Omit<TObject, TKey> : never;
-type OmitKeyof<TObject, TKey extends TStrictly extends 'safely' ? keyof TObject | (string & Record<never, never>) | (number & Record<never, never>) | (symbol & Record<never, never>) : keyof TObject, TStrictly extends 'strictly' | 'safely' = 'strictly'> = Omit<TObject, TKey>;
+type OmitKeyof<TObject, TKey extends (TStrictly extends 'safely' ? keyof TObject | (string & Record<never, never>) | (number & Record<never, never>) | (symbol & Record<never, never>) : keyof TObject), TStrictly extends 'strictly' | 'safely' = 'strictly'> = Omit<TObject, TKey>;
 type Override<TTargetA, TTargetB> = { [AKey in keyof TTargetA]: AKey extends keyof TTargetB ? TTargetB[AKey] : TTargetA[AKey]; };
+/**
+ * The interface to augment via declaration merging to override Query's default types repository-wide.
+ * Each field it declares replaces the default of the matching type: `defaultError` for {@link DefaultError},
+ * `queryKey` for {@link QueryKey}, `mutationKey` for {@link MutationKey}, `queryMeta` for {@link QueryMeta} and
+ * `mutationMeta` for {@link MutationMeta}. Leave a field out to keep that type's default.
+ * Augment the module you install — `@tanstack/react-query`, `@tanstack/vue-query`,
+ * `@tanstack/solid-query`, `@tanstack/svelte-query`, `@tanstack/preact-query`,
+ * `@tanstack/angular-query-experimental` or `@tanstack/lit-query`. Augmenting `@tanstack/query-core`
+ * works too and covers every adapter at once.
+ * @example
+ * ```ts
+ * // Use the module you installed — here, the React adapter.
+ * declare module '@tanstack/react-query' {
+ *   interface Register {
+ *     defaultError: AxiosError
+ *   }
+ * }
+ * ```
+ */
 interface Register {}
+/**
+ * The error type used wherever an error is not given an explicit type parameter.
+ * Defaults to `Error`; declare `defaultError` on {@link Register} to change it everywhere at once.
+ */
 type DefaultError = Register extends {
   defaultError: infer TError;
 } ? TError : Error;
+/**
+ * The type of a query key — the serializable array that identifies a query in the cache.
+ * Defaults to `ReadonlyArray<unknown>`; declare `queryKey` on {@link Register} to narrow it repository-wide.
+ */
 type QueryKey = Register extends {
   queryKey: infer TQueryKey;
 } ? TQueryKey extends ReadonlyArray<unknown> ? TQueryKey : TQueryKey extends Array<unknown> ? TQueryKey : ReadonlyArray<unknown> : ReadonlyArray<unknown>;
@@ -1778,10 +1816,15 @@ type QueryKeyWithDataTag<TQueryKey extends QueryKey = QueryKey, TQueryFnData = u
 };
 type InferDataFromTag<TQueryFnData, TTaggedQueryKey extends QueryKey> = TTaggedQueryKey extends DataTag<unknown, infer TaggedValue, unknown> ? TaggedValue : TQueryFnData;
 type InferErrorFromTag<TError, TTaggedQueryKey extends QueryKey> = TTaggedQueryKey extends DataTag<unknown, unknown, infer TaggedError> ? TaggedError extends UnsetMarker ? TError : TaggedError : TError;
+/** @inline */
 type QueryFunction<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => T | Promise<T>;
+/** @inline */
 type StaleTime = number | 'static';
+/** @inline */
 type StaleTimeFunction<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = StaleTime | ((query: Query<TQueryFnData, TError, TData, TQueryKey>) => StaleTime);
+/** @inline */
 type QueryBooleanOption<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = boolean | ((query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean);
+/** @inline */
 type QueryPersister<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = [TPageParam] extends [never] ? (queryFn: QueryFunction<T, TQueryKey, never>, context: QueryFunctionContext<TQueryKey>, query: Query) => T | Promise<T> : (queryFn: QueryFunction<T, TQueryKey, TPageParam>, context: QueryFunctionContext<TQueryKey>, query: Query) => T | Promise<T>;
 type QueryFunctionContext<TQueryKey extends QueryKey = QueryKey, TPageParam = never> = [TPageParam] extends [never] ? {
   client: QueryClient;
@@ -1806,21 +1849,36 @@ type QueryFunctionContext<TQueryKey extends QueryKey = QueryKey, TPageParam = ne
   direction: FetchDirection;
   meta: QueryMeta | undefined;
 };
+/** @inline */
 type InitialDataFunction<T> = () => T | undefined;
 type NonFunctionGuard<T> = T extends Function ? never : T;
+/** @inline */
 type PlaceholderDataFunction<TQueryFnData = unknown, TError = DefaultError, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = (previousData: TQueryData | undefined, previousQuery: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => TQueryData | undefined;
 type QueriesPlaceholderDataFunction<TQueryData> = (previousData: undefined, previousQuery: undefined) => TQueryData | undefined;
+/** @inline */
 type QueryKeyHashFunction<TQueryKey extends QueryKey> = (queryKey: TQueryKey) => string;
+/** @inline */
 type GetPreviousPageParamFunction<TPageParam, TQueryFnData = unknown> = (firstPage: TQueryFnData, allPages: Array<TQueryFnData>, firstPageParam: TPageParam, allPageParams: Array<TPageParam>) => TPageParam | undefined | null;
+/** @inline */
 type GetNextPageParamFunction<TPageParam, TQueryFnData = unknown> = (lastPage: TQueryFnData, allPages: Array<TQueryFnData>, lastPageParam: TPageParam, allPageParams: Array<TPageParam>) => TPageParam | undefined | null;
+/**
+ * The data shape of an infinite query: every page fetched so far, plus the page param each one was fetched with.
+ * `pages` and `pageParams` are index-aligned — `pageParams[i]` is the param that produced `pages[i]`.
+ */
 interface InfiniteData<TData, TPageParam = unknown> {
   pages: Array<TData>;
   pageParams: Array<TPageParam>;
 }
+/**
+ * The type of the `meta` object that can be attached to a query and read back from `queryFn`, callbacks and
+ * cache-level handlers. Defaults to `Record<string, unknown>`; declare `queryMeta` on {@link Register} to narrow it.
+ */
 type QueryMeta = Register extends {
   queryMeta: infer TQueryMeta;
 } ? TQueryMeta extends Record<string, unknown> ? TQueryMeta : Record<string, unknown> : Record<string, unknown>;
+/** @inline */
 type NetworkMode = 'online' | 'always' | 'offlineFirst';
+/** @inline */
 type NotifyOnChangeProps = Array<keyof InfiniteQueryObserverResult> | 'all' | undefined | (() => Array<keyof InfiniteQueryObserverResult> | 'all' | undefined);
 interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> {
   /**
@@ -1847,7 +1905,7 @@ interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQ
   /**
    * Controls whether a query is allowed to run based on the current network connectivity.
    *
-   * Defaults to `'online'`.
+   * @defaultValue 'online'
    * @see [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
    */
   networkMode?: NetworkMode;
@@ -1913,7 +1971,7 @@ interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQ
    * Set this to `false` to disable structural sharing between query results.
    * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.
    *
-   * Defaults to `true`.
+   * @defaultValue true
    */
   structuralSharing?: boolean | ((oldData: unknown | undefined, newData: unknown) => unknown);
   /** @internal */
@@ -1931,6 +1989,13 @@ interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQ
   maxPages?: number;
 }
 interface InitialPageParam<TPageParam = unknown> {
+  /**
+   * The page param to start from when an infinite query has no pages yet.
+   * It is passed to `queryFn` as `pageParam` for the first page; every page after that gets the
+   * value returned by `getNextPageParam` or `getPreviousPageParam`.
+   * It only applies while the query has no pages: once a first page exists, refetching starts from
+   * that page's own param instead.
+   */
   initialPageParam: TPageParam;
 }
 interface InfiniteQueryPageParamsOptions<TQueryFnData = unknown, TPageParam = unknown> extends InitialPageParam<TPageParam> {
@@ -1945,6 +2010,7 @@ interface InfiniteQueryPageParamsOptions<TQueryFnData = unknown, TPageParam = un
    */
   getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>;
 }
+/** @inline */
 type ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey extends QueryKey> = boolean | ((error: TError, query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean);
 interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam>, 'queryKey'> {
   /**
@@ -1952,7 +2018,7 @@ interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TD
    * To refetch the query, use the `refetch` method returned from the `useQuery` instance.
    * Accepts a boolean or function that returns a boolean.
    *
-   * Defaults to `true`.
+   * @defaultValue true
    */
   enabled?: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>;
   /**
@@ -1961,20 +2027,20 @@ interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TD
    * If set to `'static'`, the data will never be considered stale.
    * If set to a function, the function will be executed with the query to compute a `staleTime`.
    *
-   * Defaults to `0`.
+   * @defaultValue 0
    */
   staleTime?: StaleTimeFunction<TQueryFnData, TError, TQueryData, TQueryKey>;
   /**
    * If set to a number, the query will continuously refetch at this frequency in milliseconds.
    * If set to a function, the function will be executed with the latest data and query to compute a frequency
    *
-   * Defaults to `false`.
+   * @defaultValue false
    */
   refetchInterval?: number | false | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => number | false | undefined);
   /**
    * If set to `true`, the query will continue to refetch while their tab/window is in the background.
    *
-   * Defaults to `false`.
+   * @defaultValue false
    */
   refetchIntervalInBackground?: boolean;
   /**
@@ -1983,7 +2049,7 @@ interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TD
    * If set to `'always'`, the query will always refetch on window focus (except when `staleTime: 'static'` is used).
    * If set to a function, the function will be executed with the latest data and query to compute the value.
    *
-   * Defaults to `true`.
+   * @defaultValue true
    */
   refetchOnWindowFocus?: boolean | 'always' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | 'always');
   /**
@@ -2001,14 +2067,14 @@ interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TD
    * If set to `'always'`, the query will always refetch on mount (except when `staleTime: 'static'` is used).
    * If set to a function, the function will be executed with the latest data and query to compute the value
    *
-   * Defaults to `true`.
+   * @defaultValue true
    */
   refetchOnMount?: boolean | 'always' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | 'always');
   /**
    * If set to `false`, the query will not be retried on mount if it contains an error.
    * If set to a function, the function will be executed with the query to compute the value.
    *
-   * Defaults to `true`.
+   * @defaultValue true
    */
   retryOnMount?: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>;
   /**
@@ -2027,7 +2093,7 @@ interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TD
    * If set to `false` and `suspense` is `false`, errors are returned as state.
    * If set to a function, it will be passed the error and the query, and it should return a boolean indicating whether to show the error in an error boundary (`true`) or return the error as state (`false`).
    *
-   * Defaults to `false`.
+   * @defaultValue false
    */
   throwOnError?: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
   /**
@@ -2041,7 +2107,7 @@ interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TD
    * If set to `true`, the query will suspend when `status === 'pending'`
    * and throw errors when `status === 'error'`.
    *
-   * Defaults to `false`.
+   * @defaultValue false
    */
   suspense?: boolean;
   /**
@@ -2057,6 +2123,10 @@ interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultE
 type DefaultedInfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = WithRequired<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'throwOnError' | 'refetchOnReconnect' | 'queryHash'>;
 interface QueryExecuteOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam>, 'queryKey'> {
   initialPageParam?: never;
+  /**
+   * This option can be used to transform or select a part of the data returned by the query function. It affects
+   * the value this call resolves with, but does not affect what gets stored in the query cache.
+   */
   select?: (data: TQueryData) => TData;
   /**
    * The time in milliseconds after data is considered stale.
@@ -2093,9 +2163,9 @@ type FetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TD
 interface ResultOptions {
   /**
    * If set to `true`, the method throws if any of the underlying query refetch tasks fail.
+   * If set to `false`, failed refetches are swallowed and not surfaced to the caller.
    *
-   * Defaults to `false`, in which case failed refetches are swallowed and not surfaced to the
-   * caller.
+   * @defaultValue false
    */
   throwOnError?: boolean;
 }
@@ -2105,7 +2175,7 @@ interface RefetchOptions extends ResultOptions {
    *
    * If set to `false`, no refetch will be made if there is already a request running.
    *
-   * Defaults to `true`.
+   * @defaultValue true
    */
   cancelRefetch?: boolean;
 }
@@ -2113,11 +2183,12 @@ interface InvalidateQueryFilters<TQueryKey extends QueryKey = QueryKey> extends
   /**
    * Controls which of the matched (now-invalidated) queries are refetched in the background.
    *
-   * Defaults to `'active'`.
    * - `'active'`: only queries with at least one active observer are refetched.
    * - `'inactive'`: only queries with no active observer are refetched.
    * - `'all'`: every matched query is refetched, active or not.
    * - `'none'`: no query is refetched; matched queries are only marked as invalidated.
+   *
+   * @defaultValue 'active'
    */
   refetchType?: QueryTypeFilter | 'none';
 }
@@ -2131,7 +2202,7 @@ interface FetchNextPageOptions extends ResultOptions {
    *
    * If set to `false`, calling `fetchNextPage` repeatedly won't have any effect until the first invocation has resolved.
    *
-   * Defaults to `true`.
+   * @defaultValue true
    */
   cancelRefetch?: boolean;
 }
@@ -2142,11 +2213,13 @@ interface FetchPreviousPageOptions extends ResultOptions {
    *
    * If set to `false`, calling `fetchPreviousPage` repeatedly won't have any effect until the first invocation has resolved.
    *
-   * Defaults to `true`.
+   * @defaultValue true
    */
   cancelRefetch?: boolean;
 }
+/** @inline */
 type QueryStatus = 'pending' | 'error' | 'success';
+/** @inline */
 type FetchStatus = 'fetching' | 'paused' | 'idle';
 interface QueryObserverBaseResult<TData = unknown, TError = DefaultError> {
   /**
@@ -2460,13 +2533,27 @@ interface InfiniteQueryObserverPlaceholderResult<TData = unknown, TError = Defau
 }
 type DefinedInfiniteQueryObserverResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverRefetchErrorResult<TData, TError> | InfiniteQueryObserverSuccessResult<TData, TError>;
 type InfiniteQueryObserverResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError> | InfiniteQueryObserverLoadingErrorResult<TData, TError> | InfiniteQueryObserverLoadingResult<TData, TError> | InfiniteQueryObserverPendingResult<TData, TError> | InfiniteQueryObserverPlaceholderResult<TData, TError>;
+/**
+ * The type of a mutation key — the serializable array used to identify and filter mutations.
+ * Defaults to `ReadonlyArray<unknown>`; declare `mutationKey` on {@link Register} to narrow it repository-wide.
+ */
 type MutationKey = Register extends {
   mutationKey: infer TMutationKey;
 } ? TMutationKey extends ReadonlyArray<unknown> ? TMutationKey : TMutationKey extends Array<unknown> ? TMutationKey : ReadonlyArray<unknown> : ReadonlyArray<unknown>;
+/** @inline */
 type MutationStatus = 'idle' | 'pending' | 'success' | 'error';
+/**
+ * Groups mutations so they run one after another instead of in parallel.
+ * Mutations that share the same `id` form a queue: while one is running, the others wait in `isPaused: true`
+ * state and resume automatically when their turn comes. Mutations with no scope always run in parallel.
+ */
 type MutationScope = {
   id: string;
 };
+/**
+ * The type of the `meta` object that can be attached to a mutation and read back from `mutationFn`, callbacks and
+ * cache-level handlers. Defaults to `Record<string, unknown>`; declare `mutationMeta` on {@link Register} to narrow it.
+ */
 type MutationMeta = Register extends {
   mutationMeta: infer TMutationMeta;
 } ? TMutationMeta extends Record<string, unknown> ? TMutationMeta : Record<string, unknown> : Record<string, unknown>;
@@ -2475,13 +2562,47 @@ type MutationFunctionContext = {
   meta: MutationMeta | undefined;
   mutationKey?: MutationKey;
 };
+/** @inline */
 type MutationFunction<TData = unknown, TVariables = unknown> = (variables: TVariables, context: MutationFunctionContext) => Promise<TData>;
 interface MutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> {
+  /**
+   * The function that performs the asynchronous task this mutation runs.
+   * Required, unless a default mutation function has been set for the matching `mutationKey` via
+   * `queryClient.setMutationDefaults`.
+   * Receives the `variables` passed to `mutate`, and a {@link MutationFunctionContext} holding the
+   * `QueryClient`, the `mutationKey` and `meta`.
+   * Must return a promise that resolves the mutation's data.
+   */
   mutationFn?: MutationFunction<TData, TVariables>;
+  /**
+   * The key to use for this mutation. Optional, but required to inherit defaults registered with
+   * `queryClient.setMutationDefaults`, and to match this mutation with `useMutationState` or
+   * `queryClient.isMutating`.
+   */
   mutationKey?: MutationKey;
+  /**
+   * This function fires before the mutation function runs, and receives the same variables.
+   * Useful for optimistic updates applied in the hope that the mutation succeeds.
+   * The value it returns is passed to `onSuccess`, `onError` and `onSettled` as `onMutateResult`,
+   * which is where an optimistic update is usually rolled back.
+   * If a promise is returned, it is awaited before the mutation function runs.
+   */
   onMutate?: (variables: TVariables, context: MutationFunctionContext) => Promise<TOnMutateResult> | TOnMutateResult;
+  /**
+   * This function fires when the mutation succeeds, and is passed the mutation's result.
+   * If a promise is returned, it is awaited before `onSettled` runs.
+   */
   onSuccess?: (data: TData, variables: TVariables, onMutateResult: TOnMutateResult, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  /**
+   * This function fires when the mutation encounters an error, and is passed the error.
+   * If a promise is returned, it is awaited before `onSettled` runs.
+   */
   onError?: (error: TError, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  /**
+   * This function fires when the mutation either succeeds or errors, and is passed either the data
+   * or the error.
+   * If a promise is returned, it is awaited before the mutation settles.
+   */
   onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => Promise<unknown> | unknown;
   /**
    * If `false`, failed mutations will not retry by default.
@@ -2489,7 +2610,7 @@ interface MutationOptions<TData = unknown, TError = DefaultError, TVariables = v
    * If set to an integer number, e.g. 3, failed mutations will retry until the failed mutation count meets that number.
    * If set to a function `(failureCount, error) => boolean` failed mutations will retry until the function returns false.
    *
-   * Defaults to `0`.
+   * @defaultValue 0
    */
   retry?: RetryValue<TError>;
   /**
@@ -2502,7 +2623,7 @@ interface MutationOptions<TData = unknown, TError = DefaultError, TVariables = v
   /**
    * Controls whether a mutation is allowed to run based on the current network connectivity.
    *
-   * Defaults to `'online'`.
+   * @defaultValue 'online'
    * @see [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
    */
   networkMode?: NetworkMode;
@@ -2515,7 +2636,17 @@ interface MutationOptions<TData = unknown, TError = DefaultError, TVariables = v
   gcTime?: number;
   /** @internal */
   _defaulted?: boolean;
+  /**
+   * Additional payload to be stored on the mutation cache entry.
+   * Use it to pass information that can be read wherever the `mutation` is available, such as the
+   * `onError` and `onSuccess` callbacks of the `MutationCache`.
+   */
   meta?: MutationMeta;
+  /**
+   * Controls whether this mutation runs alongside others or waits its turn.
+   * Mutations sharing the same `scope.id` run serially, in the order they were started.
+   * Without a scope, a mutation runs as soon as it is triggered.
+   */
   scope?: MutationScope;
 }
 interface MutationObserverOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationOptions<TData, TError, TVariables, TOnMutateResult> {
@@ -2525,7 +2656,7 @@ interface MutationObserverOptions<TData = unknown, TError = DefaultError, TVaria
    * If set to a function, it will be passed the error and should return a boolean indicating whether to throw the
    * error (`true`) or return it as state (`false`).
    *
-   * Defaults to `false`.
+   * @defaultValue false
    */
   throwOnError?: boolean | ((error: TError) => boolean);
 }
@@ -2657,13 +2788,23 @@ interface DefaultOptions<TError = DefaultError> {
   /** Default options used when dehydrating the client's caches; see {@link DehydrateOptions}. */
   dehydrate?: DehydrateOptions;
 }
+/**
+ * Options for cancelling an in-flight fetch, e.g. via `query.cancel()`.
+ * They are carried on the {@link CancelledError} that the cancelled fetch rejects with.
+ */
 interface CancelOptions {
   revert?: boolean;
   silent?: boolean;
 }
+/**
+ * Options for writing data into the cache, e.g. via `queryClient.setQueryData()`.
+ * `updatedAt` overrides the timestamp the data is recorded with, which is what staleness is measured from;
+ * omit it to use the current time.
+ */
 interface SetDataOptions {
   updatedAt?: number;
 }
+/** @inline */
 type NotifyEventType = 'added' | 'removed' | 'updated' | 'observerAdded' | 'observerRemoved' | 'observerResultsUpdated' | 'observerOptionsUpdated';
 interface NotifyEvent {
   type: NotifyEventType;
@@ -2694,6 +2835,7 @@ interface DehydrateOptions {
  * `DehydratedState`, and how to reverse any transformation applied by `DehydrateOptions.serializeData`.
  */
 interface HydrateOptions {
+  /** Options applied to the queries and mutations restored from the dehydrated state. */
   defaultOptions?: {
     /** Transforms a query's `data` after it is read from the dehydrated state, reversing `serializeData`. */
     deserializeData?: TransformerFn;
@@ -2787,4 +2929,4 @@ declare function dehydrate(client: QueryClient, options?: DehydrateOptions): Deh
 declare function hydrate(client: QueryClient, dehydratedState: Partial<DehydratedState>, options?: HydrateOptions): void;
 //#endregion
 export { MutationObserverBaseResult as $, Query as $n, CancelledError as $t, InfiniteData as A, noop as An, QueryObserverOptions as At, InfiniteQueryObserverSuccessResult as B, Action as Bn, RefetchQueryFilters as Bt, FetchPreviousPageOptions as C, isPlainArray as Cn, QueryKey as Ct, GetPreviousPageParamFunction as D, keepPreviousData as Dn, QueryObserverBaseResult as Dt, GetNextPageParamFunction as E, isValidTimeout as En, QueryMeta as Et, InfiniteQueryObserverOptions as F, shallowEqualObjects as Fn, QueryObserverSuccessResult as Ft, InvalidateQueryFilters as G, MutationCacheConfig as Gn, StaleTime as Gt, InitialDataFunction as H, MutationState as Hn, ResetOptions as Ht, InfiniteQueryObserverPendingResult as I, shouldThrowError as In, QueryOptions as It, MutateOptions as J, Action$1 as Jn, UnsetMarker as Jt, MutateFunction as K, MutationCacheNotifyEvent as Kn, StaleTimeFunction as Kt, InfiniteQueryObserverPlaceholderResult as L, skipToken as Ln, QueryPersister as Lt, InfiniteQueryObserverBaseResult as M, replaceData as Mn, QueryObserverPlaceholderResult as Mt, InfiniteQueryObserverLoadingErrorResult as N, replaceEqualDeep as Nn, QueryObserverRefetchErrorResult as Nt, InferDataFromTag as O, matchMutation as On, QueryObserverLoadingErrorResult as Ot, InfiniteQueryObserverLoadingResult as P, resolveQueryValue as Pn, QueryObserverResult as Pt, MutationMeta as Q, FetchOptions as Qn, unsetMarker as Qt, InfiniteQueryObserverRefetchErrorResult as R, sleep as Rn, QueryStatus as Rt, FetchNextPageOptions as S, hashQueryKeyByOptions as Sn, QueryFunctionContext as St, FetchStatus as T, isServer as Tn, QueryKeyWithDataTag as Tt, InitialPageParam as U, getDefaultState as Un, ResultOptions as Ut, InfiniteQueryPageParamsOptions as V, Mutation as Vn, Register as Vt, InvalidateOptions as W, MutationCache as Wn, SetDataOptions as Wt, MutationFunctionContext as X, FetchDirection as Xn, dataTagErrorSymbol as Xt, MutationFunction as Y, FetchContext as Yn, WithRequired as Yt, MutationKey as Z, FetchMeta as Zn, dataTagSymbol as Zt, DefinedQueryObserverResult as _, addToEnd as _n, QueriesPlaceholderDataFunction as _t, defaultShouldDehydrateQuery as a, isCancelledError as an, MutationObserverSuccessResult as at, EnsureQueryDataOptions as b, functionalUpdate as bn, QueryExecuteOptions as bt, hydrate as c, QueryCacheConfig as cn, MutationStatus as ct, DataTag as d, MutationFilters as dn, NotifyEvent as dt, RetryDelayValue as en, QueryBehavior as er, MutationObserverErrorResult as et, DefaultError as f, QueryFilters as fn, NotifyEventType as ft, DefinedInfiniteQueryObserverResult as g, addConsumeAwareSignal as gn, PlaceholderDataFunction as gt, DefaultedQueryObserverOptions as h, Updater as hn, Override as ht, defaultShouldDehydrateMutation as i, createRetryer as in, MutationObserverResult as it, InfiniteQueryExecuteOptions as j, partialMatchKey as jn, QueryObserverPendingResult as jt, InferErrorFromTag as k, matchQuery as kn, QueryObserverLoadingResult as kt, AnyDataTag as l, QueryCacheNotifyEvent as ln, NetworkMode as lt, DefaultedInfiniteQueryObserverOptions as m, SkipToken as mn, OmitKeyof as mt, DehydratedState as n, Retryer as nn, fetchState as nr, MutationObserverLoadingResult as nt, dehydrate as o, QueryClient as on, MutationOptions as ot, DefaultOptions as p, QueryTypeFilter as pn, NotifyOnChangeProps as pt, MutateFunctionRest as q, MutationObserver as qn, ThrowOnError as qt, HydrateOptions as r, canFetch as rn, QueryObserver as rr, MutationObserverOptions as rt, dehydrateQuery as s, QueryCache as sn, MutationScope as st, DehydrateOptions as t, RetryValue as tn, QueryState as tr, MutationObserverIdleResult as tt, CancelOptions as u, QueryStore as un, NonUndefinedGuard as ut, DistributiveOmit as v, addToStart as vn, QueryBooleanOption as vt, FetchQueryOptions as w, isPlainObject as wn, QueryKeyHashFunction as wt, FetchInfiniteQueryOptions as x, hashKey as xn, QueryFunction as xt, EnsureInfiniteQueryDataOptions as y, ensureQueryFn as yn, QueryClientConfig as yt, InfiniteQueryObserverResult as z, timeUntilStale as zn, RefetchOptions as zt };
-//# sourceMappingURL=hydration-Cq7QYAzB.d.ts.map
+//# sourceMappingURL=hydration-Br9VIGXa.d.cts.map

package/build/modern/hydration-Br9VIGXa.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydration-Br9VIGXa.d.cts","names":["FailedAction","SuccessAction","ErrorAction","PauseAction","ContinueAction","Action","Action"],"sources":["../../src/queryObserver.ts","../../src/query.ts","../../src/mutationObserver.ts","../../src/mutationCache.ts","../../src/mutation.ts","../../src/utils.ts","../../src/queryCache.ts","../../src/queryClient.ts","../../src/retryer.ts","../../src/types.ts","../../src/hydration.ts"],"mappings":"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C,MAAM;EACN,OAAO;EACP;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe,2BACf,iBACA,SAAS,sBACD,wBAAwB,OAAO;EACvC,MAAM;EACN;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe,+BACf,iBACA,SAAS,sBACD,wBAAwB,OAAO;EACvC,MAAM;EACN;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;KAGU,2BAA2B,iBAAiB,SAAS,gBAC7D,gCAAgC,OAAO,UACvC,2BAA2B,OAAO;KAE1B,oBAAoB,iBAAiB,SAAS,gBACtD,2BAA2B,OAAO,UAClC,gCAAgC,OAAO,UACvC,2BAA2B,OAAO,UAClC,2BAA2B,OAAO,UAClC,+BAA+B,OAAO;UAEzB,gCACf,iBACA,SAAS,sBACD,wBAAwB,OAAO;;;;EAIvC,gBACE,UAAU,yBACP,QAAQ,4BAA4B,OAAO;;;;EAIhD,oBACE,UAAU,6BACP,QAAQ,4BAA4B,OAAO;;;;EAIhD;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;UAGe,mCACf,iBACA,SAAS,sBACD,gCAAgC,OAAO;EAC/C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe,mCACf,iBACA,SAAS,sBACD,gCAAgC,OAAO;EAC/C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe,wCACf,iBACA,SAAS,sBACD,gCAAgC,OAAO;EAC/C;EACA,OAAO;EACP;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe,wCACf,iBACA,SAAS,sBACD,gCAAgC,OAAO;EAC/C,MAAM;EACN,OAAO;EACP;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe,mCACf,iBACA,SAAS,sBACD,gCAAgC,OAAO;EAC/C,MAAM;EACN;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe,uCACf,iBACA,SAAS,sBACD,gCAAgC,OAAO;EAC/C,MAAM;EACN;EACA;EACA;EACA;EACA;EAC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"}

package/build/modern/hydration.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hydration.cjs","names":["noop"],"sources":["../../src/hydration.ts"],"sourcesContent":["import { noop } from './utils'\nimport type {\n  DefaultError,\n  MutationKey,\n  MutationMeta,\n  MutationOptions,\n  MutationScope,\n  QueryKey,\n  QueryMeta,\n  QueryOptions,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query, QueryState } from './query'\nimport type { Mutation, MutationState } from './mutation'\n\n// TYPES\ntype TransformerFn = (data: any) => any\n\nfunction tryResolveSync(promise: PromiseLike<unknown>) {\n  let data: unknown\n\n  const thenResult = promise.then((result) => {\n    data = result\n    return result\n  }, noop) as Promise<unknown> | undefined\n\n  // .catch can be unavailable on certain kinds of thenable's\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  thenResult?.catch?.(noop)\n\n  if (data !== undefined) {\n    return { data }\n  }\n\n  return undefined\n}\n\n/**\n * Options for `dehydrate`, controlling which queries/mutations are included in the resulting `DehydratedState` and\n * how their data/errors are transformed before being serialized (e.g. for embedding in server-rendered markup).\n */\nexport interface DehydrateOptions {\n  /** Transforms a query's `data` before it is dehydrated. Useful for non-JSON-serializable data. */\n  serializeData?: TransformerFn\n  /** Predicate to decide whether a given `Mutation` should be dehydrated. Defaults to `defaultShouldDehydrateMutation`. */\n  shouldDehydrateMutation?: (mutation: Mutation) => boolean\n  /** Predicate to decide whether a given `Query` should be dehydrated. Defaults to `defaultShouldDehydrateQuery`. */\n  shouldDehydrateQuery?: (query: Query) => boolean\n  /**\n   * Predicate to decide whether a query's error should be redacted before dehydration. Errors are redacted\n   * (replaced with a generic `Error('redacted')`) unless this function is provided and returns `false` for the\n   * given error, in which case the original error is kept.\n   */\n  shouldRedactErrors?: (error: unknown) => boolean\n}\n\n/**\n * Options for `hydrate`, controlling the default options applied to queries/mutations restored from a\n * `DehydratedState`, and how to reverse any transformation applied by `DehydrateOptions.serializeData`.\n */\nexport interface HydrateOptions {\n  defaultOptions?: {\n    /** Transforms a query's `data` after it is read from the dehydrated state, reversing `serializeData`. */\n    deserializeData?: TransformerFn\n    /** Default options merged into every query restored from the dehydrated state. */\n    queries?: QueryOptions\n    /** Default options merged into every mutation restored from the dehydrated state. */\n    mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>\n  }\n}\n\ninterface DehydratedMutation {\n  mutationKey?: MutationKey\n  state: MutationState\n  meta?: MutationMeta\n  scope?: MutationScope\n}\n\ninterface DehydratedQuery {\n  queryHash: string\n  queryKey: QueryKey\n  state: QueryState\n  dehydratedAt: number\n  promise?: Promise<unknown>\n  meta?: QueryMeta\n  queryType?: 'infinite'\n}\n\n/**\n * A serializable snapshot of a `QueryClient`'s cache, as produced by `dehydrate` and consumed by `hydrate`. Typically\n * transported from server to client (e.g. embedded in server-rendered markup) to seed the client's cache with data\n * that has already been fetched, avoiding a redundant fetch on the client.\n */\nexport interface DehydratedState {\n  mutations: Array<DehydratedMutation>\n  queries: Array<DehydratedQuery>\n}\n\n// FUNCTIONS\n\nfunction dehydrateMutation(mutation: Mutation): DehydratedMutation {\n  return {\n    mutationKey: mutation.options.mutationKey,\n    state: mutation.state,\n    ...(mutation.options.scope && { scope: mutation.options.scope }),\n    ...(mutation.meta && { meta: mutation.meta }),\n  }\n}\n\nfunction dehydratePromise(\n  query: Query,\n  serializeData?: TransformerFn,\n  shouldRedactErrors?: (error: unknown) => boolean,\n): Promise<unknown> | undefined {\n  const promise = query.promise?.then(serializeData).catch((error) => {\n    if (shouldRedactErrors?.(error) === false) {\n      // Reject original error if it should not be redacted\n      return Promise.reject(error)\n    }\n    // If not in production, log original error before rejecting redacted error\n    if (process.env.NODE_ENV !== 'production') {\n      console.error(\n        `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`,\n      )\n    }\n    return Promise.reject(new Error('redacted'))\n  })\n\n  // Avoid unhandled promise rejections\n  // We need the promise we dehydrate to reject to get the correct result into\n  // the query cache, but we also want to avoid unhandled promise rejections\n  // in whatever environment the prefetches are happening in.\n  promise?.catch(noop)\n\n  return promise\n}\n\n/**\n * Dehydrates a single `Query` into a serializable `DehydratedQuery` snapshot. Note that most query config (e.g.\n * `queryFn`, `staleTime`) is not dehydrated but instead meant to be configured again when consuming the\n * de/rehydrated data, typically with `useQuery` on the client. If the query is still `pending`, its in-flight\n * promise is dehydrated too so it can be resumed on the other side instead of re-fetched.\n * @param query - The query to dehydrate.\n * @param serializeData - Optional transform applied to `query.state.data` before it is included in the snapshot.\n * @param shouldRedactErrors - Optional predicate; if it returns `false` for the promise's rejection error, that\n * error is kept as-is instead of being redacted.\n */\nexport function dehydrateQuery(\n  query: Query,\n  serializeData?: TransformerFn,\n  shouldRedactErrors?: (error: unknown) => boolean,\n): DehydratedQuery {\n  return {\n    dehydratedAt: Date.now(),\n    state: {\n      ...query.state,\n      ...(query.state.data !== undefined && {\n        data: serializeData\n          ? serializeData(query.state.data)\n          : query.state.data,\n      }),\n    },\n    queryKey: query.queryKey,\n    queryHash: query.queryHash,\n    ...(query.state.status === 'pending' && {\n      promise: dehydratePromise(query, serializeData, shouldRedactErrors),\n    }),\n    ...(query.meta && { meta: query.meta }),\n    ...(query.queryType && { queryType: query.queryType }),\n  }\n}\n\n/**\n * The default `shouldDehydrateMutation` predicate used by `dehydrate`. Only dehydrates mutations that are\n * currently paused (e.g. paused by `networkMode` while offline).\n */\nexport function defaultShouldDehydrateMutation(mutation: Mutation) {\n  return mutation.state.isPaused\n}\n\n/**\n * The default `shouldDehydrateQuery` predicate used by `dehydrate`. Only dehydrates queries whose status is\n * `'success'`.\n */\nexport function defaultShouldDehydrateQuery(query: Query) {\n  return query.state.status === 'success'\n}\n\n/**\n * Dehydrates a `QueryClient`'s cache (queries and mutations) into a plain, serializable `DehydratedState`,\n * typically to embed in server-rendered markup and later restore into a client-side `QueryClient` via `hydrate`.\n * Which queries/mutations are included, and how their data/errors are transformed, is controlled by `options`,\n * falling back to the client's `dehydrate` default options, and finally to `defaultShouldDehydrateQuery` /\n * `defaultShouldDehydrateMutation`.\n * @example\n * ```ts\n * const queryClient = new QueryClient()\n *\n * await queryClient.prefetchQuery({\n *   queryKey: ['posts'],\n *   queryFn: getPosts,\n * })\n *\n * const dehydratedState = dehydrate(queryClient)\n * ```\n */\nexport function dehydrate(\n  client: QueryClient,\n  options: DehydrateOptions = {},\n): DehydratedState {\n  const filterMutation =\n    options.shouldDehydrateMutation ??\n    client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ??\n    defaultShouldDehydrateMutation\n\n  const mutations = client\n    .getMutationCache()\n    .getAll()\n    .flatMap((mutation) =>\n      filterMutation(mutation) ? [dehydrateMutation(mutation)] : [],\n    )\n\n  const filterQuery =\n    options.shouldDehydrateQuery ??\n    client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ??\n    defaultShouldDehydrateQuery\n\n  const shouldRedactErrors =\n    options.shouldRedactErrors ??\n    client.getDefaultOptions().dehydrate?.shouldRedactErrors\n\n  const serializeData =\n    options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData\n\n  const queries = client\n    .getQueryCache()\n    .getAll()\n    .flatMap((query) =>\n      filterQuery(query)\n        ? [dehydrateQuery(query, serializeData, shouldRedactErrors)]\n        : [],\n    )\n\n  return { mutations, queries }\n}\n\n/**\n * Restores a `DehydratedState` (as produced by `dehydrate`) into a `QueryClient`'s cache, typically to seed the\n * client with data already fetched on the server. `mutations` and `queries` are each optional on `dehydratedState`.\n * Queries not yet in the cache are built from the dehydrated snapshot; queries that already exist are only updated\n * when the dehydrated data is newer than what's already cached. Newly built queries have their `fetchStatus` reset\n * to `'idle'` so they don't hydrate stuck in a fetching state. If a dehydrated query still had an in-flight\n * promise, it is resumed via `query.fetch()` (reusing that promise as `initialPromise`) rather than re-invoking\n * `queryFn`.\n * @example\n * ```ts\n * // dehydratedState was produced by `dehydrate` on the server\n * // and sent to the client, e.g. embedded in server-rendered markup.\n * const queryClient = new QueryClient()\n *\n * hydrate(queryClient, dehydratedState)\n * ```\n */\nexport function hydrate(\n  client: QueryClient,\n  dehydratedState: Partial<DehydratedState>,\n  options?: HydrateOptions,\n): void {\n  const mutationCache = client.getMutationCache()\n  const queryCache = client.getQueryCache()\n  const deserializeData =\n    options?.defaultOptions?.deserializeData ??\n    client.getDefaultOptions().hydrate?.deserializeData\n\n  dehydratedState.mutations?.forEach(({ state, ...mutationOptions }) => {\n    mutationCache.build(\n      client,\n      {\n        ...client.getDefaultOptions().hydrate?.mutations,\n        ...options?.defaultOptions?.mutations,\n        ...mutationOptions,\n      },\n      state,\n    )\n  })\n\n  dehydratedState.queries?.forEach(\n    ({\n      queryKey,\n      state,\n      queryHash,\n      meta,\n      promise,\n      dehydratedAt,\n      queryType,\n    }) => {\n      const syncData = promise ? tryResolveSync(promise) : undefined\n      const rawData = state.data === undefined ? syncData?.data : state.data\n      const data =\n        rawData === undefined\n          ? rawData\n          : deserializeData\n            ? deserializeData(rawData)\n            : rawData\n\n      let query = queryCache.get(queryHash)\n      const existingQueryIsPending = query?.state.status === 'pending'\n      const existingQueryIsFetching = query?.state.fetchStatus === 'fetching'\n\n      // Do not hydrate if an existing query exists with newer data\n      if (query) {\n        const hasNewerSyncData =\n          syncData && dehydratedAt > query.state.dataUpdatedAt\n        if (\n          state.dataUpdatedAt > query.state.dataUpdatedAt ||\n          hasNewerSyncData\n        ) {\n          // Omit fetchStatus from dehydrated state so that query stays in its current fetchStatus\n          const { fetchStatus: _ignored, ...serializedState } = state\n          query.setState({\n            ...serializedState,\n            data,\n            // If the query was pending at the moment of dehydration, but resolved to have data\n            // before hydration, we can assume the query should be hydrated as successful.\n            //\n            // Since you can opt into dehydrating failed queries, and those can have data from\n            // previous successful fetches, we make sure we only do this for pending queries.\n            ...(state.status === 'pending' &&\n              data !== undefined && {\n                status: 'success' as const,\n                dataUpdatedAt: dehydratedAt,\n                // Preserve existing fetchStatus if the existing query is actively fetching.\n                ...(!existingQueryIsFetching && {\n                  fetchStatus: 'idle' as const,\n                }),\n              }),\n          })\n        }\n      } else {\n        // Restore query\n        query = queryCache.build(\n          client,\n          {\n            ...client.getDefaultOptions().hydrate?.queries,\n            ...options?.defaultOptions?.queries,\n            queryKey,\n            queryHash,\n            meta,\n            _type: queryType,\n          },\n          // Reset fetch status to idle to avoid\n          // query being stuck in fetching state upon hydration\n          {\n            ...state,\n            data,\n            fetchStatus: 'idle',\n            // Like above, if the query was pending at the moment of dehydration but has data,\n            // we can assume it should be hydrated as successful.\n            status:\n              state.status === 'pending' && data !== undefined\n                ? 'success'\n                : state.status,\n            ...(state.status === 'pending' &&\n              data !== undefined && {\n                dataUpdatedAt: dehydratedAt,\n              }),\n          },\n        )\n      }\n\n      if (\n        promise &&\n        // If the data was synchronously available, there is no need to set up\n        // a retryer and thus no reason to call fetch\n        !syncData &&\n        !existingQueryIsPending &&\n        !existingQueryIsFetching &&\n        // Only hydrate if dehydration is newer than any existing data,\n        // this is always true for new queries\n        dehydratedAt > query.state.dataUpdatedAt\n      ) {\n        // This doesn't actually fetch - it just creates a retryer\n        // which will re-use the passed `initialPromise`\n        query\n          .fetch(undefined, {\n            // RSC transformed promises are not thenable\n            initialPromise: Promise.resolve(promise).then(deserializeData),\n          })\n          // Avoid unhandled promise rejections\n          .catch(noop)\n      }\n    },\n  )\n}\n"],"mappings":"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"}
+{"version":3,"file":"hydration.cjs","names":["noop"],"sources":["../../src/hydration.ts"],"sourcesContent":["import { noop } from './utils'\nimport type {\n  DefaultError,\n  MutationKey,\n  MutationMeta,\n  MutationOptions,\n  MutationScope,\n  QueryKey,\n  QueryMeta,\n  QueryOptions,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query, QueryState } from './query'\nimport type { Mutation, MutationState } from './mutation'\n\n// TYPES\ntype TransformerFn = (data: any) => any\n\nfunction tryResolveSync(promise: PromiseLike<unknown>) {\n  let data: unknown\n\n  const thenResult = promise.then((result) => {\n    data = result\n    return result\n  }, noop) as Promise<unknown> | undefined\n\n  // .catch can be unavailable on certain kinds of thenable's\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  thenResult?.catch?.(noop)\n\n  if (data !== undefined) {\n    return { data }\n  }\n\n  return undefined\n}\n\n/**\n * Options for `dehydrate`, controlling which queries/mutations are included in the resulting `DehydratedState` and\n * how their data/errors are transformed before being serialized (e.g. for embedding in server-rendered markup).\n */\nexport interface DehydrateOptions {\n  /** Transforms a query's `data` before it is dehydrated. Useful for non-JSON-serializable data. */\n  serializeData?: TransformerFn\n  /** Predicate to decide whether a given `Mutation` should be dehydrated. Defaults to `defaultShouldDehydrateMutation`. */\n  shouldDehydrateMutation?: (mutation: Mutation) => boolean\n  /** Predicate to decide whether a given `Query` should be dehydrated. Defaults to `defaultShouldDehydrateQuery`. */\n  shouldDehydrateQuery?: (query: Query) => boolean\n  /**\n   * Predicate to decide whether a query's error should be redacted before dehydration. Errors are redacted\n   * (replaced with a generic `Error('redacted')`) unless this function is provided and returns `false` for the\n   * given error, in which case the original error is kept.\n   */\n  shouldRedactErrors?: (error: unknown) => boolean\n}\n\n/**\n * Options for `hydrate`, controlling the default options applied to queries/mutations restored from a\n * `DehydratedState`, and how to reverse any transformation applied by `DehydrateOptions.serializeData`.\n */\nexport interface HydrateOptions {\n  /** Options applied to the queries and mutations restored from the dehydrated state. */\n  defaultOptions?: {\n    /** Transforms a query's `data` after it is read from the dehydrated state, reversing `serializeData`. */\n    deserializeData?: TransformerFn\n    /** Default options merged into every query restored from the dehydrated state. */\n    queries?: QueryOptions\n    /** Default options merged into every mutation restored from the dehydrated state. */\n    mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>\n  }\n}\n\ninterface DehydratedMutation {\n  mutationKey?: MutationKey\n  state: MutationState\n  meta?: MutationMeta\n  scope?: MutationScope\n}\n\ninterface DehydratedQuery {\n  queryHash: string\n  queryKey: QueryKey\n  state: QueryState\n  dehydratedAt: number\n  promise?: Promise<unknown>\n  meta?: QueryMeta\n  queryType?: 'infinite'\n}\n\n/**\n * A serializable snapshot of a `QueryClient`'s cache, as produced by `dehydrate` and consumed by `hydrate`. Typically\n * transported from server to client (e.g. embedded in server-rendered markup) to seed the client's cache with data\n * that has already been fetched, avoiding a redundant fetch on the client.\n */\nexport interface DehydratedState {\n  mutations: Array<DehydratedMutation>\n  queries: Array<DehydratedQuery>\n}\n\n// FUNCTIONS\n\nfunction dehydrateMutation(mutation: Mutation): DehydratedMutation {\n  return {\n    mutationKey: mutation.options.mutationKey,\n    state: mutation.state,\n    ...(mutation.options.scope && { scope: mutation.options.scope }),\n    ...(mutation.meta && { meta: mutation.meta }),\n  }\n}\n\nfunction dehydratePromise(\n  query: Query,\n  serializeData?: TransformerFn,\n  shouldRedactErrors?: (error: unknown) => boolean,\n): Promise<unknown> | undefined {\n  const promise = query.promise?.then(serializeData).catch((error) => {\n    if (shouldRedactErrors?.(error) === false) {\n      // Reject original error if it should not be redacted\n      return Promise.reject(error)\n    }\n    // If not in production, log original error before rejecting redacted error\n    if (process.env.NODE_ENV !== 'production') {\n      console.error(\n        `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`,\n      )\n    }\n    return Promise.reject(new Error('redacted'))\n  })\n\n  // Avoid unhandled promise rejections\n  // We need the promise we dehydrate to reject to get the correct result into\n  // the query cache, but we also want to avoid unhandled promise rejections\n  // in whatever environment the prefetches are happening in.\n  promise?.catch(noop)\n\n  return promise\n}\n\n/**\n * Dehydrates a single `Query` into a serializable `DehydratedQuery` snapshot. Note that most query config (e.g.\n * `queryFn`, `staleTime`) is not dehydrated but instead meant to be configured again when consuming the\n * de/rehydrated data, typically with `useQuery` on the client. If the query is still `pending`, its in-flight\n * promise is dehydrated too so it can be resumed on the other side instead of re-fetched.\n * @param query - The query to dehydrate.\n * @param serializeData - Optional transform applied to `query.state.data` before it is included in the snapshot.\n * @param shouldRedactErrors - Optional predicate; if it returns `false` for the promise's rejection error, that\n * error is kept as-is instead of being redacted.\n */\nexport function dehydrateQuery(\n  query: Query,\n  serializeData?: TransformerFn,\n  shouldRedactErrors?: (error: unknown) => boolean,\n): DehydratedQuery {\n  return {\n    dehydratedAt: Date.now(),\n    state: {\n      ...query.state,\n      ...(query.state.data !== undefined && {\n        data: serializeData\n          ? serializeData(query.state.data)\n          : query.state.data,\n      }),\n    },\n    queryKey: query.queryKey,\n    queryHash: query.queryHash,\n    ...(query.state.status === 'pending' && {\n      promise: dehydratePromise(query, serializeData, shouldRedactErrors),\n    }),\n    ...(query.meta && { meta: query.meta }),\n    ...(query.queryType && { queryType: query.queryType }),\n  }\n}\n\n/**\n * The default `shouldDehydrateMutation` predicate used by `dehydrate`. Only dehydrates mutations that are\n * currently paused (e.g. paused by `networkMode` while offline).\n */\nexport function defaultShouldDehydrateMutation(mutation: Mutation) {\n  return mutation.state.isPaused\n}\n\n/**\n * The default `shouldDehydrateQuery` predicate used by `dehydrate`. Only dehydrates queries whose status is\n * `'success'`.\n */\nexport function defaultShouldDehydrateQuery(query: Query) {\n  return query.state.status === 'success'\n}\n\n/**\n * Dehydrates a `QueryClient`'s cache (queries and mutations) into a plain, serializable `DehydratedState`,\n * typically to embed in server-rendered markup and later restore into a client-side `QueryClient` via `hydrate`.\n * Which queries/mutations are included, and how their data/errors are transformed, is controlled by `options`,\n * falling back to the client's `dehydrate` default options, and finally to `defaultShouldDehydrateQuery` /\n * `defaultShouldDehydrateMutation`.\n * @example\n * ```ts\n * const queryClient = new QueryClient()\n *\n * await queryClient.prefetchQuery({\n *   queryKey: ['posts'],\n *   queryFn: getPosts,\n * })\n *\n * const dehydratedState = dehydrate(queryClient)\n * ```\n */\nexport function dehydrate(\n  client: QueryClient,\n  options: DehydrateOptions = {},\n): DehydratedState {\n  const filterMutation =\n    options.shouldDehydrateMutation ??\n    client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ??\n    defaultShouldDehydrateMutation\n\n  const mutations = client\n    .getMutationCache()\n    .getAll()\n    .flatMap((mutation) =>\n      filterMutation(mutation) ? [dehydrateMutation(mutation)] : [],\n    )\n\n  const filterQuery =\n    options.shouldDehydrateQuery ??\n    client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ??\n    defaultShouldDehydrateQuery\n\n  const shouldRedactErrors =\n    options.shouldRedactErrors ??\n    client.getDefaultOptions().dehydrate?.shouldRedactErrors\n\n  const serializeData =\n    options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData\n\n  const queries = client\n    .getQueryCache()\n    .getAll()\n    .flatMap((query) =>\n      filterQuery(query)\n        ? [dehydrateQuery(query, serializeData, shouldRedactErrors)]\n        : [],\n    )\n\n  return { mutations, queries }\n}\n\n/**\n * Restores a `DehydratedState` (as produced by `dehydrate`) into a `QueryClient`'s cache, typically to seed the\n * client with data already fetched on the server. `mutations` and `queries` are each optional on `dehydratedState`.\n * Queries not yet in the cache are built from the dehydrated snapshot; queries that already exist are only updated\n * when the dehydrated data is newer than what's already cached. Newly built queries have their `fetchStatus` reset\n * to `'idle'` so they don't hydrate stuck in a fetching state. If a dehydrated query still had an in-flight\n * promise, it is resumed via `query.fetch()` (reusing that promise as `initialPromise`) rather than re-invoking\n * `queryFn`.\n * @example\n * ```ts\n * // dehydratedState was produced by `dehydrate` on the server\n * // and sent to the client, e.g. embedded in server-rendered markup.\n * const queryClient = new QueryClient()\n *\n * hydrate(queryClient, dehydratedState)\n * ```\n */\nexport function hydrate(\n  client: QueryClient,\n  dehydratedState: Partial<DehydratedState>,\n  options?: HydrateOptions,\n): void {\n  const mutationCache = client.getMutationCache()\n  const queryCache = client.getQueryCache()\n  const deserializeData =\n    options?.defaultOptions?.deserializeData ??\n    client.getDefaultOptions().hydrate?.deserializeData\n\n  dehydratedState.mutations?.forEach(({ state, ...mutationOptions }) => {\n    mutationCache.build(\n      client,\n      {\n        ...client.getDefaultOptions().hydrate?.mutations,\n        ...options?.defaultOptions?.mutations,\n        ...mutationOptions,\n      },\n      state,\n    )\n  })\n\n  dehydratedState.queries?.forEach(\n    ({\n      queryKey,\n      state,\n      queryHash,\n      meta,\n      promise,\n      dehydratedAt,\n      queryType,\n    }) => {\n      const syncData = promise ? tryResolveSync(promise) : undefined\n      const rawData = state.data === undefined ? syncData?.data : state.data\n      const data =\n        rawData === undefined\n          ? rawData\n          : deserializeData\n            ? deserializeData(rawData)\n            : rawData\n\n      let query = queryCache.get(queryHash)\n      const existingQueryIsPending = query?.state.status === 'pending'\n      const existingQueryIsFetching = query?.state.fetchStatus === 'fetching'\n\n      // Do not hydrate if an existing query exists with newer data\n      if (query) {\n        const hasNewerSyncData =\n          syncData && dehydratedAt > query.state.dataUpdatedAt\n        if (\n          state.dataUpdatedAt > query.state.dataUpdatedAt ||\n          hasNewerSyncData\n        ) {\n          // Omit fetchStatus from dehydrated state so that query stays in its current fetchStatus\n          const { fetchStatus: _ignored, ...serializedState } = state\n          query.setState({\n            ...serializedState,\n            data,\n            // If the query was pending at the moment of dehydration, but resolved to have data\n            // before hydration, we can assume the query should be hydrated as successful.\n            //\n            // Since you can opt into dehydrating failed queries, and those can have data from\n            // previous successful fetches, we make sure we only do this for pending queries.\n            ...(state.status === 'pending' &&\n              data !== undefined && {\n                status: 'success' as const,\n                dataUpdatedAt: dehydratedAt,\n                // Preserve existing fetchStatus if the existing query is actively fetching.\n                ...(!existingQueryIsFetching && {\n                  fetchStatus: 'idle' as const,\n                }),\n              }),\n          })\n        }\n      } else {\n        // Restore query\n        query = queryCache.build(\n          client,\n          {\n            ...client.getDefaultOptions().hydrate?.queries,\n            ...options?.defaultOptions?.queries,\n            queryKey,\n            queryHash,\n            meta,\n            _type: queryType,\n          },\n          // Reset fetch status to idle to avoid\n          // query being stuck in fetching state upon hydration\n          {\n            ...state,\n            data,\n            fetchStatus: 'idle',\n            // Like above, if the query was pending at the moment of dehydration but has data,\n            // we can assume it should be hydrated as successful.\n            status:\n              state.status === 'pending' && data !== undefined\n                ? 'success'\n                : state.status,\n            ...(state.status === 'pending' &&\n              data !== undefined && {\n                dataUpdatedAt: dehydratedAt,\n              }),\n          },\n        )\n      }\n\n      if (\n        promise &&\n        // If the data was synchronously available, there is no need to set up\n        // a retryer and thus no reason to call fetch\n        !syncData &&\n        !existingQueryIsPending &&\n        !existingQueryIsFetching &&\n        // Only hydrate if dehydration is newer than any existing data,\n        // this is always true for new queries\n        dehydratedAt > query.state.dataUpdatedAt\n      ) {\n        // This doesn't actually fetch - it just creates a retryer\n        // which will re-use the passed `initialPromise`\n        query\n          .fetch(undefined, {\n            // RSC transformed promises are not thenable\n            initialPromise: Promise.resolve(promise).then(deserializeData),\n          })\n          // Avoid unhandled promise rejections\n          .catch(noop)\n      }\n    },\n  )\n}\n"],"mappings":";;;AAkBA,SAAS,eAAe,SAA+B;CACrD,IAAI;CASJ,QAP2B,MAAM,WAAW;EAC1C,OAAO;EACP,OAAO;CACT,GAAGA,cAAAA,IAIM,CAAC,EAAE,QAAQA,cAAAA,IAAI;CAExB,IAAI,SAAS,KAAA,GACX,OAAO,EAAE,KAAK;AAIlB;AAkEA,SAAS,kBAAkB,UAAwC;CACjE,OAAO;EACL,aAAa,SAAS,QAAQ;EAC9B,OAAO,SAAS;EAChB,GAAI,SAAS,QAAQ,SAAS,EAAE,OAAO,SAAS,QAAQ,MAAM;EAC9D,GAAI,SAAS,QAAQ,EAAE,MAAM,SAAS,KAAK;CAC7C;AACF;AAEA,SAAS,iBACP,OACA,eACA,oBAC8B;CAC9B,MAAM,UAAU,MAAM,SAAS,KAAK,aAAa,CAAC,CAAC,OAAO,UAAU;EAClE,IAAI,qBAAqB,KAAK,MAAM,OAElC,OAAO,QAAQ,OAAO,KAAK;EAG7B,IAAI,QAAQ,IAAI,aAAa,cAC3B,QAAQ,MACN,+DAA+D,MAAM,UAAU,KAAK,MAAM,kDAC5F;EAEF,OAAO,QAAQ,uBAAO,IAAI,MAAM,UAAU,CAAC;CAC7C,CAAC;CAMD,SAAS,MAAMA,cAAAA,IAAI;CAEnB,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,eACd,OACA,eACA,oBACiB;CACjB,OAAO;EACL,cAAc,KAAK,IAAI;EACvB,OAAO;GACL,GAAG,MAAM;GACT,GAAI,MAAM,MAAM,SAAS,KAAA,KAAa,EACpC,MAAM,gBACF,cAAc,MAAM,MAAM,IAAI,IAC9B,MAAM,MAAM,KAClB;EACF;EACA,UAAU,MAAM;EAChB,WAAW,MAAM;EACjB,GAAI,MAAM,MAAM,WAAW,aAAa,EACtC,SAAS,iBAAiB,OAAO,eAAe,kBAAkB,EACpE;EACA,GAAI,MAAM,QAAQ,EAAE,MAAM,MAAM,KAAK;EACrC,GAAI,MAAM,aAAa,EAAE,WAAW,MAAM,UAAU;CACtD;AACF;;;;;AAMA,SAAgB,+BAA+B,UAAoB;CACjE,OAAO,SAAS,MAAM;AACxB;;;;;AAMA,SAAgB,4BAA4B,OAAc;CACxD,OAAO,MAAM,MAAM,WAAW;AAChC;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,UACd,QACA,UAA4B,CAAC,GACZ;CACjB,MAAM,iBACJ,QAAQ,2BACR,OAAO,kBAAkB,CAAC,CAAC,WAAW,2BACtC;CAEF,MAAM,YAAY,OACf,iBAAiB,CAAC,CAClB,OAAO,CAAC,CACR,SAAS,aACR,eAAe,QAAQ,IAAI,CAAC,kBAAkB,QAAQ,CAAC,IAAI,CAAC,CAC9D;CAEF,MAAM,cACJ,QAAQ,wBACR,OAAO,kBAAkB,CAAC,CAAC,WAAW,wBACtC;CAEF,MAAM,qBACJ,QAAQ,sBACR,OAAO,kBAAkB,CAAC,CAAC,WAAW;CAExC,MAAM,gBACJ,QAAQ,iBAAiB,OAAO,kBAAkB,CAAC,CAAC,WAAW;CAWjE,OAAO;EAAE;EAAW,SATJ,OACb,cAAc,CAAC,CACf,OAAO,CAAC,CACR,SAAS,UACR,YAAY,KAAK,IACb,CAAC,eAAe,OAAO,eAAe,kBAAkB,CAAC,IACzD,CAAC,CAGiB;CAAE;AAC9B;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,QACd,QACA,iBACA,SACM;CACN,MAAM,gBAAgB,OAAO,iBAAiB;CAC9C,MAAM,aAAa,OAAO,cAAc;CACxC,MAAM,kBACJ,SAAS,gBAAgB,mBACzB,OAAO,kBAAkB,CAAC,CAAC,SAAS;CAEtC,gBAAgB,WAAW,SAAS,EAAE,OAAO,GAAG,sBAAsB;EACpE,cAAc,MACZ,QACA;GACE,GAAG,OAAO,kBAAkB,CAAC,CAAC,SAAS;GACvC,GAAG,SAAS,gBAAgB;GAC5B,GAAG;EACL,GACA,KACF;CACF,CAAC;CAED,gBAAgB,SAAS,SACtB,EACC,UACA,OACA,WACA,MACA,SACA,cACA,gBACI;EACJ,MAAM,WAAW,UAAU,eAAe,OAAO,IAAI,KAAA;EACrD,MAAM,UAAU,MAAM,SAAS,KAAA,IAAY,UAAU,OAAO,MAAM;EAClE,MAAM,OACJ,YAAY,KAAA,IACR,UACA,kBACE,gBAAgB,OAAO,IACvB;EAER,IAAI,QAAQ,WAAW,IAAI,SAAS;EACpC,MAAM,yBAAyB,OAAO,MAAM,WAAW;EACvD,MAAM,0BAA0B,OAAO,MAAM,gBAAgB;EAG7D,IAAI,OAAO;GACT,MAAM,mBACJ,YAAY,eAAe,MAAM,MAAM;GACzC,IACE,MAAM,gBAAgB,MAAM,MAAM,iBAClC,kBACA;IAEA,MAAM,EAAE,aAAa,UAAU,GAAG,oBAAoB;IACtD,MAAM,SAAS;KACb,GAAG;KACH;KAMA,GAAI,MAAM,WAAW,aACnB,SAAS,KAAA,KAAa;MACpB,QAAQ;MACR,eAAe;MAEf,GAAI,CAAC,2BAA2B,EAC9B,aAAa,OACf;KACF;IACJ,CAAC;GACH;EACF,OAEE,QAAQ,WAAW,MACjB,QACA;GACE,GAAG,OAAO,kBAAkB,CAAC,CAAC,SAAS;GACvC,GAAG,SAAS,gBAAgB;GAC5B;GACA;GACA;GACA,OAAO;EACT,GAGA;GACE,GAAG;GACH;GACA,aAAa;GAGb,QACE,MAAM,WAAW,aAAa,SAAS,KAAA,IACnC,YACA,MAAM;GACZ,GAAI,MAAM,WAAW,aACnB,SAAS,KAAA,KAAa,EACpB,eAAe,aACjB;EACJ,CACF;EAGF,IACE,WAGA,CAAC,YACD,CAAC,0BACD,CAAC,2BAGD,eAAe,MAAM,MAAM,eAI3B,MACG,MAAM,KAAA,GAAW,EAEhB,gBAAgB,QAAQ,QAAQ,OAAO,CAAC,CAAC,KAAK,eAAe,EAC/D,CAAC,CAAC,CAED,MAAMA,cAAAA,IAAI;CAEjB,CACF;AACF"}