@tanstack/react-query 5.102.8 → 5.103.0

package/build/legacy/useMutationState.js.map

@@ -1 +1 @@
-{"version":3,"file":"useMutationState.js","names":[],"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n  Mutation,\n  MutationCache,\n  MutationFilters,\n  MutationState,\n  QueryClient,\n} from '@tanstack/query-core'\n\nexport function useIsMutating(\n  filters?: MutationFilters,\n  queryClient?: QueryClient,\n): number {\n  const client = useQueryClient(queryClient)\n  return useMutationState(\n    { filters: { ...filters, status: 'pending' } },\n    client,\n  ).length\n}\n\ntype MutationTypeFromResult<TResult> = [TResult] extends [\n  MutationState<\n    infer TData,\n    infer TError,\n    infer TVariables,\n    infer TOnMutateResult\n  >,\n]\n  ? Mutation<TData, TError, TVariables, TOnMutateResult>\n  : Mutation\n\ntype MutationStateOptions<\n  TResult = MutationState,\n  TMutation extends Mutation<any, any, any, any> =\n    MutationTypeFromResult<TResult>,\n> = {\n  filters?: MutationFilters\n  select?: (mutation: TMutation) => TResult\n}\n\nfunction getResult<\n  TResult = MutationState,\n  TMutation extends Mutation<any, any, any, any> =\n    MutationTypeFromResult<TResult>,\n>(\n  mutationCache: MutationCache,\n  options: MutationStateOptions<TResult, TMutation>,\n): Array<TResult> {\n  return mutationCache\n    .findAll(options.filters)\n    .map(\n      (mutation): TResult =>\n        (options.select\n          ? options.select(mutation as TMutation)\n          : mutation.state) as TResult,\n    )\n}\n\nexport function useMutationState<\n  TResult = MutationState,\n  TMutation extends Mutation<any, any, any, any> =\n    MutationTypeFromResult<TResult>,\n>(\n  options: MutationStateOptions<TResult, TMutation> = {},\n  queryClient?: QueryClient,\n): Array<TResult> {\n  const mutationCache = useQueryClient(queryClient).getMutationCache()\n  const optionsRef = React.useRef(options)\n  const result = React.useRef<Array<TResult>>(null)\n  if (result.current === null) {\n    result.current = getResult(mutationCache, options)\n  }\n\n  React.useEffect(() => {\n    optionsRef.current = options\n  })\n\n  return React.useSyncExternalStore(\n    React.useCallback(\n      (onStoreChange) =>\n        mutationCache.subscribe(() => {\n          const nextResult = replaceEqualDeep(\n            result.current,\n            getResult(mutationCache, optionsRef.current),\n          )\n          if (result.current !== nextResult) {\n            result.current = nextResult\n            notifyManager.schedule(onStoreChange)\n          }\n        }),\n      [mutationCache],\n    ),\n    () => result.current,\n    () => result.current,\n  )!\n}\n"],"mappings":";;;;;AAaA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAAS,eAAe,WAAW;CACzC,OAAO,iBACL,EAAE,SAAS;EAAE,GAAG;EAAS,QAAQ;CAAU,EAAE,GAC7C,MACF,CAAC,CAAC;AACJ;AAsBA,SAAS,UAKP,eACA,SACgB;CAChB,OAAO,cACJ,QAAQ,QAAQ,OAAO,CAAC,CACxB,KACE,aACE,QAAQ,SACL,QAAQ,OAAO,QAAqB,IACpC,SAAS,KACjB;AACJ;AAEA,SAAgB,iBAKd,UAAoD,CAAC,GACrD,aACgB;CAChB,MAAM,gBAAgB,eAAe,WAAW,CAAC,CAAC,iBAAiB;CACnE,MAAM,aAAa,MAAM,OAAO,OAAO;CACvC,MAAM,SAAS,MAAM,OAAuB,IAAI;CAChD,IAAI,OAAO,YAAY,MACrB,OAAO,UAAU,UAAU,eAAe,OAAO;CAGnD,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAED,OAAO,MAAM,qBACX,MAAM,aACH,kBACC,cAAc,gBAAgB;EAC5B,MAAM,aAAa,iBACjB,OAAO,SACP,UAAU,eAAe,WAAW,OAAO,CAC7C;EACA,IAAI,OAAO,YAAY,YAAY;GACjC,OAAO,UAAU;GACjB,cAAc,SAAS,aAAa;EACtC;CACF,CAAC,GACH,CAAC,aAAa,CAChB,SACM,OAAO,eACP,OAAO,OACf;AACF"}
+{"version":3,"file":"useMutationState.js","names":[],"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n  Mutation,\n  MutationCache,\n  MutationFilters,\n  MutationState,\n  QueryClient,\n} from '@tanstack/query-core'\n\n/**\n * The `useIsMutating` hook returns the `number` of mutations that your application currently has `pending`\n * (useful for app-wide loading indicators).\n *\n * @param filters - The {@link MutationFilters} to narrow down the matched mutations.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns Will be the `number` of the mutations that your application currently has `pending`.\n *\n * @example\n * ```tsx\n * import { useIsMutating } from '@tanstack/react-query'\n *\n * function PostsMutatingIndicator() {\n *   // How many mutations matching the posts prefix are in progress?\n *   const isMutatingPosts = useIsMutating({ mutationKey: ['posts'] })\n *\n *   return isMutatingPosts ? <span>Saving posts...</span> : null\n * }\n * ```\n */\nexport function useIsMutating(\n  filters?: MutationFilters,\n  queryClient?: QueryClient,\n): number {\n  const client = useQueryClient(queryClient)\n  return useMutationState(\n    { filters: { ...filters, status: 'pending' } },\n    client,\n  ).length\n}\n\ntype MutationTypeFromResult<TResult> = [TResult] extends [\n  MutationState<\n    infer TData,\n    infer TError,\n    infer TVariables,\n    infer TOnMutateResult\n  >,\n]\n  ? Mutation<TData, TError, TVariables, TOnMutateResult>\n  : Mutation\n\ntype MutationStateOptions<\n  TResult = MutationState,\n  TMutation extends Mutation<any, any, any, any> =\n    MutationTypeFromResult<TResult>,\n> = {\n  filters?: MutationFilters\n  select?: (mutation: TMutation) => TResult\n}\n\nfunction getResult<\n  TResult = MutationState,\n  TMutation extends Mutation<any, any, any, any> =\n    MutationTypeFromResult<TResult>,\n>(\n  mutationCache: MutationCache,\n  options: MutationStateOptions<TResult, TMutation>,\n): Array<TResult> {\n  return mutationCache\n    .findAll(options.filters)\n    .map(\n      (mutation): TResult =>\n        (options.select\n          ? options.select(mutation as TMutation)\n          : mutation.state) as TResult,\n    )\n}\n\n/**\n * `useMutationState` is a hook that gives you access to all mutations in the `MutationCache`. You can pass\n * `filters` ({@link MutationFilters}) to narrow down your mutations, and `select` to transform the mutation\n * state.\n *\n * @param options - The `filters` to narrow down matched mutations, and an optional `select` to transform the\n * mutation state.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns Will be an Array of whatever `select` returns for each matching mutation.\n *\n * @example\n * Get all variables of all running mutations:\n * ```tsx\n * import { useMutationState } from '@tanstack/react-query'\n *\n * function PendingPosts() {\n *   const pendingVariables = useMutationState({\n *     filters: { status: 'pending' },\n *     select: (mutation) => mutation.state.variables,\n *   })\n *\n *   return <>{pendingVariables.length} posts saving...</>\n * }\n * ```\n *\n * @example\n * Get all data for specific mutations via the `mutationKey`:\n * ```tsx\n * import { useMutation, useMutationState } from '@tanstack/react-query'\n *\n * const mutationKey = ['posts']\n *\n * function Posts() {\n *   // Some mutation that we want to get the state for\n *   const mutation = useMutation({\n *     mutationKey,\n *     mutationFn: createPosts,\n *   })\n *\n *   const savedPosts = useMutationState({\n *     // this mutation key needs to match the mutation key of the given mutation (see above)\n *     filters: { mutationKey, status: 'success' },\n *     select: (mutation) => mutation.state.data,\n *   })\n *\n *   return (\n *     <button onClick={() => mutation.mutate(['New Post'])}>\n *       Create post ({savedPosts.length} saved so far)\n *     </button>\n *   )\n * }\n * ```\n *\n * @example\n * Access the latest successful mutation data via the `mutationKey`. Each invocation of `mutate` adds a new\n * entry to the mutation cache for `gcTime` milliseconds — with the `status: 'success'` filter below, check the\n * last item that `useMutationState` returns to get the latest successful invocation:\n * ```tsx\n * import { useMutationState } from '@tanstack/react-query'\n *\n * function LatestPost() {\n *   const savedPosts = useMutationState({\n *     filters: { mutationKey: ['posts'], status: 'success' },\n *     select: (mutation) => mutation.state.data,\n *   })\n *\n *   const latestSavedPost = savedPosts[savedPosts.length - 1]\n *\n *   return <>{latestSavedPost ? 'Saved' : 'Nothing saved yet'}</>\n * }\n * ```\n */\nexport function useMutationState<\n  TResult = MutationState,\n  TMutation extends Mutation<any, any, any, any> =\n    MutationTypeFromResult<TResult>,\n>(\n  options: MutationStateOptions<TResult, TMutation> = {},\n  queryClient?: QueryClient,\n): Array<TResult> {\n  const mutationCache = useQueryClient(queryClient).getMutationCache()\n  const optionsRef = React.useRef(options)\n  const result = React.useRef<Array<TResult>>(null)\n  if (result.current === null) {\n    result.current = getResult(mutationCache, options)\n  }\n\n  React.useEffect(() => {\n    optionsRef.current = options\n  })\n\n  return React.useSyncExternalStore(\n    React.useCallback(\n      (onStoreChange) =>\n        mutationCache.subscribe(() => {\n          const nextResult = replaceEqualDeep(\n            result.current,\n            getResult(mutationCache, optionsRef.current),\n          )\n          if (result.current !== nextResult) {\n            result.current = nextResult\n            notifyManager.schedule(onStoreChange)\n          }\n        }),\n      [mutationCache],\n    ),\n    () => result.current,\n    () => result.current,\n  )!\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAAS,eAAe,WAAW;CACzC,OAAO,iBACL,EAAE,SAAS;EAAE,GAAG;EAAS,QAAQ;CAAU,EAAE,GAC7C,MACF,CAAC,CAAC;AACJ;AAsBA,SAAS,UAKP,eACA,SACgB;CAChB,OAAO,cACJ,QAAQ,QAAQ,OAAO,CAAC,CACxB,KACE,aACE,QAAQ,SACL,QAAQ,OAAO,QAAqB,IACpC,SAAS,KACjB;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,SAAgB,iBAKd,UAAoD,CAAC,GACrD,aACgB;CAChB,MAAM,gBAAgB,eAAe,WAAW,CAAC,CAAC,iBAAiB;CACnE,MAAM,aAAa,MAAM,OAAO,OAAO;CACvC,MAAM,SAAS,MAAM,OAAuB,IAAI;CAChD,IAAI,OAAO,YAAY,MACrB,OAAO,UAAU,UAAU,eAAe,OAAO;CAGnD,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAED,OAAO,MAAM,qBACX,MAAM,aACH,kBACC,cAAc,gBAAgB;EAC5B,MAAM,aAAa,iBACjB,OAAO,SACP,UAAU,eAAe,WAAW,OAAO,CAC7C;EACA,IAAI,OAAO,YAAY,YAAY;GACjC,OAAO,UAAU;GACjB,cAAc,SAAS,aAAa;EACtC;CACF,CAAC,GACH,CAAC,aAAa,CAChB,SACM,OAAO,eACP,OAAO,OACf;AACF"}

