@tanstack/preact-query 5.103.1 → 5.103.3

package/build/modern/useSuspenseQueries.js.map

@@ -1 +1 @@
-{"version":3,"file":"useSuspenseQueries.js","names":[],"sources":["../../src/useSuspenseQueries.ts"],"sourcesContent":["import { skipToken } from '@tanstack/query-core'\nimport type {\n  DefaultError,\n  QueryClient,\n  QueryFunction,\n  ThrowOnError,\n} from '@tanstack/query-core'\n\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport { useQueries } from './useQueries'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions<T> =\n  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n  T extends {\n    queryFnData: infer TQueryFnData\n    error?: infer TError\n    data: infer TData\n  }\n    ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseSuspenseQueryOptions<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseSuspenseQueryOptions<unknown, TError, TData>\n        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n          T extends [infer TQueryFnData, infer TError, infer TData]\n          ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseSuspenseQueryOptions<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseSuspenseQueryOptions<TQueryFnData>\n              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? UseSuspenseQueryOptions<\n                    TQueryFnData,\n                    TError,\n                    TData,\n                    TQueryKey\n                  >\n                : T extends {\n                      queryFn?:\n                        | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                        | SkipTokenForUseQueries\n                      throwOnError?: ThrowOnError<any, infer TError, any, any>\n                    }\n                  ? UseSuspenseQueryOptions<\n                      TQueryFnData,\n                      TError,\n                      TQueryFnData,\n                      TQueryKey\n                    >\n                  : // Fallback\n                    UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult<T> =\n  // Part 1: responsible for mapping explicit type parameter to function result, if object\n  T extends { queryFnData: any; error?: infer TError; data: infer TData }\n    ? UseSuspenseQueryResult<TData, TError>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseSuspenseQueryResult<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseSuspenseQueryResult<TData, TError>\n        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n          T extends [any, infer TError, infer TData]\n          ? UseSuspenseQueryResult<TData, TError>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseSuspenseQueryResult<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseSuspenseQueryResult<TQueryFnData>\n              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, any>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? UseSuspenseQueryResult<\n                    unknown extends TData ? TQueryFnData : TData,\n                    unknown extends TError ? DefaultError : TError\n                  >\n                : T extends {\n                      queryFn?:\n                        | QueryFunction<infer TQueryFnData, any>\n                        | SkipTokenForUseQueries\n                      throwOnError?: ThrowOnError<any, infer TError, any, any>\n                    }\n                  ? UseSuspenseQueryResult<\n                      TQueryFnData,\n                      unknown extends TError ? DefaultError : TError\n                    >\n                  : // Fallback\n                    UseSuspenseQueryResult\n\n/**\n * The `queries` array accepted by `useSuspenseQueries`. Recursively unwraps each tuple element so every\n * entry's `queryFn`/`select` are inferred individually, up to 20 elements. An opaque array (e.g. `unknown[]`)\n * is returned as-is; a non-tuple array of a known element type, or a tuple past 20 elements, falls back to a\n * single homogeneous {@link UseSuspenseQueryOptions} type.\n *\n * @template T - The type of the `queries` array as written at the call site.\n * @template TResults - The internal accumulator that this type builds during recursion. It is not meant\n * to be set explicitly.\n * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not\n * meant to be set explicitly.\n */\nexport type SuspenseQueriesOptions<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseSuspenseQueryOptions>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseSuspenseQueryOptions<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? SuspenseQueriesOptions<\n            [...Tails],\n            [...TResults, GetUseSuspenseQueryOptions<Head>],\n            [...TDepth, 1]\n          >\n        : Array<unknown> extends T\n          ? T\n          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n            // use this to infer the param types in the case of Array.map() argument\n            T extends Array<\n                UseSuspenseQueryOptions<\n                  infer TQueryFnData,\n                  infer TError,\n                  infer TData,\n                  infer TQueryKey\n                >\n              >\n            ? Array<\n                UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>\n              >\n            : // Fallback\n              Array<UseSuspenseQueryOptions>\n\n/**\n * The result type returned by `useSuspenseQueries`, when no `combine` is provided. Mirrors\n * {@link SuspenseQueriesOptions}: each tuple element's result type is inferred individually, up to 20 elements.\n * A non-tuple array is mapped per-element instead, still inferring each entry individually; only past 20\n * elements does this fall back to a single homogeneous {@link UseSuspenseQueryResult} type.\n *\n * @template T - The type of the `queries` array, as inferred by {@link SuspenseQueriesOptions}.\n * @template TResults - The internal accumulator that this type builds during recursion. It is not meant\n * to be set explicitly.\n * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not\n * meant to be set explicitly.\n */\nexport type SuspenseQueriesResults<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseSuspenseQueryResult>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseSuspenseQueryResult<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? SuspenseQueriesResults<\n            [...Tails],\n            [...TResults, GetUseSuspenseQueryResult<Head>],\n            [...TDepth, 1]\n          >\n        : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]> }\n\n/**\n * The options for `useSuspenseQueries` are the same as for `useQueries`, except that the top-level `subscribed`\n * option isn't supported, and each `query` can't have `throwOnError`, `enabled`, or `placeholderData`.\n *\n * @param options - The `queries` array to run in Suspense, and an optional `combine` function.\n * @param queryClient - Use this to provide a custom `QueryClient`. Otherwise, the one from the nearest context\n * will be used.\n * @returns The same structure as `useQueries`, except that for each `query`, `data` is guaranteed to be\n * defined, `isPlaceholderData` is missing, and `status` is either `success` or `error` (with the derived\n * flags set accordingly).\n *\n * Caveat: the component will only re-mount after all queries have finished loading. Hence, if a query has gone\n * stale in the time it took for all the queries to complete, it will be fetched again at re-mount. To avoid\n * this, make sure to set a high enough `staleTime`. Cancellation does not work.\n *\n * @example\n * The query error is thrown if a fetch fails and no cached data exists yet, so an error boundary is\n * required around `<Suspense>`. A failed background refetch instead continues to render the cached data.\n * Use {@link QueryErrorResetBoundary} to let the user retry after such an error:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n *   QueryErrorResetBoundary,\n *   useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Posts({ ids }: { ids: Array<number> }) {\n *   // Every result is guaranteed to be defined — no per-query `isPending` check needed.\n *   const postQueries = useSuspenseQueries({\n *     queries: ids.map((id) => ({\n *       queryKey: ['post', id],\n *       queryFn: () => fetchPost(id),\n *     })),\n *   })\n *\n *   return (\n *     <ul>\n *       {postQueries.map((query) => (\n *         <li key={query.data.id}>{query.data.title}</li>\n *       ))}\n *     </ul>\n *   )\n * }\n *\n * function App() {\n *   return (\n *     <QueryErrorResetBoundary>\n *       {({ reset }) => (\n *         <ErrorBoundary\n *           onReset={reset}\n *           fallbackRender={({ resetErrorBoundary }) => (\n *             <div>\n *               There was an error!\n *               <button onClick={() => resetErrorBoundary()}>Try again</button>\n *             </div>\n *           )}\n *         >\n *           <Suspense fallback={<h1>Loading posts...</h1>}>\n *             <Posts ids={[1, 2, 3]} />\n *           </Suspense>\n *         </ErrorBoundary>\n *       )}\n *     </QueryErrorResetBoundary>\n *   )\n * }\n *\n * function ErrorBoundary({\n *   children,\n *   onReset,\n *   fallbackRender,\n * }: {\n *   children: ComponentChildren\n *   onReset: () => void\n *   fallbackRender: (props: {\n *     error: Error\n *     resetErrorBoundary: () => void\n *   }) => ComponentChildren\n * }) {\n *   const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n *   if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n *   return children\n * }\n * ```\n *\n * @example\n * Several different queries — use `useSuspenseQueries` instead of multiple `useSuspenseQuery` calls, so\n * they fetch in parallel rather than suspending one after another:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n *   QueryErrorResetBoundary,\n *   useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Dashboard() {\n *   const [usersQuery, teamsQuery, projectsQuery] = useSuspenseQueries({\n *     queries: [\n *       { queryKey: ['users'], queryFn: fetchUsers },\n *       { queryKey: ['teams'], queryFn: fetchTeams },\n *       { queryKey: ['projects'], queryFn: fetchProjects },\n *     ],\n *   })\n *\n *   return (\n *     <div>\n *       <UserList users={usersQuery.data} />\n *       <TeamList teams={teamsQuery.data} />\n *       <ProjectList projects={projectsQuery.data} />\n *     </div>\n *   )\n * }\n *\n * function App() {\n *   return (\n *     <QueryErrorResetBoundary>\n *       {({ reset }) => (\n *         <ErrorBoundary\n *           onReset={reset}\n *           fallbackRender={({ resetErrorBoundary }) => (\n *             <div>\n *               There was an error!\n *               <button onClick={() => resetErrorBoundary()}>Try again</button>\n *             </div>\n *           )}\n *         >\n *           <Suspense fallback={<h1>Loading dashboard...</h1>}>\n *             <Dashboard />\n *           </Suspense>\n *         </ErrorBoundary>\n *       )}\n *     </QueryErrorResetBoundary>\n *   )\n * }\n *\n * function ErrorBoundary({\n *   children,\n *   onReset,\n *   fallbackRender,\n * }: {\n *   children: ComponentChildren\n *   onReset: () => void\n *   fallbackRender: (props: {\n *     error: Error\n *     resetErrorBoundary: () => void\n *   }) => ComponentChildren\n * }) {\n *   const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n *   if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n *   return children\n * }\n * ```\n *\n * @example\n * `combine`s the results into a single boolean, so `Refresh` only re-renders when that boolean changes,\n * not on every individual query update. This overload is the only one that accepts `combine`:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n *   QueryErrorResetBoundary,\n *   useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Refresh() {\n *   const anyFetching = useSuspenseQueries({\n *     queries: [\n *       { queryKey: ['users'], queryFn: fetchUsers },\n *       { queryKey: ['teams'], queryFn: fetchTeams },\n *     ],\n *     combine: (results) => results.some((result) => result.isFetching),\n *   })\n *\n *   return anyFetching ? <span>Refreshing…</span> : null\n * }\n *\n * function App() {\n *   return (\n *     <QueryErrorResetBoundary>\n *       {({ reset }) => (\n *         <ErrorBoundary\n *           onReset={reset}\n *           fallbackRender={({ resetErrorBoundary }) => (\n *             <div>\n *               There was an error!\n *               <button onClick={() => resetErrorBoundary()}>Try again</button>\n *             </div>\n *           )}\n *         >\n *           <Suspense fallback={<h1>Loading dashboard...</h1>}>\n *             <Refresh />\n *           </Suspense>\n *         </ErrorBoundary>\n *       )}\n *     </QueryErrorResetBoundary>\n *   )\n * }\n *\n * function ErrorBoundary({\n *   children,\n *   onReset,\n *   fallbackRender,\n * }: {\n *   children: ComponentChildren\n *   onReset: () => void\n *   fallbackRender: (props: {\n *     error: Error\n *     resetErrorBoundary: () => void\n *   }) => ComponentChildren\n * }) {\n *   const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n *   if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n *   return children\n * }\n * ```\n */\nexport function useSuspenseQueries<\n  T extends Array<any>,\n  TCombinedResult = SuspenseQueriesResults<T>,\n>(\n  options: {\n    /**\n     * An array with query option objects identical to `useSuspenseQuery`.\n     */\n    queries:\n      | readonly [...SuspenseQueriesOptions<T>]\n      | readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]> }]\n    /**\n     * Use this to combine the results of the queries into a single value. The result will be structurally\n     * shared to be as referentially stable as possible.\n     */\n    combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n  },\n  queryClient?: QueryClient,\n): TCombinedResult\n\n/**\n * The options for `useSuspenseQueries` are the same as for `useQueries`, except that the top-level `subscribed`\n * option isn't supported, and each `query` can't have `throwOnError`, `enabled`, or `placeholderData`.\n *\n * @param options - The `queries` array to run in Suspense, and an optional `combine` function.\n * @param queryClient - Use this to provide a custom `QueryClient`. Otherwise, the one from the nearest context\n * will be used.\n * @returns The same structure as `useQueries`, except that for each `query`, `data` is guaranteed to be\n * defined, `isPlaceholderData` is missing, and `status` is either `success` or `error` (with the derived\n * flags set accordingly).\n *\n * Caveat: the component will only re-mount after all queries have finished loading. Hence, if a query has gone\n * stale in the time it took for all the queries to complete, it will be fetched again at re-mount. To avoid\n * this, make sure to set a high enough `staleTime`. Cancellation does not work.\n *\n * @example\n * The query error is thrown if a fetch fails and no cached data exists yet, so an error boundary is\n * required around `<Suspense>`. A failed background refetch instead continues to render the cached data.\n * Use {@link QueryErrorResetBoundary} to let the user retry after such an error:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n *   QueryErrorResetBoundary,\n *   useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Posts({ ids }: { ids: Array<number> }) {\n *   // Every result is guaranteed to be defined — no per-query `isPending` check needed.\n *   const postQueries = useSuspenseQueries({\n *     queries: ids.map((id) => ({\n *       queryKey: ['post', id],\n *       queryFn: () => fetchPost(id),\n *     })),\n *   })\n *\n *   return (\n *     <ul>\n *       {postQueries.map((query) => (\n *         <li key={query.data.id}>{query.data.title}</li>\n *       ))}\n *     </ul>\n *   )\n * }\n *\n * function App() {\n *   return (\n *     <QueryErrorResetBoundary>\n *       {({ reset }) => (\n *         <ErrorBoundary\n *           onReset={reset}\n *           fallbackRender={({ resetErrorBoundary }) => (\n *             <div>\n *               There was an error!\n *               <button onClick={() => resetErrorBoundary()}>Try again</button>\n *             </div>\n *           )}\n *         >\n *           <Suspense fallback={<h1>Loading posts...</h1>}>\n *             <Posts ids={[1, 2, 3]} />\n *           </Suspense>\n *         </ErrorBoundary>\n *       )}\n *     </QueryErrorResetBoundary>\n *   )\n * }\n *\n * function ErrorBoundary({\n *   children,\n *   onReset,\n *   fallbackRender,\n * }: {\n *   children: ComponentChildren\n *   onReset: () => void\n *   fallbackRender: (props: {\n *     error: Error\n *     resetErrorBoundary: () => void\n *   }) => ComponentChildren\n * }) {\n *   const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n *   if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n *   return children\n * }\n * ```\n *\n * @example\n * Several different queries — use `useSuspenseQueries` instead of multiple `useSuspenseQuery` calls, so\n * they fetch in parallel rather than suspending one after another:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n *   QueryErrorResetBoundary,\n *   useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Dashboard() {\n *   const [usersQuery, teamsQuery, projectsQuery] = useSuspenseQueries({\n *     queries: [\n *       { queryKey: ['users'], queryFn: fetchUsers },\n *       { queryKey: ['teams'], queryFn: fetchTeams },\n *       { queryKey: ['projects'], queryFn: fetchProjects },\n *     ],\n *   })\n *\n *   return (\n *     <div>\n *       <UserList users={usersQuery.data} />\n *       <TeamList teams={teamsQuery.data} />\n *       <ProjectList projects={projectsQuery.data} />\n *     </div>\n *   )\n * }\n *\n * function App() {\n *   return (\n *     <QueryErrorResetBoundary>\n *       {({ reset }) => (\n *         <ErrorBoundary\n *           onReset={reset}\n *           fallbackRender={({ resetErrorBoundary }) => (\n *             <div>\n *               There was an error!\n *               <button onClick={() => resetErrorBoundary()}>Try again</button>\n *             </div>\n *           )}\n *         >\n *           <Suspense fallback={<h1>Loading dashboard...</h1>}>\n *             <Dashboard />\n *           </Suspense>\n *         </ErrorBoundary>\n *       )}\n *     </QueryErrorResetBoundary>\n *   )\n * }\n *\n * function ErrorBoundary({\n *   children,\n *   onReset,\n *   fallbackRender,\n * }: {\n *   children: ComponentChildren\n *   onReset: () => void\n *   fallbackRender: (props: {\n *     error: Error\n *     resetErrorBoundary: () => void\n *   }) => ComponentChildren\n * }) {\n *   const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n *   if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n *   return children\n * }\n * ```\n */\nexport function useSuspenseQueries<\n  T extends Array<any>,\n  TCombinedResult = SuspenseQueriesResults<T>,\n>(\n  options: {\n    /**\n     * An array with query option objects identical to `useSuspenseQuery`.\n     */\n    queries: readonly [...SuspenseQueriesOptions<T>]\n    /**\n     * Use this to combine the results of the queries into a single value. The result will be structurally\n     * shared to be as referentially stable as possible.\n     */\n    combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n  },\n  queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n  return useQueries(\n    {\n      ...options,\n      queries: options.queries.map((query: any) => {\n        if (process.env.NODE_ENV !== 'production') {\n          if (query.queryFn === skipToken) {\n            console.error('skipToken is not allowed for useSuspenseQueries')\n          }\n        }\n\n        return {\n          ...query,\n          suspense: true,\n          throwOnError: defaultThrowOnError,\n          enabled: true,\n          placeholderData: undefined,\n        }\n      }),\n    },\n    queryClient,\n  )\n}\n"],"mappings":";;;;AA8lBA,SAAgB,mBAAmB,SAAc,aAA2B;CAC1E,OAAO,WACL;EACE,GAAG;EACH,SAAS,QAAQ,QAAQ,KAAK,UAAe;GAC3C,IAAI,QAAQ,IAAI,aAAa,cACvB;QAAA,MAAM,YAAY,WACpB,QAAQ,MAAM,iDAAiD;GAAA;GAInE,OAAO;IACL,GAAG;IACH,UAAU;IACV,cAAc;IACd,SAAS;IACT,iBAAiB,KAAA;GACnB;EACF,CAAC;CACH,GACA,WACF;AACF"}
+{"version":3,"file":"useSuspenseQueries.js","names":[],"sources":["../../src/useSuspenseQueries.ts"],"sourcesContent":["import { skipToken } from '@tanstack/query-core'\nimport type {\n  DefaultError,\n  QueryClient,\n  QueryFunction,\n  ThrowOnError,\n} from '@tanstack/query-core'\n\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport { useQueries } from './useQueries'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions<T> =\n  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n  T extends {\n    queryFnData: infer TQueryFnData\n    error?: infer TError\n    data: infer TData\n  }\n    ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseSuspenseQueryOptions<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseSuspenseQueryOptions<unknown, TError, TData>\n        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n          T extends [infer TQueryFnData, infer TError, infer TData]\n          ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseSuspenseQueryOptions<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseSuspenseQueryOptions<TQueryFnData>\n              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? UseSuspenseQueryOptions<\n                    TQueryFnData,\n                    TError,\n                    TData,\n                    TQueryKey\n                  >\n                : T extends {\n                      queryFn?:\n                        | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                        | SkipTokenForUseQueries\n                      throwOnError?: ThrowOnError<any, infer TError, any, any>\n                    }\n                  ? UseSuspenseQueryOptions<\n                      TQueryFnData,\n                      TError,\n                      TQueryFnData,\n                      TQueryKey\n                    >\n                  : // Fallback\n                    UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult<T> =\n  // Part 1: responsible for mapping explicit type parameter to function result, if object\n  T extends { queryFnData: any; error?: infer TError; data: infer TData }\n    ? UseSuspenseQueryResult<TData, TError>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseSuspenseQueryResult<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseSuspenseQueryResult<TData, TError>\n        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n          T extends [any, infer TError, infer TData]\n          ? UseSuspenseQueryResult<TData, TError>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseSuspenseQueryResult<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseSuspenseQueryResult<TQueryFnData>\n              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, any>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? UseSuspenseQueryResult<\n                    unknown extends TData ? TQueryFnData : TData,\n                    unknown extends TError ? DefaultError : TError\n                  >\n                : T extends {\n                      queryFn?:\n                        | QueryFunction<infer TQueryFnData, any>\n                        | SkipTokenForUseQueries\n                      throwOnError?: ThrowOnError<any, infer TError, any, any>\n                    }\n                  ? UseSuspenseQueryResult<\n                      TQueryFnData,\n                      unknown extends TError ? DefaultError : TError\n                    >\n                  : // Fallback\n                    UseSuspenseQueryResult\n\n/**\n * The `queries` array accepted by `useSuspenseQueries`. Recursively unwraps each tuple element so every\n * entry's `queryFn`/`select` are inferred individually, up to 20 elements — past that, a tuple falls back to\n * a single homogeneous {@link UseSuspenseQueryOptions} type.\n *\n * An opaque array (e.g. `unknown[]`) is returned as-is; a non-tuple array whose element type structurally\n * matches a query options object is mapped per-element instead, still inferring each entry individually; any\n * other non-tuple array — one whose element type doesn't match the expected options shape — falls back to\n * that same homogeneous options type too.\n *\n * @template T - The type of the `queries` array as written at the call site.\n * @template TResults - The internal accumulator that this type builds during recursion. It is not meant\n * to be set explicitly.\n * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not\n * meant to be set explicitly.\n */\nexport type SuspenseQueriesOptions<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseSuspenseQueryOptions>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseSuspenseQueryOptions<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? SuspenseQueriesOptions<\n            [...Tails],\n            [...TResults, GetUseSuspenseQueryOptions<Head>],\n            [...TDepth, 1]\n          >\n        : Array<unknown> extends T\n          ? T\n          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n            // use this to infer the param types in the case of Array.map() argument\n            T extends Array<\n                UseSuspenseQueryOptions<\n                  infer TQueryFnData,\n                  infer TError,\n                  infer TData,\n                  infer TQueryKey\n                >\n              >\n            ? Array<\n                UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>\n              >\n            : // Fallback\n              Array<UseSuspenseQueryOptions>\n\n/**\n * The result type returned by `useSuspenseQueries`, when no `combine` is provided. Mirrors\n * {@link SuspenseQueriesOptions}: each tuple element's result type is inferred individually, up to 20 elements.\n * A non-tuple array is mapped per-element instead, still inferring each entry individually; only past 20\n * elements does this fall back to a single homogeneous {@link UseSuspenseQueryResult} type.\n *\n * @template T - The type of the `queries` array, as inferred by {@link SuspenseQueriesOptions}.\n * @template TResults - The internal accumulator that this type builds during recursion. It is not meant\n * to be set explicitly.\n * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not\n * meant to be set explicitly.\n */\nexport type SuspenseQueriesResults<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseSuspenseQueryResult>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseSuspenseQueryResult<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? SuspenseQueriesResults<\n            [...Tails],\n            [...TResults, GetUseSuspenseQueryResult<Head>],\n            [...TDepth, 1]\n          >\n        : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]> }\n\n/**\n * The options for `useSuspenseQueries` are the same as for `useQueries`, except that the top-level `subscribed`\n * option isn't supported, and each `query` can't have `throwOnError`, `enabled`, or `placeholderData`.\n *\n * @param options - The `queries` array to run in Suspense, and an optional `combine` function.\n * @param queryClient - Use this to provide a custom `QueryClient`. Otherwise, the one from the nearest context\n * will be used.\n * @returns The same structure as `useQueries`, except that for each `query`, `data` is guaranteed to be\n * defined, `isPlaceholderData` is missing, and `status` is either `success` or `error` (with the derived\n * flags set accordingly).\n *\n * Caveat: the component will only re-mount after all queries have finished loading. Hence, if a query has gone\n * stale in the time it took for all the queries to complete, it will be fetched again at re-mount. To avoid\n * this, make sure to set a high enough `staleTime`. Cancellation does not work.\n *\n * @example\n * The query error is thrown if a fetch fails and no cached data exists yet, so an error boundary is\n * required around `<Suspense>`. A failed background refetch instead continues to render the cached data.\n * Use {@link QueryErrorResetBoundary} to let the user retry after such an error:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n *   QueryErrorResetBoundary,\n *   useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Posts({ ids }: { ids: Array<number> }) {\n *   // Every result is guaranteed to be defined — no per-query `isPending` check needed.\n *   const postQueries = useSuspenseQueries({\n *     queries: ids.map((id) => ({\n *       queryKey: ['post', id],\n *       queryFn: () => fetchPost(id),\n *     })),\n *   })\n *\n *   return (\n *     <ul>\n *       {postQueries.map((query) => (\n *         <li key={query.data.id}>{query.data.title}</li>\n *       ))}\n *     </ul>\n *   )\n * }\n *\n * function App() {\n *   return (\n *     <QueryErrorResetBoundary>\n *       {({ reset }) => (\n *         <ErrorBoundary\n *           onReset={reset}\n *           fallbackRender={({ resetErrorBoundary }) => (\n *             <div>\n *               There was an error!\n *               <button onClick={() => resetErrorBoundary()}>Try again</button>\n *             </div>\n *           )}\n *         >\n *           <Suspense fallback={<h1>Loading posts...</h1>}>\n *             <Posts ids={[1, 2, 3]} />\n *           </Suspense>\n *         </ErrorBoundary>\n *       )}\n *     </QueryErrorResetBoundary>\n *   )\n * }\n *\n * function ErrorBoundary({\n *   children,\n *   onReset,\n *   fallbackRender,\n * }: {\n *   children: ComponentChildren\n *   onReset: () => void\n *   fallbackRender: (props: {\n *     error: Error\n *     resetErrorBoundary: () => void\n *   }) => ComponentChildren\n * }) {\n *   const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n *   if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n *   return children\n * }\n * ```\n *\n * @example\n * Several different queries — use `useSuspenseQueries` instead of multiple `useSuspenseQuery` calls, so\n * they fetch in parallel rather than suspending one after another:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n *   QueryErrorResetBoundary,\n *   useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Dashboard() {\n *   const [usersQuery, teamsQuery, projectsQuery] = useSuspenseQueries({\n *     queries: [\n *       { queryKey: ['users'], queryFn: fetchUsers },\n *       { queryKey: ['teams'], queryFn: fetchTeams },\n *       { queryKey: ['projects'], queryFn: fetchProjects },\n *     ],\n *   })\n *\n *   return (\n *     <div>\n *       <UserList users={usersQuery.data} />\n *       <TeamList teams={teamsQuery.data} />\n *       <ProjectList projects={projectsQuery.data} />\n *     </div>\n *   )\n * }\n *\n * function App() {\n *   return (\n *     <QueryErrorResetBoundary>\n *       {({ reset }) => (\n *         <ErrorBoundary\n *           onReset={reset}\n *           fallbackRender={({ resetErrorBoundary }) => (\n *             <div>\n *               There was an error!\n *               <button onClick={() => resetErrorBoundary()}>Try again</button>\n *             </div>\n *           )}\n *         >\n *           <Suspense fallback={<h1>Loading dashboard...</h1>}>\n *             <Dashboard />\n *           </Suspense>\n *         </ErrorBoundary>\n *       )}\n *     </QueryErrorResetBoundary>\n *   )\n * }\n *\n * function ErrorBoundary({\n *   children,\n *   onReset,\n *   fallbackRender,\n * }: {\n *   children: ComponentChildren\n *   onReset: () => void\n *   fallbackRender: (props: {\n *     error: Error\n *     resetErrorBoundary: () => void\n *   }) => ComponentChildren\n * }) {\n *   const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n *   if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n *   return children\n * }\n * ```\n *\n * @example\n * `combine`s the results into a single boolean, so `Refresh` only re-renders when that boolean changes,\n * not on every individual query update. This overload is the only one that accepts `combine`:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n *   QueryErrorResetBoundary,\n *   useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Refresh() {\n *   const anyFetching = useSuspenseQueries({\n *     queries: [\n *       { queryKey: ['users'], queryFn: fetchUsers },\n *       { queryKey: ['teams'], queryFn: fetchTeams },\n *     ],\n *     combine: (results) => results.some((result) => result.isFetching),\n *   })\n *\n *   return anyFetching ? <span>Refreshing…</span> : null\n * }\n *\n * function App() {\n *   return (\n *     <QueryErrorResetBoundary>\n *       {({ reset }) => (\n *         <ErrorBoundary\n *           onReset={reset}\n *           fallbackRender={({ resetErrorBoundary }) => (\n *             <div>\n *               There was an error!\n *               <button onClick={() => resetErrorBoundary()}>Try again</button>\n *             </div>\n *           )}\n *         >\n *           <Suspense fallback={<h1>Loading dashboard...</h1>}>\n *             <Refresh />\n *           </Suspense>\n *         </ErrorBoundary>\n *       )}\n *     </QueryErrorResetBoundary>\n *   )\n * }\n *\n * function ErrorBoundary({\n *   children,\n *   onReset,\n *   fallbackRender,\n * }: {\n *   children: ComponentChildren\n *   onReset: () => void\n *   fallbackRender: (props: {\n *     error: Error\n *     resetErrorBoundary: () => void\n *   }) => ComponentChildren\n * }) {\n *   const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n *   if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n *   return children\n * }\n * ```\n */\nexport function useSuspenseQueries<\n  T extends Array<any>,\n  TCombinedResult = SuspenseQueriesResults<T>,\n>(\n  options: {\n    /**\n     * An array with query option objects identical to `useSuspenseQuery`.\n     */\n    queries:\n      | readonly [...SuspenseQueriesOptions<T>]\n      | readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]> }]\n    /**\n     * Use this to combine the results of the queries into a single value. The result will be structurally\n     * shared to be as referentially stable as possible.\n     */\n    combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n  },\n  queryClient?: QueryClient,\n): TCombinedResult\n\n/**\n * The options for `useSuspenseQueries` are the same as for `useQueries`, except that the top-level `subscribed`\n * option isn't supported, and each `query` can't have `throwOnError`, `enabled`, or `placeholderData`.\n *\n * @param options - The `queries` array to run in Suspense, and an optional `combine` function.\n * @param queryClient - Use this to provide a custom `QueryClient`. Otherwise, the one from the nearest context\n * will be used.\n * @returns The same structure as `useQueries`, except that for each `query`, `data` is guaranteed to be\n * defined, `isPlaceholderData` is missing, and `status` is either `success` or `error` (with the derived\n * flags set accordingly).\n *\n * Caveat: the component will only re-mount after all queries have finished loading. Hence, if a query has gone\n * stale in the time it took for all the queries to complete, it will be fetched again at re-mount. To avoid\n * this, make sure to set a high enough `staleTime`. Cancellation does not work.\n *\n * @example\n * The query error is thrown if a fetch fails and no cached data exists yet, so an error boundary is\n * required around `<Suspense>`. A failed background refetch instead continues to render the cached data.\n * Use {@link QueryErrorResetBoundary} to let the user retry after such an error:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n *   QueryErrorResetBoundary,\n *   useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Posts({ ids }: { ids: Array<number> }) {\n *   // Every result is guaranteed to be defined — no per-query `isPending` check needed.\n *   const postQueries = useSuspenseQueries({\n *     queries: ids.map((id) => ({\n *       queryKey: ['post', id],\n *       queryFn: () => fetchPost(id),\n *     })),\n *   })\n *\n *   return (\n *     <ul>\n *       {postQueries.map((query) => (\n *         <li key={query.data.id}>{query.data.title}</li>\n *       ))}\n *     </ul>\n *   )\n * }\n *\n * function App() {\n *   return (\n *     <QueryErrorResetBoundary>\n *       {({ reset }) => (\n *         <ErrorBoundary\n *           onReset={reset}\n *           fallbackRender={({ resetErrorBoundary }) => (\n *             <div>\n *               There was an error!\n *               <button onClick={() => resetErrorBoundary()}>Try again</button>\n *             </div>\n *           )}\n *         >\n *           <Suspense fallback={<h1>Loading posts...</h1>}>\n *             <Posts ids={[1, 2, 3]} />\n *           </Suspense>\n *         </ErrorBoundary>\n *       )}\n *     </QueryErrorResetBoundary>\n *   )\n * }\n *\n * function ErrorBoundary({\n *   children,\n *   onReset,\n *   fallbackRender,\n * }: {\n *   children: ComponentChildren\n *   onReset: () => void\n *   fallbackRender: (props: {\n *     error: Error\n *     resetErrorBoundary: () => void\n *   }) => ComponentChildren\n * }) {\n *   const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n *   if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n *   return children\n * }\n * ```\n *\n * @example\n * Several different queries — use `useSuspenseQueries` instead of multiple `useSuspenseQuery` calls, so\n * they fetch in parallel rather than suspending one after another:\n * ```tsx\n * import { Suspense } from 'preact/compat'\n * import { useErrorBoundary } from 'preact/hooks'\n * import {\n *   QueryErrorResetBoundary,\n *   useSuspenseQueries,\n * } from '@tanstack/preact-query'\n * import type { ComponentChildren } from 'preact'\n *\n * function Dashboard() {\n *   const [usersQuery, teamsQuery, projectsQuery] = useSuspenseQueries({\n *     queries: [\n *       { queryKey: ['users'], queryFn: fetchUsers },\n *       { queryKey: ['teams'], queryFn: fetchTeams },\n *       { queryKey: ['projects'], queryFn: fetchProjects },\n *     ],\n *   })\n *\n *   return (\n *     <div>\n *       <UserList users={usersQuery.data} />\n *       <TeamList teams={teamsQuery.data} />\n *       <ProjectList projects={projectsQuery.data} />\n *     </div>\n *   )\n * }\n *\n * function App() {\n *   return (\n *     <QueryErrorResetBoundary>\n *       {({ reset }) => (\n *         <ErrorBoundary\n *           onReset={reset}\n *           fallbackRender={({ resetErrorBoundary }) => (\n *             <div>\n *               There was an error!\n *               <button onClick={() => resetErrorBoundary()}>Try again</button>\n *             </div>\n *           )}\n *         >\n *           <Suspense fallback={<h1>Loading dashboard...</h1>}>\n *             <Dashboard />\n *           </Suspense>\n *         </ErrorBoundary>\n *       )}\n *     </QueryErrorResetBoundary>\n *   )\n * }\n *\n * function ErrorBoundary({\n *   children,\n *   onReset,\n *   fallbackRender,\n * }: {\n *   children: ComponentChildren\n *   onReset: () => void\n *   fallbackRender: (props: {\n *     error: Error\n *     resetErrorBoundary: () => void\n *   }) => ComponentChildren\n * }) {\n *   const [error, resetErrorBoundary] = useErrorBoundary(() => onReset())\n *\n *   if (error) return fallbackRender({ error, resetErrorBoundary })\n *\n *   return children\n * }\n * ```\n */\nexport function useSuspenseQueries<\n  T extends Array<any>,\n  TCombinedResult = SuspenseQueriesResults<T>,\n>(\n  options: {\n    /**\n     * An array with query option objects identical to `useSuspenseQuery`.\n     */\n    queries: readonly [...SuspenseQueriesOptions<T>]\n    /**\n     * Use this to combine the results of the queries into a single value. The result will be structurally\n     * shared to be as referentially stable as possible.\n     */\n    combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n  },\n  queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n  return useQueries(\n    {\n      ...options,\n      queries: options.queries.map((query: any) => {\n        if (process.env.NODE_ENV !== 'production') {\n          if (query.queryFn === skipToken) {\n            console.error('skipToken is not allowed for useSuspenseQueries')\n          }\n        }\n\n        return {\n          ...query,\n          suspense: true,\n          throwOnError: defaultThrowOnError,\n          enabled: true,\n          placeholderData: undefined,\n        }\n      }),\n    },\n    queryClient,\n  )\n}\n"],"mappings":";;;;AAkmBA,SAAgB,mBAAmB,SAAc,aAA2B;CAC1E,OAAO,WACL;EACE,GAAG;EACH,SAAS,QAAQ,QAAQ,KAAK,UAAe;GAC3C,IAAI,QAAQ,IAAI,aAAa,cACvB;QAAA,MAAM,YAAY,WACpB,QAAQ,MAAM,iDAAiD;GAAA;GAInE,OAAO;IACL,GAAG;IACH,UAAU;IACV,cAAc;IACd,SAAS;IACT,iBAAiB,KAAA;GACnB;EACF,CAAC;CACH,GACA,WACF;AACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/preact-query",
-  "version": "5.103.1",
+  "version": "5.103.3",
   "description": "Hooks for managing, caching and syncing asynchronous and remote data in preact",
   "author": "tannerlinsley",
   "license": "MIT",
@@ -43,20 +43,19 @@
     "!build/codemods/**/__tests__"
   ],
   "dependencies": {
-    "@tanstack/query-core": "5.103.1"
+    "@tanstack/query-core": "5.103.3"
   },
   "devDependencies": {
-    "@preact/preset-vite": "^2.10.2",
+    "@preact/preset-vite": "^2.10.6",
+    "@tanstack/query-persist-client-core": "5.103.3",
+    "@tanstack/query-test-utils": "0.0.0",
     "@testing-library/preact": "^3.2.4",
-    "cpy-cli": "^5.0.0",
     "eslint-config-preact": "^2.0.0",
-    "npm-run-all2": "^5.0.0",
-    "preact": "^10.28.0",
+    "npm-run-all2": "^9.0.3",
+    "preact": "^10.29.8",
     "preact-render-to-string": "^6.6.4",
     "typescript": "6.0.3",
-    "typescript-eslint": "^8.54.0",
-    "@tanstack/query-persist-client-core": "5.103.1",
-    "@tanstack/query-test-utils": "0.0.0"
+    "typescript-eslint": "^8.54.0"
   },
   "peerDependencies": {
     "preact": "^10.0.0"
@@ -77,6 +76,6 @@
     "test:build": "publint --strict && attw --pack",
     "build": "pnpm build:tsdown && pnpm build:codemods",
     "build:tsdown": "tsdown --tsconfig tsconfig.prod.json",
-    "build:codemods": "cpy ../query-codemods/* ./build/codemods"
+    "build:codemods": "rm -rf ./build/codemods && mkdir ./build/codemods && cp -r ../query-codemods/src/* ./build/codemods"
   }
 }

