@tanstack/query-core 5.103.2 → 5.103.3

package/build/modern/queryCache.js.map

@@ -1 +1 @@
-{"version":3,"file":"queryCache.js","names":["#queries"],"sources":["../../src/queryCache.ts"],"sourcesContent":["import { hashQueryKeyByOptions, matchQuery } from './utils'\nimport { Query } from './query'\nimport { notifyManager } from './notifyManager'\nimport { Subscribable } from './subscribable'\nimport type { QueryFilters } from './utils'\nimport type { Action, QueryState } from './query'\nimport type {\n  DefaultError,\n  NotifyEvent,\n  QueryKey,\n  QueryOptions,\n  WithRequired,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { QueryObserver } from './queryObserver'\n\n// TYPES\n\n/**\n * Global callbacks that fire for every query handled by a `QueryCache`, regardless of which\n * component or observer triggered it. Unlike `QueryClient`'s `defaultOptions`, which a query can\n * override, these callbacks are always called. Unlike `MutationCacheConfig`'s callbacks, these\n * are fire-and-forget: their return value is not awaited before the query settles.\n */\nexport interface QueryCacheConfig {\n  /** Called when any query in the cache encounters an error. */\n  onError?: (\n    error: DefaultError,\n    query: Query<unknown, unknown, unknown>,\n  ) => void\n  /** Called when any query in the cache is successful. */\n  onSuccess?: (data: unknown, query: Query<unknown, unknown, unknown>) => void\n  /** Called when any query in the cache is settled, either successfully or with an error. */\n  onSettled?: (\n    data: unknown | undefined,\n    error: DefaultError | null,\n    query: Query<unknown, unknown, unknown>,\n  ) => void\n}\n\ninterface NotifyEventQueryAdded extends NotifyEvent {\n  type: 'added'\n  query: Query<any, any, any, any>\n}\n\ninterface NotifyEventQueryRemoved extends NotifyEvent {\n  type: 'removed'\n  query: Query<any, any, any, any>\n}\n\ninterface NotifyEventQueryUpdated extends NotifyEvent {\n  type: 'updated'\n  query: Query<any, any, any, any>\n  action: Action<any, any>\n}\n\ninterface NotifyEventQueryObserverAdded extends NotifyEvent {\n  type: 'observerAdded'\n  query: Query<any, any, any, any>\n  observer: QueryObserver<any, any, any, any, any>\n}\n\ninterface NotifyEventQueryObserverRemoved extends NotifyEvent {\n  type: 'observerRemoved'\n  query: Query<any, any, any, any>\n  observer: QueryObserver<any, any, any, any, any>\n}\n\ninterface NotifyEventQueryObserverResultsUpdated extends NotifyEvent {\n  type: 'observerResultsUpdated'\n  query: Query<any, any, any, any>\n}\n\ninterface NotifyEventQueryObserverOptionsUpdated extends NotifyEvent {\n  type: 'observerOptionsUpdated'\n  query: Query<any, any, any, any>\n  observer: QueryObserver<any, any, any, any, any>\n}\n\n/**\n * The event passed to a `QueryCache` subscriber. Fired whenever a query is added or removed from\n * the cache, its state is updated (e.g. via `query.setState` or `queryClient.removeQueries`), or\n * one of its observers is added, removed, or has its results or options updated.\n */\nexport type QueryCacheNotifyEvent =\n  | NotifyEventQueryAdded\n  | NotifyEventQueryRemoved\n  | NotifyEventQueryUpdated\n  | NotifyEventQueryObserverAdded\n  | NotifyEventQueryObserverRemoved\n  | NotifyEventQueryObserverResultsUpdated\n  | NotifyEventQueryObserverOptionsUpdated\n\ntype QueryCacheListener = (event: QueryCacheNotifyEvent) => void\n\nexport interface QueryStore {\n  has: (queryHash: string) => boolean\n  set: (queryHash: string, query: Query) => void\n  get: (queryHash: string) => Query | undefined\n  delete: (queryHash: string) => void\n  values: () => IterableIterator<Query>\n}\n\n// CLASS\n\n/**\n * The `QueryCache` is the storage mechanism for TanStack Query. It stores all the data, meta\n * information, and state of the queries it contains.\n *\n * Normally, you will not interact with the `QueryCache` directly and instead use a `QueryClient`\n * for a specific cache. You can subscribe to it (inherited from `Subscribable`) to be informed of\n * safe/known updates to the cache, such as queries being added, removed, or updated — updates made\n * outside of the cache's own tracked mechanisms (e.g. mutating a query's state object directly) do\n * not notify subscribers.\n *\n * @example\n * ```ts\n * const unsubscribe = queryCache.subscribe((event) => {\n *   console.log(event.type, event.query)\n * })\n * ```\n */\nexport class QueryCache extends Subscribable<QueryCacheListener> {\n  #queries: QueryStore\n\n  constructor(public config: QueryCacheConfig = {}) {\n    super()\n    this.#queries = new Map<string, Query>()\n  }\n\n  /**\n   * Returns the existing `Query` instance for the given options' `queryKey`/`queryHash`, or\n   * builds and adds a new one to the cache if none exists yet. Used by framework adapters and\n   * plugins (e.g. broadcast/persistence) that need to get-or-create a `Query` directly, bypassing\n   * the reactive `QueryObserver` machinery.\n   *\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   *\n   * const query = queryCache.build(queryClient, {\n   *   queryKey: ['posts'],\n   *   queryFn: fetchPosts,\n   * })\n   * ```\n   */\n  build<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n  >(\n    client: QueryClient,\n    options: WithRequired<\n      QueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n      'queryKey'\n    >,\n    state?: QueryState<TData, TError>,\n  ): Query<TQueryFnData, TError, TData, TQueryKey> {\n    const queryKey = options.queryKey\n    const queryHash =\n      options.queryHash ?? hashQueryKeyByOptions(queryKey, options)\n    let query = this.get<TQueryFnData, TError, TData, TQueryKey>(queryHash)\n\n    if (!query) {\n      query = new Query({\n        client,\n        queryKey,\n        queryHash,\n        options: client.defaultQueryOptions(options),\n        state,\n        defaultOptions: client.getQueryDefaults(queryKey),\n      })\n      this.add(query)\n    }\n\n    return query\n  }\n\n  /** @internal */\n  add(query: Query<any, any, any, any>): void {\n    if (!this.#queries.has(query.queryHash)) {\n      this.#queries.set(query.queryHash, query)\n\n      this.notify({\n        type: 'added',\n        query,\n      })\n    }\n  }\n\n  /**\n   * Destroys the given `Query` and removes it from the cache, notifying subscribers with a\n   * `'removed'` event. A no-op if the query is no longer the one currently stored under its hash\n   * (e.g. it was already replaced). Used by plugins (e.g. the broadcast client) that mirror\n   * removals across `QueryCache` instances.\n   *\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   * const query = queryCache.find({ queryKey: ['posts'] })\n   *\n   * if (query) {\n   *   queryCache.remove(query)\n   * }\n   * ```\n   */\n  remove(query: Query<any, any, any, any>): void {\n    const queryInMap = this.#queries.get(query.queryHash)\n\n    if (queryInMap === query) {\n      query.destroy()\n      this.#queries.delete(query.queryHash)\n      this.notify({ type: 'removed', query })\n    }\n  }\n\n  /**\n   * Removes all queries from the cache.\n   *\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   *\n   * queryCache.clear()\n   * ```\n   */\n  clear(): void {\n    notifyManager.batch(() => {\n      this.getAll().forEach((query) => {\n        this.remove(query)\n      })\n    })\n  }\n\n  /**\n   * Returns the `Query` instance stored under the given `queryHash`, or `undefined` if none\n   * exists. Unlike {@link QueryCache#find}, this looks up by the already-computed hash rather\n   * than by `QueryFilters`. Used by plugins (e.g. broadcast/hydration) that already have a hash\n   * to look up directly.\n   *\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   * const queryHash = hashKey(['posts'])\n   *\n   * const query = queryCache.get(queryHash)\n   * ```\n   */\n  get<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n  >(\n    queryHash: string,\n  ): Query<TQueryFnData, TError, TData, TQueryKey> | undefined {\n    return this.#queries.get(queryHash) as\n      | Query<TQueryFnData, TError, TData, TQueryKey>\n      | undefined\n  }\n\n  /**\n   * Returns all queries within the cache.\n   *\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   *\n   * const queries = queryCache.getAll()\n   * ```\n   */\n  getAll(): Array<Query> {\n    return [...this.#queries.values()]\n  }\n\n  /**\n   * A slightly more advanced method that can be used to get an existing query instance from the\n   * cache. This instance not only contains all the state for the query, but all of the instances,\n   * and underlying guts of the query as well. If the query does not exist, `undefined` is\n   * returned.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about a query in rare scenarios (e.g. looking at `query.state.dataUpdatedAt` to\n   * decide whether a query is fresh enough to be used as an initial value).\n   *\n   * @see {@link QueryCache#findAll}\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   *\n   * const query = queryCache.find({ queryKey: ['posts'] })\n   * ```\n   */\n  find<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData>(\n    filters: WithRequired<QueryFilters, 'queryKey'>,\n  ): Query<TQueryFnData, TError, TData> | undefined {\n    const defaultedFilters = { exact: true, ...filters }\n\n    return this.getAll().find((query) =>\n      matchQuery(defaultedFilters, query),\n    ) as Query<TQueryFnData, TError, TData> | undefined\n  }\n\n  /**\n   * An even more advanced method that can be used to get existing query instances from the cache\n   * that partially match a query key. If no queries match, an empty array is returned.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about queries in rare scenarios.\n   *\n   * @see {@link QueryCache#find}\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   *\n   * const queries = queryCache.findAll({ queryKey: ['posts'] })\n   * ```\n   */\n  findAll(filters: QueryFilters<any> = {}): Array<Query> {\n    const queries = this.getAll()\n    return Object.keys(filters).length > 0\n      ? queries.filter((query) => matchQuery(filters, query))\n      : queries\n  }\n\n  /** @internal */\n  notify(event: QueryCacheNotifyEvent): void {\n    notifyManager.batch(() => {\n      this.listeners.forEach((listener) => {\n        listener(event)\n      })\n    })\n  }\n\n  /** @internal */\n  onFocus(): void {\n    notifyManager.batch(() => {\n      this.getAll().forEach((query) => {\n        query.onFocus()\n      })\n    })\n  }\n\n  /** @internal */\n  onOnline(): void {\n    notifyManager.batch(() => {\n      this.getAll().forEach((query) => {\n        query.onOnline()\n      })\n    })\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA0HA,IAAa,aAAb,cAAgC,aAAiC;CAC/D;CAEA,YAAY,SAAkC,CAAC,GAAG;EAChD,MAAM;EADW,KAAA,SAAA;EAEjB,KAAKA,2BAAW,IAAI,IAAmB;CACzC;;;;;;;;;;;;;;;;;CAkBA,MAME,QACA,SAIA,OAC+C;EAC/C,MAAM,WAAW,QAAQ;EACzB,MAAM,YACJ,QAAQ,aAAa,sBAAsB,UAAU,OAAO;EAC9D,IAAI,QAAQ,KAAK,IAA4C,SAAS;EAEtE,IAAI,CAAC,OAAO;GACV,QAAQ,IAAI,MAAM;IAChB;IACA;IACA;IACA,SAAS,OAAO,oBAAoB,OAAO;IAC3C;IACA,gBAAgB,OAAO,iBAAiB,QAAQ;GAClD,CAAC;GACD,KAAK,IAAI,KAAK;EAChB;EAEA,OAAO;CACT;;CAGA,IAAI,OAAwC;EAC1C,IAAI,CAAC,KAAKA,SAAS,IAAI,MAAM,SAAS,GAAG;GACvC,KAAKA,SAAS,IAAI,MAAM,WAAW,KAAK;GAExC,KAAK,OAAO;IACV,MAAM;IACN;GACF,CAAC;EACH;CACF;;;;;;;;;;;;;;;;;CAkBA,OAAO,OAAwC;EAG7C,IAFmB,KAAKA,SAAS,IAAI,MAAM,SAE9B,MAAM,OAAO;GACxB,MAAM,QAAQ;GACd,KAAKA,SAAS,OAAO,MAAM,SAAS;GACpC,KAAK,OAAO;IAAE,MAAM;IAAW;GAAM,CAAC;EACxC;CACF;;;;;;;;;;;CAYA,QAAc;EACZ,cAAc,YAAY;GACxB,KAAK,OAAO,CAAC,CAAC,SAAS,UAAU;IAC/B,KAAK,OAAO,KAAK;GACnB,CAAC;EACH,CAAC;CACH;;;;;;;;;;;;;;;CAgBA,IAME,WAC2D;EAC3D,OAAO,KAAKA,SAAS,IAAI,SAAS;CAGpC;;;;;;;;;;;CAYA,SAAuB;EACrB,OAAO,CAAC,GAAG,KAAKA,SAAS,OAAO,CAAC;CACnC;;;;;;;;;;;;;;;;;;;CAoBA,KACE,SACgD;EAChD,MAAM,mBAAmB;GAAE,OAAO;GAAM,GAAG;EAAQ;EAEnD,OAAO,KAAK,OAAO,CAAC,CAAC,MAAM,UACzB,WAAW,kBAAkB,KAAK,CACpC;CACF;;;;;;;;;;;;;;;;CAiBA,QAAQ,UAA6B,CAAC,GAAiB;EACrD,MAAM,UAAU,KAAK,OAAO;EAC5B,OAAO,OAAO,KAAK,OAAO,CAAC,CAAC,SAAS,IACjC,QAAQ,QAAQ,UAAU,WAAW,SAAS,KAAK,CAAC,IACpD;CACN;;CAGA,OAAO,OAAoC;EACzC,cAAc,YAAY;GACxB,KAAK,UAAU,SAAS,aAAa;IACnC,SAAS,KAAK;GAChB,CAAC;EACH,CAAC;CACH;;CAGA,UAAgB;EACd,cAAc,YAAY;GACxB,KAAK,OAAO,CAAC,CAAC,SAAS,UAAU;IAC/B,MAAM,QAAQ;GAChB,CAAC;EACH,CAAC;CACH;;CAGA,WAAiB;EACf,cAAc,YAAY;GACxB,KAAK,OAAO,CAAC,CAAC,SAAS,UAAU;IAC/B,MAAM,SAAS;GACjB,CAAC;EACH,CAAC;CACH;AACF"}
+{"version":3,"file":"queryCache.js","names":[],"sources":["../../src/queryCache.ts"],"sourcesContent":["import { hashQueryKeyByOptions, matchQuery } from './utils'\nimport { Query } from './query'\nimport { notifyManager } from './notifyManager'\nimport { Subscribable } from './subscribable'\nimport type { QueryFilters } from './utils'\nimport type { Action, QueryState } from './query'\nimport type {\n  DefaultError,\n  NotifyEvent,\n  QueryKey,\n  QueryOptions,\n  WithRequired,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { QueryObserver } from './queryObserver'\n\n// TYPES\n\n/**\n * Global callbacks that fire for every query handled by a `QueryCache`, regardless of which\n * component or observer triggered it. Unlike `QueryClient`'s `defaultOptions`, which a query can\n * override, these callbacks are always called. Unlike `MutationCacheConfig`'s callbacks, these\n * are fire-and-forget: their return value is not awaited before the query settles.\n */\nexport interface QueryCacheConfig {\n  /** Called when any query in the cache encounters an error. */\n  onError?: (\n    error: DefaultError,\n    query: Query<unknown, unknown, unknown>,\n  ) => void\n  /** Called when any query in the cache is successful. */\n  onSuccess?: (data: unknown, query: Query<unknown, unknown, unknown>) => void\n  /** Called when any query in the cache is settled, either successfully or with an error. */\n  onSettled?: (\n    data: unknown | undefined,\n    error: DefaultError | null,\n    query: Query<unknown, unknown, unknown>,\n  ) => void\n}\n\ninterface NotifyEventQueryAdded extends NotifyEvent {\n  type: 'added'\n  query: Query<any, any, any, any>\n}\n\ninterface NotifyEventQueryRemoved extends NotifyEvent {\n  type: 'removed'\n  query: Query<any, any, any, any>\n}\n\ninterface NotifyEventQueryUpdated extends NotifyEvent {\n  type: 'updated'\n  query: Query<any, any, any, any>\n  action: Action<any, any>\n}\n\ninterface NotifyEventQueryObserverAdded extends NotifyEvent {\n  type: 'observerAdded'\n  query: Query<any, any, any, any>\n  observer: QueryObserver<any, any, any, any, any>\n}\n\ninterface NotifyEventQueryObserverRemoved extends NotifyEvent {\n  type: 'observerRemoved'\n  query: Query<any, any, any, any>\n  observer: QueryObserver<any, any, any, any, any>\n}\n\ninterface NotifyEventQueryObserverResultsUpdated extends NotifyEvent {\n  type: 'observerResultsUpdated'\n  query: Query<any, any, any, any>\n}\n\ninterface NotifyEventQueryObserverOptionsUpdated extends NotifyEvent {\n  type: 'observerOptionsUpdated'\n  query: Query<any, any, any, any>\n  observer: QueryObserver<any, any, any, any, any>\n}\n\n/**\n * The event passed to a `QueryCache` subscriber. Fired whenever a query is added or removed from\n * the cache, its state is updated (e.g. via `query.setState` or `queryClient.removeQueries`), or\n * one of its observers is added, removed, or has its results or options updated.\n */\nexport type QueryCacheNotifyEvent =\n  | NotifyEventQueryAdded\n  | NotifyEventQueryRemoved\n  | NotifyEventQueryUpdated\n  | NotifyEventQueryObserverAdded\n  | NotifyEventQueryObserverRemoved\n  | NotifyEventQueryObserverResultsUpdated\n  | NotifyEventQueryObserverOptionsUpdated\n\ntype QueryCacheListener = (event: QueryCacheNotifyEvent) => void\n\nexport interface QueryStore {\n  has: (queryHash: string) => boolean\n  set: (queryHash: string, query: Query) => void\n  get: (queryHash: string) => Query | undefined\n  delete: (queryHash: string) => void\n  values: () => IterableIterator<Query>\n}\n\n// CLASS\n\n/**\n * The `QueryCache` is the storage mechanism for TanStack Query. It stores all the data, meta\n * information, and state of the queries it contains.\n *\n * Normally, you will not interact with the `QueryCache` directly and instead use a `QueryClient`\n * for a specific cache. You can subscribe to it (inherited from `Subscribable`) to be informed of\n * safe/known updates to the cache, such as queries being added, removed, or updated — updates made\n * outside of the cache's own tracked mechanisms (e.g. mutating a query's state object directly) do\n * not notify subscribers.\n *\n * @example\n * ```ts\n * const unsubscribe = queryCache.subscribe((event) => {\n *   console.log(event.type, event.query)\n * })\n * ```\n */\nexport class QueryCache extends Subscribable<QueryCacheListener> {\n  #queries: QueryStore\n\n  constructor(public config: QueryCacheConfig = {}) {\n    super()\n    this.#queries = new Map<string, Query>()\n  }\n\n  /**\n   * Returns the existing `Query` instance for the given options' `queryKey`/`queryHash`, or\n   * builds and adds a new one to the cache if none exists yet. Used by framework adapters and\n   * plugins (e.g. broadcast/persistence) that need to get-or-create a `Query` directly, bypassing\n   * the reactive `QueryObserver` machinery.\n   *\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   *\n   * const query = queryCache.build(queryClient, {\n   *   queryKey: ['posts'],\n   *   queryFn: fetchPosts,\n   * })\n   * ```\n   */\n  build<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n  >(\n    client: QueryClient,\n    options: WithRequired<\n      QueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n      'queryKey'\n    >,\n    state?: QueryState<TData, TError>,\n  ): Query<TQueryFnData, TError, TData, TQueryKey> {\n    const queryKey = options.queryKey\n    const queryHash =\n      options.queryHash ?? hashQueryKeyByOptions(queryKey, options)\n    let query = this.get<TQueryFnData, TError, TData, TQueryKey>(queryHash)\n\n    if (!query) {\n      query = new Query({\n        client,\n        queryKey,\n        queryHash,\n        options: client.defaultQueryOptions(options),\n        state,\n        defaultOptions: client.getQueryDefaults(queryKey),\n      })\n      this.add(query)\n    }\n\n    return query\n  }\n\n  /** @internal */\n  add(query: Query<any, any, any, any>): void {\n    if (!this.#queries.has(query.queryHash)) {\n      this.#queries.set(query.queryHash, query)\n\n      this.notify({\n        type: 'added',\n        query,\n      })\n    }\n  }\n\n  /**\n   * Destroys the given `Query` and removes it from the cache, notifying subscribers with a\n   * `'removed'` event. A no-op if the query is no longer the one currently stored under its hash\n   * (e.g. it was already replaced). Used by plugins (e.g. the broadcast client) that mirror\n   * removals across `QueryCache` instances.\n   *\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   * const query = queryCache.find({ queryKey: ['posts'] })\n   *\n   * if (query) {\n   *   queryCache.remove(query)\n   * }\n   * ```\n   */\n  remove(query: Query<any, any, any, any>): void {\n    const queryInMap = this.#queries.get(query.queryHash)\n\n    if (queryInMap === query) {\n      query.destroy()\n      this.#queries.delete(query.queryHash)\n      this.notify({ type: 'removed', query })\n    }\n  }\n\n  /**\n   * Removes all queries from the cache.\n   *\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   *\n   * queryCache.clear()\n   * ```\n   */\n  clear(): void {\n    notifyManager.batch(() => {\n      this.getAll().forEach((query) => {\n        this.remove(query)\n      })\n    })\n  }\n\n  /**\n   * Returns the `Query` instance stored under the given `queryHash`, or `undefined` if none\n   * exists. Unlike {@link QueryCache#find}, this looks up by the already-computed hash rather\n   * than by `QueryFilters`. Used by plugins (e.g. broadcast/hydration) that already have a hash\n   * to look up directly.\n   *\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   * const queryHash = hashKey(['posts'])\n   *\n   * const query = queryCache.get(queryHash)\n   * ```\n   */\n  get<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n  >(\n    queryHash: string,\n  ): Query<TQueryFnData, TError, TData, TQueryKey> | undefined {\n    return this.#queries.get(queryHash) as\n      Query<TQueryFnData, TError, TData, TQueryKey> | undefined\n  }\n\n  /**\n   * Returns all queries within the cache.\n   *\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   *\n   * const queries = queryCache.getAll()\n   * ```\n   */\n  getAll(): Array<Query> {\n    return [...this.#queries.values()]\n  }\n\n  /**\n   * A slightly more advanced method that can be used to get an existing query instance from the\n   * cache. This instance not only contains all the state for the query, but all of the instances,\n   * and underlying guts of the query as well. If the query does not exist, `undefined` is\n   * returned.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about a query in rare scenarios (e.g. looking at `query.state.dataUpdatedAt` to\n   * decide whether a query is fresh enough to be used as an initial value).\n   *\n   * @see {@link QueryCache#findAll}\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   *\n   * const query = queryCache.find({ queryKey: ['posts'] })\n   * ```\n   */\n  find<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData>(\n    filters: WithRequired<QueryFilters, 'queryKey'>,\n  ): Query<TQueryFnData, TError, TData> | undefined {\n    const defaultedFilters = { exact: true, ...filters }\n\n    return this.getAll().find((query) =>\n      matchQuery(defaultedFilters, query),\n    ) as Query<TQueryFnData, TError, TData> | undefined\n  }\n\n  /**\n   * An even more advanced method that can be used to get existing query instances from the cache\n   * that partially match a query key. If no queries match, an empty array is returned.\n   *\n   * This is not typically needed for most applications, but can come in handy when needing more\n   * information about queries in rare scenarios.\n   *\n   * @see {@link QueryCache#find}\n   * @example\n   * ```ts\n   * const queryCache = queryClient.getQueryCache()\n   *\n   * const queries = queryCache.findAll({ queryKey: ['posts'] })\n   * ```\n   */\n  findAll(filters: QueryFilters<any> = {}): Array<Query> {\n    const queries = this.getAll()\n    return Object.keys(filters).length > 0\n      ? queries.filter((query) => matchQuery(filters, query))\n      : queries\n  }\n\n  /** @internal */\n  notify(event: QueryCacheNotifyEvent): void {\n    notifyManager.batch(() => {\n      this.listeners.forEach((listener) => {\n        listener(event)\n      })\n    })\n  }\n\n  /** @internal */\n  onFocus(): void {\n    notifyManager.batch(() => {\n      this.getAll().forEach((query) => {\n        query.onFocus()\n      })\n    })\n  }\n\n  /** @internal */\n  onOnline(): void {\n    notifyManager.batch(() => {\n      this.getAll().forEach((query) => {\n        query.onOnline()\n      })\n    })\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA0HA,IAAa,aAAb,cAAgC,aAAiC;CAC/D;CAEA,YAAY,SAAkC,CAAC,GAAG;EAChD,MAAM;EADW,KAAA,SAAA;EAEjB,KAAK,2BAAW,IAAI,IAAmB;CACzC;;;;;;;;;;;;;;;;;CAkBA,MAME,QACA,SAIA,OAC+C;EAC/C,MAAM,WAAW,QAAQ;EACzB,MAAM,YACJ,QAAQ,aAAa,sBAAsB,UAAU,OAAO;EAC9D,IAAI,QAAQ,KAAK,IAA4C,SAAS;EAEtE,IAAI,CAAC,OAAO;GACV,QAAQ,IAAI,MAAM;IAChB;IACA;IACA;IACA,SAAS,OAAO,oBAAoB,OAAO;IAC3C;IACA,gBAAgB,OAAO,iBAAiB,QAAQ;GAClD,CAAC;GACD,KAAK,IAAI,KAAK;EAChB;EAEA,OAAO;CACT;;CAGA,IAAI,OAAwC;EAC1C,IAAI,CAAC,KAAK,SAAS,IAAI,MAAM,SAAS,GAAG;GACvC,KAAK,SAAS,IAAI,MAAM,WAAW,KAAK;GAExC,KAAK,OAAO;IACV,MAAM;IACN;GACF,CAAC;EACH;CACF;;;;;;;;;;;;;;;;;CAkBA,OAAO,OAAwC;EAG7C,IAFmB,KAAK,SAAS,IAAI,MAAM,SAE9B,MAAM,OAAO;GACxB,MAAM,QAAQ;GACd,KAAK,SAAS,OAAO,MAAM,SAAS;GACpC,KAAK,OAAO;IAAE,MAAM;IAAW;GAAM,CAAC;EACxC;CACF;;;;;;;;;;;CAYA,QAAc;EACZ,cAAc,YAAY;GACxB,KAAK,OAAO,CAAC,CAAC,SAAS,UAAU;IAC/B,KAAK,OAAO,KAAK;GACnB,CAAC;EACH,CAAC;CACH;;;;;;;;;;;;;;;CAgBA,IAME,WAC2D;EAC3D,OAAO,KAAK,SAAS,IAAI,SAAS;CAEpC;;;;;;;;;;;CAYA,SAAuB;EACrB,OAAO,CAAC,GAAG,KAAK,SAAS,OAAO,CAAC;CACnC;;;;;;;;;;;;;;;;;;;CAoBA,KACE,SACgD;EAChD,MAAM,mBAAmB;GAAE,OAAO;GAAM,GAAG;EAAQ;EAEnD,OAAO,KAAK,OAAO,CAAC,CAAC,MAAM,UACzB,WAAW,kBAAkB,KAAK,CACpC;CACF;;;;;;;;;;;;;;;;CAiBA,QAAQ,UAA6B,CAAC,GAAiB;EACrD,MAAM,UAAU,KAAK,OAAO;EAC5B,OAAO,OAAO,KAAK,OAAO,CAAC,CAAC,SAAS,IACjC,QAAQ,QAAQ,UAAU,WAAW,SAAS,KAAK,CAAC,IACpD;CACN;;CAGA,OAAO,OAAoC;EACzC,cAAc,YAAY;GACxB,KAAK,UAAU,SAAS,aAAa;IACnC,SAAS,KAAK;GAChB,CAAC;EACH,CAAC;CACH;;CAGA,UAAgB;EACd,cAAc,YAAY;GACxB,KAAK,OAAO,CAAC,CAAC,SAAS,UAAU;IAC/B,MAAM,QAAQ;GAChB,CAAC;EACH,CAAC;CACH;;CAGA,WAAiB;EACf,cAAc,YAAY;GACxB,KAAK,OAAO,CAAC,CAAC,SAAS,UAAU;IAC/B,MAAM,SAAS;GACjB,CAAC;EACH,CAAC;CACH;AACF"}

package/build/modern/queryClient.cjs

@@ -118,6 +118,7 @@ var QueryClient = class {
 	* 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(queryKey) {
@@ -146,6 +147,7 @@ var QueryClient = class {
 	* 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
@@ -169,6 +171,9 @@ var QueryClient = class {
 	* @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
@@ -194,6 +199,8 @@ var QueryClient = class {
 	* 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) =>

package/build/modern/queryClient.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"queryClient.cjs","names":["#queryCache","QueryCache","#mutationCache","MutationCache","#defaultOptions","#queryDefaults","#mutationDefaults","#mountCount","#unsubscribeFocus","focusManager","#unsubscribeOnline","onlineManager","resolveQueryValue","functionalUpdate","notifyManager","noop","hashKey","partialMatchKey","hashQueryKeyByOptions","skipToken"],"sources":["../../src/queryClient.ts"],"sourcesContent":["import {\n  functionalUpdate,\n  hashKey,\n  hashQueryKeyByOptions,\n  noop,\n  partialMatchKey,\n  resolveQueryValue,\n  skipToken,\n} from './utils'\nimport { QueryCache } from './queryCache'\nimport { MutationCache } from './mutationCache'\nimport { focusManager } from './focusManager'\nimport { onlineManager } from './onlineManager'\nimport { notifyManager } from './notifyManager'\nimport type {\n  CancelOptions,\n  DefaultError,\n  DefaultOptions,\n  DefaultedQueryObserverOptions,\n  EnsureInfiniteQueryDataOptions,\n  EnsureQueryDataOptions,\n  FetchInfiniteQueryOptions,\n  FetchQueryOptions,\n  InferDataFromTag,\n  InferErrorFromTag,\n  InfiniteData,\n  InfiniteQueryExecuteOptions,\n  InvalidateOptions,\n  InvalidateQueryFilters,\n  MutationKey,\n  MutationObserverOptions,\n  MutationOptions,\n  OmitKeyof,\n  QueryClientConfig,\n  QueryExecuteOptions,\n  QueryKey,\n  QueryObserverOptions,\n  QueryOptions,\n  RefetchOptions,\n  RefetchQueryFilters,\n  ResetOptions,\n  SetDataOptions,\n} from './types'\nimport type { QueryState } from './query'\nimport type { MutationFilters, QueryFilters, Updater } from './utils'\n\n// TYPES\n\ninterface QueryDefaults {\n  queryKey: QueryKey\n  defaultOptions: OmitKeyof<QueryOptions<any, any, any>, 'queryKey'>\n}\n\ninterface MutationDefaults {\n  mutationKey: MutationKey\n  defaultOptions: MutationOptions<any, any, any, any>\n}\n\n// CLASS\n\n/**\n * `QueryClient` is used to interact with a cache of queries and mutations. It owns a\n * `QueryCache` and a `MutationCache` (creating default ones if none are passed in) and holds\n * the default options that are applied to queries and mutations created through it.\n *\n * @example\n * ```ts\n * const queryClient = new QueryClient({\n *   defaultOptions: {\n *     queries: {\n *       staleTime: Infinity,\n *     },\n *   },\n * })\n *\n * await queryClient.query({ queryKey: ['posts'], queryFn: fetchPosts })\n * ```\n */\nexport class QueryClient {\n  #queryCache: QueryCache\n  #mutationCache: MutationCache\n  #defaultOptions: DefaultOptions\n  #queryDefaults: Map<string, QueryDefaults>\n  #mutationDefaults: Map<string, MutationDefaults>\n  #mountCount: number\n  #unsubscribeFocus?: () => void\n  #unsubscribeOnline?: () => void\n\n  constructor(config: QueryClientConfig = {}) {\n    this.#queryCache = config.queryCache || new QueryCache()\n    this.#mutationCache = config.mutationCache || new MutationCache()\n    this.#defaultOptions = config.defaultOptions || {}\n    this.#queryDefaults = new Map()\n    this.#mutationDefaults = new Map()\n    this.#mountCount = 0\n  }\n\n  /**\n   * Called by a framework adapter's `QueryClientProvider`-equivalent when it mounts, to start\n   * listening for focus/online events and resume paused mutations. Ref-counted via an internal\n   * mount count, so nested or multiple providers sharing the same `QueryClient` don't tear down\n   * the shared listeners until the last one unmounts.\n   */\n  mount(): void {\n    this.#mountCount++\n    if (this.#mountCount !== 1) return\n\n    this.#unsubscribeFocus = focusManager.subscribe(async (focused) => {\n      if (focused) {\n        await this.resumePausedMutations()\n        this.#queryCache.onFocus()\n      }\n    })\n    this.#unsubscribeOnline = onlineManager.subscribe(async (online) => {\n      if (online) {\n        await this.resumePausedMutations()\n        this.#queryCache.onOnline()\n      }\n    })\n  }\n\n  /**\n   * The inverse of {@link QueryClient#mount} — called by a framework adapter's\n   * `QueryClientProvider`-equivalent when it unmounts. Only tears down the focus/online\n   * listeners once the mount count returns to `0`.\n   */\n  unmount(): void {\n    this.#mountCount--\n    if (this.#mountCount !== 0) return\n\n    this.#unsubscribeFocus?.()\n    this.#unsubscribeFocus = undefined\n\n    this.#unsubscribeOnline?.()\n    this.#unsubscribeOnline = undefined\n  }\n\n  /**\n   * Returns the number of queries in the cache that are currently fetching, optionally\n   * matching a set of filters. This includes background-fetching, loading new pages, and\n   * loading more infinite query results.\n   *\n   * @example\n   * ```ts\n   * if (queryClient.isFetching()) {\n   *   console.log('At least one query is fetching!')\n   * }\n   * ```\n   */\n  isFetching<TQueryFilters extends QueryFilters<any> = QueryFilters>(\n    filters?: TQueryFilters,\n  ): number {\n    return this.#queryCache.findAll({ ...filters, fetchStatus: 'fetching' })\n      .length\n  }\n\n  /**\n   * Returns the number of mutations in the cache that are currently pending, optionally\n   * matching a set of filters.\n   *\n   * @example\n   * ```ts\n   * if (queryClient.isMutating()) {\n   *   console.log('At least one mutation is pending!')\n   * }\n   * ```\n   */\n  isMutating<\n    TMutationFilters extends MutationFilters<any, any> = MutationFilters,\n  >(filters?: TMutationFilters): number {\n    return this.#mutationCache.findAll({ ...filters, status: 'pending' }).length\n  }\n\n  /**\n   * Imperative (non-reactive) way to retrieve data for a QueryKey.\n   * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.\n   *\n   * Hint: Do not use this function inside a component, because it won't receive updates.\n   * Use `useQuery` to create a `QueryObserver` that subscribes to changes.\n   *\n   * @see {@link QueryClient#getQueriesData}\n   */\n  getQueryData<\n    TQueryFnData = unknown,\n    TTaggedQueryKey extends QueryKey = QueryKey,\n    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,\n  >(queryKey: TTaggedQueryKey): TInferredQueryFnData | undefined {\n    const options = this.defaultQueryOptions({ queryKey })\n\n    return this.#queryCache.get<TInferredQueryFnData>(options.queryHash)?.state\n      .data\n  }\n\n  /**\n   * @deprecated Use queryClient.query({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.\n   */\n  ensureQueryData<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n  >(\n    options: EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n  ): Promise<TData> {\n    const defaultedOptions = this.defaultQueryOptions(options)\n    const query = this.#queryCache.build(this, defaultedOptions)\n    const cachedData = query.state.data\n\n    if (cachedData === undefined) {\n      // eslint-disable-next-line no-restricted-syntax\n      return this.fetchQuery(options)\n    }\n\n    if (\n      options.revalidateIfStale &&\n      query.isStaleByTime(resolveQueryValue(defaultedOptions.staleTime, query))\n    ) {\n      // eslint-disable-next-line no-restricted-syntax\n      void this.prefetchQuery(defaultedOptions)\n    }\n\n    return Promise.resolve(cachedData)\n  }\n\n  /**\n   * Imperative (non-reactive) way to retrieve the cached data of multiple queries at once.\n   * Only queries matching the given filters are returned; if none match, an empty array is\n   * returned.\n   *\n   * Because the matched queries can hold data of different shapes (e.g. a broad filter can match\n   * queries with unrelated data types), the `TQueryFnData` generic defaults to `unknown` rather\n   * than being inferred. Passing a more specific type is a convenience for call sites that know\n   * every matched query holds the same shape — it is not checked against the actual cache\n   * contents.\n   *\n   * @see {@link QueryClient#getQueryData}\n   * @example\n   * ```ts\n   * const data = queryClient.getQueriesData({ queryKey: ['posts'] })\n   * ```\n   */\n  getQueriesData<\n    TQueryFnData = unknown,\n    TQueryFilters extends QueryFilters<any> = QueryFilters,\n  >(filters: TQueryFilters): Array<[QueryKey, TQueryFnData | undefined]> {\n    return this.#queryCache.findAll(filters).map(({ queryKey, state }) => {\n      const data = state.data as TQueryFnData | undefined\n      return [queryKey, data]\n    })\n  }\n\n  /**\n   * Synchronous way to immediately update a query's cached data. If the updater (or the value\n   * passed) resolves to `undefined`, the cache is left untouched and no query is created;\n   * otherwise, if the query does not exist yet, it will be created. To update multiple queries\n   * at once by partially matching query keys, use {@link QueryClient#setQueriesData} instead.\n   *\n   * Updates must be performed immutably: do not mutate `oldData`, or data previously retrieved\n   * via {@link QueryClient#getQueryData}, in place.\n   *\n   * @param queryKey - The query key to set data for.\n   * @param updater - Either the new data, or a function that receives the current data (which\n   * may be `undefined`) and returns the new data.\n   *\n   * @example\n   * ```ts\n   * queryClient.setQueryData(['posts'], newPosts)\n   *\n   * // Or, using an updater function that receives the current data:\n   * queryClient.setQueryData(['posts'], (oldPosts) => [...oldPosts, newPost])\n   * ```\n   */\n  setQueryData<\n    TQueryFnData = unknown,\n    TTaggedQueryKey extends QueryKey = QueryKey,\n    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,\n  >(\n    queryKey: TTaggedQueryKey,\n    updater: Updater<\n      NoInfer<TInferredQueryFnData> | undefined,\n      NoInfer<TInferredQueryFnData> | undefined\n    >,\n    options?: SetDataOptions,\n  ): NoInfer<TInferredQueryFnData> | undefined {\n    const defaultedOptions = this.defaultQueryOptions<\n      any,\n      any,\n      unknown,\n      any,\n      QueryKey\n    >({ queryKey })\n\n    const query = this.#queryCache.get<TInferredQueryFnData>(\n      defaultedOptions.queryHash,\n    )\n    const prevData = query?.state.data\n    const data = functionalUpdate(updater, prevData)\n\n    if (data === undefined) {\n      return undefined\n    }\n\n    return this.#queryCache\n      .build(this, defaultedOptions)\n      .setData(data, { ...options, manual: true })\n  }\n\n  /**\n   * Synchronous way to immediately update the cached data of multiple queries at once, using\n   * filters or partial query key matching. Only queries that already exist and match the given\n   * filters are updated; no new cache entries are created. Internally this calls\n   * {@link QueryClient#setQueryData} for each matching query.\n   *\n   * @example\n   * ```ts\n   * queryClient.setQueriesData({ queryKey: ['posts'] }, (oldPosts) =>\n   *   oldPosts ? oldPosts.filter((post) => post.id !== deletedId) : oldPosts,\n   * )\n   * ```\n   */\n  setQueriesData<\n    TQueryFnData,\n    TQueryFilters extends QueryFilters<any> = QueryFilters,\n  >(\n    filters: TQueryFilters,\n    updater: Updater<\n      NoInfer<TQueryFnData> | undefined,\n      NoInfer<TQueryFnData> | undefined\n    >,\n    options?: SetDataOptions,\n  ): Array<[QueryKey, TQueryFnData | undefined]> {\n    return notifyManager.batch(() =>\n      this.#queryCache\n        .findAll(filters)\n        .map(({ queryKey }) => [\n          queryKey,\n          this.setQueryData<TQueryFnData>(queryKey, updater, options),\n        ]),\n    )\n  }\n\n  /**\n   * Imperative (non-reactive) way to retrieve an existing query's state. If the query does not\n   * exist, `undefined` is returned.\n   *\n   * @example\n   * ```ts\n   * const state = queryClient.getQueryState(['posts'])\n   * console.log(state?.dataUpdatedAt)\n   * ```\n   */\n  getQueryState<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TTaggedQueryKey extends QueryKey = QueryKey,\n    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,\n    TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>,\n  >(\n    queryKey: TTaggedQueryKey,\n  ): QueryState<TInferredQueryFnData, TInferredError> | undefined {\n    const options = this.defaultQueryOptions({ queryKey })\n    return this.#queryCache.get<TInferredQueryFnData, TInferredError>(\n      options.queryHash,\n    )?.state\n  }\n\n  /**\n   * Removes queries from the cache that match the given filters. Unlike\n   * {@link QueryClient#invalidateQueries} or {@link QueryClient#refetchQueries}, this removes\n   * matching queries from the cache instead of refetching them. Without filters, every query in\n   * the cache is removed.\n   *\n   * @example\n   * ```ts\n   * queryClient.removeQueries({ queryKey: ['posts'], exact: true })\n   * ```\n   */\n  removeQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: QueryFilters<TTaggedQueryKey>,\n  ): void {\n    const queryCache = this.#queryCache\n    notifyManager.batch(() => {\n      queryCache.findAll(filters).forEach((query) => {\n        queryCache.remove(query)\n      })\n    })\n  }\n\n  /**\n   * Resets queries matching the given filters back to their initial state (e.g. any\n   * `initialData`), notifying subscribers rather than removing them. Active queries among the\n   * matched set are then refetched, and the returned promise resolves once that refetch settles.\n   *\n   * @example\n   * ```ts\n   * await queryClient.resetQueries({ queryKey: ['posts'], exact: true })\n   * ```\n   */\n  resetQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: QueryFilters<TTaggedQueryKey>,\n    options?: ResetOptions,\n  ): Promise<void> {\n    const queryCache = this.#queryCache\n\n    return notifyManager.batch(() => {\n      const matched = queryCache.findAll(filters)\n      const queriesToRefetch = new Set(matched)\n      matched.forEach((query) => {\n        query.reset()\n      })\n      return this.refetchQueries(\n        {\n          type: 'active',\n          predicate: (query) => queriesToRefetch.has(query),\n        },\n        options,\n      )\n    })\n  }\n\n  /**\n   * Cancels outgoing fetches for queries matching the given filters. Most useful when performing\n   * optimistic updates, since any outgoing refetch that resolves afterwards would otherwise\n   * overwrite the optimistic update. By default (`revert: true`), a cancelled query's data is\n   * reverted to its state before the outgoing fetch started.\n   *\n   * The returned promise never rejects, even if individual cancellations fail.\n   *\n   * @example\n   * ```ts\n   * await queryClient.cancelQueries({ queryKey: ['posts'], exact: true })\n   * ```\n   */\n  cancelQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: QueryFilters<TTaggedQueryKey>,\n    cancelOptions: CancelOptions = {},\n  ): Promise<void> {\n    const defaultedCancelOptions = { revert: true, ...cancelOptions }\n\n    const promises = notifyManager.batch(() =>\n      this.#queryCache\n        .findAll(filters)\n        .map((query) => query.cancel(defaultedCancelOptions)),\n    )\n\n    return Promise.all(promises).then(noop).catch(noop)\n  }\n\n  /**\n   * Marks queries matching the given filters as invalidated. Unlike\n   * {@link QueryClient#removeQueries}, invalidated queries stay in the cache.\n   *\n   * Unless `filters.refetchType` is `'none'`, matching queries are then refetched via\n   * {@link QueryClient#refetchQueries}, using `filters.refetchType` if set, otherwise\n   * `filters.type`, otherwise `'active'`.\n   *\n   * @example\n   * ```ts\n   * await queryClient.invalidateQueries({ queryKey: ['posts'], refetchType: 'active' })\n   * ```\n   */\n  invalidateQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: InvalidateQueryFilters<TTaggedQueryKey>,\n    options: InvalidateOptions = {},\n  ): Promise<void> {\n    return notifyManager.batch(() => {\n      this.#queryCache.findAll(filters).forEach((query) => {\n        query.invalidate()\n      })\n\n      if (filters?.refetchType === 'none') {\n        return Promise.resolve()\n      }\n      return this.refetchQueries(\n        {\n          ...filters,\n          type: filters?.refetchType ?? filters?.type ?? 'active',\n        },\n        options,\n      )\n    })\n  }\n\n  /**\n   * Refetches queries matching the given filters, regardless of whether they are stale. Without\n   * filters, every query in the cache is refetched. Queries that are disabled, or static (only\n   * have observers with a static `staleTime`), are never refetched.\n   *\n   * By default (`cancelRefetch: true`), a currently running fetch is cancelled before the new\n   * one starts. The returned promise resolves once all matching queries have settled; it does\n   * not reject on individual query failures unless `throwOnError` is set.\n   *\n   * @example\n   * ```ts\n   * // refetch all active queries partially matching a query key:\n   * await queryClient.refetchQueries({ queryKey: ['posts'], type: 'active' })\n   * ```\n   */\n  refetchQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: RefetchQueryFilters<TTaggedQueryKey>,\n    options: RefetchOptions = {},\n  ): Promise<void> {\n    const fetchOptions = {\n      ...options,\n      cancelRefetch: options.cancelRefetch ?? true,\n    }\n    const promises = notifyManager.batch(() =>\n      this.#queryCache\n        .findAll(filters)\n        .filter((query) => !query.isDisabled() && !query.isStatic())\n        .map((query) => {\n          let promise = query.fetch(undefined, fetchOptions)\n          if (!fetchOptions.throwOnError) {\n            promise = promise.catch(noop)\n          }\n          return query.state.fetchStatus === 'paused'\n            ? Promise.resolve()\n            : promise\n        }),\n    )\n\n    return Promise.all(promises).then(noop)\n  }\n\n  /**\n   * Asynchronous method to fetch and cache a query, resolving with the data or throwing with\n   * the error.\n   *\n   * If the query already exists in the cache and its data is not stale (per the given\n   * `staleTime`), the cached data is returned without fetching. Otherwise, the query is fetched\n   * and the promise resolves once the fetch settles. If a `select` function is provided, it is\n   * applied to the data in both cases (cached or freshly fetched) before it is returned.\n   *\n   * Unlike a reactive observer, retries are disabled by default here (`retry: false`) unless\n   * explicitly configured, since there is no component to catch a thrown error and retry through\n   * re-render.\n   *\n   * The accepted options are `QueryObserverOptions` minus the fields that only make sense for a\n   * reactive observer — `enabled`, `refetchInterval`, `refetchIntervalInBackground`,\n   * `refetchOnWindowFocus`, `refetchOnReconnect`, `refetchOnMount`, `retryOnMount`,\n   * `notifyOnChangeProps`, `throwOnError`, `suspense`, and `placeholderData` are not part of this\n   * method's options.\n   *\n   * This method replaces the deprecated `fetchQuery`, and — combined with\n   * `{ staleTime: 'static' }` — the deprecated `ensureQueryData`.\n   *\n   * @example\n   * ```ts\n   * try {\n   *   const data = await queryClient.query({ queryKey, queryFn, staleTime: 10000 })\n   * } catch (error) {\n   *   console.log(error)\n   * }\n   * ```\n   */\n  async query<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = never,\n  >(\n    options: QueryExecuteOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<TData> {\n    const defaultedOptions = this.defaultQueryOptions(options)\n\n    // https://github.com/tannerlinsley/react-query/issues/652\n    if (defaultedOptions.retry === undefined) {\n      defaultedOptions.retry = false\n    }\n\n    const query = this.#queryCache.build(this, defaultedOptions)\n\n    const isStale = query.isStaleByTime(\n      resolveQueryValue(defaultedOptions.staleTime, query),\n    )\n\n    const queryData = isStale\n      ? await query.fetch(defaultedOptions)\n      : (query.state.data as TQueryData)\n\n    const select = defaultedOptions.select\n\n    if (select) {\n      return select(queryData)\n    }\n\n    return queryData as unknown as TData\n  }\n\n  /**\n   * @deprecated Use queryClient.query(options) instead. This method will be removed in the next major version.\n   */\n  fetchQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = never,\n  >(\n    options: FetchQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<TData> {\n    const defaultedOptions = this.defaultQueryOptions(options)\n\n    // https://github.com/tannerlinsley/react-query/issues/652\n    if (defaultedOptions.retry === undefined) {\n      defaultedOptions.retry = false\n    }\n\n    const query = this.#queryCache.build(this, defaultedOptions)\n\n    return query.isStaleByTime(\n      resolveQueryValue(defaultedOptions.staleTime, query),\n    )\n      ? query.fetch(defaultedOptions)\n      : Promise.resolve(query.state.data as TData)\n  }\n\n  /**\n   * @deprecated Use queryClient.query(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.\n   */\n  prefetchQuery<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n  >(\n    options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  ): Promise<void> {\n    // eslint-disable-next-line no-restricted-syntax\n    return this.fetchQuery(options).then(noop).catch(noop)\n  }\n\n  /**\n   * Asynchronous method to fetch and cache an infinite query, resolving with an\n   * {@link InfiniteData} object or throwing with the error.\n   *\n   * Behaves like {@link QueryClient#query}, accepting the same options (minus\n   * `initialPageParam`), plus the required `initialPageParam`, and an optional `pages` /\n   * `getNextPageParam` pair used to refetch a fixed number of pages from the start.\n   *\n   * This method replaces the deprecated `fetchInfiniteQuery`, and — combined with\n   * `{ staleTime: 'static' }` — the deprecated `ensureInfiniteQueryData`.\n   *\n   * @example\n   * ```ts\n   * try {\n   *   const data = await queryClient.infiniteQuery({ queryKey, queryFn, initialPageParam: 0 })\n   *   console.log(data.pages)\n   * } catch (error) {\n   *   console.log(error)\n   * }\n   * ```\n   */\n  infiniteQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = InfiniteData<TQueryFnData>,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: InfiniteQueryExecuteOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<\n    Array<TData> extends Array<InfiniteData<TQueryFnData>>\n      ? InfiniteData<TQueryFnData, TPageParam>\n      : TData\n  > {\n    options._type = 'infinite'\n    return this.query(options as any)\n  }\n\n  /**\n   * @deprecated Use queryClient.infiniteQuery(options) instead. This method will be removed in the next major version.\n   */\n  fetchInfiniteQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: FetchInfiniteQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<InfiniteData<TData, TPageParam>> {\n    options._type = 'infinite'\n    // eslint-disable-next-line no-restricted-syntax\n    return this.fetchQuery(options as any)\n  }\n\n  /**\n   * @deprecated Use queryClient.infiniteQuery(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.\n   */\n  prefetchInfiniteQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: FetchInfiniteQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<void> {\n    // eslint-disable-next-line no-restricted-syntax\n    return this.fetchInfiniteQuery(options).then(noop).catch(noop)\n  }\n\n  /**\n   * @deprecated Use queryClient.infiniteQuery({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.\n   */\n  ensureInfiniteQueryData<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: EnsureInfiniteQueryDataOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<InfiniteData<TData, TPageParam>> {\n    options._type = 'infinite'\n\n    // eslint-disable-next-line no-restricted-syntax\n    return this.ensureQueryData(options as any)\n  }\n\n  /**\n   * Resumes mutations that were paused because there was no network connection. Does nothing\n   * (resolving immediately) if the client is currently offline.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * await queryClient.resumePausedMutations()\n   * ```\n   */\n  resumePausedMutations(): Promise<unknown> {\n    if (onlineManager.isOnline()) {\n      return this.#mutationCache.resumePausedMutations()\n    }\n    return Promise.resolve()\n  }\n\n  /**\n   * Returns the query cache this client is connected to.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * const queryCache = queryClient.getQueryCache()\n   * const queries = queryCache.findAll({ queryKey: ['posts'] })\n   * ```\n   */\n  getQueryCache(): QueryCache {\n    return this.#queryCache\n  }\n\n  /**\n   * Returns the mutation cache this client is connected to.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * const mutationCache = queryClient.getMutationCache()\n   * const mutations = mutationCache.findAll({ status: 'pending' })\n   * ```\n   */\n  getMutationCache(): MutationCache {\n    return this.#mutationCache\n  }\n\n  /**\n   * Returns the default options that were set when creating the client, or via\n   * {@link QueryClient#setDefaultOptions}.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * const defaultOptions = queryClient.getDefaultOptions()\n   * ```\n   */\n  getDefaultOptions(): DefaultOptions {\n    return this.#defaultOptions\n  }\n\n  /**\n   * Dynamically sets the default options for this client, overwriting any previously defined\n   * default options.\n   *\n   * @see {@link QueryClient#getDefaultOptions}\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * queryClient.setDefaultOptions({\n   *   queries: {\n   *     staleTime: Infinity,\n   *   },\n   * })\n   * ```\n   */\n  setDefaultOptions(options: DefaultOptions): void {\n    this.#defaultOptions = options\n  }\n\n  /**\n   * Sets default options for queries whose query key partially matches the given `queryKey`.\n   *\n   * If several registered query defaults match a given query key, they are merged together in\n   * registration order by {@link QueryClient#getQueryDefaults}, so register defaults from the\n   * most generic key to the least generic one — more specific defaults should be registered\n   * after more generic ones so they take precedence.\n   *\n   * @example\n   * ```ts\n   * queryClient.setQueryDefaults(['posts'], { queryFn: fetchPosts })\n   *\n   * await queryClient.query({ queryKey: ['posts'] })\n   * ```\n   */\n  setQueryDefaults<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n  >(\n    queryKey: QueryKey,\n    options: Partial<\n      OmitKeyof<\n        QueryObserverOptions<TQueryFnData, TError, TData, TQueryData>,\n        'queryKey'\n      >\n    >,\n  ): void {\n    this.#queryDefaults.set(hashKey(queryKey), {\n      queryKey,\n      defaultOptions: options,\n    })\n  }\n\n  /**\n   * Returns the default options registered for queries whose query key partially matches the\n   * given `queryKey`, via {@link QueryClient#setQueryDefaults}. If multiple registered defaults\n   * match, they are merged together in registration order.\n   *\n   * @example\n   * ```ts\n   * const defaultOptions = queryClient.getQueryDefaults(['posts'])\n   * ```\n   */\n  getQueryDefaults(\n    queryKey: QueryKey,\n  ): OmitKeyof<QueryObserverOptions<any, any, any, any, any>, 'queryKey'> {\n    const defaults = [...this.#queryDefaults.values()]\n\n    const result: OmitKeyof<\n      QueryObserverOptions<any, any, any, any, any>,\n      'queryKey'\n    > = {}\n\n    defaults.forEach((queryDefault) => {\n      if (partialMatchKey(queryKey, queryDefault.queryKey)) {\n        Object.assign(result, queryDefault.defaultOptions)\n      }\n    })\n    return result\n  }\n\n  /**\n   * Sets default options for mutations whose mutation key partially matches the given\n   * `mutationKey`. As with {@link QueryClient#setQueryDefaults}, the order of registration\n   * matters when several registered defaults match the same mutation key.\n   *\n   * @see {@link QueryClient#getMutationDefaults}\n   * @example\n   * ```ts\n   * queryClient.setMutationDefaults(['addPost'], { mutationFn: addPost })\n   * ```\n   */\n  setMutationDefaults<\n    TData = unknown,\n    TError = DefaultError,\n    TVariables = void,\n    TOnMutateResult = unknown,\n  >(\n    mutationKey: MutationKey,\n    options: OmitKeyof<\n      MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>,\n      'mutationKey'\n    >,\n  ): void {\n    this.#mutationDefaults.set(hashKey(mutationKey), {\n      mutationKey,\n      defaultOptions: options,\n    })\n  }\n\n  /**\n   * Returns the default options registered for mutations whose mutation key partially matches\n   * the given `mutationKey`, via {@link QueryClient#setMutationDefaults}. If multiple registered\n   * defaults match, they are merged together in registration order.\n   *\n   * @example\n   * ```ts\n   * const defaultOptions = queryClient.getMutationDefaults(['addPost'])\n   * ```\n   */\n  getMutationDefaults(\n    mutationKey: MutationKey,\n  ): OmitKeyof<MutationObserverOptions<any, any, any, any>, 'mutationKey'> {\n    const defaults = [...this.#mutationDefaults.values()]\n\n    const result: OmitKeyof<\n      MutationObserverOptions<any, any, any, any>,\n      'mutationKey'\n    > = {}\n\n    defaults.forEach((queryDefault) => {\n      if (partialMatchKey(mutationKey, queryDefault.mutationKey)) {\n        Object.assign(result, queryDefault.defaultOptions)\n      }\n    })\n\n    return result\n  }\n\n  /**\n   * Called by framework adapters (e.g. inside `useQuery`) to resolve the options passed by the\n   * caller into their final, defaulted form: merging `queryClient.setQueryDefaults` for the\n   * given `queryKey`, then the client's own `defaultOptions.queries`, then the caller's options\n   * on top. A no-op if the options are already defaulted (`_defaulted: true`).\n   */\n  defaultQueryOptions<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = never,\n  >(\n    options:\n      | QueryObserverOptions<\n          TQueryFnData,\n          TError,\n          TData,\n          TQueryData,\n          TQueryKey,\n          TPageParam\n        >\n      | DefaultedQueryObserverOptions<\n          TQueryFnData,\n          TError,\n          TData,\n          TQueryData,\n          TQueryKey\n        >,\n  ): DefaultedQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  > {\n    if (options._defaulted) {\n      return options as DefaultedQueryObserverOptions<\n        TQueryFnData,\n        TError,\n        TData,\n        TQueryData,\n        TQueryKey\n      >\n    }\n\n    const defaultedOptions = {\n      ...this.#defaultOptions.queries,\n      ...this.getQueryDefaults(options.queryKey),\n      ...options,\n      _defaulted: true,\n    }\n\n    if (!defaultedOptions.queryHash) {\n      defaultedOptions.queryHash = hashQueryKeyByOptions(\n        defaultedOptions.queryKey,\n        defaultedOptions,\n      )\n    }\n\n    // dependent default values\n    if (defaultedOptions.refetchOnReconnect === undefined) {\n      defaultedOptions.refetchOnReconnect =\n        defaultedOptions.networkMode !== 'always'\n    }\n    if (defaultedOptions.throwOnError === undefined) {\n      defaultedOptions.throwOnError = !!defaultedOptions.suspense\n    }\n\n    if (!defaultedOptions.networkMode && defaultedOptions.persister) {\n      defaultedOptions.networkMode = 'offlineFirst'\n    }\n\n    if (defaultedOptions.queryFn === skipToken) {\n      defaultedOptions.enabled = false\n    }\n\n    return defaultedOptions as DefaultedQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey\n    >\n  }\n\n  /**\n   * The mutation counterpart of {@link QueryClient#defaultQueryOptions}. Called by framework\n   * adapters (e.g. inside `useMutation`) to merge `queryClient.setMutationDefaults` for the\n   * given `mutationKey`, then the client's `defaultOptions.mutations`, then the caller's options\n   * on top. A no-op if the options are already defaulted (`_defaulted: true`).\n   */\n  defaultMutationOptions<T extends MutationOptions<any, any, any, any>>(\n    options?: T,\n  ): T {\n    if (options?._defaulted) {\n      return options\n    }\n    return {\n      ...this.#defaultOptions.mutations,\n      ...(options?.mutationKey &&\n        this.getMutationDefaults(options.mutationKey)),\n      ...options,\n      _defaulted: true,\n    } as T\n  }\n\n  /**\n   * Clears both the query cache and the mutation cache this client is connected to.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * queryClient.clear()\n   * ```\n   */\n  clear(): void {\n    this.#queryCache.clear()\n    this.#mutationCache.clear()\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"queryClient.cjs","names":["QueryCache","MutationCache","focusManager","onlineManager","resolveQueryValue","functionalUpdate","notifyManager","noop","hashKey","partialMatchKey","hashQueryKeyByOptions","skipToken"],"sources":["../../src/queryClient.ts"],"sourcesContent":["import {\n  functionalUpdate,\n  hashKey,\n  hashQueryKeyByOptions,\n  noop,\n  partialMatchKey,\n  resolveQueryValue,\n  skipToken,\n} from './utils'\nimport { QueryCache } from './queryCache'\nimport { MutationCache } from './mutationCache'\nimport { focusManager } from './focusManager'\nimport { onlineManager } from './onlineManager'\nimport { notifyManager } from './notifyManager'\nimport type {\n  CancelOptions,\n  DefaultError,\n  DefaultOptions,\n  DefaultedQueryObserverOptions,\n  EnsureInfiniteQueryDataOptions,\n  EnsureQueryDataOptions,\n  FetchInfiniteQueryOptions,\n  FetchQueryOptions,\n  InferDataFromTag,\n  InferErrorFromTag,\n  InfiniteData,\n  InfiniteQueryExecuteOptions,\n  InvalidateOptions,\n  InvalidateQueryFilters,\n  MutationKey,\n  MutationObserverOptions,\n  MutationOptions,\n  OmitKeyof,\n  QueryClientConfig,\n  QueryExecuteOptions,\n  QueryKey,\n  QueryObserverOptions,\n  QueryOptions,\n  RefetchOptions,\n  RefetchQueryFilters,\n  ResetOptions,\n  SetDataOptions,\n} from './types'\nimport type { QueryState } from './query'\nimport type { MutationFilters, QueryFilters, Updater } from './utils'\n\n// TYPES\n\ninterface QueryDefaults {\n  queryKey: QueryKey\n  defaultOptions: OmitKeyof<QueryOptions<any, any, any>, 'queryKey'>\n}\n\ninterface MutationDefaults {\n  mutationKey: MutationKey\n  defaultOptions: MutationOptions<any, any, any, any>\n}\n\n// CLASS\n\n/**\n * `QueryClient` is used to interact with a cache of queries and mutations. It owns a\n * `QueryCache` and a `MutationCache` (creating default ones if none are passed in) and holds\n * the default options that are applied to queries and mutations created through it.\n *\n * @example\n * ```ts\n * const queryClient = new QueryClient({\n *   defaultOptions: {\n *     queries: {\n *       staleTime: Infinity,\n *     },\n *   },\n * })\n *\n * await queryClient.query({ queryKey: ['posts'], queryFn: fetchPosts })\n * ```\n */\nexport class QueryClient {\n  #queryCache: QueryCache\n  #mutationCache: MutationCache\n  #defaultOptions: DefaultOptions\n  #queryDefaults: Map<string, QueryDefaults>\n  #mutationDefaults: Map<string, MutationDefaults>\n  #mountCount: number\n  #unsubscribeFocus?: () => void\n  #unsubscribeOnline?: () => void\n\n  constructor(config: QueryClientConfig = {}) {\n    this.#queryCache = config.queryCache || new QueryCache()\n    this.#mutationCache = config.mutationCache || new MutationCache()\n    this.#defaultOptions = config.defaultOptions || {}\n    this.#queryDefaults = new Map()\n    this.#mutationDefaults = new Map()\n    this.#mountCount = 0\n  }\n\n  /**\n   * Called by a framework adapter's `QueryClientProvider`-equivalent when it mounts, to start\n   * listening for focus/online events and resume paused mutations. Ref-counted via an internal\n   * mount count, so nested or multiple providers sharing the same `QueryClient` don't tear down\n   * the shared listeners until the last one unmounts.\n   */\n  mount(): void {\n    this.#mountCount++\n    if (this.#mountCount !== 1) return\n\n    this.#unsubscribeFocus = focusManager.subscribe(async (focused) => {\n      if (focused) {\n        await this.resumePausedMutations()\n        this.#queryCache.onFocus()\n      }\n    })\n    this.#unsubscribeOnline = onlineManager.subscribe(async (online) => {\n      if (online) {\n        await this.resumePausedMutations()\n        this.#queryCache.onOnline()\n      }\n    })\n  }\n\n  /**\n   * The inverse of {@link QueryClient#mount} — called by a framework adapter's\n   * `QueryClientProvider`-equivalent when it unmounts. Only tears down the focus/online\n   * listeners once the mount count returns to `0`.\n   */\n  unmount(): void {\n    this.#mountCount--\n    if (this.#mountCount !== 0) return\n\n    this.#unsubscribeFocus?.()\n    this.#unsubscribeFocus = undefined\n\n    this.#unsubscribeOnline?.()\n    this.#unsubscribeOnline = undefined\n  }\n\n  /**\n   * Returns the number of queries in the cache that are currently fetching, optionally\n   * matching a set of filters. This includes background-fetching, loading new pages, and\n   * loading more infinite query results.\n   *\n   * @example\n   * ```ts\n   * if (queryClient.isFetching()) {\n   *   console.log('At least one query is fetching!')\n   * }\n   * ```\n   */\n  isFetching<TQueryFilters extends QueryFilters<any> = QueryFilters>(\n    filters?: TQueryFilters,\n  ): number {\n    return this.#queryCache.findAll({ ...filters, fetchStatus: 'fetching' })\n      .length\n  }\n\n  /**\n   * Returns the number of mutations in the cache that are currently pending, optionally\n   * matching a set of filters.\n   *\n   * @example\n   * ```ts\n   * if (queryClient.isMutating()) {\n   *   console.log('At least one mutation is pending!')\n   * }\n   * ```\n   */\n  isMutating<\n    TMutationFilters extends MutationFilters<any, any> = MutationFilters,\n  >(filters?: TMutationFilters): number {\n    return this.#mutationCache.findAll({ ...filters, status: 'pending' }).length\n  }\n\n  /**\n   * Imperative (non-reactive) way to retrieve data for a QueryKey.\n   * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.\n   *\n   * Hint: Do not use this function inside a component, because it won't receive updates.\n   * Use `useQuery` to create a `QueryObserver` that subscribes to changes.\n   *\n   * @returns The cached data for the query, or `undefined` if no query with this key has been observed yet.\n   * @see {@link QueryClient#getQueriesData}\n   */\n  getQueryData<\n    TQueryFnData = unknown,\n    TTaggedQueryKey extends QueryKey = QueryKey,\n    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,\n  >(queryKey: TTaggedQueryKey): TInferredQueryFnData | undefined {\n    const options = this.defaultQueryOptions({ queryKey })\n\n    return this.#queryCache.get<TInferredQueryFnData>(options.queryHash)?.state\n      .data\n  }\n\n  /**\n   * @deprecated Use queryClient.query({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.\n   */\n  ensureQueryData<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n  >(\n    options: EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n  ): Promise<TData> {\n    const defaultedOptions = this.defaultQueryOptions(options)\n    const query = this.#queryCache.build(this, defaultedOptions)\n    const cachedData = query.state.data\n\n    if (cachedData === undefined) {\n      // eslint-disable-next-line no-restricted-syntax\n      return this.fetchQuery(options)\n    }\n\n    if (\n      options.revalidateIfStale &&\n      query.isStaleByTime(resolveQueryValue(defaultedOptions.staleTime, query))\n    ) {\n      // eslint-disable-next-line no-restricted-syntax\n      void this.prefetchQuery(defaultedOptions)\n    }\n\n    return Promise.resolve(cachedData)\n  }\n\n  /**\n   * Imperative (non-reactive) way to retrieve the cached data of multiple queries at once.\n   * Only queries matching the given filters are returned; if none match, an empty array is\n   * returned.\n   *\n   * Because the matched queries can hold data of different shapes (e.g. a broad filter can match\n   * queries with unrelated data types), the `TQueryFnData` generic defaults to `unknown` rather\n   * than being inferred. Passing a more specific type is a convenience for call sites that know\n   * every matched query holds the same shape — it is not checked against the actual cache\n   * contents.\n   *\n   * @returns An array of query key and data pairs. The data is `undefined` for a query with no cached data.\n   * @see {@link QueryClient#getQueryData}\n   * @example\n   * ```ts\n   * const data = queryClient.getQueriesData({ queryKey: ['posts'] })\n   * ```\n   */\n  getQueriesData<\n    TQueryFnData = unknown,\n    TQueryFilters extends QueryFilters<any> = QueryFilters,\n  >(filters: TQueryFilters): Array<[QueryKey, TQueryFnData | undefined]> {\n    return this.#queryCache.findAll(filters).map(({ queryKey, state }) => {\n      const data = state.data as TQueryFnData | undefined\n      return [queryKey, data]\n    })\n  }\n\n  /**\n   * Synchronous way to immediately update a query's cached data. If the updater (or the value\n   * passed) resolves to `undefined`, the cache is left untouched and no query is created;\n   * otherwise, if the query does not exist yet, it will be created. To update multiple queries\n   * at once by partially matching query keys, use {@link QueryClient#setQueriesData} instead.\n   *\n   * Updates must be performed immutably: do not mutate `oldData`, or data previously retrieved\n   * via {@link QueryClient#getQueryData}, in place.\n   *\n   * @param queryKey - The query key to set data for.\n   * @param updater - Either the new data, or a function that receives the current data (which\n   * may be `undefined`) and returns the new data.\n   * @param options - Set `updatedAt` to override the timestamp the written data is recorded with.\n   * @returns The data that was written, or `undefined` if the updater returned `undefined` — in that case\n   * the write is skipped and the cache is left unchanged.\n   *\n   * @example\n   * ```ts\n   * queryClient.setQueryData(['posts'], newPosts)\n   *\n   * // Or, using an updater function that receives the current data:\n   * queryClient.setQueryData(['posts'], (oldPosts) => [...oldPosts, newPost])\n   * ```\n   */\n  setQueryData<\n    TQueryFnData = unknown,\n    TTaggedQueryKey extends QueryKey = QueryKey,\n    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,\n  >(\n    queryKey: TTaggedQueryKey,\n    updater: Updater<\n      NoInfer<TInferredQueryFnData> | undefined,\n      NoInfer<TInferredQueryFnData> | undefined\n    >,\n    options?: SetDataOptions,\n  ): NoInfer<TInferredQueryFnData> | undefined {\n    const defaultedOptions = this.defaultQueryOptions<\n      any,\n      any,\n      unknown,\n      any,\n      QueryKey\n    >({ queryKey })\n\n    const query = this.#queryCache.get<TInferredQueryFnData>(\n      defaultedOptions.queryHash,\n    )\n    const prevData = query?.state.data\n    const data = functionalUpdate(updater, prevData)\n\n    if (data === undefined) {\n      return undefined\n    }\n\n    return this.#queryCache\n      .build(this, defaultedOptions)\n      .setData(data, { ...options, manual: true })\n  }\n\n  /**\n   * Synchronous way to immediately update the cached data of multiple queries at once, using\n   * filters or partial query key matching. Only queries that already exist and match the given\n   * filters are updated; no new cache entries are created. Internally this calls\n   * {@link QueryClient#setQueryData} for each matching query.\n   *\n   * @returns One `[queryKey, data]` tuple per matched query, in the same shape and with the same\n   * `undefined` case as {@link QueryClient#setQueryData}.\n   * @example\n   * ```ts\n   * queryClient.setQueriesData({ queryKey: ['posts'] }, (oldPosts) =>\n   *   oldPosts ? oldPosts.filter((post) => post.id !== deletedId) : oldPosts,\n   * )\n   * ```\n   */\n  setQueriesData<\n    TQueryFnData,\n    TQueryFilters extends QueryFilters<any> = QueryFilters,\n  >(\n    filters: TQueryFilters,\n    updater: Updater<\n      NoInfer<TQueryFnData> | undefined,\n      NoInfer<TQueryFnData> | undefined\n    >,\n    options?: SetDataOptions,\n  ): Array<[QueryKey, TQueryFnData | undefined]> {\n    return notifyManager.batch(() =>\n      this.#queryCache\n        .findAll(filters)\n        .map(({ queryKey }) => [\n          queryKey,\n          this.setQueryData<TQueryFnData>(queryKey, updater, options),\n        ]),\n    )\n  }\n\n  /**\n   * Imperative (non-reactive) way to retrieve an existing query's state. If the query does not\n   * exist, `undefined` is returned.\n   *\n   * @example\n   * ```ts\n   * const state = queryClient.getQueryState(['posts'])\n   * console.log(state?.dataUpdatedAt)\n   * ```\n   */\n  getQueryState<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TTaggedQueryKey extends QueryKey = QueryKey,\n    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,\n    TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>,\n  >(\n    queryKey: TTaggedQueryKey,\n  ): QueryState<TInferredQueryFnData, TInferredError> | undefined {\n    const options = this.defaultQueryOptions({ queryKey })\n    return this.#queryCache.get<TInferredQueryFnData, TInferredError>(\n      options.queryHash,\n    )?.state\n  }\n\n  /**\n   * Removes queries from the cache that match the given filters. Unlike\n   * {@link QueryClient#invalidateQueries} or {@link QueryClient#refetchQueries}, this removes\n   * matching queries from the cache instead of refetching them. Without filters, every query in\n   * the cache is removed.\n   *\n   * @example\n   * ```ts\n   * queryClient.removeQueries({ queryKey: ['posts'], exact: true })\n   * ```\n   */\n  removeQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: QueryFilters<TTaggedQueryKey>,\n  ): void {\n    const queryCache = this.#queryCache\n    notifyManager.batch(() => {\n      queryCache.findAll(filters).forEach((query) => {\n        queryCache.remove(query)\n      })\n    })\n  }\n\n  /**\n   * Resets queries matching the given filters back to their initial state (e.g. any\n   * `initialData`), notifying subscribers rather than removing them. Active queries among the\n   * matched set are then refetched, and the returned promise resolves once that refetch settles.\n   *\n   * @example\n   * ```ts\n   * await queryClient.resetQueries({ queryKey: ['posts'], exact: true })\n   * ```\n   */\n  resetQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: QueryFilters<TTaggedQueryKey>,\n    options?: ResetOptions,\n  ): Promise<void> {\n    const queryCache = this.#queryCache\n\n    return notifyManager.batch(() => {\n      const matched = queryCache.findAll(filters)\n      const queriesToRefetch = new Set(matched)\n      matched.forEach((query) => {\n        query.reset()\n      })\n      return this.refetchQueries(\n        {\n          type: 'active',\n          predicate: (query) => queriesToRefetch.has(query),\n        },\n        options,\n      )\n    })\n  }\n\n  /**\n   * Cancels outgoing fetches for queries matching the given filters. Most useful when performing\n   * optimistic updates, since any outgoing refetch that resolves afterwards would otherwise\n   * overwrite the optimistic update. By default (`revert: true`), a cancelled query's data is\n   * reverted to its state before the outgoing fetch started.\n   *\n   * The returned promise never rejects, even if individual cancellations fail.\n   *\n   * @example\n   * ```ts\n   * await queryClient.cancelQueries({ queryKey: ['posts'], exact: true })\n   * ```\n   */\n  cancelQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: QueryFilters<TTaggedQueryKey>,\n    cancelOptions: CancelOptions = {},\n  ): Promise<void> {\n    const defaultedCancelOptions = { revert: true, ...cancelOptions }\n\n    const promises = notifyManager.batch(() =>\n      this.#queryCache\n        .findAll(filters)\n        .map((query) => query.cancel(defaultedCancelOptions)),\n    )\n\n    return Promise.all(promises).then(noop).catch(noop)\n  }\n\n  /**\n   * Marks queries matching the given filters as invalidated. Unlike\n   * {@link QueryClient#removeQueries}, invalidated queries stay in the cache.\n   *\n   * Unless `filters.refetchType` is `'none'`, matching queries are then refetched via\n   * {@link QueryClient#refetchQueries}, using `filters.refetchType` if set, otherwise\n   * `filters.type`, otherwise `'active'`.\n   *\n   * @example\n   * ```ts\n   * await queryClient.invalidateQueries({ queryKey: ['posts'], refetchType: 'active' })\n   * ```\n   */\n  invalidateQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: InvalidateQueryFilters<TTaggedQueryKey>,\n    options: InvalidateOptions = {},\n  ): Promise<void> {\n    return notifyManager.batch(() => {\n      this.#queryCache.findAll(filters).forEach((query) => {\n        query.invalidate()\n      })\n\n      if (filters?.refetchType === 'none') {\n        return Promise.resolve()\n      }\n      return this.refetchQueries(\n        {\n          ...filters,\n          type: filters?.refetchType ?? filters?.type ?? 'active',\n        },\n        options,\n      )\n    })\n  }\n\n  /**\n   * Refetches queries matching the given filters, regardless of whether they are stale. Without\n   * filters, every query in the cache is refetched. Queries that are disabled, or static (only\n   * have observers with a static `staleTime`), are never refetched.\n   *\n   * By default (`cancelRefetch: true`), a currently running fetch is cancelled before the new\n   * one starts. The returned promise resolves once all matching queries have settled; it does\n   * not reject on individual query failures unless `throwOnError` is set.\n   *\n   * @example\n   * ```ts\n   * // refetch all active queries partially matching a query key:\n   * await queryClient.refetchQueries({ queryKey: ['posts'], type: 'active' })\n   * ```\n   */\n  refetchQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: RefetchQueryFilters<TTaggedQueryKey>,\n    options: RefetchOptions = {},\n  ): Promise<void> {\n    const fetchOptions = {\n      ...options,\n      cancelRefetch: options.cancelRefetch ?? true,\n    }\n    const promises = notifyManager.batch(() =>\n      this.#queryCache\n        .findAll(filters)\n        .filter((query) => !query.isDisabled() && !query.isStatic())\n        .map((query) => {\n          let promise = query.fetch(undefined, fetchOptions)\n          if (!fetchOptions.throwOnError) {\n            promise = promise.catch(noop)\n          }\n          return query.state.fetchStatus === 'paused'\n            ? Promise.resolve()\n            : promise\n        }),\n    )\n\n    return Promise.all(promises).then(noop)\n  }\n\n  /**\n   * Asynchronous method to fetch and cache a query, resolving with the data or throwing with\n   * the error.\n   *\n   * If the query already exists in the cache and its data is not stale (per the given\n   * `staleTime`), the cached data is returned without fetching. Otherwise, the query is fetched\n   * and the promise resolves once the fetch settles. If a `select` function is provided, it is\n   * applied to the data in both cases (cached or freshly fetched) before it is returned.\n   *\n   * Unlike a reactive observer, retries are disabled by default here (`retry: false`) unless\n   * explicitly configured, since there is no component to catch a thrown error and retry through\n   * re-render.\n   *\n   * The accepted options are `QueryObserverOptions` minus the fields that only make sense for a\n   * reactive observer — `enabled`, `refetchInterval`, `refetchIntervalInBackground`,\n   * `refetchOnWindowFocus`, `refetchOnReconnect`, `refetchOnMount`, `retryOnMount`,\n   * `notifyOnChangeProps`, `throwOnError`, `suspense`, and `placeholderData` are not part of this\n   * method's options.\n   *\n   * This method replaces the deprecated `fetchQuery`, and — combined with\n   * `{ staleTime: 'static' }` — the deprecated `ensureQueryData`.\n   *\n   * @example\n   * ```ts\n   * try {\n   *   const data = await queryClient.query({ queryKey, queryFn, staleTime: 10000 })\n   * } catch (error) {\n   *   console.log(error)\n   * }\n   * ```\n   */\n  async query<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = never,\n  >(\n    options: QueryExecuteOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<TData> {\n    const defaultedOptions = this.defaultQueryOptions(options)\n\n    // https://github.com/tannerlinsley/react-query/issues/652\n    if (defaultedOptions.retry === undefined) {\n      defaultedOptions.retry = false\n    }\n\n    const query = this.#queryCache.build(this, defaultedOptions)\n\n    const isStale = query.isStaleByTime(\n      resolveQueryValue(defaultedOptions.staleTime, query),\n    )\n\n    const queryData = isStale\n      ? await query.fetch(defaultedOptions)\n      : (query.state.data as TQueryData)\n\n    const select = defaultedOptions.select\n\n    if (select) {\n      return select(queryData)\n    }\n\n    return queryData as unknown as TData\n  }\n\n  /**\n   * @deprecated Use queryClient.query(options) instead. This method will be removed in the next major version.\n   */\n  fetchQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = never,\n  >(\n    options: FetchQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<TData> {\n    const defaultedOptions = this.defaultQueryOptions(options)\n\n    // https://github.com/tannerlinsley/react-query/issues/652\n    if (defaultedOptions.retry === undefined) {\n      defaultedOptions.retry = false\n    }\n\n    const query = this.#queryCache.build(this, defaultedOptions)\n\n    return query.isStaleByTime(\n      resolveQueryValue(defaultedOptions.staleTime, query),\n    )\n      ? query.fetch(defaultedOptions)\n      : Promise.resolve(query.state.data as TData)\n  }\n\n  /**\n   * @deprecated Use queryClient.query(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.\n   */\n  prefetchQuery<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n  >(\n    options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  ): Promise<void> {\n    // eslint-disable-next-line no-restricted-syntax\n    return this.fetchQuery(options).then(noop).catch(noop)\n  }\n\n  /**\n   * Asynchronous method to fetch and cache an infinite query, resolving with an\n   * {@link InfiniteData} object or throwing with the error.\n   *\n   * Behaves like {@link QueryClient#query}, accepting the same options (minus\n   * `initialPageParam`), plus the required `initialPageParam`, and an optional `pages` /\n   * `getNextPageParam` pair used to refetch a fixed number of pages from the start.\n   *\n   * This method replaces the deprecated `fetchInfiniteQuery`, and — combined with\n   * `{ staleTime: 'static' }` — the deprecated `ensureInfiniteQueryData`.\n   *\n   * @example\n   * ```ts\n   * try {\n   *   const data = await queryClient.infiniteQuery({ queryKey, queryFn, initialPageParam: 0 })\n   *   console.log(data.pages)\n   * } catch (error) {\n   *   console.log(error)\n   * }\n   * ```\n   */\n  infiniteQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = InfiniteData<TQueryFnData>,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: InfiniteQueryExecuteOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<\n    Array<TData> extends Array<InfiniteData<TQueryFnData>>\n      ? InfiniteData<TQueryFnData, TPageParam>\n      : TData\n  > {\n    options._type = 'infinite'\n    return this.query(options as any)\n  }\n\n  /**\n   * @deprecated Use queryClient.infiniteQuery(options) instead. This method will be removed in the next major version.\n   */\n  fetchInfiniteQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: FetchInfiniteQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<InfiniteData<TData, TPageParam>> {\n    options._type = 'infinite'\n    // eslint-disable-next-line no-restricted-syntax\n    return this.fetchQuery(options as any)\n  }\n\n  /**\n   * @deprecated Use queryClient.infiniteQuery(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.\n   */\n  prefetchInfiniteQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: FetchInfiniteQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<void> {\n    // eslint-disable-next-line no-restricted-syntax\n    return this.fetchInfiniteQuery(options).then(noop).catch(noop)\n  }\n\n  /**\n   * @deprecated Use queryClient.infiniteQuery({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.\n   */\n  ensureInfiniteQueryData<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: EnsureInfiniteQueryDataOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<InfiniteData<TData, TPageParam>> {\n    options._type = 'infinite'\n\n    // eslint-disable-next-line no-restricted-syntax\n    return this.ensureQueryData(options as any)\n  }\n\n  /**\n   * Resumes mutations that were paused because there was no network connection. Does nothing\n   * (resolving immediately) if the client is currently offline.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * await queryClient.resumePausedMutations()\n   * ```\n   */\n  resumePausedMutations(): Promise<unknown> {\n    if (onlineManager.isOnline()) {\n      return this.#mutationCache.resumePausedMutations()\n    }\n    return Promise.resolve()\n  }\n\n  /**\n   * Returns the query cache this client is connected to.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * const queryCache = queryClient.getQueryCache()\n   * const queries = queryCache.findAll({ queryKey: ['posts'] })\n   * ```\n   */\n  getQueryCache(): QueryCache {\n    return this.#queryCache\n  }\n\n  /**\n   * Returns the mutation cache this client is connected to.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * const mutationCache = queryClient.getMutationCache()\n   * const mutations = mutationCache.findAll({ status: 'pending' })\n   * ```\n   */\n  getMutationCache(): MutationCache {\n    return this.#mutationCache\n  }\n\n  /**\n   * Returns the default options that were set when creating the client, or via\n   * {@link QueryClient#setDefaultOptions}.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * const defaultOptions = queryClient.getDefaultOptions()\n   * ```\n   */\n  getDefaultOptions(): DefaultOptions {\n    return this.#defaultOptions\n  }\n\n  /**\n   * Dynamically sets the default options for this client, overwriting any previously defined\n   * default options.\n   *\n   * @see {@link QueryClient#getDefaultOptions}\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * queryClient.setDefaultOptions({\n   *   queries: {\n   *     staleTime: Infinity,\n   *   },\n   * })\n   * ```\n   */\n  setDefaultOptions(options: DefaultOptions): void {\n    this.#defaultOptions = options\n  }\n\n  /**\n   * Sets default options for queries whose query key partially matches the given `queryKey`.\n   *\n   * If several registered query defaults match a given query key, they are merged together in\n   * registration order by {@link QueryClient#getQueryDefaults}, so register defaults from the\n   * most generic key to the least generic one — more specific defaults should be registered\n   * after more generic ones so they take precedence.\n   *\n   * @example\n   * ```ts\n   * queryClient.setQueryDefaults(['posts'], { queryFn: fetchPosts })\n   *\n   * await queryClient.query({ queryKey: ['posts'] })\n   * ```\n   */\n  setQueryDefaults<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n  >(\n    queryKey: QueryKey,\n    options: Partial<\n      OmitKeyof<\n        QueryObserverOptions<TQueryFnData, TError, TData, TQueryData>,\n        'queryKey'\n      >\n    >,\n  ): void {\n    this.#queryDefaults.set(hashKey(queryKey), {\n      queryKey,\n      defaultOptions: options,\n    })\n  }\n\n  /**\n   * Returns the default options registered for queries whose query key partially matches the\n   * given `queryKey`, via {@link QueryClient#setQueryDefaults}. If multiple registered defaults\n   * match, they are merged together in registration order.\n   *\n   * @example\n   * ```ts\n   * const defaultOptions = queryClient.getQueryDefaults(['posts'])\n   * ```\n   */\n  getQueryDefaults(\n    queryKey: QueryKey,\n  ): OmitKeyof<QueryObserverOptions<any, any, any, any, any>, 'queryKey'> {\n    const defaults = [...this.#queryDefaults.values()]\n\n    const result: OmitKeyof<\n      QueryObserverOptions<any, any, any, any, any>,\n      'queryKey'\n    > = {}\n\n    defaults.forEach((queryDefault) => {\n      if (partialMatchKey(queryKey, queryDefault.queryKey)) {\n        Object.assign(result, queryDefault.defaultOptions)\n      }\n    })\n    return result\n  }\n\n  /**\n   * Sets default options for mutations whose mutation key partially matches the given\n   * `mutationKey`. As with {@link QueryClient#setQueryDefaults}, the order of registration\n   * matters when several registered defaults match the same mutation key.\n   *\n   * @see {@link QueryClient#getMutationDefaults}\n   * @example\n   * ```ts\n   * queryClient.setMutationDefaults(['addPost'], { mutationFn: addPost })\n   * ```\n   */\n  setMutationDefaults<\n    TData = unknown,\n    TError = DefaultError,\n    TVariables = void,\n    TOnMutateResult = unknown,\n  >(\n    mutationKey: MutationKey,\n    options: OmitKeyof<\n      MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>,\n      'mutationKey'\n    >,\n  ): void {\n    this.#mutationDefaults.set(hashKey(mutationKey), {\n      mutationKey,\n      defaultOptions: options,\n    })\n  }\n\n  /**\n   * Returns the default options registered for mutations whose mutation key partially matches\n   * the given `mutationKey`, via {@link QueryClient#setMutationDefaults}. If multiple registered\n   * defaults match, they are merged together in registration order.\n   *\n   * @example\n   * ```ts\n   * const defaultOptions = queryClient.getMutationDefaults(['addPost'])\n   * ```\n   */\n  getMutationDefaults(\n    mutationKey: MutationKey,\n  ): OmitKeyof<MutationObserverOptions<any, any, any, any>, 'mutationKey'> {\n    const defaults = [...this.#mutationDefaults.values()]\n\n    const result: OmitKeyof<\n      MutationObserverOptions<any, any, any, any>,\n      'mutationKey'\n    > = {}\n\n    defaults.forEach((queryDefault) => {\n      if (partialMatchKey(mutationKey, queryDefault.mutationKey)) {\n        Object.assign(result, queryDefault.defaultOptions)\n      }\n    })\n\n    return result\n  }\n\n  /**\n   * Called by framework adapters (e.g. inside `useQuery`) to resolve the options passed by the\n   * caller into their final, defaulted form: merging `queryClient.setQueryDefaults` for the\n   * given `queryKey`, then the client's own `defaultOptions.queries`, then the caller's options\n   * on top. A no-op if the options are already defaulted (`_defaulted: true`).\n   */\n  defaultQueryOptions<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = never,\n  >(\n    options:\n      | QueryObserverOptions<\n          TQueryFnData,\n          TError,\n          TData,\n          TQueryData,\n          TQueryKey,\n          TPageParam\n        >\n      | DefaultedQueryObserverOptions<\n          TQueryFnData,\n          TError,\n          TData,\n          TQueryData,\n          TQueryKey\n        >,\n  ): DefaultedQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  > {\n    if (options._defaulted) {\n      return options as DefaultedQueryObserverOptions<\n        TQueryFnData,\n        TError,\n        TData,\n        TQueryData,\n        TQueryKey\n      >\n    }\n\n    const defaultedOptions = {\n      ...this.#defaultOptions.queries,\n      ...this.getQueryDefaults(options.queryKey),\n      ...options,\n      _defaulted: true,\n    }\n\n    if (!defaultedOptions.queryHash) {\n      defaultedOptions.queryHash = hashQueryKeyByOptions(\n        defaultedOptions.queryKey,\n        defaultedOptions,\n      )\n    }\n\n    // dependent default values\n    if (defaultedOptions.refetchOnReconnect === undefined) {\n      defaultedOptions.refetchOnReconnect =\n        defaultedOptions.networkMode !== 'always'\n    }\n    if (defaultedOptions.throwOnError === undefined) {\n      defaultedOptions.throwOnError = !!defaultedOptions.suspense\n    }\n\n    if (!defaultedOptions.networkMode && defaultedOptions.persister) {\n      defaultedOptions.networkMode = 'offlineFirst'\n    }\n\n    if (defaultedOptions.queryFn === skipToken) {\n      defaultedOptions.enabled = false\n    }\n\n    return defaultedOptions as DefaultedQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey\n    >\n  }\n\n  /**\n   * The mutation counterpart of {@link QueryClient#defaultQueryOptions}. Called by framework\n   * adapters (e.g. inside `useMutation`) to merge `queryClient.setMutationDefaults` for the\n   * given `mutationKey`, then the client's `defaultOptions.mutations`, then the caller's options\n   * on top. A no-op if the options are already defaulted (`_defaulted: true`).\n   */\n  defaultMutationOptions<T extends MutationOptions<any, any, any, any>>(\n    options?: T,\n  ): T {\n    if (options?._defaulted) {\n      return options\n    }\n    return {\n      ...this.#defaultOptions.mutations,\n      ...(options?.mutationKey &&\n        this.getMutationDefaults(options.mutationKey)),\n      ...options,\n      _defaulted: true,\n    } as T\n  }\n\n  /**\n   * Clears both the query cache and the mutation cache this client is connected to.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * queryClient.clear()\n   * ```\n   */\n  clear(): void {\n    this.#queryCache.clear()\n    this.#mutationCache.clear()\n  }\n}\n"],"mappings":"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"}

package/build/modern/queryClient.d.cts

@@ -1,2 +1,2 @@
-import { on as QueryClient } from "./hydration-DRcloXEn.cjs";
+import { on as QueryClient } from "./hydration-Br9VIGXa.cjs";
 export { QueryClient };

package/build/modern/queryClient.d.ts

@@ -1,2 +1,2 @@
-import { on as QueryClient } from "./hydration-Bp57N3SP.js";
+import { on as QueryClient } from "./hydration-B9t5w6NC.js";
 export { QueryClient };

package/build/modern/queryClient.js

@@ -117,6 +117,7 @@ var QueryClient = class {
 	* 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(queryKey) {
@@ -145,6 +146,7 @@ var QueryClient = class {
 	* 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
@@ -168,6 +170,9 @@ var QueryClient = class {
 	* @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
@@ -193,6 +198,8 @@ var QueryClient = class {
 	* 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) =>

package/build/modern/queryClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"queryClient.js","names":["#queryCache","#mutationCache","#defaultOptions","#queryDefaults","#mutationDefaults","#mountCount","#unsubscribeFocus","#unsubscribeOnline"],"sources":["../../src/queryClient.ts"],"sourcesContent":["import {\n  functionalUpdate,\n  hashKey,\n  hashQueryKeyByOptions,\n  noop,\n  partialMatchKey,\n  resolveQueryValue,\n  skipToken,\n} from './utils'\nimport { QueryCache } from './queryCache'\nimport { MutationCache } from './mutationCache'\nimport { focusManager } from './focusManager'\nimport { onlineManager } from './onlineManager'\nimport { notifyManager } from './notifyManager'\nimport type {\n  CancelOptions,\n  DefaultError,\n  DefaultOptions,\n  DefaultedQueryObserverOptions,\n  EnsureInfiniteQueryDataOptions,\n  EnsureQueryDataOptions,\n  FetchInfiniteQueryOptions,\n  FetchQueryOptions,\n  InferDataFromTag,\n  InferErrorFromTag,\n  InfiniteData,\n  InfiniteQueryExecuteOptions,\n  InvalidateOptions,\n  InvalidateQueryFilters,\n  MutationKey,\n  MutationObserverOptions,\n  MutationOptions,\n  OmitKeyof,\n  QueryClientConfig,\n  QueryExecuteOptions,\n  QueryKey,\n  QueryObserverOptions,\n  QueryOptions,\n  RefetchOptions,\n  RefetchQueryFilters,\n  ResetOptions,\n  SetDataOptions,\n} from './types'\nimport type { QueryState } from './query'\nimport type { MutationFilters, QueryFilters, Updater } from './utils'\n\n// TYPES\n\ninterface QueryDefaults {\n  queryKey: QueryKey\n  defaultOptions: OmitKeyof<QueryOptions<any, any, any>, 'queryKey'>\n}\n\ninterface MutationDefaults {\n  mutationKey: MutationKey\n  defaultOptions: MutationOptions<any, any, any, any>\n}\n\n// CLASS\n\n/**\n * `QueryClient` is used to interact with a cache of queries and mutations. It owns a\n * `QueryCache` and a `MutationCache` (creating default ones if none are passed in) and holds\n * the default options that are applied to queries and mutations created through it.\n *\n * @example\n * ```ts\n * const queryClient = new QueryClient({\n *   defaultOptions: {\n *     queries: {\n *       staleTime: Infinity,\n *     },\n *   },\n * })\n *\n * await queryClient.query({ queryKey: ['posts'], queryFn: fetchPosts })\n * ```\n */\nexport class QueryClient {\n  #queryCache: QueryCache\n  #mutationCache: MutationCache\n  #defaultOptions: DefaultOptions\n  #queryDefaults: Map<string, QueryDefaults>\n  #mutationDefaults: Map<string, MutationDefaults>\n  #mountCount: number\n  #unsubscribeFocus?: () => void\n  #unsubscribeOnline?: () => void\n\n  constructor(config: QueryClientConfig = {}) {\n    this.#queryCache = config.queryCache || new QueryCache()\n    this.#mutationCache = config.mutationCache || new MutationCache()\n    this.#defaultOptions = config.defaultOptions || {}\n    this.#queryDefaults = new Map()\n    this.#mutationDefaults = new Map()\n    this.#mountCount = 0\n  }\n\n  /**\n   * Called by a framework adapter's `QueryClientProvider`-equivalent when it mounts, to start\n   * listening for focus/online events and resume paused mutations. Ref-counted via an internal\n   * mount count, so nested or multiple providers sharing the same `QueryClient` don't tear down\n   * the shared listeners until the last one unmounts.\n   */\n  mount(): void {\n    this.#mountCount++\n    if (this.#mountCount !== 1) return\n\n    this.#unsubscribeFocus = focusManager.subscribe(async (focused) => {\n      if (focused) {\n        await this.resumePausedMutations()\n        this.#queryCache.onFocus()\n      }\n    })\n    this.#unsubscribeOnline = onlineManager.subscribe(async (online) => {\n      if (online) {\n        await this.resumePausedMutations()\n        this.#queryCache.onOnline()\n      }\n    })\n  }\n\n  /**\n   * The inverse of {@link QueryClient#mount} — called by a framework adapter's\n   * `QueryClientProvider`-equivalent when it unmounts. Only tears down the focus/online\n   * listeners once the mount count returns to `0`.\n   */\n  unmount(): void {\n    this.#mountCount--\n    if (this.#mountCount !== 0) return\n\n    this.#unsubscribeFocus?.()\n    this.#unsubscribeFocus = undefined\n\n    this.#unsubscribeOnline?.()\n    this.#unsubscribeOnline = undefined\n  }\n\n  /**\n   * Returns the number of queries in the cache that are currently fetching, optionally\n   * matching a set of filters. This includes background-fetching, loading new pages, and\n   * loading more infinite query results.\n   *\n   * @example\n   * ```ts\n   * if (queryClient.isFetching()) {\n   *   console.log('At least one query is fetching!')\n   * }\n   * ```\n   */\n  isFetching<TQueryFilters extends QueryFilters<any> = QueryFilters>(\n    filters?: TQueryFilters,\n  ): number {\n    return this.#queryCache.findAll({ ...filters, fetchStatus: 'fetching' })\n      .length\n  }\n\n  /**\n   * Returns the number of mutations in the cache that are currently pending, optionally\n   * matching a set of filters.\n   *\n   * @example\n   * ```ts\n   * if (queryClient.isMutating()) {\n   *   console.log('At least one mutation is pending!')\n   * }\n   * ```\n   */\n  isMutating<\n    TMutationFilters extends MutationFilters<any, any> = MutationFilters,\n  >(filters?: TMutationFilters): number {\n    return this.#mutationCache.findAll({ ...filters, status: 'pending' }).length\n  }\n\n  /**\n   * Imperative (non-reactive) way to retrieve data for a QueryKey.\n   * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.\n   *\n   * Hint: Do not use this function inside a component, because it won't receive updates.\n   * Use `useQuery` to create a `QueryObserver` that subscribes to changes.\n   *\n   * @see {@link QueryClient#getQueriesData}\n   */\n  getQueryData<\n    TQueryFnData = unknown,\n    TTaggedQueryKey extends QueryKey = QueryKey,\n    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,\n  >(queryKey: TTaggedQueryKey): TInferredQueryFnData | undefined {\n    const options = this.defaultQueryOptions({ queryKey })\n\n    return this.#queryCache.get<TInferredQueryFnData>(options.queryHash)?.state\n      .data\n  }\n\n  /**\n   * @deprecated Use queryClient.query({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.\n   */\n  ensureQueryData<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n  >(\n    options: EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n  ): Promise<TData> {\n    const defaultedOptions = this.defaultQueryOptions(options)\n    const query = this.#queryCache.build(this, defaultedOptions)\n    const cachedData = query.state.data\n\n    if (cachedData === undefined) {\n      // eslint-disable-next-line no-restricted-syntax\n      return this.fetchQuery(options)\n    }\n\n    if (\n      options.revalidateIfStale &&\n      query.isStaleByTime(resolveQueryValue(defaultedOptions.staleTime, query))\n    ) {\n      // eslint-disable-next-line no-restricted-syntax\n      void this.prefetchQuery(defaultedOptions)\n    }\n\n    return Promise.resolve(cachedData)\n  }\n\n  /**\n   * Imperative (non-reactive) way to retrieve the cached data of multiple queries at once.\n   * Only queries matching the given filters are returned; if none match, an empty array is\n   * returned.\n   *\n   * Because the matched queries can hold data of different shapes (e.g. a broad filter can match\n   * queries with unrelated data types), the `TQueryFnData` generic defaults to `unknown` rather\n   * than being inferred. Passing a more specific type is a convenience for call sites that know\n   * every matched query holds the same shape — it is not checked against the actual cache\n   * contents.\n   *\n   * @see {@link QueryClient#getQueryData}\n   * @example\n   * ```ts\n   * const data = queryClient.getQueriesData({ queryKey: ['posts'] })\n   * ```\n   */\n  getQueriesData<\n    TQueryFnData = unknown,\n    TQueryFilters extends QueryFilters<any> = QueryFilters,\n  >(filters: TQueryFilters): Array<[QueryKey, TQueryFnData | undefined]> {\n    return this.#queryCache.findAll(filters).map(({ queryKey, state }) => {\n      const data = state.data as TQueryFnData | undefined\n      return [queryKey, data]\n    })\n  }\n\n  /**\n   * Synchronous way to immediately update a query's cached data. If the updater (or the value\n   * passed) resolves to `undefined`, the cache is left untouched and no query is created;\n   * otherwise, if the query does not exist yet, it will be created. To update multiple queries\n   * at once by partially matching query keys, use {@link QueryClient#setQueriesData} instead.\n   *\n   * Updates must be performed immutably: do not mutate `oldData`, or data previously retrieved\n   * via {@link QueryClient#getQueryData}, in place.\n   *\n   * @param queryKey - The query key to set data for.\n   * @param updater - Either the new data, or a function that receives the current data (which\n   * may be `undefined`) and returns the new data.\n   *\n   * @example\n   * ```ts\n   * queryClient.setQueryData(['posts'], newPosts)\n   *\n   * // Or, using an updater function that receives the current data:\n   * queryClient.setQueryData(['posts'], (oldPosts) => [...oldPosts, newPost])\n   * ```\n   */\n  setQueryData<\n    TQueryFnData = unknown,\n    TTaggedQueryKey extends QueryKey = QueryKey,\n    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,\n  >(\n    queryKey: TTaggedQueryKey,\n    updater: Updater<\n      NoInfer<TInferredQueryFnData> | undefined,\n      NoInfer<TInferredQueryFnData> | undefined\n    >,\n    options?: SetDataOptions,\n  ): NoInfer<TInferredQueryFnData> | undefined {\n    const defaultedOptions = this.defaultQueryOptions<\n      any,\n      any,\n      unknown,\n      any,\n      QueryKey\n    >({ queryKey })\n\n    const query = this.#queryCache.get<TInferredQueryFnData>(\n      defaultedOptions.queryHash,\n    )\n    const prevData = query?.state.data\n    const data = functionalUpdate(updater, prevData)\n\n    if (data === undefined) {\n      return undefined\n    }\n\n    return this.#queryCache\n      .build(this, defaultedOptions)\n      .setData(data, { ...options, manual: true })\n  }\n\n  /**\n   * Synchronous way to immediately update the cached data of multiple queries at once, using\n   * filters or partial query key matching. Only queries that already exist and match the given\n   * filters are updated; no new cache entries are created. Internally this calls\n   * {@link QueryClient#setQueryData} for each matching query.\n   *\n   * @example\n   * ```ts\n   * queryClient.setQueriesData({ queryKey: ['posts'] }, (oldPosts) =>\n   *   oldPosts ? oldPosts.filter((post) => post.id !== deletedId) : oldPosts,\n   * )\n   * ```\n   */\n  setQueriesData<\n    TQueryFnData,\n    TQueryFilters extends QueryFilters<any> = QueryFilters,\n  >(\n    filters: TQueryFilters,\n    updater: Updater<\n      NoInfer<TQueryFnData> | undefined,\n      NoInfer<TQueryFnData> | undefined\n    >,\n    options?: SetDataOptions,\n  ): Array<[QueryKey, TQueryFnData | undefined]> {\n    return notifyManager.batch(() =>\n      this.#queryCache\n        .findAll(filters)\n        .map(({ queryKey }) => [\n          queryKey,\n          this.setQueryData<TQueryFnData>(queryKey, updater, options),\n        ]),\n    )\n  }\n\n  /**\n   * Imperative (non-reactive) way to retrieve an existing query's state. If the query does not\n   * exist, `undefined` is returned.\n   *\n   * @example\n   * ```ts\n   * const state = queryClient.getQueryState(['posts'])\n   * console.log(state?.dataUpdatedAt)\n   * ```\n   */\n  getQueryState<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TTaggedQueryKey extends QueryKey = QueryKey,\n    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,\n    TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>,\n  >(\n    queryKey: TTaggedQueryKey,\n  ): QueryState<TInferredQueryFnData, TInferredError> | undefined {\n    const options = this.defaultQueryOptions({ queryKey })\n    return this.#queryCache.get<TInferredQueryFnData, TInferredError>(\n      options.queryHash,\n    )?.state\n  }\n\n  /**\n   * Removes queries from the cache that match the given filters. Unlike\n   * {@link QueryClient#invalidateQueries} or {@link QueryClient#refetchQueries}, this removes\n   * matching queries from the cache instead of refetching them. Without filters, every query in\n   * the cache is removed.\n   *\n   * @example\n   * ```ts\n   * queryClient.removeQueries({ queryKey: ['posts'], exact: true })\n   * ```\n   */\n  removeQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: QueryFilters<TTaggedQueryKey>,\n  ): void {\n    const queryCache = this.#queryCache\n    notifyManager.batch(() => {\n      queryCache.findAll(filters).forEach((query) => {\n        queryCache.remove(query)\n      })\n    })\n  }\n\n  /**\n   * Resets queries matching the given filters back to their initial state (e.g. any\n   * `initialData`), notifying subscribers rather than removing them. Active queries among the\n   * matched set are then refetched, and the returned promise resolves once that refetch settles.\n   *\n   * @example\n   * ```ts\n   * await queryClient.resetQueries({ queryKey: ['posts'], exact: true })\n   * ```\n   */\n  resetQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: QueryFilters<TTaggedQueryKey>,\n    options?: ResetOptions,\n  ): Promise<void> {\n    const queryCache = this.#queryCache\n\n    return notifyManager.batch(() => {\n      const matched = queryCache.findAll(filters)\n      const queriesToRefetch = new Set(matched)\n      matched.forEach((query) => {\n        query.reset()\n      })\n      return this.refetchQueries(\n        {\n          type: 'active',\n          predicate: (query) => queriesToRefetch.has(query),\n        },\n        options,\n      )\n    })\n  }\n\n  /**\n   * Cancels outgoing fetches for queries matching the given filters. Most useful when performing\n   * optimistic updates, since any outgoing refetch that resolves afterwards would otherwise\n   * overwrite the optimistic update. By default (`revert: true`), a cancelled query's data is\n   * reverted to its state before the outgoing fetch started.\n   *\n   * The returned promise never rejects, even if individual cancellations fail.\n   *\n   * @example\n   * ```ts\n   * await queryClient.cancelQueries({ queryKey: ['posts'], exact: true })\n   * ```\n   */\n  cancelQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: QueryFilters<TTaggedQueryKey>,\n    cancelOptions: CancelOptions = {},\n  ): Promise<void> {\n    const defaultedCancelOptions = { revert: true, ...cancelOptions }\n\n    const promises = notifyManager.batch(() =>\n      this.#queryCache\n        .findAll(filters)\n        .map((query) => query.cancel(defaultedCancelOptions)),\n    )\n\n    return Promise.all(promises).then(noop).catch(noop)\n  }\n\n  /**\n   * Marks queries matching the given filters as invalidated. Unlike\n   * {@link QueryClient#removeQueries}, invalidated queries stay in the cache.\n   *\n   * Unless `filters.refetchType` is `'none'`, matching queries are then refetched via\n   * {@link QueryClient#refetchQueries}, using `filters.refetchType` if set, otherwise\n   * `filters.type`, otherwise `'active'`.\n   *\n   * @example\n   * ```ts\n   * await queryClient.invalidateQueries({ queryKey: ['posts'], refetchType: 'active' })\n   * ```\n   */\n  invalidateQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: InvalidateQueryFilters<TTaggedQueryKey>,\n    options: InvalidateOptions = {},\n  ): Promise<void> {\n    return notifyManager.batch(() => {\n      this.#queryCache.findAll(filters).forEach((query) => {\n        query.invalidate()\n      })\n\n      if (filters?.refetchType === 'none') {\n        return Promise.resolve()\n      }\n      return this.refetchQueries(\n        {\n          ...filters,\n          type: filters?.refetchType ?? filters?.type ?? 'active',\n        },\n        options,\n      )\n    })\n  }\n\n  /**\n   * Refetches queries matching the given filters, regardless of whether they are stale. Without\n   * filters, every query in the cache is refetched. Queries that are disabled, or static (only\n   * have observers with a static `staleTime`), are never refetched.\n   *\n   * By default (`cancelRefetch: true`), a currently running fetch is cancelled before the new\n   * one starts. The returned promise resolves once all matching queries have settled; it does\n   * not reject on individual query failures unless `throwOnError` is set.\n   *\n   * @example\n   * ```ts\n   * // refetch all active queries partially matching a query key:\n   * await queryClient.refetchQueries({ queryKey: ['posts'], type: 'active' })\n   * ```\n   */\n  refetchQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: RefetchQueryFilters<TTaggedQueryKey>,\n    options: RefetchOptions = {},\n  ): Promise<void> {\n    const fetchOptions = {\n      ...options,\n      cancelRefetch: options.cancelRefetch ?? true,\n    }\n    const promises = notifyManager.batch(() =>\n      this.#queryCache\n        .findAll(filters)\n        .filter((query) => !query.isDisabled() && !query.isStatic())\n        .map((query) => {\n          let promise = query.fetch(undefined, fetchOptions)\n          if (!fetchOptions.throwOnError) {\n            promise = promise.catch(noop)\n          }\n          return query.state.fetchStatus === 'paused'\n            ? Promise.resolve()\n            : promise\n        }),\n    )\n\n    return Promise.all(promises).then(noop)\n  }\n\n  /**\n   * Asynchronous method to fetch and cache a query, resolving with the data or throwing with\n   * the error.\n   *\n   * If the query already exists in the cache and its data is not stale (per the given\n   * `staleTime`), the cached data is returned without fetching. Otherwise, the query is fetched\n   * and the promise resolves once the fetch settles. If a `select` function is provided, it is\n   * applied to the data in both cases (cached or freshly fetched) before it is returned.\n   *\n   * Unlike a reactive observer, retries are disabled by default here (`retry: false`) unless\n   * explicitly configured, since there is no component to catch a thrown error and retry through\n   * re-render.\n   *\n   * The accepted options are `QueryObserverOptions` minus the fields that only make sense for a\n   * reactive observer — `enabled`, `refetchInterval`, `refetchIntervalInBackground`,\n   * `refetchOnWindowFocus`, `refetchOnReconnect`, `refetchOnMount`, `retryOnMount`,\n   * `notifyOnChangeProps`, `throwOnError`, `suspense`, and `placeholderData` are not part of this\n   * method's options.\n   *\n   * This method replaces the deprecated `fetchQuery`, and — combined with\n   * `{ staleTime: 'static' }` — the deprecated `ensureQueryData`.\n   *\n   * @example\n   * ```ts\n   * try {\n   *   const data = await queryClient.query({ queryKey, queryFn, staleTime: 10000 })\n   * } catch (error) {\n   *   console.log(error)\n   * }\n   * ```\n   */\n  async query<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = never,\n  >(\n    options: QueryExecuteOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<TData> {\n    const defaultedOptions = this.defaultQueryOptions(options)\n\n    // https://github.com/tannerlinsley/react-query/issues/652\n    if (defaultedOptions.retry === undefined) {\n      defaultedOptions.retry = false\n    }\n\n    const query = this.#queryCache.build(this, defaultedOptions)\n\n    const isStale = query.isStaleByTime(\n      resolveQueryValue(defaultedOptions.staleTime, query),\n    )\n\n    const queryData = isStale\n      ? await query.fetch(defaultedOptions)\n      : (query.state.data as TQueryData)\n\n    const select = defaultedOptions.select\n\n    if (select) {\n      return select(queryData)\n    }\n\n    return queryData as unknown as TData\n  }\n\n  /**\n   * @deprecated Use queryClient.query(options) instead. This method will be removed in the next major version.\n   */\n  fetchQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = never,\n  >(\n    options: FetchQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<TData> {\n    const defaultedOptions = this.defaultQueryOptions(options)\n\n    // https://github.com/tannerlinsley/react-query/issues/652\n    if (defaultedOptions.retry === undefined) {\n      defaultedOptions.retry = false\n    }\n\n    const query = this.#queryCache.build(this, defaultedOptions)\n\n    return query.isStaleByTime(\n      resolveQueryValue(defaultedOptions.staleTime, query),\n    )\n      ? query.fetch(defaultedOptions)\n      : Promise.resolve(query.state.data as TData)\n  }\n\n  /**\n   * @deprecated Use queryClient.query(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.\n   */\n  prefetchQuery<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n  >(\n    options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  ): Promise<void> {\n    // eslint-disable-next-line no-restricted-syntax\n    return this.fetchQuery(options).then(noop).catch(noop)\n  }\n\n  /**\n   * Asynchronous method to fetch and cache an infinite query, resolving with an\n   * {@link InfiniteData} object or throwing with the error.\n   *\n   * Behaves like {@link QueryClient#query}, accepting the same options (minus\n   * `initialPageParam`), plus the required `initialPageParam`, and an optional `pages` /\n   * `getNextPageParam` pair used to refetch a fixed number of pages from the start.\n   *\n   * This method replaces the deprecated `fetchInfiniteQuery`, and — combined with\n   * `{ staleTime: 'static' }` — the deprecated `ensureInfiniteQueryData`.\n   *\n   * @example\n   * ```ts\n   * try {\n   *   const data = await queryClient.infiniteQuery({ queryKey, queryFn, initialPageParam: 0 })\n   *   console.log(data.pages)\n   * } catch (error) {\n   *   console.log(error)\n   * }\n   * ```\n   */\n  infiniteQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = InfiniteData<TQueryFnData>,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: InfiniteQueryExecuteOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<\n    Array<TData> extends Array<InfiniteData<TQueryFnData>>\n      ? InfiniteData<TQueryFnData, TPageParam>\n      : TData\n  > {\n    options._type = 'infinite'\n    return this.query(options as any)\n  }\n\n  /**\n   * @deprecated Use queryClient.infiniteQuery(options) instead. This method will be removed in the next major version.\n   */\n  fetchInfiniteQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: FetchInfiniteQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<InfiniteData<TData, TPageParam>> {\n    options._type = 'infinite'\n    // eslint-disable-next-line no-restricted-syntax\n    return this.fetchQuery(options as any)\n  }\n\n  /**\n   * @deprecated Use queryClient.infiniteQuery(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.\n   */\n  prefetchInfiniteQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: FetchInfiniteQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<void> {\n    // eslint-disable-next-line no-restricted-syntax\n    return this.fetchInfiniteQuery(options).then(noop).catch(noop)\n  }\n\n  /**\n   * @deprecated Use queryClient.infiniteQuery({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.\n   */\n  ensureInfiniteQueryData<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: EnsureInfiniteQueryDataOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<InfiniteData<TData, TPageParam>> {\n    options._type = 'infinite'\n\n    // eslint-disable-next-line no-restricted-syntax\n    return this.ensureQueryData(options as any)\n  }\n\n  /**\n   * Resumes mutations that were paused because there was no network connection. Does nothing\n   * (resolving immediately) if the client is currently offline.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * await queryClient.resumePausedMutations()\n   * ```\n   */\n  resumePausedMutations(): Promise<unknown> {\n    if (onlineManager.isOnline()) {\n      return this.#mutationCache.resumePausedMutations()\n    }\n    return Promise.resolve()\n  }\n\n  /**\n   * Returns the query cache this client is connected to.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * const queryCache = queryClient.getQueryCache()\n   * const queries = queryCache.findAll({ queryKey: ['posts'] })\n   * ```\n   */\n  getQueryCache(): QueryCache {\n    return this.#queryCache\n  }\n\n  /**\n   * Returns the mutation cache this client is connected to.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * const mutationCache = queryClient.getMutationCache()\n   * const mutations = mutationCache.findAll({ status: 'pending' })\n   * ```\n   */\n  getMutationCache(): MutationCache {\n    return this.#mutationCache\n  }\n\n  /**\n   * Returns the default options that were set when creating the client, or via\n   * {@link QueryClient#setDefaultOptions}.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * const defaultOptions = queryClient.getDefaultOptions()\n   * ```\n   */\n  getDefaultOptions(): DefaultOptions {\n    return this.#defaultOptions\n  }\n\n  /**\n   * Dynamically sets the default options for this client, overwriting any previously defined\n   * default options.\n   *\n   * @see {@link QueryClient#getDefaultOptions}\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * queryClient.setDefaultOptions({\n   *   queries: {\n   *     staleTime: Infinity,\n   *   },\n   * })\n   * ```\n   */\n  setDefaultOptions(options: DefaultOptions): void {\n    this.#defaultOptions = options\n  }\n\n  /**\n   * Sets default options for queries whose query key partially matches the given `queryKey`.\n   *\n   * If several registered query defaults match a given query key, they are merged together in\n   * registration order by {@link QueryClient#getQueryDefaults}, so register defaults from the\n   * most generic key to the least generic one — more specific defaults should be registered\n   * after more generic ones so they take precedence.\n   *\n   * @example\n   * ```ts\n   * queryClient.setQueryDefaults(['posts'], { queryFn: fetchPosts })\n   *\n   * await queryClient.query({ queryKey: ['posts'] })\n   * ```\n   */\n  setQueryDefaults<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n  >(\n    queryKey: QueryKey,\n    options: Partial<\n      OmitKeyof<\n        QueryObserverOptions<TQueryFnData, TError, TData, TQueryData>,\n        'queryKey'\n      >\n    >,\n  ): void {\n    this.#queryDefaults.set(hashKey(queryKey), {\n      queryKey,\n      defaultOptions: options,\n    })\n  }\n\n  /**\n   * Returns the default options registered for queries whose query key partially matches the\n   * given `queryKey`, via {@link QueryClient#setQueryDefaults}. If multiple registered defaults\n   * match, they are merged together in registration order.\n   *\n   * @example\n   * ```ts\n   * const defaultOptions = queryClient.getQueryDefaults(['posts'])\n   * ```\n   */\n  getQueryDefaults(\n    queryKey: QueryKey,\n  ): OmitKeyof<QueryObserverOptions<any, any, any, any, any>, 'queryKey'> {\n    const defaults = [...this.#queryDefaults.values()]\n\n    const result: OmitKeyof<\n      QueryObserverOptions<any, any, any, any, any>,\n      'queryKey'\n    > = {}\n\n    defaults.forEach((queryDefault) => {\n      if (partialMatchKey(queryKey, queryDefault.queryKey)) {\n        Object.assign(result, queryDefault.defaultOptions)\n      }\n    })\n    return result\n  }\n\n  /**\n   * Sets default options for mutations whose mutation key partially matches the given\n   * `mutationKey`. As with {@link QueryClient#setQueryDefaults}, the order of registration\n   * matters when several registered defaults match the same mutation key.\n   *\n   * @see {@link QueryClient#getMutationDefaults}\n   * @example\n   * ```ts\n   * queryClient.setMutationDefaults(['addPost'], { mutationFn: addPost })\n   * ```\n   */\n  setMutationDefaults<\n    TData = unknown,\n    TError = DefaultError,\n    TVariables = void,\n    TOnMutateResult = unknown,\n  >(\n    mutationKey: MutationKey,\n    options: OmitKeyof<\n      MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>,\n      'mutationKey'\n    >,\n  ): void {\n    this.#mutationDefaults.set(hashKey(mutationKey), {\n      mutationKey,\n      defaultOptions: options,\n    })\n  }\n\n  /**\n   * Returns the default options registered for mutations whose mutation key partially matches\n   * the given `mutationKey`, via {@link QueryClient#setMutationDefaults}. If multiple registered\n   * defaults match, they are merged together in registration order.\n   *\n   * @example\n   * ```ts\n   * const defaultOptions = queryClient.getMutationDefaults(['addPost'])\n   * ```\n   */\n  getMutationDefaults(\n    mutationKey: MutationKey,\n  ): OmitKeyof<MutationObserverOptions<any, any, any, any>, 'mutationKey'> {\n    const defaults = [...this.#mutationDefaults.values()]\n\n    const result: OmitKeyof<\n      MutationObserverOptions<any, any, any, any>,\n      'mutationKey'\n    > = {}\n\n    defaults.forEach((queryDefault) => {\n      if (partialMatchKey(mutationKey, queryDefault.mutationKey)) {\n        Object.assign(result, queryDefault.defaultOptions)\n      }\n    })\n\n    return result\n  }\n\n  /**\n   * Called by framework adapters (e.g. inside `useQuery`) to resolve the options passed by the\n   * caller into their final, defaulted form: merging `queryClient.setQueryDefaults` for the\n   * given `queryKey`, then the client's own `defaultOptions.queries`, then the caller's options\n   * on top. A no-op if the options are already defaulted (`_defaulted: true`).\n   */\n  defaultQueryOptions<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = never,\n  >(\n    options:\n      | QueryObserverOptions<\n          TQueryFnData,\n          TError,\n          TData,\n          TQueryData,\n          TQueryKey,\n          TPageParam\n        >\n      | DefaultedQueryObserverOptions<\n          TQueryFnData,\n          TError,\n          TData,\n          TQueryData,\n          TQueryKey\n        >,\n  ): DefaultedQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  > {\n    if (options._defaulted) {\n      return options as DefaultedQueryObserverOptions<\n        TQueryFnData,\n        TError,\n        TData,\n        TQueryData,\n        TQueryKey\n      >\n    }\n\n    const defaultedOptions = {\n      ...this.#defaultOptions.queries,\n      ...this.getQueryDefaults(options.queryKey),\n      ...options,\n      _defaulted: true,\n    }\n\n    if (!defaultedOptions.queryHash) {\n      defaultedOptions.queryHash = hashQueryKeyByOptions(\n        defaultedOptions.queryKey,\n        defaultedOptions,\n      )\n    }\n\n    // dependent default values\n    if (defaultedOptions.refetchOnReconnect === undefined) {\n      defaultedOptions.refetchOnReconnect =\n        defaultedOptions.networkMode !== 'always'\n    }\n    if (defaultedOptions.throwOnError === undefined) {\n      defaultedOptions.throwOnError = !!defaultedOptions.suspense\n    }\n\n    if (!defaultedOptions.networkMode && defaultedOptions.persister) {\n      defaultedOptions.networkMode = 'offlineFirst'\n    }\n\n    if (defaultedOptions.queryFn === skipToken) {\n      defaultedOptions.enabled = false\n    }\n\n    return defaultedOptions as DefaultedQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey\n    >\n  }\n\n  /**\n   * The mutation counterpart of {@link QueryClient#defaultQueryOptions}. Called by framework\n   * adapters (e.g. inside `useMutation`) to merge `queryClient.setMutationDefaults` for the\n   * given `mutationKey`, then the client's `defaultOptions.mutations`, then the caller's options\n   * on top. A no-op if the options are already defaulted (`_defaulted: true`).\n   */\n  defaultMutationOptions<T extends MutationOptions<any, any, any, any>>(\n    options?: T,\n  ): T {\n    if (options?._defaulted) {\n      return options\n    }\n    return {\n      ...this.#defaultOptions.mutations,\n      ...(options?.mutationKey &&\n        this.getMutationDefaults(options.mutationKey)),\n      ...options,\n      _defaulted: true,\n    } as T\n  }\n\n  /**\n   * Clears both the query cache and the mutation cache this client is connected to.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * queryClient.clear()\n   * ```\n   */\n  clear(): void {\n    this.#queryCache.clear()\n    this.#mutationCache.clear()\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"queryClient.js","names":[],"sources":["../../src/queryClient.ts"],"sourcesContent":["import {\n  functionalUpdate,\n  hashKey,\n  hashQueryKeyByOptions,\n  noop,\n  partialMatchKey,\n  resolveQueryValue,\n  skipToken,\n} from './utils'\nimport { QueryCache } from './queryCache'\nimport { MutationCache } from './mutationCache'\nimport { focusManager } from './focusManager'\nimport { onlineManager } from './onlineManager'\nimport { notifyManager } from './notifyManager'\nimport type {\n  CancelOptions,\n  DefaultError,\n  DefaultOptions,\n  DefaultedQueryObserverOptions,\n  EnsureInfiniteQueryDataOptions,\n  EnsureQueryDataOptions,\n  FetchInfiniteQueryOptions,\n  FetchQueryOptions,\n  InferDataFromTag,\n  InferErrorFromTag,\n  InfiniteData,\n  InfiniteQueryExecuteOptions,\n  InvalidateOptions,\n  InvalidateQueryFilters,\n  MutationKey,\n  MutationObserverOptions,\n  MutationOptions,\n  OmitKeyof,\n  QueryClientConfig,\n  QueryExecuteOptions,\n  QueryKey,\n  QueryObserverOptions,\n  QueryOptions,\n  RefetchOptions,\n  RefetchQueryFilters,\n  ResetOptions,\n  SetDataOptions,\n} from './types'\nimport type { QueryState } from './query'\nimport type { MutationFilters, QueryFilters, Updater } from './utils'\n\n// TYPES\n\ninterface QueryDefaults {\n  queryKey: QueryKey\n  defaultOptions: OmitKeyof<QueryOptions<any, any, any>, 'queryKey'>\n}\n\ninterface MutationDefaults {\n  mutationKey: MutationKey\n  defaultOptions: MutationOptions<any, any, any, any>\n}\n\n// CLASS\n\n/**\n * `QueryClient` is used to interact with a cache of queries and mutations. It owns a\n * `QueryCache` and a `MutationCache` (creating default ones if none are passed in) and holds\n * the default options that are applied to queries and mutations created through it.\n *\n * @example\n * ```ts\n * const queryClient = new QueryClient({\n *   defaultOptions: {\n *     queries: {\n *       staleTime: Infinity,\n *     },\n *   },\n * })\n *\n * await queryClient.query({ queryKey: ['posts'], queryFn: fetchPosts })\n * ```\n */\nexport class QueryClient {\n  #queryCache: QueryCache\n  #mutationCache: MutationCache\n  #defaultOptions: DefaultOptions\n  #queryDefaults: Map<string, QueryDefaults>\n  #mutationDefaults: Map<string, MutationDefaults>\n  #mountCount: number\n  #unsubscribeFocus?: () => void\n  #unsubscribeOnline?: () => void\n\n  constructor(config: QueryClientConfig = {}) {\n    this.#queryCache = config.queryCache || new QueryCache()\n    this.#mutationCache = config.mutationCache || new MutationCache()\n    this.#defaultOptions = config.defaultOptions || {}\n    this.#queryDefaults = new Map()\n    this.#mutationDefaults = new Map()\n    this.#mountCount = 0\n  }\n\n  /**\n   * Called by a framework adapter's `QueryClientProvider`-equivalent when it mounts, to start\n   * listening for focus/online events and resume paused mutations. Ref-counted via an internal\n   * mount count, so nested or multiple providers sharing the same `QueryClient` don't tear down\n   * the shared listeners until the last one unmounts.\n   */\n  mount(): void {\n    this.#mountCount++\n    if (this.#mountCount !== 1) return\n\n    this.#unsubscribeFocus = focusManager.subscribe(async (focused) => {\n      if (focused) {\n        await this.resumePausedMutations()\n        this.#queryCache.onFocus()\n      }\n    })\n    this.#unsubscribeOnline = onlineManager.subscribe(async (online) => {\n      if (online) {\n        await this.resumePausedMutations()\n        this.#queryCache.onOnline()\n      }\n    })\n  }\n\n  /**\n   * The inverse of {@link QueryClient#mount} — called by a framework adapter's\n   * `QueryClientProvider`-equivalent when it unmounts. Only tears down the focus/online\n   * listeners once the mount count returns to `0`.\n   */\n  unmount(): void {\n    this.#mountCount--\n    if (this.#mountCount !== 0) return\n\n    this.#unsubscribeFocus?.()\n    this.#unsubscribeFocus = undefined\n\n    this.#unsubscribeOnline?.()\n    this.#unsubscribeOnline = undefined\n  }\n\n  /**\n   * Returns the number of queries in the cache that are currently fetching, optionally\n   * matching a set of filters. This includes background-fetching, loading new pages, and\n   * loading more infinite query results.\n   *\n   * @example\n   * ```ts\n   * if (queryClient.isFetching()) {\n   *   console.log('At least one query is fetching!')\n   * }\n   * ```\n   */\n  isFetching<TQueryFilters extends QueryFilters<any> = QueryFilters>(\n    filters?: TQueryFilters,\n  ): number {\n    return this.#queryCache.findAll({ ...filters, fetchStatus: 'fetching' })\n      .length\n  }\n\n  /**\n   * Returns the number of mutations in the cache that are currently pending, optionally\n   * matching a set of filters.\n   *\n   * @example\n   * ```ts\n   * if (queryClient.isMutating()) {\n   *   console.log('At least one mutation is pending!')\n   * }\n   * ```\n   */\n  isMutating<\n    TMutationFilters extends MutationFilters<any, any> = MutationFilters,\n  >(filters?: TMutationFilters): number {\n    return this.#mutationCache.findAll({ ...filters, status: 'pending' }).length\n  }\n\n  /**\n   * Imperative (non-reactive) way to retrieve data for a QueryKey.\n   * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.\n   *\n   * Hint: Do not use this function inside a component, because it won't receive updates.\n   * Use `useQuery` to create a `QueryObserver` that subscribes to changes.\n   *\n   * @returns The cached data for the query, or `undefined` if no query with this key has been observed yet.\n   * @see {@link QueryClient#getQueriesData}\n   */\n  getQueryData<\n    TQueryFnData = unknown,\n    TTaggedQueryKey extends QueryKey = QueryKey,\n    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,\n  >(queryKey: TTaggedQueryKey): TInferredQueryFnData | undefined {\n    const options = this.defaultQueryOptions({ queryKey })\n\n    return this.#queryCache.get<TInferredQueryFnData>(options.queryHash)?.state\n      .data\n  }\n\n  /**\n   * @deprecated Use queryClient.query({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.\n   */\n  ensureQueryData<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n  >(\n    options: EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n  ): Promise<TData> {\n    const defaultedOptions = this.defaultQueryOptions(options)\n    const query = this.#queryCache.build(this, defaultedOptions)\n    const cachedData = query.state.data\n\n    if (cachedData === undefined) {\n      // eslint-disable-next-line no-restricted-syntax\n      return this.fetchQuery(options)\n    }\n\n    if (\n      options.revalidateIfStale &&\n      query.isStaleByTime(resolveQueryValue(defaultedOptions.staleTime, query))\n    ) {\n      // eslint-disable-next-line no-restricted-syntax\n      void this.prefetchQuery(defaultedOptions)\n    }\n\n    return Promise.resolve(cachedData)\n  }\n\n  /**\n   * Imperative (non-reactive) way to retrieve the cached data of multiple queries at once.\n   * Only queries matching the given filters are returned; if none match, an empty array is\n   * returned.\n   *\n   * Because the matched queries can hold data of different shapes (e.g. a broad filter can match\n   * queries with unrelated data types), the `TQueryFnData` generic defaults to `unknown` rather\n   * than being inferred. Passing a more specific type is a convenience for call sites that know\n   * every matched query holds the same shape — it is not checked against the actual cache\n   * contents.\n   *\n   * @returns An array of query key and data pairs. The data is `undefined` for a query with no cached data.\n   * @see {@link QueryClient#getQueryData}\n   * @example\n   * ```ts\n   * const data = queryClient.getQueriesData({ queryKey: ['posts'] })\n   * ```\n   */\n  getQueriesData<\n    TQueryFnData = unknown,\n    TQueryFilters extends QueryFilters<any> = QueryFilters,\n  >(filters: TQueryFilters): Array<[QueryKey, TQueryFnData | undefined]> {\n    return this.#queryCache.findAll(filters).map(({ queryKey, state }) => {\n      const data = state.data as TQueryFnData | undefined\n      return [queryKey, data]\n    })\n  }\n\n  /**\n   * Synchronous way to immediately update a query's cached data. If the updater (or the value\n   * passed) resolves to `undefined`, the cache is left untouched and no query is created;\n   * otherwise, if the query does not exist yet, it will be created. To update multiple queries\n   * at once by partially matching query keys, use {@link QueryClient#setQueriesData} instead.\n   *\n   * Updates must be performed immutably: do not mutate `oldData`, or data previously retrieved\n   * via {@link QueryClient#getQueryData}, in place.\n   *\n   * @param queryKey - The query key to set data for.\n   * @param updater - Either the new data, or a function that receives the current data (which\n   * may be `undefined`) and returns the new data.\n   * @param options - Set `updatedAt` to override the timestamp the written data is recorded with.\n   * @returns The data that was written, or `undefined` if the updater returned `undefined` — in that case\n   * the write is skipped and the cache is left unchanged.\n   *\n   * @example\n   * ```ts\n   * queryClient.setQueryData(['posts'], newPosts)\n   *\n   * // Or, using an updater function that receives the current data:\n   * queryClient.setQueryData(['posts'], (oldPosts) => [...oldPosts, newPost])\n   * ```\n   */\n  setQueryData<\n    TQueryFnData = unknown,\n    TTaggedQueryKey extends QueryKey = QueryKey,\n    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,\n  >(\n    queryKey: TTaggedQueryKey,\n    updater: Updater<\n      NoInfer<TInferredQueryFnData> | undefined,\n      NoInfer<TInferredQueryFnData> | undefined\n    >,\n    options?: SetDataOptions,\n  ): NoInfer<TInferredQueryFnData> | undefined {\n    const defaultedOptions = this.defaultQueryOptions<\n      any,\n      any,\n      unknown,\n      any,\n      QueryKey\n    >({ queryKey })\n\n    const query = this.#queryCache.get<TInferredQueryFnData>(\n      defaultedOptions.queryHash,\n    )\n    const prevData = query?.state.data\n    const data = functionalUpdate(updater, prevData)\n\n    if (data === undefined) {\n      return undefined\n    }\n\n    return this.#queryCache\n      .build(this, defaultedOptions)\n      .setData(data, { ...options, manual: true })\n  }\n\n  /**\n   * Synchronous way to immediately update the cached data of multiple queries at once, using\n   * filters or partial query key matching. Only queries that already exist and match the given\n   * filters are updated; no new cache entries are created. Internally this calls\n   * {@link QueryClient#setQueryData} for each matching query.\n   *\n   * @returns One `[queryKey, data]` tuple per matched query, in the same shape and with the same\n   * `undefined` case as {@link QueryClient#setQueryData}.\n   * @example\n   * ```ts\n   * queryClient.setQueriesData({ queryKey: ['posts'] }, (oldPosts) =>\n   *   oldPosts ? oldPosts.filter((post) => post.id !== deletedId) : oldPosts,\n   * )\n   * ```\n   */\n  setQueriesData<\n    TQueryFnData,\n    TQueryFilters extends QueryFilters<any> = QueryFilters,\n  >(\n    filters: TQueryFilters,\n    updater: Updater<\n      NoInfer<TQueryFnData> | undefined,\n      NoInfer<TQueryFnData> | undefined\n    >,\n    options?: SetDataOptions,\n  ): Array<[QueryKey, TQueryFnData | undefined]> {\n    return notifyManager.batch(() =>\n      this.#queryCache\n        .findAll(filters)\n        .map(({ queryKey }) => [\n          queryKey,\n          this.setQueryData<TQueryFnData>(queryKey, updater, options),\n        ]),\n    )\n  }\n\n  /**\n   * Imperative (non-reactive) way to retrieve an existing query's state. If the query does not\n   * exist, `undefined` is returned.\n   *\n   * @example\n   * ```ts\n   * const state = queryClient.getQueryState(['posts'])\n   * console.log(state?.dataUpdatedAt)\n   * ```\n   */\n  getQueryState<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TTaggedQueryKey extends QueryKey = QueryKey,\n    TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>,\n    TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>,\n  >(\n    queryKey: TTaggedQueryKey,\n  ): QueryState<TInferredQueryFnData, TInferredError> | undefined {\n    const options = this.defaultQueryOptions({ queryKey })\n    return this.#queryCache.get<TInferredQueryFnData, TInferredError>(\n      options.queryHash,\n    )?.state\n  }\n\n  /**\n   * Removes queries from the cache that match the given filters. Unlike\n   * {@link QueryClient#invalidateQueries} or {@link QueryClient#refetchQueries}, this removes\n   * matching queries from the cache instead of refetching them. Without filters, every query in\n   * the cache is removed.\n   *\n   * @example\n   * ```ts\n   * queryClient.removeQueries({ queryKey: ['posts'], exact: true })\n   * ```\n   */\n  removeQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: QueryFilters<TTaggedQueryKey>,\n  ): void {\n    const queryCache = this.#queryCache\n    notifyManager.batch(() => {\n      queryCache.findAll(filters).forEach((query) => {\n        queryCache.remove(query)\n      })\n    })\n  }\n\n  /**\n   * Resets queries matching the given filters back to their initial state (e.g. any\n   * `initialData`), notifying subscribers rather than removing them. Active queries among the\n   * matched set are then refetched, and the returned promise resolves once that refetch settles.\n   *\n   * @example\n   * ```ts\n   * await queryClient.resetQueries({ queryKey: ['posts'], exact: true })\n   * ```\n   */\n  resetQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: QueryFilters<TTaggedQueryKey>,\n    options?: ResetOptions,\n  ): Promise<void> {\n    const queryCache = this.#queryCache\n\n    return notifyManager.batch(() => {\n      const matched = queryCache.findAll(filters)\n      const queriesToRefetch = new Set(matched)\n      matched.forEach((query) => {\n        query.reset()\n      })\n      return this.refetchQueries(\n        {\n          type: 'active',\n          predicate: (query) => queriesToRefetch.has(query),\n        },\n        options,\n      )\n    })\n  }\n\n  /**\n   * Cancels outgoing fetches for queries matching the given filters. Most useful when performing\n   * optimistic updates, since any outgoing refetch that resolves afterwards would otherwise\n   * overwrite the optimistic update. By default (`revert: true`), a cancelled query's data is\n   * reverted to its state before the outgoing fetch started.\n   *\n   * The returned promise never rejects, even if individual cancellations fail.\n   *\n   * @example\n   * ```ts\n   * await queryClient.cancelQueries({ queryKey: ['posts'], exact: true })\n   * ```\n   */\n  cancelQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: QueryFilters<TTaggedQueryKey>,\n    cancelOptions: CancelOptions = {},\n  ): Promise<void> {\n    const defaultedCancelOptions = { revert: true, ...cancelOptions }\n\n    const promises = notifyManager.batch(() =>\n      this.#queryCache\n        .findAll(filters)\n        .map((query) => query.cancel(defaultedCancelOptions)),\n    )\n\n    return Promise.all(promises).then(noop).catch(noop)\n  }\n\n  /**\n   * Marks queries matching the given filters as invalidated. Unlike\n   * {@link QueryClient#removeQueries}, invalidated queries stay in the cache.\n   *\n   * Unless `filters.refetchType` is `'none'`, matching queries are then refetched via\n   * {@link QueryClient#refetchQueries}, using `filters.refetchType` if set, otherwise\n   * `filters.type`, otherwise `'active'`.\n   *\n   * @example\n   * ```ts\n   * await queryClient.invalidateQueries({ queryKey: ['posts'], refetchType: 'active' })\n   * ```\n   */\n  invalidateQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: InvalidateQueryFilters<TTaggedQueryKey>,\n    options: InvalidateOptions = {},\n  ): Promise<void> {\n    return notifyManager.batch(() => {\n      this.#queryCache.findAll(filters).forEach((query) => {\n        query.invalidate()\n      })\n\n      if (filters?.refetchType === 'none') {\n        return Promise.resolve()\n      }\n      return this.refetchQueries(\n        {\n          ...filters,\n          type: filters?.refetchType ?? filters?.type ?? 'active',\n        },\n        options,\n      )\n    })\n  }\n\n  /**\n   * Refetches queries matching the given filters, regardless of whether they are stale. Without\n   * filters, every query in the cache is refetched. Queries that are disabled, or static (only\n   * have observers with a static `staleTime`), are never refetched.\n   *\n   * By default (`cancelRefetch: true`), a currently running fetch is cancelled before the new\n   * one starts. The returned promise resolves once all matching queries have settled; it does\n   * not reject on individual query failures unless `throwOnError` is set.\n   *\n   * @example\n   * ```ts\n   * // refetch all active queries partially matching a query key:\n   * await queryClient.refetchQueries({ queryKey: ['posts'], type: 'active' })\n   * ```\n   */\n  refetchQueries<TTaggedQueryKey extends QueryKey = QueryKey>(\n    filters?: RefetchQueryFilters<TTaggedQueryKey>,\n    options: RefetchOptions = {},\n  ): Promise<void> {\n    const fetchOptions = {\n      ...options,\n      cancelRefetch: options.cancelRefetch ?? true,\n    }\n    const promises = notifyManager.batch(() =>\n      this.#queryCache\n        .findAll(filters)\n        .filter((query) => !query.isDisabled() && !query.isStatic())\n        .map((query) => {\n          let promise = query.fetch(undefined, fetchOptions)\n          if (!fetchOptions.throwOnError) {\n            promise = promise.catch(noop)\n          }\n          return query.state.fetchStatus === 'paused'\n            ? Promise.resolve()\n            : promise\n        }),\n    )\n\n    return Promise.all(promises).then(noop)\n  }\n\n  /**\n   * Asynchronous method to fetch and cache a query, resolving with the data or throwing with\n   * the error.\n   *\n   * If the query already exists in the cache and its data is not stale (per the given\n   * `staleTime`), the cached data is returned without fetching. Otherwise, the query is fetched\n   * and the promise resolves once the fetch settles. If a `select` function is provided, it is\n   * applied to the data in both cases (cached or freshly fetched) before it is returned.\n   *\n   * Unlike a reactive observer, retries are disabled by default here (`retry: false`) unless\n   * explicitly configured, since there is no component to catch a thrown error and retry through\n   * re-render.\n   *\n   * The accepted options are `QueryObserverOptions` minus the fields that only make sense for a\n   * reactive observer — `enabled`, `refetchInterval`, `refetchIntervalInBackground`,\n   * `refetchOnWindowFocus`, `refetchOnReconnect`, `refetchOnMount`, `retryOnMount`,\n   * `notifyOnChangeProps`, `throwOnError`, `suspense`, and `placeholderData` are not part of this\n   * method's options.\n   *\n   * This method replaces the deprecated `fetchQuery`, and — combined with\n   * `{ staleTime: 'static' }` — the deprecated `ensureQueryData`.\n   *\n   * @example\n   * ```ts\n   * try {\n   *   const data = await queryClient.query({ queryKey, queryFn, staleTime: 10000 })\n   * } catch (error) {\n   *   console.log(error)\n   * }\n   * ```\n   */\n  async query<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = never,\n  >(\n    options: QueryExecuteOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<TData> {\n    const defaultedOptions = this.defaultQueryOptions(options)\n\n    // https://github.com/tannerlinsley/react-query/issues/652\n    if (defaultedOptions.retry === undefined) {\n      defaultedOptions.retry = false\n    }\n\n    const query = this.#queryCache.build(this, defaultedOptions)\n\n    const isStale = query.isStaleByTime(\n      resolveQueryValue(defaultedOptions.staleTime, query),\n    )\n\n    const queryData = isStale\n      ? await query.fetch(defaultedOptions)\n      : (query.state.data as TQueryData)\n\n    const select = defaultedOptions.select\n\n    if (select) {\n      return select(queryData)\n    }\n\n    return queryData as unknown as TData\n  }\n\n  /**\n   * @deprecated Use queryClient.query(options) instead. This method will be removed in the next major version.\n   */\n  fetchQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = never,\n  >(\n    options: FetchQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<TData> {\n    const defaultedOptions = this.defaultQueryOptions(options)\n\n    // https://github.com/tannerlinsley/react-query/issues/652\n    if (defaultedOptions.retry === undefined) {\n      defaultedOptions.retry = false\n    }\n\n    const query = this.#queryCache.build(this, defaultedOptions)\n\n    return query.isStaleByTime(\n      resolveQueryValue(defaultedOptions.staleTime, query),\n    )\n      ? query.fetch(defaultedOptions)\n      : Promise.resolve(query.state.data as TData)\n  }\n\n  /**\n   * @deprecated Use queryClient.query(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.\n   */\n  prefetchQuery<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n  >(\n    options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  ): Promise<void> {\n    // eslint-disable-next-line no-restricted-syntax\n    return this.fetchQuery(options).then(noop).catch(noop)\n  }\n\n  /**\n   * Asynchronous method to fetch and cache an infinite query, resolving with an\n   * {@link InfiniteData} object or throwing with the error.\n   *\n   * Behaves like {@link QueryClient#query}, accepting the same options (minus\n   * `initialPageParam`), plus the required `initialPageParam`, and an optional `pages` /\n   * `getNextPageParam` pair used to refetch a fixed number of pages from the start.\n   *\n   * This method replaces the deprecated `fetchInfiniteQuery`, and — combined with\n   * `{ staleTime: 'static' }` — the deprecated `ensureInfiniteQueryData`.\n   *\n   * @example\n   * ```ts\n   * try {\n   *   const data = await queryClient.infiniteQuery({ queryKey, queryFn, initialPageParam: 0 })\n   *   console.log(data.pages)\n   * } catch (error) {\n   *   console.log(error)\n   * }\n   * ```\n   */\n  infiniteQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = InfiniteData<TQueryFnData>,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: InfiniteQueryExecuteOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<\n    Array<TData> extends Array<InfiniteData<TQueryFnData>>\n      ? InfiniteData<TQueryFnData, TPageParam>\n      : TData\n  > {\n    options._type = 'infinite'\n    return this.query(options as any)\n  }\n\n  /**\n   * @deprecated Use queryClient.infiniteQuery(options) instead. This method will be removed in the next major version.\n   */\n  fetchInfiniteQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: FetchInfiniteQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<InfiniteData<TData, TPageParam>> {\n    options._type = 'infinite'\n    // eslint-disable-next-line no-restricted-syntax\n    return this.fetchQuery(options as any)\n  }\n\n  /**\n   * @deprecated Use queryClient.infiniteQuery(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.\n   */\n  prefetchInfiniteQuery<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: FetchInfiniteQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<void> {\n    // eslint-disable-next-line no-restricted-syntax\n    return this.fetchInfiniteQuery(options).then(noop).catch(noop)\n  }\n\n  /**\n   * @deprecated Use queryClient.infiniteQuery({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.\n   */\n  ensureInfiniteQueryData<\n    TQueryFnData,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = unknown,\n  >(\n    options: EnsureInfiniteQueryDataOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n  ): Promise<InfiniteData<TData, TPageParam>> {\n    options._type = 'infinite'\n\n    // eslint-disable-next-line no-restricted-syntax\n    return this.ensureQueryData(options as any)\n  }\n\n  /**\n   * Resumes mutations that were paused because there was no network connection. Does nothing\n   * (resolving immediately) if the client is currently offline.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * await queryClient.resumePausedMutations()\n   * ```\n   */\n  resumePausedMutations(): Promise<unknown> {\n    if (onlineManager.isOnline()) {\n      return this.#mutationCache.resumePausedMutations()\n    }\n    return Promise.resolve()\n  }\n\n  /**\n   * Returns the query cache this client is connected to.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * const queryCache = queryClient.getQueryCache()\n   * const queries = queryCache.findAll({ queryKey: ['posts'] })\n   * ```\n   */\n  getQueryCache(): QueryCache {\n    return this.#queryCache\n  }\n\n  /**\n   * Returns the mutation cache this client is connected to.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * const mutationCache = queryClient.getMutationCache()\n   * const mutations = mutationCache.findAll({ status: 'pending' })\n   * ```\n   */\n  getMutationCache(): MutationCache {\n    return this.#mutationCache\n  }\n\n  /**\n   * Returns the default options that were set when creating the client, or via\n   * {@link QueryClient#setDefaultOptions}.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * const defaultOptions = queryClient.getDefaultOptions()\n   * ```\n   */\n  getDefaultOptions(): DefaultOptions {\n    return this.#defaultOptions\n  }\n\n  /**\n   * Dynamically sets the default options for this client, overwriting any previously defined\n   * default options.\n   *\n   * @see {@link QueryClient#getDefaultOptions}\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * queryClient.setDefaultOptions({\n   *   queries: {\n   *     staleTime: Infinity,\n   *   },\n   * })\n   * ```\n   */\n  setDefaultOptions(options: DefaultOptions): void {\n    this.#defaultOptions = options\n  }\n\n  /**\n   * Sets default options for queries whose query key partially matches the given `queryKey`.\n   *\n   * If several registered query defaults match a given query key, they are merged together in\n   * registration order by {@link QueryClient#getQueryDefaults}, so register defaults from the\n   * most generic key to the least generic one — more specific defaults should be registered\n   * after more generic ones so they take precedence.\n   *\n   * @example\n   * ```ts\n   * queryClient.setQueryDefaults(['posts'], { queryFn: fetchPosts })\n   *\n   * await queryClient.query({ queryKey: ['posts'] })\n   * ```\n   */\n  setQueryDefaults<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n  >(\n    queryKey: QueryKey,\n    options: Partial<\n      OmitKeyof<\n        QueryObserverOptions<TQueryFnData, TError, TData, TQueryData>,\n        'queryKey'\n      >\n    >,\n  ): void {\n    this.#queryDefaults.set(hashKey(queryKey), {\n      queryKey,\n      defaultOptions: options,\n    })\n  }\n\n  /**\n   * Returns the default options registered for queries whose query key partially matches the\n   * given `queryKey`, via {@link QueryClient#setQueryDefaults}. If multiple registered defaults\n   * match, they are merged together in registration order.\n   *\n   * @example\n   * ```ts\n   * const defaultOptions = queryClient.getQueryDefaults(['posts'])\n   * ```\n   */\n  getQueryDefaults(\n    queryKey: QueryKey,\n  ): OmitKeyof<QueryObserverOptions<any, any, any, any, any>, 'queryKey'> {\n    const defaults = [...this.#queryDefaults.values()]\n\n    const result: OmitKeyof<\n      QueryObserverOptions<any, any, any, any, any>,\n      'queryKey'\n    > = {}\n\n    defaults.forEach((queryDefault) => {\n      if (partialMatchKey(queryKey, queryDefault.queryKey)) {\n        Object.assign(result, queryDefault.defaultOptions)\n      }\n    })\n    return result\n  }\n\n  /**\n   * Sets default options for mutations whose mutation key partially matches the given\n   * `mutationKey`. As with {@link QueryClient#setQueryDefaults}, the order of registration\n   * matters when several registered defaults match the same mutation key.\n   *\n   * @see {@link QueryClient#getMutationDefaults}\n   * @example\n   * ```ts\n   * queryClient.setMutationDefaults(['addPost'], { mutationFn: addPost })\n   * ```\n   */\n  setMutationDefaults<\n    TData = unknown,\n    TError = DefaultError,\n    TVariables = void,\n    TOnMutateResult = unknown,\n  >(\n    mutationKey: MutationKey,\n    options: OmitKeyof<\n      MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>,\n      'mutationKey'\n    >,\n  ): void {\n    this.#mutationDefaults.set(hashKey(mutationKey), {\n      mutationKey,\n      defaultOptions: options,\n    })\n  }\n\n  /**\n   * Returns the default options registered for mutations whose mutation key partially matches\n   * the given `mutationKey`, via {@link QueryClient#setMutationDefaults}. If multiple registered\n   * defaults match, they are merged together in registration order.\n   *\n   * @example\n   * ```ts\n   * const defaultOptions = queryClient.getMutationDefaults(['addPost'])\n   * ```\n   */\n  getMutationDefaults(\n    mutationKey: MutationKey,\n  ): OmitKeyof<MutationObserverOptions<any, any, any, any>, 'mutationKey'> {\n    const defaults = [...this.#mutationDefaults.values()]\n\n    const result: OmitKeyof<\n      MutationObserverOptions<any, any, any, any>,\n      'mutationKey'\n    > = {}\n\n    defaults.forEach((queryDefault) => {\n      if (partialMatchKey(mutationKey, queryDefault.mutationKey)) {\n        Object.assign(result, queryDefault.defaultOptions)\n      }\n    })\n\n    return result\n  }\n\n  /**\n   * Called by framework adapters (e.g. inside `useQuery`) to resolve the options passed by the\n   * caller into their final, defaulted form: merging `queryClient.setQueryDefaults` for the\n   * given `queryKey`, then the client's own `defaultOptions.queries`, then the caller's options\n   * on top. A no-op if the options are already defaulted (`_defaulted: true`).\n   */\n  defaultQueryOptions<\n    TQueryFnData = unknown,\n    TError = DefaultError,\n    TData = TQueryFnData,\n    TQueryData = TQueryFnData,\n    TQueryKey extends QueryKey = QueryKey,\n    TPageParam = never,\n  >(\n    options:\n      | QueryObserverOptions<\n          TQueryFnData,\n          TError,\n          TData,\n          TQueryData,\n          TQueryKey,\n          TPageParam\n        >\n      | DefaultedQueryObserverOptions<\n          TQueryFnData,\n          TError,\n          TData,\n          TQueryData,\n          TQueryKey\n        >,\n  ): DefaultedQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  > {\n    if (options._defaulted) {\n      return options as DefaultedQueryObserverOptions<\n        TQueryFnData,\n        TError,\n        TData,\n        TQueryData,\n        TQueryKey\n      >\n    }\n\n    const defaultedOptions = {\n      ...this.#defaultOptions.queries,\n      ...this.getQueryDefaults(options.queryKey),\n      ...options,\n      _defaulted: true,\n    }\n\n    if (!defaultedOptions.queryHash) {\n      defaultedOptions.queryHash = hashQueryKeyByOptions(\n        defaultedOptions.queryKey,\n        defaultedOptions,\n      )\n    }\n\n    // dependent default values\n    if (defaultedOptions.refetchOnReconnect === undefined) {\n      defaultedOptions.refetchOnReconnect =\n        defaultedOptions.networkMode !== 'always'\n    }\n    if (defaultedOptions.throwOnError === undefined) {\n      defaultedOptions.throwOnError = !!defaultedOptions.suspense\n    }\n\n    if (!defaultedOptions.networkMode && defaultedOptions.persister) {\n      defaultedOptions.networkMode = 'offlineFirst'\n    }\n\n    if (defaultedOptions.queryFn === skipToken) {\n      defaultedOptions.enabled = false\n    }\n\n    return defaultedOptions as DefaultedQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey\n    >\n  }\n\n  /**\n   * The mutation counterpart of {@link QueryClient#defaultQueryOptions}. Called by framework\n   * adapters (e.g. inside `useMutation`) to merge `queryClient.setMutationDefaults` for the\n   * given `mutationKey`, then the client's `defaultOptions.mutations`, then the caller's options\n   * on top. A no-op if the options are already defaulted (`_defaulted: true`).\n   */\n  defaultMutationOptions<T extends MutationOptions<any, any, any, any>>(\n    options?: T,\n  ): T {\n    if (options?._defaulted) {\n      return options\n    }\n    return {\n      ...this.#defaultOptions.mutations,\n      ...(options?.mutationKey &&\n        this.getMutationDefaults(options.mutationKey)),\n      ...options,\n      _defaulted: true,\n    } as T\n  }\n\n  /**\n   * Clears both the query cache and the mutation cache this client is connected to.\n   *\n   * @example\n   * ```ts\n   * import { QueryClient } from '@tanstack/query-core'\n   *\n   * const queryClient = new QueryClient()\n   * queryClient.clear()\n   * ```\n   */\n  clear(): void {\n    this.#queryCache.clear()\n    this.#mutationCache.clear()\n  }\n}\n"],"mappings":"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"}