package/build/legacy/usePrefetchInfiniteQuery.cjs

@@ -2,6 +2,50 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_QueryClientProvider = require("./QueryClientProvider.cjs");
 let _tanstack_query_core = require("@tanstack/query-core");
 //#region src/usePrefetchInfiniteQuery.tsx
+/**
+* `usePrefetchInfiniteQuery` does not return anything, it should be used just to fire a prefetch during render,
+* before a suspense boundary that wraps a component that uses `useSuspenseInfiniteQuery`. You can pass
+* everything to `usePrefetchInfiniteQuery` that you can pass to `queryClient.infiniteQuery`, though
+* `queryKey`, `initialPageParam`, and `getNextPageParam` are always required, and `queryFn` is required unless
+* a default query function has been defined.
+*
+* `getNextPageParam` receives both the last page of the infinite list of data and the full array of all pages,
+* as well as pageParam information, and should return a single variable that will be passed to your query
+* function as `context.pageParam`. Return `undefined` or `null` to indicate there is no next page available.
+*
+* The prefetch is skipped if the query already has any cached state — including a `pending`/`error` state left
+* over from a previous attempt — so calling this on every render is cheap and won't refetch data that's
+* already there or already in flight.
+*
+* @param options - The {@link UsePrefetchInfiniteQueryOptions} to use — everything you can pass to `queryClient.infiniteQuery`.
+* @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+* be used.
+* @returns `void` — nothing is returned.
+*
+* @example
+* ```tsx
+* import { Suspense } from 'react'
+* import { infiniteQueryOptions, usePrefetchInfiniteQuery } from '@tanstack/react-query'
+*
+* const projectsOptions = infiniteQueryOptions({
+*   queryKey: ['projects'],
+*   queryFn: ({ pageParam }) => fetchProjects(pageParam),
+*   initialPageParam: 0,
+*   getNextPageParam: (lastPage) => lastPage.nextId,
+* })
+*
+* function App() {
+*   // Fire the prefetch during render, before the suspense boundary below.
+*   usePrefetchInfiniteQuery(projectsOptions)
+*
+*   return (
+*     <Suspense fallback={<h1>Loading projects...</h1>}>
+*       <Projects />
+*     </Suspense>
+*   )
+* }
+* ```
+*/
 function usePrefetchInfiniteQuery(options, queryClient) {
 	const client = require_QueryClientProvider.useQueryClient(queryClient);
 	if (!client.getQueryState(options.queryKey)) client.infiniteQuery(options).catch(_tanstack_query_core.noop);

package/build/legacy/usePrefetchInfiniteQuery.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"usePrefetchInfiniteQuery.cjs","names":["useQueryClient","noop"],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type {\n  DefaultError,\n  InfiniteData,\n  QueryClient,\n  QueryKey,\n} from '@tanstack/query-core'\nimport type { UsePrefetchInfiniteQueryOptions } from './types'\n\nexport function usePrefetchInfiniteQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  options: UsePrefetchInfiniteQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  queryClient?: QueryClient,\n): void {\n  const client = useQueryClient(queryClient)\n\n  if (!client.getQueryState(options.queryKey)) {\n    void client.infiniteQuery(options).catch(noop)\n  }\n}\n"],"mappings":";;;;AAWA,SAAgB,yBAOd,SAOA,aACM;CACN,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,cAAc,OAAO,CAAC,CAAC,MAAMC,qBAAAA,IAAI;AAEjD"}
+{"version":3,"file":"usePrefetchInfiniteQuery.cjs","names":["useQueryClient","noop"],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type {\n  DefaultError,\n  InfiniteData,\n  QueryClient,\n  QueryKey,\n} from '@tanstack/query-core'\nimport type { UsePrefetchInfiniteQueryOptions } from './types'\n\n/**\n * `usePrefetchInfiniteQuery` does not return anything, it should be used just to fire a prefetch during render,\n * before a suspense boundary that wraps a component that uses `useSuspenseInfiniteQuery`. You can pass\n * everything to `usePrefetchInfiniteQuery` that you can pass to `queryClient.infiniteQuery`, though\n * `queryKey`, `initialPageParam`, and `getNextPageParam` are always required, and `queryFn` is required unless\n * a default query function has been defined.\n *\n * `getNextPageParam` receives both the last page of the infinite list of data and the full array of all pages,\n * as well as pageParam information, and should return a single variable that will be passed to your query\n * function as `context.pageParam`. Return `undefined` or `null` to indicate there is no next page available.\n *\n * The prefetch is skipped if the query already has any cached state — including a `pending`/`error` state left\n * over from a previous attempt — so calling this on every render is cheap and won't refetch data that's\n * already there or already in flight.\n *\n * @param options - The {@link UsePrefetchInfiniteQueryOptions} to use — everything you can pass to `queryClient.infiniteQuery`.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns `void` — nothing is returned.\n *\n * @example\n * ```tsx\n * import { Suspense } from 'react'\n * import { infiniteQueryOptions, usePrefetchInfiniteQuery } from '@tanstack/react-query'\n *\n * const projectsOptions = infiniteQueryOptions({\n *   queryKey: ['projects'],\n *   queryFn: ({ pageParam }) => fetchProjects(pageParam),\n *   initialPageParam: 0,\n *   getNextPageParam: (lastPage) => lastPage.nextId,\n * })\n *\n * function App() {\n *   // Fire the prefetch during render, before the suspense boundary below.\n *   usePrefetchInfiniteQuery(projectsOptions)\n *\n *   return (\n *     <Suspense fallback={<h1>Loading projects...</h1>}>\n *       <Projects />\n *     </Suspense>\n *   )\n * }\n * ```\n */\nexport function usePrefetchInfiniteQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  options: UsePrefetchInfiniteQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  queryClient?: QueryClient,\n): void {\n  const client = useQueryClient(queryClient)\n\n  if (!client.getQueryState(options.queryKey)) {\n    void client.infiniteQuery(options).catch(noop)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,SAAgB,yBAOd,SAOA,aACM;CACN,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,cAAc,OAAO,CAAC,CAAC,MAAMC,qBAAAA,IAAI;AAEjD"}

package/build/legacy/usePrefetchInfiniteQuery.d.cts

@@ -1,6 +1,50 @@
 import { UsePrefetchInfiniteQueryOptions } from "./types.cjs";
 import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
 //#region src/usePrefetchInfiniteQuery.d.ts
+/**
+ * `usePrefetchInfiniteQuery` does not return anything, it should be used just to fire a prefetch during render,
+ * before a suspense boundary that wraps a component that uses `useSuspenseInfiniteQuery`. You can pass
+ * everything to `usePrefetchInfiniteQuery` that you can pass to `queryClient.infiniteQuery`, though
+ * `queryKey`, `initialPageParam`, and `getNextPageParam` are always required, and `queryFn` is required unless
+ * a default query function has been defined.
+ *
+ * `getNextPageParam` receives both the last page of the infinite list of data and the full array of all pages,
+ * as well as pageParam information, and should return a single variable that will be passed to your query
+ * function as `context.pageParam`. Return `undefined` or `null` to indicate there is no next page available.
+ *
+ * The prefetch is skipped if the query already has any cached state — including a `pending`/`error` state left
+ * over from a previous attempt — so calling this on every render is cheap and won't refetch data that's
+ * already there or already in flight.
+ *
+ * @param options - The {@link UsePrefetchInfiniteQueryOptions} to use — everything you can pass to `queryClient.infiniteQuery`.
+ * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+ * be used.
+ * @returns `void` — nothing is returned.
+ *
+ * @example
+ * ```tsx
+ * import { Suspense } from 'react'
+ * import { infiniteQueryOptions, usePrefetchInfiniteQuery } from '@tanstack/react-query'
+ *
+ * const projectsOptions = infiniteQueryOptions({
+ *   queryKey: ['projects'],
+ *   queryFn: ({ pageParam }) => fetchProjects(pageParam),
+ *   initialPageParam: 0,
+ *   getNextPageParam: (lastPage) => lastPage.nextId,
+ * })
+ *
+ * function App() {
+ *   // Fire the prefetch during render, before the suspense boundary below.
+ *   usePrefetchInfiniteQuery(projectsOptions)
+ *
+ *   return (
+ *     <Suspense fallback={<h1>Loading projects...</h1>}>
+ *       <Projects />
+ *     </Suspense>
+ *   )
+ * }
+ * ```
+ */
 declare function usePrefetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UsePrefetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): void;
 //#endregion
 export { usePrefetchInfiniteQuery };

package/build/legacy/usePrefetchInfiniteQuery.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"usePrefetchInfiniteQuery.d.cts","names":[],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"mappings":";;;iBAWgB,yBACd,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,gCACP,cACA,QACA,OACA,WACA,aAEF,cAAc"}
+{"version":3,"file":"usePrefetchInfiniteQuery.d.cts","names":[],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuDgB,yBACd,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,gCACP,cACA,QACA,OACA,WACA,aAEF,cAAc"}

package/build/legacy/usePrefetchInfiniteQuery.d.ts

@@ -1,6 +1,50 @@
 import { UsePrefetchInfiniteQueryOptions } from "./types.js";
 import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
 //#region src/usePrefetchInfiniteQuery.d.ts
+/**
+ * `usePrefetchInfiniteQuery` does not return anything, it should be used just to fire a prefetch during render,
+ * before a suspense boundary that wraps a component that uses `useSuspenseInfiniteQuery`. You can pass
+ * everything to `usePrefetchInfiniteQuery` that you can pass to `queryClient.infiniteQuery`, though
+ * `queryKey`, `initialPageParam`, and `getNextPageParam` are always required, and `queryFn` is required unless
+ * a default query function has been defined.
+ *
+ * `getNextPageParam` receives both the last page of the infinite list of data and the full array of all pages,
+ * as well as pageParam information, and should return a single variable that will be passed to your query
+ * function as `context.pageParam`. Return `undefined` or `null` to indicate there is no next page available.
+ *
+ * The prefetch is skipped if the query already has any cached state — including a `pending`/`error` state left
+ * over from a previous attempt — so calling this on every render is cheap and won't refetch data that's
+ * already there or already in flight.
+ *
+ * @param options - The {@link UsePrefetchInfiniteQueryOptions} to use — everything you can pass to `queryClient.infiniteQuery`.
+ * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+ * be used.
+ * @returns `void` — nothing is returned.
+ *
+ * @example
+ * ```tsx
+ * import { Suspense } from 'react'
+ * import { infiniteQueryOptions, usePrefetchInfiniteQuery } from '@tanstack/react-query'
+ *
+ * const projectsOptions = infiniteQueryOptions({
+ *   queryKey: ['projects'],
+ *   queryFn: ({ pageParam }) => fetchProjects(pageParam),
+ *   initialPageParam: 0,
+ *   getNextPageParam: (lastPage) => lastPage.nextId,
+ * })
+ *
+ * function App() {
+ *   // Fire the prefetch during render, before the suspense boundary below.
+ *   usePrefetchInfiniteQuery(projectsOptions)
+ *
+ *   return (
+ *     <Suspense fallback={<h1>Loading projects...</h1>}>
+ *       <Projects />
+ *     </Suspense>
+ *   )
+ * }
+ * ```
+ */
 declare function usePrefetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UsePrefetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): void;
 //#endregion
 export { usePrefetchInfiniteQuery };

