@tanstack/query-core 5.102.7 → 5.103.0

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

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

package/build/modern/hydration.cjs

@@ -26,6 +26,16 @@ function dehydratePromise(query, serializeData, shouldRedactErrors) {
 	promise?.catch(require_utils.noop);
 	return promise;
 }
+/**
+* Dehydrates a single `Query` into a serializable `DehydratedQuery` snapshot. Note that most query config (e.g.
+* `queryFn`, `staleTime`) is not dehydrated but instead meant to be configured again when consuming the
+* de/rehydrated data, typically with `useQuery` on the client. If the query is still `pending`, its in-flight
+* promise is dehydrated too so it can be resumed on the other side instead of re-fetched.
+* @param query - The query to dehydrate.
+* @param serializeData - Optional transform applied to `query.state.data` before it is included in the snapshot.
+* @param shouldRedactErrors - Optional predicate; if it returns `false` for the promise's rejection error, that
+* error is kept as-is instead of being redacted.
+*/
 function dehydrateQuery(query, serializeData, shouldRedactErrors) {
 	return {
 		dehydratedAt: Date.now(),
@@ -40,12 +50,38 @@ function dehydrateQuery(query, serializeData, shouldRedactErrors) {
 		...query.queryType && { queryType: query.queryType }
 	};
 }
+/**
+* The default `shouldDehydrateMutation` predicate used by `dehydrate`. Only dehydrates mutations that are
+* currently paused (e.g. paused by `networkMode` while offline).
+*/
 function defaultShouldDehydrateMutation(mutation) {
 	return mutation.state.isPaused;
 }
+/**
+* The default `shouldDehydrateQuery` predicate used by `dehydrate`. Only dehydrates queries whose status is
+* `'success'`.
+*/
 function defaultShouldDehydrateQuery(query) {
 	return query.state.status === "success";
 }
+/**
+* Dehydrates a `QueryClient`'s cache (queries and mutations) into a plain, serializable `DehydratedState`,
+* typically to embed in server-rendered markup and later restore into a client-side `QueryClient` via `hydrate`.
+* Which queries/mutations are included, and how their data/errors are transformed, is controlled by `options`,
+* falling back to the client's `dehydrate` default options, and finally to `defaultShouldDehydrateQuery` /
+* `defaultShouldDehydrateMutation`.
+* @example
+* ```ts
+* const queryClient = new QueryClient()
+*
+* await queryClient.prefetchQuery({
+*   queryKey: ['posts'],
+*   queryFn: getPosts,
+* })
+*
+* const dehydratedState = dehydrate(queryClient)
+* ```
+*/
 function dehydrate(client, options = {}) {
 	const filterMutation = options.shouldDehydrateMutation ?? client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ?? defaultShouldDehydrateMutation;
 	const mutations = client.getMutationCache().getAll().flatMap((mutation) => filterMutation(mutation) ? [dehydrateMutation(mutation)] : []);
@@ -57,6 +93,23 @@ function dehydrate(client, options = {}) {
 		queries: client.getQueryCache().getAll().flatMap((query) => filterQuery(query) ? [dehydrateQuery(query, serializeData, shouldRedactErrors)] : [])
 	};
 }
+/**
+* Restores a `DehydratedState` (as produced by `dehydrate`) into a `QueryClient`'s cache, typically to seed the
+* client with data already fetched on the server. `mutations` and `queries` are each optional on `dehydratedState`.
+* Queries not yet in the cache are built from the dehydrated snapshot; queries that already exist are only updated
+* when the dehydrated data is newer than what's already cached. Newly built queries have their `fetchStatus` reset
+* to `'idle'` so they don't hydrate stuck in a fetching state. If a dehydrated query still had an in-flight
+* promise, it is resumed via `query.fetch()` (reusing that promise as `initialPromise`) rather than re-invoking
+* `queryFn`.
+* @example
+* ```ts
+* // dehydratedState was produced by `dehydrate` on the server
+* // and sent to the client, e.g. embedded in server-rendered markup.
+* const queryClient = new QueryClient()
+*
+* hydrate(queryClient, dehydratedState)
+* ```
+*/
 function hydrate(client, dehydratedState, options) {
 	const mutationCache = client.getMutationCache();
 	const queryCache = client.getQueryCache();
@@ -76,7 +129,7 @@ function hydrate(client, dehydratedState, options) {
 		const existingQueryIsPending = query?.state.status === "pending";
 		const existingQueryIsFetching = query?.state.fetchStatus === "fetching";
 		if (query) {
-			const hasNewerSyncData = syncData && dehydratedAt !== void 0 && dehydratedAt > query.state.dataUpdatedAt;
+			const hasNewerSyncData = syncData && dehydratedAt > query.state.dataUpdatedAt;
 			if (state.dataUpdatedAt > query.state.dataUpdatedAt || hasNewerSyncData) {
 				const { fetchStatus: _ignored, ...serializedState } = state;
 				query.setState({
@@ -84,7 +137,7 @@ function hydrate(client, dehydratedState, options) {
 					data,
 					...state.status === "pending" && data !== void 0 && {
 						status: "success",
-						dataUpdatedAt: dehydratedAt ?? Date.now(),
+						dataUpdatedAt: dehydratedAt,
 						...!existingQueryIsFetching && { fetchStatus: "idle" }
 					}
 				});
@@ -101,9 +154,9 @@ function hydrate(client, dehydratedState, options) {
 			data,
 			fetchStatus: "idle",
 			status: state.status === "pending" && data !== void 0 ? "success" : state.status,
-			...state.status === "pending" && data !== void 0 && { dataUpdatedAt: dehydratedAt ?? Date.now() }
+			...state.status === "pending" && data !== void 0 && { dataUpdatedAt: dehydratedAt }
 		});
-		if (promise && !syncData && !existingQueryIsPending && !existingQueryIsFetching && (dehydratedAt === void 0 || dehydratedAt > query.state.dataUpdatedAt)) query.fetch(void 0, { initialPromise: Promise.resolve(promise).then(deserializeData) }).catch(require_utils.noop);
+		if (promise && !syncData && !existingQueryIsPending && !existingQueryIsFetching && dehydratedAt > query.state.dataUpdatedAt) query.fetch(void 0, { initialPromise: Promise.resolve(promise).then(deserializeData) }).catch(require_utils.noop);
 	});
 }
 //#endregion

package/build/modern/hydration.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hydration.cjs","names":["noop"],"sources":["../../src/hydration.ts"],"sourcesContent":["import { noop } from './utils'\nimport type {\n  DefaultError,\n  MutationKey,\n  MutationMeta,\n  MutationOptions,\n  MutationScope,\n  QueryKey,\n  QueryMeta,\n  QueryOptions,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query, QueryState } from './query'\nimport type { Mutation, MutationState } from './mutation'\n\n// TYPES\ntype TransformerFn = (data: any) => any\n\nfunction tryResolveSync(promise: PromiseLike<unknown>) {\n  let data: unknown\n\n  const thenResult = promise.then((result) => {\n    data = result\n    return result\n  }, noop) as Promise<unknown> | undefined\n\n  // .catch can be unavailable on certain kinds of thenable's\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  thenResult?.catch?.(noop)\n\n  if (data !== undefined) {\n    return { data }\n  }\n\n  return undefined\n}\n\nexport interface DehydrateOptions {\n  serializeData?: TransformerFn\n  shouldDehydrateMutation?: (mutation: Mutation) => boolean\n  shouldDehydrateQuery?: (query: Query) => boolean\n  shouldRedactErrors?: (error: unknown) => boolean\n}\n\nexport interface HydrateOptions {\n  defaultOptions?: {\n    deserializeData?: TransformerFn\n    queries?: QueryOptions\n    mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>\n  }\n}\n\ninterface DehydratedMutation {\n  mutationKey?: MutationKey\n  state: MutationState\n  meta?: MutationMeta\n  scope?: MutationScope\n}\n\ninterface DehydratedQuery {\n  queryHash: string\n  queryKey: QueryKey\n  state: QueryState\n  promise?: Promise<unknown>\n  meta?: QueryMeta\n  queryType?: 'infinite'\n  // This is only optional because older versions of Query might have dehydrated\n  // without it which we need to handle for backwards compatibility.\n  // This should be changed to required in the future.\n  dehydratedAt?: number\n}\n\nexport interface DehydratedState {\n  mutations: Array<DehydratedMutation>\n  queries: Array<DehydratedQuery>\n}\n\n// FUNCTIONS\n\nfunction dehydrateMutation(mutation: Mutation): DehydratedMutation {\n  return {\n    mutationKey: mutation.options.mutationKey,\n    state: mutation.state,\n    ...(mutation.options.scope && { scope: mutation.options.scope }),\n    ...(mutation.meta && { meta: mutation.meta }),\n  }\n}\n\nfunction dehydratePromise(\n  query: Query,\n  serializeData?: TransformerFn,\n  shouldRedactErrors?: (error: unknown) => boolean,\n): Promise<unknown> | undefined {\n  const promise = query.promise?.then(serializeData).catch((error) => {\n    if (shouldRedactErrors?.(error) === false) {\n      // Reject original error if it should not be redacted\n      return Promise.reject(error)\n    }\n    // If not in production, log original error before rejecting redacted error\n    if (process.env.NODE_ENV !== 'production') {\n      console.error(\n        `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`,\n      )\n    }\n    return Promise.reject(new Error('redacted'))\n  })\n\n  // Avoid unhandled promise rejections\n  // We need the promise we dehydrate to reject to get the correct result into\n  // the query cache, but we also want to avoid unhandled promise rejections\n  // in whatever environment the prefetches are happening in.\n  promise?.catch(noop)\n\n  return promise\n}\n\n// Most config is not dehydrated but instead meant to configure again when\n// consuming the de/rehydrated data, typically with useQuery on the client.\n// Sometimes it might make sense to prefetch data on the server and include\n// in the html-payload, but not consume it on the initial render.\nexport function dehydrateQuery(\n  query: Query,\n  serializeData?: TransformerFn,\n  shouldRedactErrors?: (error: unknown) => boolean,\n): DehydratedQuery {\n  return {\n    dehydratedAt: Date.now(),\n    state: {\n      ...query.state,\n      ...(query.state.data !== undefined && {\n        data: serializeData\n          ? serializeData(query.state.data)\n          : query.state.data,\n      }),\n    },\n    queryKey: query.queryKey,\n    queryHash: query.queryHash,\n    ...(query.state.status === 'pending' && {\n      promise: dehydratePromise(query, serializeData, shouldRedactErrors),\n    }),\n    ...(query.meta && { meta: query.meta }),\n    ...(query.queryType && { queryType: query.queryType }),\n  }\n}\n\nexport function defaultShouldDehydrateMutation(mutation: Mutation) {\n  return mutation.state.isPaused\n}\n\nexport function defaultShouldDehydrateQuery(query: Query) {\n  return query.state.status === 'success'\n}\n\nexport function dehydrate(\n  client: QueryClient,\n  options: DehydrateOptions = {},\n): DehydratedState {\n  const filterMutation =\n    options.shouldDehydrateMutation ??\n    client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ??\n    defaultShouldDehydrateMutation\n\n  const mutations = client\n    .getMutationCache()\n    .getAll()\n    .flatMap((mutation) =>\n      filterMutation(mutation) ? [dehydrateMutation(mutation)] : [],\n    )\n\n  const filterQuery =\n    options.shouldDehydrateQuery ??\n    client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ??\n    defaultShouldDehydrateQuery\n\n  const shouldRedactErrors =\n    options.shouldRedactErrors ??\n    client.getDefaultOptions().dehydrate?.shouldRedactErrors\n\n  const serializeData =\n    options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData\n\n  const queries = client\n    .getQueryCache()\n    .getAll()\n    .flatMap((query) =>\n      filterQuery(query)\n        ? [dehydrateQuery(query, serializeData, shouldRedactErrors)]\n        : [],\n    )\n\n  return { mutations, queries }\n}\n\nexport function hydrate(\n  client: QueryClient,\n  dehydratedState: Partial<DehydratedState>,\n  options?: HydrateOptions,\n): void {\n  const mutationCache = client.getMutationCache()\n  const queryCache = client.getQueryCache()\n  const deserializeData =\n    options?.defaultOptions?.deserializeData ??\n    client.getDefaultOptions().hydrate?.deserializeData\n\n  dehydratedState.mutations?.forEach(({ state, ...mutationOptions }) => {\n    mutationCache.build(\n      client,\n      {\n        ...client.getDefaultOptions().hydrate?.mutations,\n        ...options?.defaultOptions?.mutations,\n        ...mutationOptions,\n      },\n      state,\n    )\n  })\n\n  dehydratedState.queries?.forEach(\n    ({\n      queryKey,\n      state,\n      queryHash,\n      meta,\n      promise,\n      dehydratedAt,\n      queryType,\n    }) => {\n      const syncData = promise ? tryResolveSync(promise) : undefined\n      const rawData = state.data === undefined ? syncData?.data : state.data\n      const data =\n        rawData === undefined\n          ? rawData\n          : deserializeData\n            ? deserializeData(rawData)\n            : rawData\n\n      let query = queryCache.get(queryHash)\n      const existingQueryIsPending = query?.state.status === 'pending'\n      const existingQueryIsFetching = query?.state.fetchStatus === 'fetching'\n\n      // Do not hydrate if an existing query exists with newer data\n      if (query) {\n        const hasNewerSyncData =\n          syncData &&\n          // We only need this undefined check to handle older dehydration\n          // payloads that might not have dehydratedAt\n          dehydratedAt !== undefined &&\n          dehydratedAt > query.state.dataUpdatedAt\n        if (\n          state.dataUpdatedAt > query.state.dataUpdatedAt ||\n          hasNewerSyncData\n        ) {\n          // Omit fetchStatus from dehydrated state so that query stays in its current fetchStatus\n          const { fetchStatus: _ignored, ...serializedState } = state\n          query.setState({\n            ...serializedState,\n            data,\n            // If the query was pending at the moment of dehydration, but resolved to have data\n            // before hydration, we can assume the query should be hydrated as successful.\n            //\n            // Since you can opt into dehydrating failed queries, and those can have data from\n            // previous successful fetches, we make sure we only do this for pending queries.\n            ...(state.status === 'pending' &&\n              data !== undefined && {\n                status: 'success' as const,\n                dataUpdatedAt: dehydratedAt ?? Date.now(),\n                // Preserve existing fetchStatus if the existing query is actively fetching.\n                ...(!existingQueryIsFetching && {\n                  fetchStatus: 'idle' as const,\n                }),\n              }),\n          })\n        }\n      } else {\n        // Restore query\n        query = queryCache.build(\n          client,\n          {\n            ...client.getDefaultOptions().hydrate?.queries,\n            ...options?.defaultOptions?.queries,\n            queryKey,\n            queryHash,\n            meta,\n            _type: queryType,\n          },\n          // Reset fetch status to idle to avoid\n          // query being stuck in fetching state upon hydration\n          {\n            ...state,\n            data,\n            fetchStatus: 'idle',\n            // Like above, if the query was pending at the moment of dehydration but has data,\n            // we can assume it should be hydrated as successful.\n            status:\n              state.status === 'pending' && data !== undefined\n                ? 'success'\n                : state.status,\n            ...(state.status === 'pending' &&\n              data !== undefined && {\n                dataUpdatedAt: dehydratedAt ?? Date.now(),\n              }),\n          },\n        )\n      }\n\n      if (\n        promise &&\n        // If the data was synchronously available, there is no need to set up\n        // a retryer and thus no reason to call fetch\n        !syncData &&\n        !existingQueryIsPending &&\n        !existingQueryIsFetching &&\n        // Only hydrate if dehydration is newer than any existing data,\n        // this is always true for new queries\n        (dehydratedAt === undefined || dehydratedAt > query.state.dataUpdatedAt)\n      ) {\n        // This doesn't actually fetch - it just creates a retryer\n        // which will re-use the passed `initialPromise`\n        query\n          .fetch(undefined, {\n            // RSC transformed promises are not thenable\n            initialPromise: Promise.resolve(promise).then(deserializeData),\n          })\n          // Avoid unhandled promise rejections\n          .catch(noop)\n      }\n    },\n  )\n}\n"],"mappings":"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"}
+{"version":3,"file":"hydration.cjs","names":["noop"],"sources":["../../src/hydration.ts"],"sourcesContent":["import { noop } from './utils'\nimport type {\n  DefaultError,\n  MutationKey,\n  MutationMeta,\n  MutationOptions,\n  MutationScope,\n  QueryKey,\n  QueryMeta,\n  QueryOptions,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query, QueryState } from './query'\nimport type { Mutation, MutationState } from './mutation'\n\n// TYPES\ntype TransformerFn = (data: any) => any\n\nfunction tryResolveSync(promise: PromiseLike<unknown>) {\n  let data: unknown\n\n  const thenResult = promise.then((result) => {\n    data = result\n    return result\n  }, noop) as Promise<unknown> | undefined\n\n  // .catch can be unavailable on certain kinds of thenable's\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  thenResult?.catch?.(noop)\n\n  if (data !== undefined) {\n    return { data }\n  }\n\n  return undefined\n}\n\n/**\n * Options for `dehydrate`, controlling which queries/mutations are included in the resulting `DehydratedState` and\n * how their data/errors are transformed before being serialized (e.g. for embedding in server-rendered markup).\n */\nexport interface DehydrateOptions {\n  /** Transforms a query's `data` before it is dehydrated. Useful for non-JSON-serializable data. */\n  serializeData?: TransformerFn\n  /** Predicate to decide whether a given `Mutation` should be dehydrated. Defaults to `defaultShouldDehydrateMutation`. */\n  shouldDehydrateMutation?: (mutation: Mutation) => boolean\n  /** Predicate to decide whether a given `Query` should be dehydrated. Defaults to `defaultShouldDehydrateQuery`. */\n  shouldDehydrateQuery?: (query: Query) => boolean\n  /**\n   * Predicate to decide whether a query's error should be redacted before dehydration. Errors are redacted\n   * (replaced with a generic `Error('redacted')`) unless this function is provided and returns `false` for the\n   * given error, in which case the original error is kept.\n   */\n  shouldRedactErrors?: (error: unknown) => boolean\n}\n\n/**\n * Options for `hydrate`, controlling the default options applied to queries/mutations restored from a\n * `DehydratedState`, and how to reverse any transformation applied by `DehydrateOptions.serializeData`.\n */\nexport interface HydrateOptions {\n  defaultOptions?: {\n    /** Transforms a query's `data` after it is read from the dehydrated state, reversing `serializeData`. */\n    deserializeData?: TransformerFn\n    /** Default options merged into every query restored from the dehydrated state. */\n    queries?: QueryOptions\n    /** Default options merged into every mutation restored from the dehydrated state. */\n    mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>\n  }\n}\n\ninterface DehydratedMutation {\n  mutationKey?: MutationKey\n  state: MutationState\n  meta?: MutationMeta\n  scope?: MutationScope\n}\n\ninterface DehydratedQuery {\n  queryHash: string\n  queryKey: QueryKey\n  state: QueryState\n  dehydratedAt: number\n  promise?: Promise<unknown>\n  meta?: QueryMeta\n  queryType?: 'infinite'\n}\n\n/**\n * A serializable snapshot of a `QueryClient`'s cache, as produced by `dehydrate` and consumed by `hydrate`. Typically\n * transported from server to client (e.g. embedded in server-rendered markup) to seed the client's cache with data\n * that has already been fetched, avoiding a redundant fetch on the client.\n */\nexport interface DehydratedState {\n  mutations: Array<DehydratedMutation>\n  queries: Array<DehydratedQuery>\n}\n\n// FUNCTIONS\n\nfunction dehydrateMutation(mutation: Mutation): DehydratedMutation {\n  return {\n    mutationKey: mutation.options.mutationKey,\n    state: mutation.state,\n    ...(mutation.options.scope && { scope: mutation.options.scope }),\n    ...(mutation.meta && { meta: mutation.meta }),\n  }\n}\n\nfunction dehydratePromise(\n  query: Query,\n  serializeData?: TransformerFn,\n  shouldRedactErrors?: (error: unknown) => boolean,\n): Promise<unknown> | undefined {\n  const promise = query.promise?.then(serializeData).catch((error) => {\n    if (shouldRedactErrors?.(error) === false) {\n      // Reject original error if it should not be redacted\n      return Promise.reject(error)\n    }\n    // If not in production, log original error before rejecting redacted error\n    if (process.env.NODE_ENV !== 'production') {\n      console.error(\n        `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`,\n      )\n    }\n    return Promise.reject(new Error('redacted'))\n  })\n\n  // Avoid unhandled promise rejections\n  // We need the promise we dehydrate to reject to get the correct result into\n  // the query cache, but we also want to avoid unhandled promise rejections\n  // in whatever environment the prefetches are happening in.\n  promise?.catch(noop)\n\n  return promise\n}\n\n/**\n * Dehydrates a single `Query` into a serializable `DehydratedQuery` snapshot. Note that most query config (e.g.\n * `queryFn`, `staleTime`) is not dehydrated but instead meant to be configured again when consuming the\n * de/rehydrated data, typically with `useQuery` on the client. If the query is still `pending`, its in-flight\n * promise is dehydrated too so it can be resumed on the other side instead of re-fetched.\n * @param query - The query to dehydrate.\n * @param serializeData - Optional transform applied to `query.state.data` before it is included in the snapshot.\n * @param shouldRedactErrors - Optional predicate; if it returns `false` for the promise's rejection error, that\n * error is kept as-is instead of being redacted.\n */\nexport function dehydrateQuery(\n  query: Query,\n  serializeData?: TransformerFn,\n  shouldRedactErrors?: (error: unknown) => boolean,\n): DehydratedQuery {\n  return {\n    dehydratedAt: Date.now(),\n    state: {\n      ...query.state,\n      ...(query.state.data !== undefined && {\n        data: serializeData\n          ? serializeData(query.state.data)\n          : query.state.data,\n      }),\n    },\n    queryKey: query.queryKey,\n    queryHash: query.queryHash,\n    ...(query.state.status === 'pending' && {\n      promise: dehydratePromise(query, serializeData, shouldRedactErrors),\n    }),\n    ...(query.meta && { meta: query.meta }),\n    ...(query.queryType && { queryType: query.queryType }),\n  }\n}\n\n/**\n * The default `shouldDehydrateMutation` predicate used by `dehydrate`. Only dehydrates mutations that are\n * currently paused (e.g. paused by `networkMode` while offline).\n */\nexport function defaultShouldDehydrateMutation(mutation: Mutation) {\n  return mutation.state.isPaused\n}\n\n/**\n * The default `shouldDehydrateQuery` predicate used by `dehydrate`. Only dehydrates queries whose status is\n * `'success'`.\n */\nexport function defaultShouldDehydrateQuery(query: Query) {\n  return query.state.status === 'success'\n}\n\n/**\n * Dehydrates a `QueryClient`'s cache (queries and mutations) into a plain, serializable `DehydratedState`,\n * typically to embed in server-rendered markup and later restore into a client-side `QueryClient` via `hydrate`.\n * Which queries/mutations are included, and how their data/errors are transformed, is controlled by `options`,\n * falling back to the client's `dehydrate` default options, and finally to `defaultShouldDehydrateQuery` /\n * `defaultShouldDehydrateMutation`.\n * @example\n * ```ts\n * const queryClient = new QueryClient()\n *\n * await queryClient.prefetchQuery({\n *   queryKey: ['posts'],\n *   queryFn: getPosts,\n * })\n *\n * const dehydratedState = dehydrate(queryClient)\n * ```\n */\nexport function dehydrate(\n  client: QueryClient,\n  options: DehydrateOptions = {},\n): DehydratedState {\n  const filterMutation =\n    options.shouldDehydrateMutation ??\n    client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ??\n    defaultShouldDehydrateMutation\n\n  const mutations = client\n    .getMutationCache()\n    .getAll()\n    .flatMap((mutation) =>\n      filterMutation(mutation) ? [dehydrateMutation(mutation)] : [],\n    )\n\n  const filterQuery =\n    options.shouldDehydrateQuery ??\n    client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ??\n    defaultShouldDehydrateQuery\n\n  const shouldRedactErrors =\n    options.shouldRedactErrors ??\n    client.getDefaultOptions().dehydrate?.shouldRedactErrors\n\n  const serializeData =\n    options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData\n\n  const queries = client\n    .getQueryCache()\n    .getAll()\n    .flatMap((query) =>\n      filterQuery(query)\n        ? [dehydrateQuery(query, serializeData, shouldRedactErrors)]\n        : [],\n    )\n\n  return { mutations, queries }\n}\n\n/**\n * Restores a `DehydratedState` (as produced by `dehydrate`) into a `QueryClient`'s cache, typically to seed the\n * client with data already fetched on the server. `mutations` and `queries` are each optional on `dehydratedState`.\n * Queries not yet in the cache are built from the dehydrated snapshot; queries that already exist are only updated\n * when the dehydrated data is newer than what's already cached. Newly built queries have their `fetchStatus` reset\n * to `'idle'` so they don't hydrate stuck in a fetching state. If a dehydrated query still had an in-flight\n * promise, it is resumed via `query.fetch()` (reusing that promise as `initialPromise`) rather than re-invoking\n * `queryFn`.\n * @example\n * ```ts\n * // dehydratedState was produced by `dehydrate` on the server\n * // and sent to the client, e.g. embedded in server-rendered markup.\n * const queryClient = new QueryClient()\n *\n * hydrate(queryClient, dehydratedState)\n * ```\n */\nexport function hydrate(\n  client: QueryClient,\n  dehydratedState: Partial<DehydratedState>,\n  options?: HydrateOptions,\n): void {\n  const mutationCache = client.getMutationCache()\n  const queryCache = client.getQueryCache()\n  const deserializeData =\n    options?.defaultOptions?.deserializeData ??\n    client.getDefaultOptions().hydrate?.deserializeData\n\n  dehydratedState.mutations?.forEach(({ state, ...mutationOptions }) => {\n    mutationCache.build(\n      client,\n      {\n        ...client.getDefaultOptions().hydrate?.mutations,\n        ...options?.defaultOptions?.mutations,\n        ...mutationOptions,\n      },\n      state,\n    )\n  })\n\n  dehydratedState.queries?.forEach(\n    ({\n      queryKey,\n      state,\n      queryHash,\n      meta,\n      promise,\n      dehydratedAt,\n      queryType,\n    }) => {\n      const syncData = promise ? tryResolveSync(promise) : undefined\n      const rawData = state.data === undefined ? syncData?.data : state.data\n      const data =\n        rawData === undefined\n          ? rawData\n          : deserializeData\n            ? deserializeData(rawData)\n            : rawData\n\n      let query = queryCache.get(queryHash)\n      const existingQueryIsPending = query?.state.status === 'pending'\n      const existingQueryIsFetching = query?.state.fetchStatus === 'fetching'\n\n      // Do not hydrate if an existing query exists with newer data\n      if (query) {\n        const hasNewerSyncData =\n          syncData && dehydratedAt > query.state.dataUpdatedAt\n        if (\n          state.dataUpdatedAt > query.state.dataUpdatedAt ||\n          hasNewerSyncData\n        ) {\n          // Omit fetchStatus from dehydrated state so that query stays in its current fetchStatus\n          const { fetchStatus: _ignored, ...serializedState } = state\n          query.setState({\n            ...serializedState,\n            data,\n            // If the query was pending at the moment of dehydration, but resolved to have data\n            // before hydration, we can assume the query should be hydrated as successful.\n            //\n            // Since you can opt into dehydrating failed queries, and those can have data from\n            // previous successful fetches, we make sure we only do this for pending queries.\n            ...(state.status === 'pending' &&\n              data !== undefined && {\n                status: 'success' as const,\n                dataUpdatedAt: dehydratedAt,\n                // Preserve existing fetchStatus if the existing query is actively fetching.\n                ...(!existingQueryIsFetching && {\n                  fetchStatus: 'idle' as const,\n                }),\n              }),\n          })\n        }\n      } else {\n        // Restore query\n        query = queryCache.build(\n          client,\n          {\n            ...client.getDefaultOptions().hydrate?.queries,\n            ...options?.defaultOptions?.queries,\n            queryKey,\n            queryHash,\n            meta,\n            _type: queryType,\n          },\n          // Reset fetch status to idle to avoid\n          // query being stuck in fetching state upon hydration\n          {\n            ...state,\n            data,\n            fetchStatus: 'idle',\n            // Like above, if the query was pending at the moment of dehydration but has data,\n            // we can assume it should be hydrated as successful.\n            status:\n              state.status === 'pending' && data !== undefined\n                ? 'success'\n                : state.status,\n            ...(state.status === 'pending' &&\n              data !== undefined && {\n                dataUpdatedAt: dehydratedAt,\n              }),\n          },\n        )\n      }\n\n      if (\n        promise &&\n        // If the data was synchronously available, there is no need to set up\n        // a retryer and thus no reason to call fetch\n        !syncData &&\n        !existingQueryIsPending &&\n        !existingQueryIsFetching &&\n        // Only hydrate if dehydration is newer than any existing data,\n        // this is always true for new queries\n        dehydratedAt > query.state.dataUpdatedAt\n      ) {\n        // This doesn't actually fetch - it just creates a retryer\n        // which will re-use the passed `initialPromise`\n        query\n          .fetch(undefined, {\n            // RSC transformed promises are not thenable\n            initialPromise: Promise.resolve(promise).then(deserializeData),\n          })\n          // Avoid unhandled promise rejections\n          .catch(noop)\n      }\n    },\n  )\n}\n"],"mappings":"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"}

package/build/modern/hydration.d.cts

@@ -1,2 +1,2 @@
-import { a as defaultShouldDehydrateQuery, c as hydrate, i as defaultShouldDehydrateMutation, n as DehydratedState, o as dehydrate, r as HydrateOptions, s as dehydrateQuery, t as DehydrateOptions } from "./hydration-DWGr3cFC.cjs";
+import { a as defaultShouldDehydrateQuery, c as hydrate, i as defaultShouldDehydrateMutation, n as DehydratedState, o as dehydrate, r as HydrateOptions, s as dehydrateQuery, t as DehydrateOptions } from "./hydration-DwR10Hi-.cjs";
 export { DehydrateOptions, DehydratedState, HydrateOptions, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, hydrate };

package/build/modern/hydration.d.ts

@@ -1,2 +1,2 @@
-import { a as defaultShouldDehydrateQuery, c as hydrate, i as defaultShouldDehydrateMutation, n as DehydratedState, o as dehydrate, r as HydrateOptions, s as dehydrateQuery, t as DehydrateOptions } from "./hydration-Bjs0MSgg.js";
+import { a as defaultShouldDehydrateQuery, c as hydrate, i as defaultShouldDehydrateMutation, n as DehydratedState, o as dehydrate, r as HydrateOptions, s as dehydrateQuery, t as DehydrateOptions } from "./hydration-Cq7QYAzB.js";
 export { DehydrateOptions, DehydratedState, HydrateOptions, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, hydrate };

package/build/modern/hydration.js

@@ -25,6 +25,16 @@ function dehydratePromise(query, serializeData, shouldRedactErrors) {
 	promise?.catch(noop);
 	return promise;
 }
+/**
+* Dehydrates a single `Query` into a serializable `DehydratedQuery` snapshot. Note that most query config (e.g.
+* `queryFn`, `staleTime`) is not dehydrated but instead meant to be configured again when consuming the
+* de/rehydrated data, typically with `useQuery` on the client. If the query is still `pending`, its in-flight
+* promise is dehydrated too so it can be resumed on the other side instead of re-fetched.
+* @param query - The query to dehydrate.
+* @param serializeData - Optional transform applied to `query.state.data` before it is included in the snapshot.
+* @param shouldRedactErrors - Optional predicate; if it returns `false` for the promise's rejection error, that
+* error is kept as-is instead of being redacted.
+*/
 function dehydrateQuery(query, serializeData, shouldRedactErrors) {
 	return {
 		dehydratedAt: Date.now(),
@@ -39,12 +49,38 @@ function dehydrateQuery(query, serializeData, shouldRedactErrors) {
 		...query.queryType && { queryType: query.queryType }
 	};
 }
+/**
+* The default `shouldDehydrateMutation` predicate used by `dehydrate`. Only dehydrates mutations that are
+* currently paused (e.g. paused by `networkMode` while offline).
+*/
 function defaultShouldDehydrateMutation(mutation) {
 	return mutation.state.isPaused;
 }
+/**
+* The default `shouldDehydrateQuery` predicate used by `dehydrate`. Only dehydrates queries whose status is
+* `'success'`.
+*/
 function defaultShouldDehydrateQuery(query) {
 	return query.state.status === "success";
 }
+/**
+* Dehydrates a `QueryClient`'s cache (queries and mutations) into a plain, serializable `DehydratedState`,
+* typically to embed in server-rendered markup and later restore into a client-side `QueryClient` via `hydrate`.
+* Which queries/mutations are included, and how their data/errors are transformed, is controlled by `options`,
+* falling back to the client's `dehydrate` default options, and finally to `defaultShouldDehydrateQuery` /
+* `defaultShouldDehydrateMutation`.
+* @example
+* ```ts
+* const queryClient = new QueryClient()
+*
+* await queryClient.prefetchQuery({
+*   queryKey: ['posts'],
+*   queryFn: getPosts,
+* })
+*
+* const dehydratedState = dehydrate(queryClient)
+* ```
+*/
 function dehydrate(client, options = {}) {
 	const filterMutation = options.shouldDehydrateMutation ?? client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ?? defaultShouldDehydrateMutation;
 	const mutations = client.getMutationCache().getAll().flatMap((mutation) => filterMutation(mutation) ? [dehydrateMutation(mutation)] : []);
@@ -56,6 +92,23 @@ function dehydrate(client, options = {}) {
 		queries: client.getQueryCache().getAll().flatMap((query) => filterQuery(query) ? [dehydrateQuery(query, serializeData, shouldRedactErrors)] : [])
 	};
 }
+/**
+* Restores a `DehydratedState` (as produced by `dehydrate`) into a `QueryClient`'s cache, typically to seed the
+* client with data already fetched on the server. `mutations` and `queries` are each optional on `dehydratedState`.
+* Queries not yet in the cache are built from the dehydrated snapshot; queries that already exist are only updated
+* when the dehydrated data is newer than what's already cached. Newly built queries have their `fetchStatus` reset
+* to `'idle'` so they don't hydrate stuck in a fetching state. If a dehydrated query still had an in-flight
+* promise, it is resumed via `query.fetch()` (reusing that promise as `initialPromise`) rather than re-invoking
+* `queryFn`.
+* @example
+* ```ts
+* // dehydratedState was produced by `dehydrate` on the server
+* // and sent to the client, e.g. embedded in server-rendered markup.
+* const queryClient = new QueryClient()
+*
+* hydrate(queryClient, dehydratedState)
+* ```
+*/
 function hydrate(client, dehydratedState, options) {
 	const mutationCache = client.getMutationCache();
 	const queryCache = client.getQueryCache();
@@ -75,7 +128,7 @@ function hydrate(client, dehydratedState, options) {
 		const existingQueryIsPending = query?.state.status === "pending";
 		const existingQueryIsFetching = query?.state.fetchStatus === "fetching";
 		if (query) {
-			const hasNewerSyncData = syncData && dehydratedAt !== void 0 && dehydratedAt > query.state.dataUpdatedAt;
+			const hasNewerSyncData = syncData && dehydratedAt > query.state.dataUpdatedAt;
 			if (state.dataUpdatedAt > query.state.dataUpdatedAt || hasNewerSyncData) {
 				const { fetchStatus: _ignored, ...serializedState } = state;
 				query.setState({
@@ -83,7 +136,7 @@ function hydrate(client, dehydratedState, options) {
 					data,
 					...state.status === "pending" && data !== void 0 && {
 						status: "success",
-						dataUpdatedAt: dehydratedAt ?? Date.now(),
+						dataUpdatedAt: dehydratedAt,
 						...!existingQueryIsFetching && { fetchStatus: "idle" }
 					}
 				});
@@ -100,9 +153,9 @@ function hydrate(client, dehydratedState, options) {
 			data,
 			fetchStatus: "idle",
 			status: state.status === "pending" && data !== void 0 ? "success" : state.status,
-			...state.status === "pending" && data !== void 0 && { dataUpdatedAt: dehydratedAt ?? Date.now() }
+			...state.status === "pending" && data !== void 0 && { dataUpdatedAt: dehydratedAt }
 		});
-		if (promise && !syncData && !existingQueryIsPending && !existingQueryIsFetching && (dehydratedAt === void 0 || dehydratedAt > query.state.dataUpdatedAt)) query.fetch(void 0, { initialPromise: Promise.resolve(promise).then(deserializeData) }).catch(noop);
+		if (promise && !syncData && !existingQueryIsPending && !existingQueryIsFetching && dehydratedAt > query.state.dataUpdatedAt) query.fetch(void 0, { initialPromise: Promise.resolve(promise).then(deserializeData) }).catch(noop);
 	});
 }
 //#endregion

package/build/modern/hydration.js.map

@@ -1 +1 @@
-{"version":3,"file":"hydration.js","names":[],"sources":["../../src/hydration.ts"],"sourcesContent":["import { noop } from './utils'\nimport type {\n  DefaultError,\n  MutationKey,\n  MutationMeta,\n  MutationOptions,\n  MutationScope,\n  QueryKey,\n  QueryMeta,\n  QueryOptions,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query, QueryState } from './query'\nimport type { Mutation, MutationState } from './mutation'\n\n// TYPES\ntype TransformerFn = (data: any) => any\n\nfunction tryResolveSync(promise: PromiseLike<unknown>) {\n  let data: unknown\n\n  const thenResult = promise.then((result) => {\n    data = result\n    return result\n  }, noop) as Promise<unknown> | undefined\n\n  // .catch can be unavailable on certain kinds of thenable's\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  thenResult?.catch?.(noop)\n\n  if (data !== undefined) {\n    return { data }\n  }\n\n  return undefined\n}\n\nexport interface DehydrateOptions {\n  serializeData?: TransformerFn\n  shouldDehydrateMutation?: (mutation: Mutation) => boolean\n  shouldDehydrateQuery?: (query: Query) => boolean\n  shouldRedactErrors?: (error: unknown) => boolean\n}\n\nexport interface HydrateOptions {\n  defaultOptions?: {\n    deserializeData?: TransformerFn\n    queries?: QueryOptions\n    mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>\n  }\n}\n\ninterface DehydratedMutation {\n  mutationKey?: MutationKey\n  state: MutationState\n  meta?: MutationMeta\n  scope?: MutationScope\n}\n\ninterface DehydratedQuery {\n  queryHash: string\n  queryKey: QueryKey\n  state: QueryState\n  promise?: Promise<unknown>\n  meta?: QueryMeta\n  queryType?: 'infinite'\n  // This is only optional because older versions of Query might have dehydrated\n  // without it which we need to handle for backwards compatibility.\n  // This should be changed to required in the future.\n  dehydratedAt?: number\n}\n\nexport interface DehydratedState {\n  mutations: Array<DehydratedMutation>\n  queries: Array<DehydratedQuery>\n}\n\n// FUNCTIONS\n\nfunction dehydrateMutation(mutation: Mutation): DehydratedMutation {\n  return {\n    mutationKey: mutation.options.mutationKey,\n    state: mutation.state,\n    ...(mutation.options.scope && { scope: mutation.options.scope }),\n    ...(mutation.meta && { meta: mutation.meta }),\n  }\n}\n\nfunction dehydratePromise(\n  query: Query,\n  serializeData?: TransformerFn,\n  shouldRedactErrors?: (error: unknown) => boolean,\n): Promise<unknown> | undefined {\n  const promise = query.promise?.then(serializeData).catch((error) => {\n    if (shouldRedactErrors?.(error) === false) {\n      // Reject original error if it should not be redacted\n      return Promise.reject(error)\n    }\n    // If not in production, log original error before rejecting redacted error\n    if (process.env.NODE_ENV !== 'production') {\n      console.error(\n        `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`,\n      )\n    }\n    return Promise.reject(new Error('redacted'))\n  })\n\n  // Avoid unhandled promise rejections\n  // We need the promise we dehydrate to reject to get the correct result into\n  // the query cache, but we also want to avoid unhandled promise rejections\n  // in whatever environment the prefetches are happening in.\n  promise?.catch(noop)\n\n  return promise\n}\n\n// Most config is not dehydrated but instead meant to configure again when\n// consuming the de/rehydrated data, typically with useQuery on the client.\n// Sometimes it might make sense to prefetch data on the server and include\n// in the html-payload, but not consume it on the initial render.\nexport function dehydrateQuery(\n  query: Query,\n  serializeData?: TransformerFn,\n  shouldRedactErrors?: (error: unknown) => boolean,\n): DehydratedQuery {\n  return {\n    dehydratedAt: Date.now(),\n    state: {\n      ...query.state,\n      ...(query.state.data !== undefined && {\n        data: serializeData\n          ? serializeData(query.state.data)\n          : query.state.data,\n      }),\n    },\n    queryKey: query.queryKey,\n    queryHash: query.queryHash,\n    ...(query.state.status === 'pending' && {\n      promise: dehydratePromise(query, serializeData, shouldRedactErrors),\n    }),\n    ...(query.meta && { meta: query.meta }),\n    ...(query.queryType && { queryType: query.queryType }),\n  }\n}\n\nexport function defaultShouldDehydrateMutation(mutation: Mutation) {\n  return mutation.state.isPaused\n}\n\nexport function defaultShouldDehydrateQuery(query: Query) {\n  return query.state.status === 'success'\n}\n\nexport function dehydrate(\n  client: QueryClient,\n  options: DehydrateOptions = {},\n): DehydratedState {\n  const filterMutation =\n    options.shouldDehydrateMutation ??\n    client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ??\n    defaultShouldDehydrateMutation\n\n  const mutations = client\n    .getMutationCache()\n    .getAll()\n    .flatMap((mutation) =>\n      filterMutation(mutation) ? [dehydrateMutation(mutation)] : [],\n    )\n\n  const filterQuery =\n    options.shouldDehydrateQuery ??\n    client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ??\n    defaultShouldDehydrateQuery\n\n  const shouldRedactErrors =\n    options.shouldRedactErrors ??\n    client.getDefaultOptions().dehydrate?.shouldRedactErrors\n\n  const serializeData =\n    options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData\n\n  const queries = client\n    .getQueryCache()\n    .getAll()\n    .flatMap((query) =>\n      filterQuery(query)\n        ? [dehydrateQuery(query, serializeData, shouldRedactErrors)]\n        : [],\n    )\n\n  return { mutations, queries }\n}\n\nexport function hydrate(\n  client: QueryClient,\n  dehydratedState: Partial<DehydratedState>,\n  options?: HydrateOptions,\n): void {\n  const mutationCache = client.getMutationCache()\n  const queryCache = client.getQueryCache()\n  const deserializeData =\n    options?.defaultOptions?.deserializeData ??\n    client.getDefaultOptions().hydrate?.deserializeData\n\n  dehydratedState.mutations?.forEach(({ state, ...mutationOptions }) => {\n    mutationCache.build(\n      client,\n      {\n        ...client.getDefaultOptions().hydrate?.mutations,\n        ...options?.defaultOptions?.mutations,\n        ...mutationOptions,\n      },\n      state,\n    )\n  })\n\n  dehydratedState.queries?.forEach(\n    ({\n      queryKey,\n      state,\n      queryHash,\n      meta,\n      promise,\n      dehydratedAt,\n      queryType,\n    }) => {\n      const syncData = promise ? tryResolveSync(promise) : undefined\n      const rawData = state.data === undefined ? syncData?.data : state.data\n      const data =\n        rawData === undefined\n          ? rawData\n          : deserializeData\n            ? deserializeData(rawData)\n            : rawData\n\n      let query = queryCache.get(queryHash)\n      const existingQueryIsPending = query?.state.status === 'pending'\n      const existingQueryIsFetching = query?.state.fetchStatus === 'fetching'\n\n      // Do not hydrate if an existing query exists with newer data\n      if (query) {\n        const hasNewerSyncData =\n          syncData &&\n          // We only need this undefined check to handle older dehydration\n          // payloads that might not have dehydratedAt\n          dehydratedAt !== undefined &&\n          dehydratedAt > query.state.dataUpdatedAt\n        if (\n          state.dataUpdatedAt > query.state.dataUpdatedAt ||\n          hasNewerSyncData\n        ) {\n          // Omit fetchStatus from dehydrated state so that query stays in its current fetchStatus\n          const { fetchStatus: _ignored, ...serializedState } = state\n          query.setState({\n            ...serializedState,\n            data,\n            // If the query was pending at the moment of dehydration, but resolved to have data\n            // before hydration, we can assume the query should be hydrated as successful.\n            //\n            // Since you can opt into dehydrating failed queries, and those can have data from\n            // previous successful fetches, we make sure we only do this for pending queries.\n            ...(state.status === 'pending' &&\n              data !== undefined && {\n                status: 'success' as const,\n                dataUpdatedAt: dehydratedAt ?? Date.now(),\n                // Preserve existing fetchStatus if the existing query is actively fetching.\n                ...(!existingQueryIsFetching && {\n                  fetchStatus: 'idle' as const,\n                }),\n              }),\n          })\n        }\n      } else {\n        // Restore query\n        query = queryCache.build(\n          client,\n          {\n            ...client.getDefaultOptions().hydrate?.queries,\n            ...options?.defaultOptions?.queries,\n            queryKey,\n            queryHash,\n            meta,\n            _type: queryType,\n          },\n          // Reset fetch status to idle to avoid\n          // query being stuck in fetching state upon hydration\n          {\n            ...state,\n            data,\n            fetchStatus: 'idle',\n            // Like above, if the query was pending at the moment of dehydration but has data,\n            // we can assume it should be hydrated as successful.\n            status:\n              state.status === 'pending' && data !== undefined\n                ? 'success'\n                : state.status,\n            ...(state.status === 'pending' &&\n              data !== undefined && {\n                dataUpdatedAt: dehydratedAt ?? Date.now(),\n              }),\n          },\n        )\n      }\n\n      if (\n        promise &&\n        // If the data was synchronously available, there is no need to set up\n        // a retryer and thus no reason to call fetch\n        !syncData &&\n        !existingQueryIsPending &&\n        !existingQueryIsFetching &&\n        // Only hydrate if dehydration is newer than any existing data,\n        // this is always true for new queries\n        (dehydratedAt === undefined || dehydratedAt > query.state.dataUpdatedAt)\n      ) {\n        // This doesn't actually fetch - it just creates a retryer\n        // which will re-use the passed `initialPromise`\n        query\n          .fetch(undefined, {\n            // RSC transformed promises are not thenable\n            initialPromise: Promise.resolve(promise).then(deserializeData),\n          })\n          // Avoid unhandled promise rejections\n          .catch(noop)\n      }\n    },\n  )\n}\n"],"mappings":"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"}
+{"version":3,"file":"hydration.js","names":[],"sources":["../../src/hydration.ts"],"sourcesContent":["import { noop } from './utils'\nimport type {\n  DefaultError,\n  MutationKey,\n  MutationMeta,\n  MutationOptions,\n  MutationScope,\n  QueryKey,\n  QueryMeta,\n  QueryOptions,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query, QueryState } from './query'\nimport type { Mutation, MutationState } from './mutation'\n\n// TYPES\ntype TransformerFn = (data: any) => any\n\nfunction tryResolveSync(promise: PromiseLike<unknown>) {\n  let data: unknown\n\n  const thenResult = promise.then((result) => {\n    data = result\n    return result\n  }, noop) as Promise<unknown> | undefined\n\n  // .catch can be unavailable on certain kinds of thenable's\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  thenResult?.catch?.(noop)\n\n  if (data !== undefined) {\n    return { data }\n  }\n\n  return undefined\n}\n\n/**\n * Options for `dehydrate`, controlling which queries/mutations are included in the resulting `DehydratedState` and\n * how their data/errors are transformed before being serialized (e.g. for embedding in server-rendered markup).\n */\nexport interface DehydrateOptions {\n  /** Transforms a query's `data` before it is dehydrated. Useful for non-JSON-serializable data. */\n  serializeData?: TransformerFn\n  /** Predicate to decide whether a given `Mutation` should be dehydrated. Defaults to `defaultShouldDehydrateMutation`. */\n  shouldDehydrateMutation?: (mutation: Mutation) => boolean\n  /** Predicate to decide whether a given `Query` should be dehydrated. Defaults to `defaultShouldDehydrateQuery`. */\n  shouldDehydrateQuery?: (query: Query) => boolean\n  /**\n   * Predicate to decide whether a query's error should be redacted before dehydration. Errors are redacted\n   * (replaced with a generic `Error('redacted')`) unless this function is provided and returns `false` for the\n   * given error, in which case the original error is kept.\n   */\n  shouldRedactErrors?: (error: unknown) => boolean\n}\n\n/**\n * Options for `hydrate`, controlling the default options applied to queries/mutations restored from a\n * `DehydratedState`, and how to reverse any transformation applied by `DehydrateOptions.serializeData`.\n */\nexport interface HydrateOptions {\n  defaultOptions?: {\n    /** Transforms a query's `data` after it is read from the dehydrated state, reversing `serializeData`. */\n    deserializeData?: TransformerFn\n    /** Default options merged into every query restored from the dehydrated state. */\n    queries?: QueryOptions\n    /** Default options merged into every mutation restored from the dehydrated state. */\n    mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>\n  }\n}\n\ninterface DehydratedMutation {\n  mutationKey?: MutationKey\n  state: MutationState\n  meta?: MutationMeta\n  scope?: MutationScope\n}\n\ninterface DehydratedQuery {\n  queryHash: string\n  queryKey: QueryKey\n  state: QueryState\n  dehydratedAt: number\n  promise?: Promise<unknown>\n  meta?: QueryMeta\n  queryType?: 'infinite'\n}\n\n/**\n * A serializable snapshot of a `QueryClient`'s cache, as produced by `dehydrate` and consumed by `hydrate`. Typically\n * transported from server to client (e.g. embedded in server-rendered markup) to seed the client's cache with data\n * that has already been fetched, avoiding a redundant fetch on the client.\n */\nexport interface DehydratedState {\n  mutations: Array<DehydratedMutation>\n  queries: Array<DehydratedQuery>\n}\n\n// FUNCTIONS\n\nfunction dehydrateMutation(mutation: Mutation): DehydratedMutation {\n  return {\n    mutationKey: mutation.options.mutationKey,\n    state: mutation.state,\n    ...(mutation.options.scope && { scope: mutation.options.scope }),\n    ...(mutation.meta && { meta: mutation.meta }),\n  }\n}\n\nfunction dehydratePromise(\n  query: Query,\n  serializeData?: TransformerFn,\n  shouldRedactErrors?: (error: unknown) => boolean,\n): Promise<unknown> | undefined {\n  const promise = query.promise?.then(serializeData).catch((error) => {\n    if (shouldRedactErrors?.(error) === false) {\n      // Reject original error if it should not be redacted\n      return Promise.reject(error)\n    }\n    // If not in production, log original error before rejecting redacted error\n    if (process.env.NODE_ENV !== 'production') {\n      console.error(\n        `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`,\n      )\n    }\n    return Promise.reject(new Error('redacted'))\n  })\n\n  // Avoid unhandled promise rejections\n  // We need the promise we dehydrate to reject to get the correct result into\n  // the query cache, but we also want to avoid unhandled promise rejections\n  // in whatever environment the prefetches are happening in.\n  promise?.catch(noop)\n\n  return promise\n}\n\n/**\n * Dehydrates a single `Query` into a serializable `DehydratedQuery` snapshot. Note that most query config (e.g.\n * `queryFn`, `staleTime`) is not dehydrated but instead meant to be configured again when consuming the\n * de/rehydrated data, typically with `useQuery` on the client. If the query is still `pending`, its in-flight\n * promise is dehydrated too so it can be resumed on the other side instead of re-fetched.\n * @param query - The query to dehydrate.\n * @param serializeData - Optional transform applied to `query.state.data` before it is included in the snapshot.\n * @param shouldRedactErrors - Optional predicate; if it returns `false` for the promise's rejection error, that\n * error is kept as-is instead of being redacted.\n */\nexport function dehydrateQuery(\n  query: Query,\n  serializeData?: TransformerFn,\n  shouldRedactErrors?: (error: unknown) => boolean,\n): DehydratedQuery {\n  return {\n    dehydratedAt: Date.now(),\n    state: {\n      ...query.state,\n      ...(query.state.data !== undefined && {\n        data: serializeData\n          ? serializeData(query.state.data)\n          : query.state.data,\n      }),\n    },\n    queryKey: query.queryKey,\n    queryHash: query.queryHash,\n    ...(query.state.status === 'pending' && {\n      promise: dehydratePromise(query, serializeData, shouldRedactErrors),\n    }),\n    ...(query.meta && { meta: query.meta }),\n    ...(query.queryType && { queryType: query.queryType }),\n  }\n}\n\n/**\n * The default `shouldDehydrateMutation` predicate used by `dehydrate`. Only dehydrates mutations that are\n * currently paused (e.g. paused by `networkMode` while offline).\n */\nexport function defaultShouldDehydrateMutation(mutation: Mutation) {\n  return mutation.state.isPaused\n}\n\n/**\n * The default `shouldDehydrateQuery` predicate used by `dehydrate`. Only dehydrates queries whose status is\n * `'success'`.\n */\nexport function defaultShouldDehydrateQuery(query: Query) {\n  return query.state.status === 'success'\n}\n\n/**\n * Dehydrates a `QueryClient`'s cache (queries and mutations) into a plain, serializable `DehydratedState`,\n * typically to embed in server-rendered markup and later restore into a client-side `QueryClient` via `hydrate`.\n * Which queries/mutations are included, and how their data/errors are transformed, is controlled by `options`,\n * falling back to the client's `dehydrate` default options, and finally to `defaultShouldDehydrateQuery` /\n * `defaultShouldDehydrateMutation`.\n * @example\n * ```ts\n * const queryClient = new QueryClient()\n *\n * await queryClient.prefetchQuery({\n *   queryKey: ['posts'],\n *   queryFn: getPosts,\n * })\n *\n * const dehydratedState = dehydrate(queryClient)\n * ```\n */\nexport function dehydrate(\n  client: QueryClient,\n  options: DehydrateOptions = {},\n): DehydratedState {\n  const filterMutation =\n    options.shouldDehydrateMutation ??\n    client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ??\n    defaultShouldDehydrateMutation\n\n  const mutations = client\n    .getMutationCache()\n    .getAll()\n    .flatMap((mutation) =>\n      filterMutation(mutation) ? [dehydrateMutation(mutation)] : [],\n    )\n\n  const filterQuery =\n    options.shouldDehydrateQuery ??\n    client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ??\n    defaultShouldDehydrateQuery\n\n  const shouldRedactErrors =\n    options.shouldRedactErrors ??\n    client.getDefaultOptions().dehydrate?.shouldRedactErrors\n\n  const serializeData =\n    options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData\n\n  const queries = client\n    .getQueryCache()\n    .getAll()\n    .flatMap((query) =>\n      filterQuery(query)\n        ? [dehydrateQuery(query, serializeData, shouldRedactErrors)]\n        : [],\n    )\n\n  return { mutations, queries }\n}\n\n/**\n * Restores a `DehydratedState` (as produced by `dehydrate`) into a `QueryClient`'s cache, typically to seed the\n * client with data already fetched on the server. `mutations` and `queries` are each optional on `dehydratedState`.\n * Queries not yet in the cache are built from the dehydrated snapshot; queries that already exist are only updated\n * when the dehydrated data is newer than what's already cached. Newly built queries have their `fetchStatus` reset\n * to `'idle'` so they don't hydrate stuck in a fetching state. If a dehydrated query still had an in-flight\n * promise, it is resumed via `query.fetch()` (reusing that promise as `initialPromise`) rather than re-invoking\n * `queryFn`.\n * @example\n * ```ts\n * // dehydratedState was produced by `dehydrate` on the server\n * // and sent to the client, e.g. embedded in server-rendered markup.\n * const queryClient = new QueryClient()\n *\n * hydrate(queryClient, dehydratedState)\n * ```\n */\nexport function hydrate(\n  client: QueryClient,\n  dehydratedState: Partial<DehydratedState>,\n  options?: HydrateOptions,\n): void {\n  const mutationCache = client.getMutationCache()\n  const queryCache = client.getQueryCache()\n  const deserializeData =\n    options?.defaultOptions?.deserializeData ??\n    client.getDefaultOptions().hydrate?.deserializeData\n\n  dehydratedState.mutations?.forEach(({ state, ...mutationOptions }) => {\n    mutationCache.build(\n      client,\n      {\n        ...client.getDefaultOptions().hydrate?.mutations,\n        ...options?.defaultOptions?.mutations,\n        ...mutationOptions,\n      },\n      state,\n    )\n  })\n\n  dehydratedState.queries?.forEach(\n    ({\n      queryKey,\n      state,\n      queryHash,\n      meta,\n      promise,\n      dehydratedAt,\n      queryType,\n    }) => {\n      const syncData = promise ? tryResolveSync(promise) : undefined\n      const rawData = state.data === undefined ? syncData?.data : state.data\n      const data =\n        rawData === undefined\n          ? rawData\n          : deserializeData\n            ? deserializeData(rawData)\n            : rawData\n\n      let query = queryCache.get(queryHash)\n      const existingQueryIsPending = query?.state.status === 'pending'\n      const existingQueryIsFetching = query?.state.fetchStatus === 'fetching'\n\n      // Do not hydrate if an existing query exists with newer data\n      if (query) {\n        const hasNewerSyncData =\n          syncData && dehydratedAt > query.state.dataUpdatedAt\n        if (\n          state.dataUpdatedAt > query.state.dataUpdatedAt ||\n          hasNewerSyncData\n        ) {\n          // Omit fetchStatus from dehydrated state so that query stays in its current fetchStatus\n          const { fetchStatus: _ignored, ...serializedState } = state\n          query.setState({\n            ...serializedState,\n            data,\n            // If the query was pending at the moment of dehydration, but resolved to have data\n            // before hydration, we can assume the query should be hydrated as successful.\n            //\n            // Since you can opt into dehydrating failed queries, and those can have data from\n            // previous successful fetches, we make sure we only do this for pending queries.\n            ...(state.status === 'pending' &&\n              data !== undefined && {\n                status: 'success' as const,\n                dataUpdatedAt: dehydratedAt,\n                // Preserve existing fetchStatus if the existing query is actively fetching.\n                ...(!existingQueryIsFetching && {\n                  fetchStatus: 'idle' as const,\n                }),\n              }),\n          })\n        }\n      } else {\n        // Restore query\n        query = queryCache.build(\n          client,\n          {\n            ...client.getDefaultOptions().hydrate?.queries,\n            ...options?.defaultOptions?.queries,\n            queryKey,\n            queryHash,\n            meta,\n            _type: queryType,\n          },\n          // Reset fetch status to idle to avoid\n          // query being stuck in fetching state upon hydration\n          {\n            ...state,\n            data,\n            fetchStatus: 'idle',\n            // Like above, if the query was pending at the moment of dehydration but has data,\n            // we can assume it should be hydrated as successful.\n            status:\n              state.status === 'pending' && data !== undefined\n                ? 'success'\n                : state.status,\n            ...(state.status === 'pending' &&\n              data !== undefined && {\n                dataUpdatedAt: dehydratedAt,\n              }),\n          },\n        )\n      }\n\n      if (\n        promise &&\n        // If the data was synchronously available, there is no need to set up\n        // a retryer and thus no reason to call fetch\n        !syncData &&\n        !existingQueryIsPending &&\n        !existingQueryIsFetching &&\n        // Only hydrate if dehydration is newer than any existing data,\n        // this is always true for new queries\n        dehydratedAt > query.state.dataUpdatedAt\n      ) {\n        // This doesn't actually fetch - it just creates a retryer\n        // which will re-use the passed `initialPromise`\n        query\n          .fetch(undefined, {\n            // RSC transformed promises are not thenable\n            initialPromise: Promise.resolve(promise).then(deserializeData),\n          })\n          // Avoid unhandled promise rejections\n          .catch(noop)\n      }\n    },\n  )\n}\n"],"mappings":"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"}

package/build/modern/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file */\n\nexport { focusManager } from './focusManager'\nexport { environmentManager } from './environmentManager'\nexport {\n  defaultShouldDehydrateMutation,\n  defaultShouldDehydrateQuery,\n  dehydrate,\n  dehydrateQuery,\n  hydrate,\n} from './hydration'\nexport { InfiniteQueryObserver } from './infiniteQueryObserver'\nexport { MutationCache } from './mutationCache'\nexport type { MutationCacheNotifyEvent } from './mutationCache'\nexport { MutationObserver } from './mutationObserver'\nexport { defaultScheduler, notifyManager } from './notifyManager'\nexport { onlineManager } from './onlineManager'\nexport { QueriesObserver } from './queriesObserver'\nexport { QueryCache } from './queryCache'\nexport type { QueryCacheNotifyEvent } from './queryCache'\nexport { QueryClient } from './queryClient'\nexport { QueryObserver } from './queryObserver'\nexport { CancelledError, isCancelledError } from './retryer'\nexport {\n  timeoutManager,\n  type ManagedTimerId,\n  type TimeoutCallback,\n  type TimeoutProvider,\n} from './timeoutManager'\nexport {\n  hashKey,\n  isServer,\n  keepPreviousData,\n  matchMutation,\n  matchQuery,\n  noop,\n  partialMatchKey,\n  replaceEqualDeep,\n  shouldThrowError,\n  skipToken,\n} from './utils'\nexport type { MutationFilters, QueryFilters, SkipToken, Updater } from './utils'\n\nexport { streamedQuery as experimental_streamedQuery } from './streamedQuery'\n\n// Types\nexport type {\n  DehydratedState,\n  DehydrateOptions,\n  HydrateOptions,\n} from './hydration'\nexport { Mutation } from './mutation'\nexport type { MutationState } from './mutation'\nexport type { MutationCacheConfig } from './mutationCache'\nexport type { QueriesObserverOptions } from './queriesObserver'\nexport { Query } from './query'\nexport type { QueryState } from './query'\nexport type { QueryCacheConfig } from './queryCache'\nexport * from './types'\n"],"mappings":""}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file */\n\nexport { focusManager } from './focusManager'\nexport type { FocusManager } from './focusManager'\nexport { environmentManager } from './environmentManager'\nexport {\n  defaultShouldDehydrateMutation,\n  defaultShouldDehydrateQuery,\n  dehydrate,\n  dehydrateQuery,\n  hydrate,\n} from './hydration'\nexport { InfiniteQueryObserver } from './infiniteQueryObserver'\nexport { MutationCache } from './mutationCache'\nexport type { MutationCacheNotifyEvent } from './mutationCache'\nexport { MutationObserver } from './mutationObserver'\nexport { defaultScheduler, notifyManager } from './notifyManager'\nexport { onlineManager } from './onlineManager'\nexport type { OnlineManager } from './onlineManager'\nexport { QueriesObserver } from './queriesObserver'\nexport { QueryCache } from './queryCache'\nexport type { QueryCacheNotifyEvent } from './queryCache'\nexport { QueryClient } from './queryClient'\nexport { QueryObserver } from './queryObserver'\nexport { CancelledError, isCancelledError } from './retryer'\nexport {\n  timeoutManager,\n  type ManagedTimerId,\n  type TimeoutCallback,\n  type TimeoutManager,\n  type TimeoutProvider,\n} from './timeoutManager'\nexport {\n  hashKey,\n  isServer,\n  keepPreviousData,\n  matchMutation,\n  matchQuery,\n  noop,\n  partialMatchKey,\n  replaceEqualDeep,\n  shouldThrowError,\n  skipToken,\n} from './utils'\nexport type { MutationFilters, QueryFilters, SkipToken, Updater } from './utils'\n\nexport { streamedQuery as experimental_streamedQuery } from './streamedQuery'\n\n// Types\nexport type {\n  DehydratedState,\n  DehydrateOptions,\n  HydrateOptions,\n} from './hydration'\nexport { Mutation } from './mutation'\nexport type { MutationState } from './mutation'\nexport type { MutationCacheConfig } from './mutationCache'\nexport type { QueriesObserverOptions } from './queriesObserver'\nexport { Query } from './query'\nexport type { QueryState } from './query'\nexport type { QueryCacheConfig } from './queryCache'\nexport * from './types'\n"],"mappings":""}

package/build/modern/index.d.cts

@@ -1,10 +1,10 @@
 import { environmentManager } from "./environmentManager.cjs";
-import { focusManager } from "./focusManager.cjs";
-import { $ as MutationObserverBaseResult, $n as Query, $t as CancelledError, A as InfiniteData, An as noop, At as QueryObserverOptions, B as InfiniteQueryObserverSuccessResult, Bt as RefetchQueryFilters, C as FetchPreviousPageOptions, Ct as QueryKey, D as GetPreviousPageParamFunction, Dn as keepPreviousData, Dt as QueryObserverBaseResult, E as GetNextPageParamFunction, Et as QueryMeta, F as InfiniteQueryObserverOptions, Ft as QueryObserverSuccessResult, G as InvalidateQueryFilters, Gn as MutationCacheConfig, Gt as StaleTime, H as InitialDataFunction, Hn as MutationState, Ht as ResetOptions, I as InfiniteQueryObserverPendingResult, In as shouldThrowError, It as QueryOptions, J as MutateOptions, Jt as UnsetMarker, K as MutateFunction, Kn as MutationCacheNotifyEvent, Kt as StaleTimeFunction, L as InfiniteQueryObserverPlaceholderResult, Ln as skipToken, Lt as QueryPersister, M as InfiniteQueryObserverBaseResult, Mt as QueryObserverPlaceholderResult, N as InfiniteQueryObserverLoadingErrorResult, Nn as replaceEqualDeep, Nt as QueryObserverRefetchErrorResult, O as InferDataFromTag, On as matchMutation, Ot as QueryObserverLoadingErrorResult, P as InfiniteQueryObserverLoadingResult, Pt as QueryObserverResult, Q as MutationMeta, Qt as unsetMarker, R as InfiniteQueryObserverRefetchErrorResult, Rt as QueryStatus, S as FetchNextPageOptions, St as QueryFunctionContext, T as FetchStatus, Tn as isServer, Tt as QueryKeyWithDataTag, U as InitialPageParam, Ut as ResultOptions, V as InfiniteQueryPageParamsOptions, Vn as Mutation, Vt as Register, W as InvalidateOptions, Wn as MutationCache, Wt as SetDataOptions, X as MutationFunctionContext, Xt as dataTagErrorSymbol, Y as MutationFunction, Yt as WithRequired, Z as MutationKey, Zt as dataTagSymbol, _ as DefinedQueryObserverResult, _t as QueriesPlaceholderDataFunction, a as defaultShouldDehydrateQuery, an as isCancelledError, at as MutationObserverSuccessResult, b as EnsureQueryDataOptions, bt as QueryExecuteOptions, c as hydrate, cn as QueryCacheConfig, ct as MutationStatus, d as DataTag, dn as MutationFilters, dt as NotifyEvent, et as MutationObserverErrorResult, f as DefaultError, fn as QueryFilters, ft as NotifyEventType, g as DefinedInfiniteQueryObserverResult, gt as PlaceholderDataFunction, h as DefaultedQueryObserverOptions, hn as Updater, ht as Override, i as defaultShouldDehydrateMutation, it as MutationObserverResult, j as InfiniteQueryExecuteOptions, jn as partialMatchKey, jt as QueryObserverPendingResult, k as InferErrorFromTag, kn as matchQuery, kt as QueryObserverLoadingResult, l as AnyDataTag, ln as QueryCacheNotifyEvent, lt as NetworkMode, m as DefaultedInfiniteQueryObserverOptions, mn as SkipToken, mt as OmitKeyof, n as DehydratedState, nt as MutationObserverLoadingResult, o as dehydrate, on as QueryClient, ot as MutationOptions, p as DefaultOptions, pt as NotifyOnChangeProps, q as MutateFunctionRest, qn as MutationObserver, qt as ThrowOnError, r as HydrateOptions, rr as QueryObserver, rt as MutationObserverOptions, s as dehydrateQuery, sn as QueryCache, st as MutationScope, t as DehydrateOptions, tr as QueryState, tt as MutationObserverIdleResult, u as CancelOptions, ut as NonUndefinedGuard, v as DistributiveOmit, vt as QueryBooleanOption, w as FetchQueryOptions, wt as QueryKeyHashFunction, x as FetchInfiniteQueryOptions, xn as hashKey, xt as QueryFunction, y as EnsureInfiniteQueryDataOptions, yt as QueryClientConfig, z as InfiniteQueryObserverResult, zt as RefetchOptions } from "./hydration-DWGr3cFC.cjs";
+import { FocusManager, focusManager } from "./focusManager.cjs";
+import { $ as MutationObserverBaseResult, $n as Query, $t as CancelledError, A as InfiniteData, An as noop, At as QueryObserverOptions, B as InfiniteQueryObserverSuccessResult, Bt as RefetchQueryFilters, C as FetchPreviousPageOptions, Ct as QueryKey, D as GetPreviousPageParamFunction, Dn as keepPreviousData, Dt as QueryObserverBaseResult, E as GetNextPageParamFunction, Et as QueryMeta, F as InfiniteQueryObserverOptions, Ft as QueryObserverSuccessResult, G as InvalidateQueryFilters, Gn as MutationCacheConfig, Gt as StaleTime, H as InitialDataFunction, Hn as MutationState, Ht as ResetOptions, I as InfiniteQueryObserverPendingResult, In as shouldThrowError, It as QueryOptions, J as MutateOptions, Jt as UnsetMarker, K as MutateFunction, Kn as MutationCacheNotifyEvent, Kt as StaleTimeFunction, L as InfiniteQueryObserverPlaceholderResult, Ln as skipToken, Lt as QueryPersister, M as InfiniteQueryObserverBaseResult, Mt as QueryObserverPlaceholderResult, N as InfiniteQueryObserverLoadingErrorResult, Nn as replaceEqualDeep, Nt as QueryObserverRefetchErrorResult, O as InferDataFromTag, On as matchMutation, Ot as QueryObserverLoadingErrorResult, P as InfiniteQueryObserverLoadingResult, Pt as QueryObserverResult, Q as MutationMeta, Qt as unsetMarker, R as InfiniteQueryObserverRefetchErrorResult, Rt as QueryStatus, S as FetchNextPageOptions, St as QueryFunctionContext, T as FetchStatus, Tn as isServer, Tt as QueryKeyWithDataTag, U as InitialPageParam, Ut as ResultOptions, V as InfiniteQueryPageParamsOptions, Vn as Mutation, Vt as Register, W as InvalidateOptions, Wn as MutationCache, Wt as SetDataOptions, X as MutationFunctionContext, Xt as dataTagErrorSymbol, Y as MutationFunction, Yt as WithRequired, Z as MutationKey, Zt as dataTagSymbol, _ as DefinedQueryObserverResult, _t as QueriesPlaceholderDataFunction, a as defaultShouldDehydrateQuery, an as isCancelledError, at as MutationObserverSuccessResult, b as EnsureQueryDataOptions, bt as QueryExecuteOptions, c as hydrate, cn as QueryCacheConfig, ct as MutationStatus, d as DataTag, dn as MutationFilters, dt as NotifyEvent, et as MutationObserverErrorResult, f as DefaultError, fn as QueryFilters, ft as NotifyEventType, g as DefinedInfiniteQueryObserverResult, gt as PlaceholderDataFunction, h as DefaultedQueryObserverOptions, hn as Updater, ht as Override, i as defaultShouldDehydrateMutation, it as MutationObserverResult, j as InfiniteQueryExecuteOptions, jn as partialMatchKey, jt as QueryObserverPendingResult, k as InferErrorFromTag, kn as matchQuery, kt as QueryObserverLoadingResult, l as AnyDataTag, ln as QueryCacheNotifyEvent, lt as NetworkMode, m as DefaultedInfiniteQueryObserverOptions, mn as SkipToken, mt as OmitKeyof, n as DehydratedState, nt as MutationObserverLoadingResult, o as dehydrate, on as QueryClient, ot as MutationOptions, p as DefaultOptions, pt as NotifyOnChangeProps, q as MutateFunctionRest, qn as MutationObserver, qt as ThrowOnError, r as HydrateOptions, rr as QueryObserver, rt as MutationObserverOptions, s as dehydrateQuery, sn as QueryCache, st as MutationScope, t as DehydrateOptions, tr as QueryState, tt as MutationObserverIdleResult, u as CancelOptions, ut as NonUndefinedGuard, v as DistributiveOmit, vt as QueryBooleanOption, w as FetchQueryOptions, wt as QueryKeyHashFunction, x as FetchInfiniteQueryOptions, xn as hashKey, xt as QueryFunction, y as EnsureInfiniteQueryDataOptions, yt as QueryClientConfig, z as InfiniteQueryObserverResult, zt as RefetchOptions } from "./hydration-DwR10Hi-.cjs";
 import { InfiniteQueryObserver } from "./infiniteQueryObserver.cjs";
 import { defaultScheduler, notifyManager } from "./notifyManager.cjs";
-import { onlineManager } from "./onlineManager.cjs";
+import { OnlineManager, onlineManager } from "./onlineManager.cjs";
 import { QueriesObserver, QueriesObserverOptions } from "./queriesObserver.cjs";
-import { ManagedTimerId, TimeoutCallback, TimeoutProvider, timeoutManager } from "./timeoutManager.cjs";
+import { ManagedTimerId, TimeoutCallback, TimeoutManager, TimeoutProvider, timeoutManager } from "./timeoutManager.cjs";
 import { streamedQuery } from "./streamedQuery.cjs";
-export { AnyDataTag, CancelOptions, CancelledError, DataTag, DefaultError, DefaultOptions, DefaultedInfiniteQueryObserverOptions, DefaultedQueryObserverOptions, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, type DehydrateOptions, type DehydratedState, DistributiveOmit, EnsureInfiniteQueryDataOptions, EnsureQueryDataOptions, FetchInfiniteQueryOptions, FetchNextPageOptions, FetchPreviousPageOptions, FetchQueryOptions, FetchStatus, GetNextPageParamFunction, GetPreviousPageParamFunction, type HydrateOptions, InferDataFromTag, InferErrorFromTag, InfiniteData, InfiniteQueryExecuteOptions, InfiniteQueryObserver, InfiniteQueryObserverBaseResult, InfiniteQueryObserverLoadingErrorResult, InfiniteQueryObserverLoadingResult, InfiniteQueryObserverOptions, InfiniteQueryObserverPendingResult, InfiniteQueryObserverPlaceholderResult, InfiniteQueryObserverRefetchErrorResult, InfiniteQueryObserverResult, InfiniteQueryObserverSuccessResult, InfiniteQueryPageParamsOptions, InitialDataFunction, InitialPageParam, InvalidateOptions, InvalidateQueryFilters, type ManagedTimerId, MutateFunction, MutateFunctionRest, MutateOptions, Mutation, MutationCache, type MutationCacheConfig, type MutationCacheNotifyEvent, type MutationFilters, MutationFunction, MutationFunctionContext, MutationKey, MutationMeta, MutationObserver, MutationObserverBaseResult, MutationObserverErrorResult, MutationObserverIdleResult, MutationObserverLoadingResult, MutationObserverOptions, MutationObserverResult, MutationObserverSuccessResult, MutationOptions, MutationScope, type MutationState, MutationStatus, NetworkMode, NonUndefinedGuard, NotifyEvent, NotifyEventType, NotifyOnChangeProps, OmitKeyof, Override, PlaceholderDataFunction, QueriesObserver, type QueriesObserverOptions, QueriesPlaceholderDataFunction, Query, QueryBooleanOption, QueryCache, type QueryCacheConfig, type QueryCacheNotifyEvent, QueryClient, QueryClientConfig, QueryExecuteOptions, type QueryFilters, QueryFunction, QueryFunctionContext, QueryKey, QueryKeyHashFunction, QueryKeyWithDataTag, QueryMeta, QueryObserver, QueryObserverBaseResult, QueryObserverLoadingErrorResult, QueryObserverLoadingResult, QueryObserverOptions, QueryObserverPendingResult, QueryObserverPlaceholderResult, QueryObserverRefetchErrorResult, QueryObserverResult, QueryObserverSuccessResult, QueryOptions, QueryPersister, type QueryState, QueryStatus, RefetchOptions, RefetchQueryFilters, Register, ResetOptions, ResultOptions, SetDataOptions, type SkipToken, StaleTime, StaleTimeFunction, ThrowOnError, type TimeoutCallback, type TimeoutProvider, UnsetMarker, type Updater, WithRequired, dataTagErrorSymbol, dataTagSymbol, defaultScheduler, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, environmentManager, streamedQuery as experimental_streamedQuery, focusManager, hashKey, hydrate, isCancelledError, isServer, keepPreviousData, matchMutation, matchQuery, noop, notifyManager, onlineManager, partialMatchKey, replaceEqualDeep, shouldThrowError, skipToken, timeoutManager, unsetMarker };
+export { AnyDataTag, CancelOptions, CancelledError, DataTag, DefaultError, DefaultOptions, DefaultedInfiniteQueryObserverOptions, DefaultedQueryObserverOptions, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, type DehydrateOptions, type DehydratedState, DistributiveOmit, EnsureInfiniteQueryDataOptions, EnsureQueryDataOptions, FetchInfiniteQueryOptions, FetchNextPageOptions, FetchPreviousPageOptions, FetchQueryOptions, FetchStatus, type FocusManager, GetNextPageParamFunction, GetPreviousPageParamFunction, type HydrateOptions, InferDataFromTag, InferErrorFromTag, InfiniteData, InfiniteQueryExecuteOptions, InfiniteQueryObserver, InfiniteQueryObserverBaseResult, InfiniteQueryObserverLoadingErrorResult, InfiniteQueryObserverLoadingResult, InfiniteQueryObserverOptions, InfiniteQueryObserverPendingResult, InfiniteQueryObserverPlaceholderResult, InfiniteQueryObserverRefetchErrorResult, InfiniteQueryObserverResult, InfiniteQueryObserverSuccessResult, InfiniteQueryPageParamsOptions, InitialDataFunction, InitialPageParam, InvalidateOptions, InvalidateQueryFilters, type ManagedTimerId, MutateFunction, MutateFunctionRest, MutateOptions, Mutation, MutationCache, type MutationCacheConfig, type MutationCacheNotifyEvent, type MutationFilters, MutationFunction, MutationFunctionContext, MutationKey, MutationMeta, MutationObserver, MutationObserverBaseResult, MutationObserverErrorResult, MutationObserverIdleResult, MutationObserverLoadingResult, MutationObserverOptions, MutationObserverResult, MutationObserverSuccessResult, MutationOptions, MutationScope, type MutationState, MutationStatus, NetworkMode, NonUndefinedGuard, NotifyEvent, NotifyEventType, NotifyOnChangeProps, OmitKeyof, type OnlineManager, Override, PlaceholderDataFunction, QueriesObserver, type QueriesObserverOptions, QueriesPlaceholderDataFunction, Query, QueryBooleanOption, QueryCache, type QueryCacheConfig, type QueryCacheNotifyEvent, QueryClient, QueryClientConfig, QueryExecuteOptions, type QueryFilters, QueryFunction, QueryFunctionContext, QueryKey, QueryKeyHashFunction, QueryKeyWithDataTag, QueryMeta, QueryObserver, QueryObserverBaseResult, QueryObserverLoadingErrorResult, QueryObserverLoadingResult, QueryObserverOptions, QueryObserverPendingResult, QueryObserverPlaceholderResult, QueryObserverRefetchErrorResult, QueryObserverResult, QueryObserverSuccessResult, QueryOptions, QueryPersister, type QueryState, QueryStatus, RefetchOptions, RefetchQueryFilters, Register, ResetOptions, ResultOptions, SetDataOptions, type SkipToken, StaleTime, StaleTimeFunction, ThrowOnError, type TimeoutCallback, type TimeoutManager, type TimeoutProvider, UnsetMarker, type Updater, WithRequired, dataTagErrorSymbol, dataTagSymbol, defaultScheduler, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, environmentManager, streamedQuery as experimental_streamedQuery, focusManager, hashKey, hydrate, isCancelledError, isServer, keepPreviousData, matchMutation, matchQuery, noop, notifyManager, onlineManager, partialMatchKey, replaceEqualDeep, shouldThrowError, skipToken, timeoutManager, unsetMarker };

package/build/modern/index.d.ts

@@ -1,10 +1,10 @@
 import { environmentManager } from "./environmentManager.js";
-import { focusManager } from "./focusManager.js";
-import { $ as MutationObserverBaseResult, $n as Query, $t as CancelledError, A as InfiniteData, An as noop, At as QueryObserverOptions, B as InfiniteQueryObserverSuccessResult, Bt as RefetchQueryFilters, C as FetchPreviousPageOptions, Ct as QueryKey, D as GetPreviousPageParamFunction, Dn as keepPreviousData, Dt as QueryObserverBaseResult, E as GetNextPageParamFunction, Et as QueryMeta, F as InfiniteQueryObserverOptions, Ft as QueryObserverSuccessResult, G as InvalidateQueryFilters, Gn as MutationCacheConfig, Gt as StaleTime, H as InitialDataFunction, Hn as MutationState, Ht as ResetOptions, I as InfiniteQueryObserverPendingResult, In as shouldThrowError, It as QueryOptions, J as MutateOptions, Jt as UnsetMarker, K as MutateFunction, Kn as MutationCacheNotifyEvent, Kt as StaleTimeFunction, L as InfiniteQueryObserverPlaceholderResult, Ln as skipToken, Lt as QueryPersister, M as InfiniteQueryObserverBaseResult, Mt as QueryObserverPlaceholderResult, N as InfiniteQueryObserverLoadingErrorResult, Nn as replaceEqualDeep, Nt as QueryObserverRefetchErrorResult, O as InferDataFromTag, On as matchMutation, Ot as QueryObserverLoadingErrorResult, P as InfiniteQueryObserverLoadingResult, Pt as QueryObserverResult, Q as MutationMeta, Qt as unsetMarker, R as InfiniteQueryObserverRefetchErrorResult, Rt as QueryStatus, S as FetchNextPageOptions, St as QueryFunctionContext, T as FetchStatus, Tn as isServer, Tt as QueryKeyWithDataTag, U as InitialPageParam, Ut as ResultOptions, V as InfiniteQueryPageParamsOptions, Vn as Mutation, Vt as Register, W as InvalidateOptions, Wn as MutationCache, Wt as SetDataOptions, X as MutationFunctionContext, Xt as dataTagErrorSymbol, Y as MutationFunction, Yt as WithRequired, Z as MutationKey, Zt as dataTagSymbol, _ as DefinedQueryObserverResult, _t as QueriesPlaceholderDataFunction, a as defaultShouldDehydrateQuery, an as isCancelledError, at as MutationObserverSuccessResult, b as EnsureQueryDataOptions, bt as QueryExecuteOptions, c as hydrate, cn as QueryCacheConfig, ct as MutationStatus, d as DataTag, dn as MutationFilters, dt as NotifyEvent, et as MutationObserverErrorResult, f as DefaultError, fn as QueryFilters, ft as NotifyEventType, g as DefinedInfiniteQueryObserverResult, gt as PlaceholderDataFunction, h as DefaultedQueryObserverOptions, hn as Updater, ht as Override, i as defaultShouldDehydrateMutation, it as MutationObserverResult, j as InfiniteQueryExecuteOptions, jn as partialMatchKey, jt as QueryObserverPendingResult, k as InferErrorFromTag, kn as matchQuery, kt as QueryObserverLoadingResult, l as AnyDataTag, ln as QueryCacheNotifyEvent, lt as NetworkMode, m as DefaultedInfiniteQueryObserverOptions, mn as SkipToken, mt as OmitKeyof, n as DehydratedState, nt as MutationObserverLoadingResult, o as dehydrate, on as QueryClient, ot as MutationOptions, p as DefaultOptions, pt as NotifyOnChangeProps, q as MutateFunctionRest, qn as MutationObserver, qt as ThrowOnError, r as HydrateOptions, rr as QueryObserver, rt as MutationObserverOptions, s as dehydrateQuery, sn as QueryCache, st as MutationScope, t as DehydrateOptions, tr as QueryState, tt as MutationObserverIdleResult, u as CancelOptions, ut as NonUndefinedGuard, v as DistributiveOmit, vt as QueryBooleanOption, w as FetchQueryOptions, wt as QueryKeyHashFunction, x as FetchInfiniteQueryOptions, xn as hashKey, xt as QueryFunction, y as EnsureInfiniteQueryDataOptions, yt as QueryClientConfig, z as InfiniteQueryObserverResult, zt as RefetchOptions } from "./hydration-Bjs0MSgg.js";
+import { FocusManager, focusManager } from "./focusManager.js";
+import { $ as MutationObserverBaseResult, $n as Query, $t as CancelledError, A as InfiniteData, An as noop, At as QueryObserverOptions, B as InfiniteQueryObserverSuccessResult, Bt as RefetchQueryFilters, C as FetchPreviousPageOptions, Ct as QueryKey, D as GetPreviousPageParamFunction, Dn as keepPreviousData, Dt as QueryObserverBaseResult, E as GetNextPageParamFunction, Et as QueryMeta, F as InfiniteQueryObserverOptions, Ft as QueryObserverSuccessResult, G as InvalidateQueryFilters, Gn as MutationCacheConfig, Gt as StaleTime, H as InitialDataFunction, Hn as MutationState, Ht as ResetOptions, I as InfiniteQueryObserverPendingResult, In as shouldThrowError, It as QueryOptions, J as MutateOptions, Jt as UnsetMarker, K as MutateFunction, Kn as MutationCacheNotifyEvent, Kt as StaleTimeFunction, L as InfiniteQueryObserverPlaceholderResult, Ln as skipToken, Lt as QueryPersister, M as InfiniteQueryObserverBaseResult, Mt as QueryObserverPlaceholderResult, N as InfiniteQueryObserverLoadingErrorResult, Nn as replaceEqualDeep, Nt as QueryObserverRefetchErrorResult, O as InferDataFromTag, On as matchMutation, Ot as QueryObserverLoadingErrorResult, P as InfiniteQueryObserverLoadingResult, Pt as QueryObserverResult, Q as MutationMeta, Qt as unsetMarker, R as InfiniteQueryObserverRefetchErrorResult, Rt as QueryStatus, S as FetchNextPageOptions, St as QueryFunctionContext, T as FetchStatus, Tn as isServer, Tt as QueryKeyWithDataTag, U as InitialPageParam, Ut as ResultOptions, V as InfiniteQueryPageParamsOptions, Vn as Mutation, Vt as Register, W as InvalidateOptions, Wn as MutationCache, Wt as SetDataOptions, X as MutationFunctionContext, Xt as dataTagErrorSymbol, Y as MutationFunction, Yt as WithRequired, Z as MutationKey, Zt as dataTagSymbol, _ as DefinedQueryObserverResult, _t as QueriesPlaceholderDataFunction, a as defaultShouldDehydrateQuery, an as isCancelledError, at as MutationObserverSuccessResult, b as EnsureQueryDataOptions, bt as QueryExecuteOptions, c as hydrate, cn as QueryCacheConfig, ct as MutationStatus, d as DataTag, dn as MutationFilters, dt as NotifyEvent, et as MutationObserverErrorResult, f as DefaultError, fn as QueryFilters, ft as NotifyEventType, g as DefinedInfiniteQueryObserverResult, gt as PlaceholderDataFunction, h as DefaultedQueryObserverOptions, hn as Updater, ht as Override, i as defaultShouldDehydrateMutation, it as MutationObserverResult, j as InfiniteQueryExecuteOptions, jn as partialMatchKey, jt as QueryObserverPendingResult, k as InferErrorFromTag, kn as matchQuery, kt as QueryObserverLoadingResult, l as AnyDataTag, ln as QueryCacheNotifyEvent, lt as NetworkMode, m as DefaultedInfiniteQueryObserverOptions, mn as SkipToken, mt as OmitKeyof, n as DehydratedState, nt as MutationObserverLoadingResult, o as dehydrate, on as QueryClient, ot as MutationOptions, p as DefaultOptions, pt as NotifyOnChangeProps, q as MutateFunctionRest, qn as MutationObserver, qt as ThrowOnError, r as HydrateOptions, rr as QueryObserver, rt as MutationObserverOptions, s as dehydrateQuery, sn as QueryCache, st as MutationScope, t as DehydrateOptions, tr as QueryState, tt as MutationObserverIdleResult, u as CancelOptions, ut as NonUndefinedGuard, v as DistributiveOmit, vt as QueryBooleanOption, w as FetchQueryOptions, wt as QueryKeyHashFunction, x as FetchInfiniteQueryOptions, xn as hashKey, xt as QueryFunction, y as EnsureInfiniteQueryDataOptions, yt as QueryClientConfig, z as InfiniteQueryObserverResult, zt as RefetchOptions } from "./hydration-Cq7QYAzB.js";
 import { InfiniteQueryObserver } from "./infiniteQueryObserver.js";
 import { defaultScheduler, notifyManager } from "./notifyManager.js";
-import { onlineManager } from "./onlineManager.js";
+import { OnlineManager, onlineManager } from "./onlineManager.js";
 import { QueriesObserver, QueriesObserverOptions } from "./queriesObserver.js";
-import { ManagedTimerId, TimeoutCallback, TimeoutProvider, timeoutManager } from "./timeoutManager.js";
+import { ManagedTimerId, TimeoutCallback, TimeoutManager, TimeoutProvider, timeoutManager } from "./timeoutManager.js";
 import { streamedQuery } from "./streamedQuery.js";
-export { AnyDataTag, CancelOptions, CancelledError, DataTag, DefaultError, DefaultOptions, DefaultedInfiniteQueryObserverOptions, DefaultedQueryObserverOptions, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, type DehydrateOptions, type DehydratedState, DistributiveOmit, EnsureInfiniteQueryDataOptions, EnsureQueryDataOptions, FetchInfiniteQueryOptions, FetchNextPageOptions, FetchPreviousPageOptions, FetchQueryOptions, FetchStatus, GetNextPageParamFunction, GetPreviousPageParamFunction, type HydrateOptions, InferDataFromTag, InferErrorFromTag, InfiniteData, InfiniteQueryExecuteOptions, InfiniteQueryObserver, InfiniteQueryObserverBaseResult, InfiniteQueryObserverLoadingErrorResult, InfiniteQueryObserverLoadingResult, InfiniteQueryObserverOptions, InfiniteQueryObserverPendingResult, InfiniteQueryObserverPlaceholderResult, InfiniteQueryObserverRefetchErrorResult, InfiniteQueryObserverResult, InfiniteQueryObserverSuccessResult, InfiniteQueryPageParamsOptions, InitialDataFunction, InitialPageParam, InvalidateOptions, InvalidateQueryFilters, type ManagedTimerId, MutateFunction, MutateFunctionRest, MutateOptions, Mutation, MutationCache, type MutationCacheConfig, type MutationCacheNotifyEvent, type MutationFilters, MutationFunction, MutationFunctionContext, MutationKey, MutationMeta, MutationObserver, MutationObserverBaseResult, MutationObserverErrorResult, MutationObserverIdleResult, MutationObserverLoadingResult, MutationObserverOptions, MutationObserverResult, MutationObserverSuccessResult, MutationOptions, MutationScope, type MutationState, MutationStatus, NetworkMode, NonUndefinedGuard, NotifyEvent, NotifyEventType, NotifyOnChangeProps, OmitKeyof, Override, PlaceholderDataFunction, QueriesObserver, type QueriesObserverOptions, QueriesPlaceholderDataFunction, Query, QueryBooleanOption, QueryCache, type QueryCacheConfig, type QueryCacheNotifyEvent, QueryClient, QueryClientConfig, QueryExecuteOptions, type QueryFilters, QueryFunction, QueryFunctionContext, QueryKey, QueryKeyHashFunction, QueryKeyWithDataTag, QueryMeta, QueryObserver, QueryObserverBaseResult, QueryObserverLoadingErrorResult, QueryObserverLoadingResult, QueryObserverOptions, QueryObserverPendingResult, QueryObserverPlaceholderResult, QueryObserverRefetchErrorResult, QueryObserverResult, QueryObserverSuccessResult, QueryOptions, QueryPersister, type QueryState, QueryStatus, RefetchOptions, RefetchQueryFilters, Register, ResetOptions, ResultOptions, SetDataOptions, type SkipToken, StaleTime, StaleTimeFunction, ThrowOnError, type TimeoutCallback, type TimeoutProvider, UnsetMarker, type Updater, WithRequired, dataTagErrorSymbol, dataTagSymbol, defaultScheduler, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, environmentManager, streamedQuery as experimental_streamedQuery, focusManager, hashKey, hydrate, isCancelledError, isServer, keepPreviousData, matchMutation, matchQuery, noop, notifyManager, onlineManager, partialMatchKey, replaceEqualDeep, shouldThrowError, skipToken, timeoutManager, unsetMarker };
+export { AnyDataTag, CancelOptions, CancelledError, DataTag, DefaultError, DefaultOptions, DefaultedInfiniteQueryObserverOptions, DefaultedQueryObserverOptions, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, type DehydrateOptions, type DehydratedState, DistributiveOmit, EnsureInfiniteQueryDataOptions, EnsureQueryDataOptions, FetchInfiniteQueryOptions, FetchNextPageOptions, FetchPreviousPageOptions, FetchQueryOptions, FetchStatus, type FocusManager, GetNextPageParamFunction, GetPreviousPageParamFunction, type HydrateOptions, InferDataFromTag, InferErrorFromTag, InfiniteData, InfiniteQueryExecuteOptions, InfiniteQueryObserver, InfiniteQueryObserverBaseResult, InfiniteQueryObserverLoadingErrorResult, InfiniteQueryObserverLoadingResult, InfiniteQueryObserverOptions, InfiniteQueryObserverPendingResult, InfiniteQueryObserverPlaceholderResult, InfiniteQueryObserverRefetchErrorResult, InfiniteQueryObserverResult, InfiniteQueryObserverSuccessResult, InfiniteQueryPageParamsOptions, InitialDataFunction, InitialPageParam, InvalidateOptions, InvalidateQueryFilters, type ManagedTimerId, MutateFunction, MutateFunctionRest, MutateOptions, Mutation, MutationCache, type MutationCacheConfig, type MutationCacheNotifyEvent, type MutationFilters, MutationFunction, MutationFunctionContext, MutationKey, MutationMeta, MutationObserver, MutationObserverBaseResult, MutationObserverErrorResult, MutationObserverIdleResult, MutationObserverLoadingResult, MutationObserverOptions, MutationObserverResult, MutationObserverSuccessResult, MutationOptions, MutationScope, type MutationState, MutationStatus, NetworkMode, NonUndefinedGuard, NotifyEvent, NotifyEventType, NotifyOnChangeProps, OmitKeyof, type OnlineManager, Override, PlaceholderDataFunction, QueriesObserver, type QueriesObserverOptions, QueriesPlaceholderDataFunction, Query, QueryBooleanOption, QueryCache, type QueryCacheConfig, type QueryCacheNotifyEvent, QueryClient, QueryClientConfig, QueryExecuteOptions, type QueryFilters, QueryFunction, QueryFunctionContext, QueryKey, QueryKeyHashFunction, QueryKeyWithDataTag, QueryMeta, QueryObserver, QueryObserverBaseResult, QueryObserverLoadingErrorResult, QueryObserverLoadingResult, QueryObserverOptions, QueryObserverPendingResult, QueryObserverPlaceholderResult, QueryObserverRefetchErrorResult, QueryObserverResult, QueryObserverSuccessResult, QueryOptions, QueryPersister, type QueryState, QueryStatus, RefetchOptions, RefetchQueryFilters, Register, ResetOptions, ResultOptions, SetDataOptions, type SkipToken, StaleTime, StaleTimeFunction, ThrowOnError, type TimeoutCallback, type TimeoutManager, type TimeoutProvider, UnsetMarker, type Updater, WithRequired, dataTagErrorSymbol, dataTagSymbol, defaultScheduler, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, dehydrateQuery, environmentManager, streamedQuery as experimental_streamedQuery, focusManager, hashKey, hydrate, isCancelledError, isServer, keepPreviousData, matchMutation, matchQuery, noop, notifyManager, onlineManager, partialMatchKey, replaceEqualDeep, shouldThrowError, skipToken, timeoutManager, unsetMarker };

package/build/modern/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file */\n\nexport { focusManager } from './focusManager'\nexport { environmentManager } from './environmentManager'\nexport {\n  defaultShouldDehydrateMutation,\n  defaultShouldDehydrateQuery,\n  dehydrate,\n  dehydrateQuery,\n  hydrate,\n} from './hydration'\nexport { InfiniteQueryObserver } from './infiniteQueryObserver'\nexport { MutationCache } from './mutationCache'\nexport type { MutationCacheNotifyEvent } from './mutationCache'\nexport { MutationObserver } from './mutationObserver'\nexport { defaultScheduler, notifyManager } from './notifyManager'\nexport { onlineManager } from './onlineManager'\nexport { QueriesObserver } from './queriesObserver'\nexport { QueryCache } from './queryCache'\nexport type { QueryCacheNotifyEvent } from './queryCache'\nexport { QueryClient } from './queryClient'\nexport { QueryObserver } from './queryObserver'\nexport { CancelledError, isCancelledError } from './retryer'\nexport {\n  timeoutManager,\n  type ManagedTimerId,\n  type TimeoutCallback,\n  type TimeoutProvider,\n} from './timeoutManager'\nexport {\n  hashKey,\n  isServer,\n  keepPreviousData,\n  matchMutation,\n  matchQuery,\n  noop,\n  partialMatchKey,\n  replaceEqualDeep,\n  shouldThrowError,\n  skipToken,\n} from './utils'\nexport type { MutationFilters, QueryFilters, SkipToken, Updater } from './utils'\n\nexport { streamedQuery as experimental_streamedQuery } from './streamedQuery'\n\n// Types\nexport type {\n  DehydratedState,\n  DehydrateOptions,\n  HydrateOptions,\n} from './hydration'\nexport { Mutation } from './mutation'\nexport type { MutationState } from './mutation'\nexport type { MutationCacheConfig } from './mutationCache'\nexport type { QueriesObserverOptions } from './queriesObserver'\nexport { Query } from './query'\nexport type { QueryState } from './query'\nexport type { QueryCacheConfig } from './queryCache'\nexport * from './types'\n"],"mappings":""}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file */\n\nexport { focusManager } from './focusManager'\nexport type { FocusManager } from './focusManager'\nexport { environmentManager } from './environmentManager'\nexport {\n  defaultShouldDehydrateMutation,\n  defaultShouldDehydrateQuery,\n  dehydrate,\n  dehydrateQuery,\n  hydrate,\n} from './hydration'\nexport { InfiniteQueryObserver } from './infiniteQueryObserver'\nexport { MutationCache } from './mutationCache'\nexport type { MutationCacheNotifyEvent } from './mutationCache'\nexport { MutationObserver } from './mutationObserver'\nexport { defaultScheduler, notifyManager } from './notifyManager'\nexport { onlineManager } from './onlineManager'\nexport type { OnlineManager } from './onlineManager'\nexport { QueriesObserver } from './queriesObserver'\nexport { QueryCache } from './queryCache'\nexport type { QueryCacheNotifyEvent } from './queryCache'\nexport { QueryClient } from './queryClient'\nexport { QueryObserver } from './queryObserver'\nexport { CancelledError, isCancelledError } from './retryer'\nexport {\n  timeoutManager,\n  type ManagedTimerId,\n  type TimeoutCallback,\n  type TimeoutManager,\n  type TimeoutProvider,\n} from './timeoutManager'\nexport {\n  hashKey,\n  isServer,\n  keepPreviousData,\n  matchMutation,\n  matchQuery,\n  noop,\n  partialMatchKey,\n  replaceEqualDeep,\n  shouldThrowError,\n  skipToken,\n} from './utils'\nexport type { MutationFilters, QueryFilters, SkipToken, Updater } from './utils'\n\nexport { streamedQuery as experimental_streamedQuery } from './streamedQuery'\n\n// Types\nexport type {\n  DehydratedState,\n  DehydrateOptions,\n  HydrateOptions,\n} from './hydration'\nexport { Mutation } from './mutation'\nexport type { MutationState } from './mutation'\nexport type { MutationCacheConfig } from './mutationCache'\nexport type { QueriesObserverOptions } from './queriesObserver'\nexport { Query } from './query'\nexport type { QueryState } from './query'\nexport type { QueryCacheConfig } from './queryCache'\nexport * from './types'\n"],"mappings":""}

package/build/modern/infiniteQueryBehavior.d.cts

@@ -1,4 +1,4 @@
-import { A as InfiniteData, V as InfiniteQueryPageParamsOptions, er as QueryBehavior } from "./hydration-DWGr3cFC.cjs";
+import { A as InfiniteData, V as InfiniteQueryPageParamsOptions, er as QueryBehavior } from "./hydration-DwR10Hi-.cjs";
 //#region src/infiniteQueryBehavior.d.ts
 declare function infiniteQueryBehavior<TQueryFnData, TError, TData, TPageParam>(pages?: number): QueryBehavior<TQueryFnData, TError, InfiniteData<TData, TPageParam>>;
 /**

package/build/modern/infiniteQueryBehavior.d.ts

@@ -1,4 +1,4 @@
-import { A as InfiniteData, V as InfiniteQueryPageParamsOptions, er as QueryBehavior } from "./hydration-Bjs0MSgg.js";
+import { A as InfiniteData, V as InfiniteQueryPageParamsOptions, er as QueryBehavior } from "./hydration-Cq7QYAzB.js";
 //#region src/infiniteQueryBehavior.d.ts
 declare function infiniteQueryBehavior<TQueryFnData, TError, TData, TPageParam>(pages?: number): QueryBehavior<TQueryFnData, TError, InfiniteData<TData, TPageParam>>;
 /**