package/src/infiniteQueryOptions.ts

@@ -92,7 +92,7 @@ export type UnusedSkipTokenInfiniteOptions<
 
 /**
  * The options accepted by the `infiniteQueryOptions` overload selected when `initialData` is set — `data` is
- * never `undefined`.
+ * never `undefined` (unless a `select` changes `TData` to include `undefined`).
  *
  * @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.
  * @template TError - The type of errors your `queryFn` may throw.

package/src/queryOptions.ts

@@ -71,7 +71,7 @@ export type UnusedSkipTokenOptions<
 
 /**
  * The options accepted by the `queryOptions` overload selected when `initialData` is set — `data` is never
- * `undefined`.
+ * `undefined` (unless a `select` changes `TData` to include `undefined`).
  *
  * @template TQueryFnData - The type your `queryFn` resolves to.
  * @template TError - The type of errors your `queryFn` may throw.
@@ -92,8 +92,7 @@ export type DefinedInitialDataOptions<
    * cache.
    */
   initialData:
-    | NonUndefinedGuard<TQueryFnData>
-    | (() => NonUndefinedGuard<TQueryFnData>)
+    NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>)
   /**
    * Optional here, but omitting it is only safe when no fetch will be attempted — for example with
    * `enabled: false`, or when a default query function has been defined. Otherwise, an enabled query with no
@@ -107,7 +106,8 @@ export type DefinedInitialDataOptions<
  * be shared across hooks and imperative APIs such as `queryClient.query`. `options.queryKey` is required and
  * is the query key to generate options for.
  *
- * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined`.
+ * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined` (unless
+ * a `select` changes `TData` to include `undefined`).
  *
  * @see {@link useQuery} to run a query with these options.
  * @see [The Query Options API](https://tkdodo.eu/blog/the-query-options-api) for more on this pattern.

package/src/suspense.ts

@@ -49,8 +49,7 @@ export const ensureSuspenseTimers = (
 
 export const shouldSuspend = (
   defaultedOptions:
-    | DefaultedQueryObserverOptions<any, any, any, any, any>
-    | undefined,
+    DefaultedQueryObserverOptions<any, any, any, any, any> | undefined,
   result: QueryObserverResult<any, any>,
 ) => defaultedOptions?.suspense && result.isPending
 

package/src/types.ts

@@ -343,8 +343,8 @@ export type UseSuspenseQueryResult<
 
 /**
  * The result of `useQuery` when `initialData` is set, or of `useSuspenseQuery` before the `isPlaceholderData`
- * omission — `data` is never `undefined`. Re-exports {@link DefinedQueryObserverResult} from
- * `@tanstack/query-core`.
+ * omission — `data` is never `undefined` (unless a `select` changes `TData` to include `undefined`).
+ * Re-exports {@link DefinedQueryObserverResult} from `@tanstack/query-core`.
  *
  * @template TData - The type `data` ends up as after `select` runs.
  * @template TError - The type of errors your `queryFn` may throw.
@@ -367,8 +367,9 @@ export type UseInfiniteQueryResult<
 > = InfiniteQueryObserverResult<TData, TError>
 
 /**
- * The result of `useInfiniteQuery` when `initialData` is set — `data` is never `undefined`. Re-exports
- * {@link DefinedInfiniteQueryObserverResult} from `@tanstack/query-core`.
+ * The result of `useInfiniteQuery` when `initialData` is set — `data` is never `undefined` (unless a
+ * `select` changes `TData` to include `undefined`). Re-exports {@link DefinedInfiniteQueryObserverResult}
+ * from `@tanstack/query-core`.
  *
  * @template TData - The type `data` ends up as after `select` runs.
  * @template TError - The type of errors your `queryFn` may throw.

package/src/useBaseQuery.ts

@@ -55,12 +55,9 @@ export function useBaseQuery<
 
   const query = client
     .getQueryCache()
-    .get<
-      TQueryFnData,
-      TError,
-      TQueryData,
-      TQueryKey
-    >(defaultedOptions.queryHash)
+    .get<TQueryFnData, TError, TQueryData, TQueryKey>(
+      defaultedOptions.queryHash,
+    )
 
   if (process.env.NODE_ENV !== 'production') {
     if (!defaultedOptions.queryFn) {

package/src/useQueries.ts

@@ -143,10 +143,14 @@ type GetUseQueryResult<T> =
 
 /**
  * The `queries` array accepted by `useQueries`. Recursively unwraps each tuple element so every entry's
- * `queryFn`/`select`/`throwOnError` are inferred individually, up to 20 elements. An opaque array (e.g.
- * `unknown[]`) is returned as-is; a non-tuple array of a known element type, or a tuple past 20 elements, falls
+ * `queryFn`/`select`/`throwOnError` are inferred individually, up to 20 elements — past that, a tuple falls
  * back to a single homogeneous options type.
  *
+ * An opaque array (e.g. `unknown[]`) is returned as-is; a non-tuple array whose element type structurally
+ * matches a query options object is mapped per-element instead, still inferring each entry individually; any
+ * other non-tuple array — one whose element type doesn't match the expected options shape — falls back to
+ * that same homogeneous options type too.
+ *
  * @template T - The type of the `queries` array as written at the call site.
  * @template TResults - The internal accumulator that this type builds during recursion. It is not meant
  * to be set explicitly.

package/src/useQuery.ts

@@ -13,7 +13,8 @@ import type {
 import { useBaseQuery } from './useBaseQuery'
 
 /**
- * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined`.
+ * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined` (unless
+ * a `select` changes `TData` to include `undefined`).
  *
  * @see {@link queryOptions} to share these options between `useQuery` and imperative APIs like `queryClient.query`.
  * @param options - The {@link DefinedInitialDataOptions} to use — everything you can pass to `useQuery`, with `initialData` set.
@@ -223,7 +224,9 @@ export function useQuery<
  * ```
  *
  * @example
- * Seeding a detail query from an already-cached list, to skip the loading state:
+ * Seeding a detail query from an already-cached list, to skip the loading state. `initialDataUpdatedAt` carries
+ * over the list's own fetch time, so that if you set a `staleTime`, it's measured from when the list was
+ * fetched rather than from now:
  * ```tsx
  * import { useQuery, useQueryClient } from '@tanstack/preact-query'
  *
@@ -237,6 +240,8 @@ export function useQuery<
  *       queryClient
  *         .getQueryData<Array<Post>>(['posts'])
  *         ?.find((post) => post.id === postId),
+ *     initialDataUpdatedAt: () =>
+ *       queryClient.getQueryState(['posts'])?.dataUpdatedAt,
  *   })
  *
  *   if (isError) return <span>Error: {error.message}</span>

package/src/useSuspenseQueries.ts

@@ -106,9 +106,13 @@ type GetUseSuspenseQueryResult<T> =
 
 /**
  * The `queries` array accepted by `useSuspenseQueries`. Recursively unwraps each tuple element so every
- * entry's `queryFn`/`select` are inferred individually, up to 20 elements. An opaque array (e.g. `unknown[]`)
- * is returned as-is; a non-tuple array of a known element type, or a tuple past 20 elements, falls back to a
- * single homogeneous {@link UseSuspenseQueryOptions} type.
+ * entry's `queryFn`/`select` are inferred individually, up to 20 elements — past that, a tuple falls back to
+ * a single homogeneous {@link UseSuspenseQueryOptions} type.
+ *
+ * An opaque array (e.g. `unknown[]`) is returned as-is; a non-tuple array whose element type structurally
+ * matches a query options object is mapped per-element instead, still inferring each entry individually; any
+ * other non-tuple array — one whose element type doesn't match the expected options shape — falls back to
+ * that same homogeneous options type too.
  *
  * @template T - The type of the `queries` array as written at the call site.
  * @template TResults - The internal accumulator that this type builds during recursion. It is not meant

package/build/query-codemods/eslint.config.js

@@ -1,25 +0,0 @@
-// @ts-check
-
-import rootConfig from './root.eslint.config.js'
-
-export default [
-  ...rootConfig,
-  {
-    rules: {
-      'cspell/spellchecker': 'off',
-      '@typescript-eslint/no-unnecessary-condition': 'off',
-      'import/no-duplicates': 'off',
-      'import/no-unresolved': 'off',
-      'import/order': 'off',
-      'no-shadow': 'off',
-      'sort-imports': 'off',
-    },
-  },
-  {
-    files: ['src/**/__testfixtures__/**'],
-    rules: {
-      // Codemod fixtures intentionally preserve historical QueryClient syntax.
-      'no-restricted-syntax': 'off',
-    },
-  },
-]

package/build/query-codemods/package.json

@@ -1,38 +0,0 @@
-{
-  "name": "@tanstack/query-codemods",
-  "private": true,
-  "description": "Collection of codemods to make the migration easier.",
-  "author": "Balázs Máté Petró",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/TanStack/query.git",
-    "directory": "packages/query-codemods"
-  },
-  "homepage": "https://tanstack.com/query",
-  "funding": {
-    "type": "github",
-    "url": "https://github.com/sponsors/tannerlinsley"
-  },
-  "scripts": {
-    "clean": "premove ./coverage ./dist-ts",
-    "test:eslint": "eslint --concurrency=auto ./src",
-    "test:lib": "vitest",
-    "test:lib:dev": "pnpm run test:lib --watch"
-  },
-  "type": "module",
-  "exports": {
-    "./package.json": "./package.json"
-  },
-  "sideEffects": false,
-  "files": [
-    "src",
-    "!src/jest.config.js",
-    "!src/**/__testfixtures__",
-    "!src/**/__tests__"
-  ],
-  "devDependencies": {
-    "@types/jscodeshift": "17.3.0",
-    "jscodeshift": "17.3.0"
-  }
-}