package/build/legacy/usePrefetchInfiniteQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePrefetchInfiniteQuery.d.ts","names":[],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"mappings":";;;iBAWgB,yBACd,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,gCACP,cACA,QACA,OACA,WACA,aAEF,cAAc"}
+{"version":3,"file":"usePrefetchInfiniteQuery.d.ts","names":[],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuDgB,yBACd,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,gCACP,cACA,QACA,OACA,WACA,aAEF,cAAc"}

package/build/legacy/usePrefetchInfiniteQuery.js

@@ -1,6 +1,50 @@
 import { useQueryClient } from "./QueryClientProvider.js";
 import { noop } from "@tanstack/query-core";
 //#region src/usePrefetchInfiniteQuery.tsx
+/**
+* `usePrefetchInfiniteQuery` does not return anything, it should be used just to fire a prefetch during render,
+* before a suspense boundary that wraps a component that uses `useSuspenseInfiniteQuery`. You can pass
+* everything to `usePrefetchInfiniteQuery` that you can pass to `queryClient.infiniteQuery`, though
+* `queryKey`, `initialPageParam`, and `getNextPageParam` are always required, and `queryFn` is required unless
+* a default query function has been defined.
+*
+* `getNextPageParam` receives both the last page of the infinite list of data and the full array of all pages,
+* as well as pageParam information, and should return a single variable that will be passed to your query
+* function as `context.pageParam`. Return `undefined` or `null` to indicate there is no next page available.
+*
+* The prefetch is skipped if the query already has any cached state — including a `pending`/`error` state left
+* over from a previous attempt — so calling this on every render is cheap and won't refetch data that's
+* already there or already in flight.
+*
+* @param options - The {@link UsePrefetchInfiniteQueryOptions} to use — everything you can pass to `queryClient.infiniteQuery`.
+* @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+* be used.
+* @returns `void` — nothing is returned.
+*
+* @example
+* ```tsx
+* import { Suspense } from 'react'
+* import { infiniteQueryOptions, usePrefetchInfiniteQuery } from '@tanstack/react-query'
+*
+* const projectsOptions = infiniteQueryOptions({
+*   queryKey: ['projects'],
+*   queryFn: ({ pageParam }) => fetchProjects(pageParam),
+*   initialPageParam: 0,
+*   getNextPageParam: (lastPage) => lastPage.nextId,
+* })
+*
+* function App() {
+*   // Fire the prefetch during render, before the suspense boundary below.
+*   usePrefetchInfiniteQuery(projectsOptions)
+*
+*   return (
+*     <Suspense fallback={<h1>Loading projects...</h1>}>
+*       <Projects />
+*     </Suspense>
+*   )
+* }
+* ```
+*/
 function usePrefetchInfiniteQuery(options, queryClient) {
 	const client = useQueryClient(queryClient);
 	if (!client.getQueryState(options.queryKey)) client.infiniteQuery(options).catch(noop);

package/build/legacy/usePrefetchInfiniteQuery.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePrefetchInfiniteQuery.js","names":[],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type {\n  DefaultError,\n  InfiniteData,\n  QueryClient,\n  QueryKey,\n} from '@tanstack/query-core'\nimport type { UsePrefetchInfiniteQueryOptions } from './types'\n\nexport function usePrefetchInfiniteQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  options: UsePrefetchInfiniteQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  queryClient?: QueryClient,\n): void {\n  const client = useQueryClient(queryClient)\n\n  if (!client.getQueryState(options.queryKey)) {\n    void client.infiniteQuery(options).catch(noop)\n  }\n}\n"],"mappings":";;;AAWA,SAAgB,yBAOd,SAOA,aACM;CACN,MAAM,SAAS,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,cAAc,OAAO,CAAC,CAAC,MAAM,IAAI;AAEjD"}
+{"version":3,"file":"usePrefetchInfiniteQuery.js","names":[],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type {\n  DefaultError,\n  InfiniteData,\n  QueryClient,\n  QueryKey,\n} from '@tanstack/query-core'\nimport type { UsePrefetchInfiniteQueryOptions } from './types'\n\n/**\n * `usePrefetchInfiniteQuery` does not return anything, it should be used just to fire a prefetch during render,\n * before a suspense boundary that wraps a component that uses `useSuspenseInfiniteQuery`. You can pass\n * everything to `usePrefetchInfiniteQuery` that you can pass to `queryClient.infiniteQuery`, though\n * `queryKey`, `initialPageParam`, and `getNextPageParam` are always required, and `queryFn` is required unless\n * a default query function has been defined.\n *\n * `getNextPageParam` receives both the last page of the infinite list of data and the full array of all pages,\n * as well as pageParam information, and should return a single variable that will be passed to your query\n * function as `context.pageParam`. Return `undefined` or `null` to indicate there is no next page available.\n *\n * The prefetch is skipped if the query already has any cached state — including a `pending`/`error` state left\n * over from a previous attempt — so calling this on every render is cheap and won't refetch data that's\n * already there or already in flight.\n *\n * @param options - The {@link UsePrefetchInfiniteQueryOptions} to use — everything you can pass to `queryClient.infiniteQuery`.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns `void` — nothing is returned.\n *\n * @example\n * ```tsx\n * import { Suspense } from 'react'\n * import { infiniteQueryOptions, usePrefetchInfiniteQuery } from '@tanstack/react-query'\n *\n * const projectsOptions = infiniteQueryOptions({\n *   queryKey: ['projects'],\n *   queryFn: ({ pageParam }) => fetchProjects(pageParam),\n *   initialPageParam: 0,\n *   getNextPageParam: (lastPage) => lastPage.nextId,\n * })\n *\n * function App() {\n *   // Fire the prefetch during render, before the suspense boundary below.\n *   usePrefetchInfiniteQuery(projectsOptions)\n *\n *   return (\n *     <Suspense fallback={<h1>Loading projects...</h1>}>\n *       <Projects />\n *     </Suspense>\n *   )\n * }\n * ```\n */\nexport function usePrefetchInfiniteQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  options: UsePrefetchInfiniteQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  queryClient?: QueryClient,\n): void {\n  const client = useQueryClient(queryClient)\n\n  if (!client.getQueryState(options.queryKey)) {\n    void client.infiniteQuery(options).catch(noop)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,SAAgB,yBAOd,SAOA,aACM;CACN,MAAM,SAAS,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,cAAc,OAAO,CAAC,CAAC,MAAM,IAAI;AAEjD"}

package/build/legacy/usePrefetchQuery.cjs

@@ -2,6 +2,41 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_QueryClientProvider = require("./QueryClientProvider.cjs");
 let _tanstack_query_core = require("@tanstack/query-core");
 //#region src/usePrefetchQuery.tsx
+/**
+* `usePrefetchQuery` does not return anything, it should be used just to fire a prefetch during render, before
+* a suspense boundary that wraps a component that uses `useSuspenseQuery`. You can pass everything to
+* `usePrefetchQuery` that you can pass to `queryClient.query`, though `queryKey` is always required, and
+* `queryFn` is required unless a default query function has been defined.
+*
+* The prefetch is skipped if the query already has any cached state — including a `pending`/`error` state left
+* over from a previous attempt — so calling this on every render is cheap and won't refetch data that's
+* already there or already in flight.
+*
+* @param options - The {@link UsePrefetchQueryOptions} to use — everything you can pass to `queryClient.query`.
+* @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+* be used.
+* @returns `void` — nothing is returned.
+*
+* @example
+* ```tsx
+* import { Suspense } from 'react'
+* import { usePrefetchQuery } from '@tanstack/react-query'
+*
+* function App() {
+*   // Fire the prefetch during render, before the suspense boundary below.
+*   usePrefetchQuery({
+*     queryKey: ['posts'],
+*     queryFn: fetchPosts,
+*   })
+*
+*   return (
+*     <Suspense fallback={<h1>Loading posts...</h1>}>
+*       <Posts />
+*     </Suspense>
+*   )
+* }
+* ```
+*/
 function usePrefetchQuery(options, queryClient) {
 	const client = require_QueryClientProvider.useQueryClient(queryClient);
 	if (!client.getQueryState(options.queryKey)) client.query(options).catch(_tanstack_query_core.noop);

package/build/legacy/usePrefetchQuery.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"usePrefetchQuery.cjs","names":["useQueryClient","noop"],"sources":["../../src/usePrefetchQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { UsePrefetchQueryOptions } from './types'\n\nexport function usePrefetchQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: UsePrefetchQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  queryClient?: QueryClient,\n): void {\n  const client = useQueryClient(queryClient)\n\n  if (!client.getQueryState(options.queryKey)) {\n    void client.query(options).catch(noop)\n  }\n}\n"],"mappings":";;;;AAMA,SAAgB,iBAOd,SAOA,aACM;CACN,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,MAAM,OAAO,CAAC,CAAC,MAAMC,qBAAAA,IAAI;AAEzC"}
+{"version":3,"file":"usePrefetchQuery.cjs","names":["useQueryClient","noop"],"sources":["../../src/usePrefetchQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { UsePrefetchQueryOptions } from './types'\n\n/**\n * `usePrefetchQuery` does not return anything, it should be used just to fire a prefetch during render, before\n * a suspense boundary that wraps a component that uses `useSuspenseQuery`. You can pass everything to\n * `usePrefetchQuery` that you can pass to `queryClient.query`, though `queryKey` is always required, and\n * `queryFn` is required unless a default query function has been defined.\n *\n * The prefetch is skipped if the query already has any cached state — including a `pending`/`error` state left\n * over from a previous attempt — so calling this on every render is cheap and won't refetch data that's\n * already there or already in flight.\n *\n * @param options - The {@link UsePrefetchQueryOptions} to use — everything you can pass to `queryClient.query`.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns `void` — nothing is returned.\n *\n * @example\n * ```tsx\n * import { Suspense } from 'react'\n * import { usePrefetchQuery } from '@tanstack/react-query'\n *\n * function App() {\n *   // Fire the prefetch during render, before the suspense boundary below.\n *   usePrefetchQuery({\n *     queryKey: ['posts'],\n *     queryFn: fetchPosts,\n *   })\n *\n *   return (\n *     <Suspense fallback={<h1>Loading posts...</h1>}>\n *       <Posts />\n *     </Suspense>\n *   )\n * }\n * ```\n */\nexport function usePrefetchQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: UsePrefetchQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  queryClient?: QueryClient,\n): void {\n  const client = useQueryClient(queryClient)\n\n  if (!client.getQueryState(options.queryKey)) {\n    void client.query(options).catch(noop)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,iBAOd,SAOA,aACM;CACN,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,MAAM,OAAO,CAAC,CAAC,MAAMC,qBAAAA,IAAI;AAEzC"}

package/build/legacy/usePrefetchQuery.d.cts

@@ -1,6 +1,41 @@
 import { UsePrefetchQueryOptions } from "./types.cjs";
 import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
 //#region src/usePrefetchQuery.d.ts
+/**
+ * `usePrefetchQuery` does not return anything, it should be used just to fire a prefetch during render, before
+ * a suspense boundary that wraps a component that uses `useSuspenseQuery`. You can pass everything to
+ * `usePrefetchQuery` that you can pass to `queryClient.query`, though `queryKey` is always required, and
+ * `queryFn` is required unless a default query function has been defined.
+ *
+ * The prefetch is skipped if the query already has any cached state — including a `pending`/`error` state left
+ * over from a previous attempt — so calling this on every render is cheap and won't refetch data that's
+ * already there or already in flight.
+ *
+ * @param options - The {@link UsePrefetchQueryOptions} to use — everything you can pass to `queryClient.query`.
+ * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+ * be used.
+ * @returns `void` — nothing is returned.
+ *
+ * @example
+ * ```tsx
+ * import { Suspense } from 'react'
+ * import { usePrefetchQuery } from '@tanstack/react-query'
+ *
+ * function App() {
+ *   // Fire the prefetch during render, before the suspense boundary below.
+ *   usePrefetchQuery({
+ *     queryKey: ['posts'],
+ *     queryFn: fetchPosts,
+ *   })
+ *
+ *   return (
+ *     <Suspense fallback={<h1>Loading posts...</h1>}>
+ *       <Posts />
+ *     </Suspense>
+ *   )
+ * }
+ * ```
+ */
 declare function usePrefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, queryClient?: QueryClient): void;
 //#endregion
 export { usePrefetchQuery };

package/build/legacy/usePrefetchQuery.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"usePrefetchQuery.d.cts","names":[],"sources":["../../src/usePrefetchQuery.tsx"],"mappings":";;;iBAMgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,UAE7B,SAAS,wBACP,cACA,QACA,OACA,YACA,YAEF,cAAc"}
+{"version":3,"file":"usePrefetchQuery.d.cts","names":[],"sources":["../../src/usePrefetchQuery.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,UAE7B,SAAS,wBACP,cACA,QACA,OACA,YACA,YAEF,cAAc"}

package/build/legacy/usePrefetchQuery.d.ts

@@ -1,6 +1,41 @@
 import { UsePrefetchQueryOptions } from "./types.js";
 import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
 //#region src/usePrefetchQuery.d.ts
+/**
+ * `usePrefetchQuery` does not return anything, it should be used just to fire a prefetch during render, before
+ * a suspense boundary that wraps a component that uses `useSuspenseQuery`. You can pass everything to
+ * `usePrefetchQuery` that you can pass to `queryClient.query`, though `queryKey` is always required, and
+ * `queryFn` is required unless a default query function has been defined.
+ *
+ * The prefetch is skipped if the query already has any cached state — including a `pending`/`error` state left
+ * over from a previous attempt — so calling this on every render is cheap and won't refetch data that's
+ * already there or already in flight.
+ *
+ * @param options - The {@link UsePrefetchQueryOptions} to use — everything you can pass to `queryClient.query`.
+ * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+ * be used.
+ * @returns `void` — nothing is returned.
+ *
+ * @example
+ * ```tsx
+ * import { Suspense } from 'react'
+ * import { usePrefetchQuery } from '@tanstack/react-query'
+ *
+ * function App() {
+ *   // Fire the prefetch during render, before the suspense boundary below.
+ *   usePrefetchQuery({
+ *     queryKey: ['posts'],
+ *     queryFn: fetchPosts,
+ *   })
+ *
+ *   return (
+ *     <Suspense fallback={<h1>Loading posts...</h1>}>
+ *       <Posts />
+ *     </Suspense>
+ *   )
+ * }
+ * ```
+ */
 declare function usePrefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, queryClient?: QueryClient): void;
 //#endregion
 export { usePrefetchQuery };

package/build/legacy/usePrefetchQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePrefetchQuery.d.ts","names":[],"sources":["../../src/usePrefetchQuery.tsx"],"mappings":";;;iBAMgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,UAE7B,SAAS,wBACP,cACA,QACA,OACA,YACA,YAEF,cAAc"}
+{"version":3,"file":"usePrefetchQuery.d.ts","names":[],"sources":["../../src/usePrefetchQuery.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,UAE7B,SAAS,wBACP,cACA,QACA,OACA,YACA,YAEF,cAAc"}

package/build/legacy/usePrefetchQuery.js

@@ -1,6 +1,41 @@
 import { useQueryClient } from "./QueryClientProvider.js";
 import { noop } from "@tanstack/query-core";
 //#region src/usePrefetchQuery.tsx
+/**
+* `usePrefetchQuery` does not return anything, it should be used just to fire a prefetch during render, before
+* a suspense boundary that wraps a component that uses `useSuspenseQuery`. You can pass everything to
+* `usePrefetchQuery` that you can pass to `queryClient.query`, though `queryKey` is always required, and
+* `queryFn` is required unless a default query function has been defined.
+*
+* The prefetch is skipped if the query already has any cached state — including a `pending`/`error` state left
+* over from a previous attempt — so calling this on every render is cheap and won't refetch data that's
+* already there or already in flight.
+*
+* @param options - The {@link UsePrefetchQueryOptions} to use — everything you can pass to `queryClient.query`.
+* @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+* be used.
+* @returns `void` — nothing is returned.
+*
+* @example
+* ```tsx
+* import { Suspense } from 'react'
+* import { usePrefetchQuery } from '@tanstack/react-query'
+*
+* function App() {
+*   // Fire the prefetch during render, before the suspense boundary below.
+*   usePrefetchQuery({
+*     queryKey: ['posts'],
+*     queryFn: fetchPosts,
+*   })
+*
+*   return (
+*     <Suspense fallback={<h1>Loading posts...</h1>}>
+*       <Posts />
+*     </Suspense>
+*   )
+* }
+* ```
+*/
 function usePrefetchQuery(options, queryClient) {
 	const client = useQueryClient(queryClient);
 	if (!client.getQueryState(options.queryKey)) client.query(options).catch(noop);

package/build/legacy/usePrefetchQuery.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePrefetchQuery.js","names":[],"sources":["../../src/usePrefetchQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { UsePrefetchQueryOptions } from './types'\n\nexport function usePrefetchQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: UsePrefetchQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  queryClient?: QueryClient,\n): void {\n  const client = useQueryClient(queryClient)\n\n  if (!client.getQueryState(options.queryKey)) {\n    void client.query(options).catch(noop)\n  }\n}\n"],"mappings":";;;AAMA,SAAgB,iBAOd,SAOA,aACM;CACN,MAAM,SAAS,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,MAAM,OAAO,CAAC,CAAC,MAAM,IAAI;AAEzC"}
+{"version":3,"file":"usePrefetchQuery.js","names":[],"sources":["../../src/usePrefetchQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { UsePrefetchQueryOptions } from './types'\n\n/**\n * `usePrefetchQuery` does not return anything, it should be used just to fire a prefetch during render, before\n * a suspense boundary that wraps a component that uses `useSuspenseQuery`. You can pass everything to\n * `usePrefetchQuery` that you can pass to `queryClient.query`, though `queryKey` is always required, and\n * `queryFn` is required unless a default query function has been defined.\n *\n * The prefetch is skipped if the query already has any cached state — including a `pending`/`error` state left\n * over from a previous attempt — so calling this on every render is cheap and won't refetch data that's\n * already there or already in flight.\n *\n * @param options - The {@link UsePrefetchQueryOptions} to use — everything you can pass to `queryClient.query`.\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns `void` — nothing is returned.\n *\n * @example\n * ```tsx\n * import { Suspense } from 'react'\n * import { usePrefetchQuery } from '@tanstack/react-query'\n *\n * function App() {\n *   // Fire the prefetch during render, before the suspense boundary below.\n *   usePrefetchQuery({\n *     queryKey: ['posts'],\n *     queryFn: fetchPosts,\n *   })\n *\n *   return (\n *     <Suspense fallback={<h1>Loading posts...</h1>}>\n *       <Posts />\n *     </Suspense>\n *   )\n * }\n * ```\n */\nexport function usePrefetchQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: UsePrefetchQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  queryClient?: QueryClient,\n): void {\n  const client = useQueryClient(queryClient)\n\n  if (!client.getQueryState(options.queryKey)) {\n    void client.query(options).catch(noop)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,iBAOd,SAOA,aACM;CACN,MAAM,SAAS,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,MAAM,OAAO,CAAC,CAAC,MAAM,IAAI;AAEzC"}

package/build/legacy/useQueries.cjs

@@ -10,6 +10,136 @@ let react = require("react");
 react = require_rolldown_runtime.__toESM(react, 1);
 let _tanstack_query_core = require("@tanstack/query-core");
 //#region src/useQueries.ts
+/**
+* The `useQueries` hook can be used to fetch a variable number of queries.
+*
+* The `queries` key accepts an array with query option objects mostly identical to `useQuery` — the top-level
+* `subscribed` option isn't accepted per query (see `placeholderData` below for another difference). A custom
+* `QueryClient` is supplied once, as `useQueries`' own top-level second argument, rather than per query.
+*
+* Having the same query key more than once in the array of query objects may cause some data to be shared
+* between queries. To avoid this, consider de-duplicating the queries and map the results back to the desired
+* structure.
+*
+* The `combine` option can be used to combine the results of the queries into a single value. The result will
+* be structurally shared to be as referentially stable as possible.
+*
+* @remarks The `combine` function only re-runs if it changed referentially, or if any of the query results
+* changed. An inlined `combine` function, as shown in the example below, therefore runs on every render — wrap
+* it in `useCallback`, or extract it to a stable function reference if it doesn't have any dependencies, to
+* avoid that.
+*
+* Unlike `useQuery`, `useQueries` cannot infer the `data` argument of an _inline_ `select` from its sibling
+* `queryFn`. Because `useQueries` infers the type of the whole `queries` array at once, the `select` parameter
+* of a query object written inline cannot be contextually typed from that same object's `queryFn`, so it falls
+* back to `unknown` — a [known TypeScript limitation](https://github.com/TanStack/query/issues/6556). Annotate
+* the `select` parameter explicitly, or define the query with {@link queryOptions}, which resolves its types in
+* a single object _before_ it reaches `useQueries`, to work around this — see the example below. The same
+* limitation applies to {@link useSuspenseQueries}.
+*
+* `placeholderData` is supported here too, but unlike `useQuery`, it doesn't receive information from
+* previously rendered queries, because the number of queries can differ between renders.
+* @param queryClient - Use this to provide a custom `QueryClient`. Otherwise, the one from the nearest context
+* will be used.
+* @returns The combined result. Without `combine`, this is an array with all the query results, in the same
+* order as the input. When `combine` is provided, this is the value returned by `combine` instead.
+*
+* @example
+* ```tsx
+* import { useQueries } from '@tanstack/react-query'
+*
+* function Posts({ ids }: { ids: Array<number> }) {
+*   const postQueries = useQueries({
+*     queries: ids.map((id) => ({
+*       queryKey: ['post', id],
+*       queryFn: () => fetchPost(id),
+*       staleTime: Infinity,
+*     })),
+*   })
+*
+*   return (
+*     <ul>
+*       {postQueries.map((query, index) => {
+*         if (query.isPending) return <li key={ids[index]}>Loading...</li>
+*         if (query.isError) return <li key={ids[index]}>Error: {query.error.message}</li>
+*         return <li key={ids[index]}>{query.data.title}</li>
+*       })}
+*     </ul>
+*   )
+* }
+* ```
+*
+* @example
+* Combining results into a single value:
+* ```tsx
+* import { useQueries } from '@tanstack/react-query'
+*
+* function Posts({ ids }: { ids: Array<number> }) {
+*   const { data, isPending, isError } = useQueries({
+*     queries: ids.map((id) => ({
+*       queryKey: ['post', id],
+*       queryFn: () => fetchPost(id),
+*     })),
+*     combine: (postQueries) => {
+*       return {
+*         data: postQueries.map((query) => query.data),
+*         isPending: postQueries.some((query) => query.isPending),
+*         isError: postQueries.some((query) => query.isError),
+*       }
+*     },
+*   })
+*
+*   if (isPending) return 'Loading...'
+*   if (isError) return 'Error loading posts'
+*
+*   return (
+*     <ul>
+*       {data.map((post) => (
+*         <li key={post?.id}>{post?.title}</li>
+*       ))}
+*     </ul>
+*   )
+* }
+* ```
+*
+* @example
+* Typing `select` via {@link queryOptions}. Note that spreading a `queryOptions` result and overriding
+* `select` inline still falls back to `unknown` — wrap the spread in `queryOptions` again so the override is
+* resolved before it reaches `useQueries`:
+* ```tsx
+* import { queryOptions, useQueries } from '@tanstack/react-query'
+*
+* const postOptions = (id: number) =>
+*   queryOptions({
+*     queryKey: ['post', id],
+*     queryFn: () => fetchPost(id),
+*   })
+*
+* function PostTitle({ id }: { id: number }) {
+*   const [{ data: broken }] = useQueries({
+*     queries: [
+*       {
+*         ...postOptions(id),
+*         // ❌ `data` is `unknown` here
+*         select: (data) => data.title,
+*       },
+*     ],
+*   })
+*
+*   const [{ data: fixed }] = useQueries({
+*     queries: [
+*       queryOptions({
+*         ...postOptions(id),
+*         // ✅ `data` is `Post`
+*         select: (data) => data.title,
+*       }),
+*     ],
+*   })
+*
+*   return <h1>{fixed}</h1>
+* }
+* ```
+*/
 function useQueries({ queries, ...options }, queryClient) {
 	const client = require_QueryClientProvider.useQueryClient(queryClient);
 	const isRestoring = require_IsRestoringProvider.useIsRestoring();