package/build/query-codemods/root.eslint.config.js

@@ -1,113 +0,0 @@
-// @ts-check
-
-// @ts-ignore Needed due to moduleResolution Node vs Bundler
-import { tanstackConfig } from '@tanstack/eslint-config'
-import pluginCspell from '@cspell/eslint-plugin'
-import vitest from '@vitest/eslint-plugin'
-
-export default [
-  ...tanstackConfig,
-  {
-    name: 'tanstack/temp',
-    plugins: {
-      cspell: pluginCspell,
-    },
-    rules: {
-      'cspell/spellchecker': [
-        'warn',
-        {
-          cspell: {
-            words: [
-              'Promisable', // Our public interface
-              'TSES', // @typescript-eslint package's interface
-              'codemod', // We support our codemod
-              'combinate', // Library name
-              'datatag', // Query options tagging
-              'extralight', // Our public interface
-              'jscodeshift',
-              'refetches', // Query refetch operations
-              'retryer', // Our public interface
-              'solidjs', // Our target framework
-              'tabular-nums', // https://developer.mozilla.org/en-US/docs/Web/CSS/font-variant-numeric
-              'tanstack', // Our package scope
-              'todos', // Too general word to be caught as error
-              'tsqd', // Our public interface (TanStack Query Devtools shorthand)
-              'tsdown', // We use tsdown as builder
-              'typecheck', // Field of vite.config.ts
-              'vue-demi', // dependency of @tanstack/vue-query
-              'ɵkind', // Angular specific
-              'ɵproviders', // Angular specific
-            ],
-          },
-        },
-      ],
-      '@typescript-eslint/no-empty-function': 'off',
-      '@typescript-eslint/no-unsafe-function-type': 'off',
-      'no-case-declarations': 'off',
-      /**
-       * Disallows direct calls to deprecated imperative query methods of `QueryClient`
-       * for new tests and code
-       *
-       * Existing tests that directly test the methods from before the refactoring
-       * will be grandfathered in and allowed to continue using the deprecated methods.
-       * They should not be removed, but new tests should use the new methods instead.
-       */
-      'no-restricted-syntax': [
-        'error',
-        {
-          selector:
-            'CallExpression[callee.type="MemberExpression"]:matches([callee.property.name="fetchQuery"], [callee.computed=true][callee.property.value="fetchQuery"])',
-          message: 'Use queryClient.query(options) instead.',
-        },
-        {
-          selector:
-            'CallExpression[callee.type="MemberExpression"]:matches([callee.property.name="prefetchQuery"], [callee.computed=true][callee.property.value="prefetchQuery"])',
-          message:
-            'Use queryClient.query(options).catch(noop) instead if errors should be swallowed.',
-        },
-        {
-          selector:
-            'CallExpression[callee.type="MemberExpression"]:matches([callee.property.name="ensureQueryData"], [callee.computed=true][callee.property.value="ensureQueryData"])',
-          message:
-            "Use queryClient.query({ ...options, staleTime: 'static' }) instead.",
-        },
-        {
-          selector:
-            'CallExpression[callee.type="MemberExpression"]:matches([callee.property.name="fetchInfiniteQuery"], [callee.computed=true][callee.property.value="fetchInfiniteQuery"])',
-          message: 'Use queryClient.infiniteQuery(options) instead.',
-        },
-        {
-          selector:
-            'CallExpression[callee.type="MemberExpression"]:matches([callee.property.name="prefetchInfiniteQuery"], [callee.computed=true][callee.property.value="prefetchInfiniteQuery"])',
-          message:
-            'Use queryClient.infiniteQuery(options).catch(noop) instead if errors should be swallowed.',
-        },
-        {
-          selector:
-            'CallExpression[callee.type="MemberExpression"]:matches([callee.property.name="ensureInfiniteQueryData"], [callee.computed=true][callee.property.value="ensureInfiniteQueryData"])',
-          message:
-            "Use queryClient.infiniteQuery({ ...options, staleTime: 'static' }) instead.",
-        },
-      ],
-      'prefer-const': 'off',
-    },
-  },
-  {
-    files: ['**/*.spec.ts*', '**/*.test.ts*', '**/*.test-d.ts*'],
-    plugins: { vitest },
-    rules: {
-      ...vitest.configs.recommended.rules,
-      'vitest/consistent-test-it': [
-        'error',
-        { fn: 'it', withinDescribe: 'it' },
-      ],
-      'vitest/no-standalone-expect': [
-        'error',
-        {
-          additionalTestBlockFunctions: ['itIf'],
-        },
-      ],
-    },
-    settings: { vitest: { typecheck: true } },
-  },
-]

package/build/query-codemods/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist-ts",
-    "rootDir": "."
-  },
-  "include": ["src", "*.config.ts", "*.config.js", "package.json"]
-}

package/build/query-codemods/vite.config.ts

@@ -1,30 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-import packageJson from './package.json'
-
-export default defineConfig({
-  // fix from https://github.com/vitest-dev/vitest/issues/6992#issuecomment-2509408660
-  resolve: {
-    conditions: ['@tanstack/custom-condition'],
-  },
-  environments: {
-    ssr: {
-      resolve: {
-        conditions: ['@tanstack/custom-condition'],
-      },
-    },
-  },
-  test: {
-    name: packageJson.name,
-    dir: './src',
-    watch: false,
-    globals: true,
-    coverage: {
-      enabled: !!process.env.CI,
-      provider: 'istanbul',
-      include: ['src/**/*.{js,ts,cjs,mjs,jsx,tsx}'],
-    },
-    typecheck: { enabled: true },
-    restoreMocks: true,
-  },
-})