@tanstack/react-query 4.35.7 → 4.39.0

package/build/lib/__tests__/queryOptions.types.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=queryOptions.types.test.d.ts.map

package/build/lib/__tests__/useSuspenseQueries.types.test.d.ts

@@ -0,0 +1,6 @@
+export declare const queryKey: readonly ["key"];
+export declare const queryFn: () => Promise<{
+    text: string;
+}>;
+export declare const select: (data: Awaited<ReturnType<typeof queryFn>>) => string;
+//# sourceMappingURL=useSuspenseQueries.types.test.d.ts.map

package/build/lib/__tests__/useSuspenseQuery.types.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useSuspenseQuery.types.test.d.ts.map

package/build/lib/__tests__/utils.d.ts

@@ -4,6 +4,7 @@ import * as React from 'react';
 import { render } from '@testing-library/react';
 import { QueryClient } from '..';
 import type { ContextOptions, MutationOptions, QueryClientConfig } from '..';
+export declare const doNotExecute: (_func: () => void) => boolean;
 export declare function renderWithClient(client: QueryClient, ui: React.ReactElement, options?: ContextOptions): ReturnType<typeof render>;
 export declare const Blink: ({ duration, children, }: {
     duration: number;

package/build/lib/index.d.ts

@@ -4,6 +4,8 @@ export * from './types';
 export { useQueries } from './useQueries';
 export type { QueriesResults, QueriesOptions } from './useQueries';
 export { useQuery } from './useQuery';
+export { useSuspenseQuery } from './useSuspenseQuery';
+export { useSuspenseQueries } from './useSuspenseQueries';
 export { defaultContext, QueryClientProvider, useQueryClient, } from './QueryClientProvider';
 export type { QueryClientProviderProps } from './QueryClientProvider';
 export type { QueryErrorResetBoundaryProps } from './QueryErrorResetBoundary';
@@ -15,4 +17,5 @@ export { useIsMutating } from './useIsMutating';
 export { useMutation } from './useMutation';
 export { useInfiniteQuery } from './useInfiniteQuery';
 export { useIsRestoring, IsRestoringProvider } from './isRestoring';
+export { queryOptions } from './queryOptions';
 //# sourceMappingURL=index.d.ts.map

package/build/lib/queryOptions.d.ts

@@ -0,0 +1,14 @@
+import type { InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryKey, WithRequired } from '@tanstack/query-core';
+import type { UseQueryOptions } from './types';
+declare type UseQueryOptionsOmitted<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'onSuccess' | 'onError' | 'onSettled' | 'refetchInterval'>;
+declare type ProhibitedQueryOptionsKeyInV5 = keyof Pick<UseQueryOptionsOmitted, 'useErrorBoundary' | 'suspense' | 'getNextPageParam' | 'getPreviousPageParam'>;
+export declare type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptionsOmitted<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData?: undefined | InitialDataFunction<NonUndefinedGuard<TQueryFnData>> | NonUndefinedGuard<TQueryFnData>;
+};
+export declare type DefinedInitialDataOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptionsOmitted<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
+};
+export declare function queryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: WithRequired<OmitKeyof<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, ProhibitedQueryOptionsKeyInV5>, 'queryKey'>): WithRequired<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'>;
+export declare function queryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: WithRequired<OmitKeyof<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, ProhibitedQueryOptionsKeyInV5>, 'queryKey'>): WithRequired<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'>;
+export {};
+//# sourceMappingURL=queryOptions.d.ts.map

package/build/lib/useQueries.d.ts

@@ -1,6 +1,6 @@
-import type { QueryFunction, QueryKey } from '@tanstack/query-core';
-import type { UseQueryOptions, UseQueryResult } from './types';
-declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'context'>;
+import type { OmitKeyof, QueryFunction, QueryKey } from '@tanstack/query-core';
+import type { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from './types';
+declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'context'>;
 declare type MAXIMUM_DEPTH = 20;
 declare type GetOptions<T> = T extends {
     queryFnData: infer TQueryFnData;
@@ -18,30 +18,41 @@ declare type GetOptions<T> = T extends {
 } ? UseQueryOptionsForUseQueries<TQueryFnData, unknown, TData, TQueryKey> : T extends {
     queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
 } ? UseQueryOptionsForUseQueries<TQueryFnData, unknown, TQueryFnData, TQueryKey> : UseQueryOptionsForUseQueries;
-declare type GetResults<T> = T extends {
+declare type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
+    initialData?: infer TInitialData;
+} ? unknown extends TInitialData ? UseQueryResult<TData, TError> : TInitialData extends TData ? DefinedUseQueryResult<TData, TError> : TInitialData extends () => infer TInitialDataResult ? unknown extends TInitialDataResult ? UseQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedUseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError>;
+declare type GetUseQueryResult<T> = T extends {
     queryFnData: any;
     error?: infer TError;
     data: infer TData;
-} ? UseQueryResult<TData, TError> : T extends {
+} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
     queryFnData: infer TQueryFnData;
     error?: infer TError;
-} ? UseQueryResult<TQueryFnData, TError> : T extends {
+} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
     data: infer TData;
     error?: infer TError;
-} ? UseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryResult<TQueryFnData> : T extends {
+} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
     queryFn?: QueryFunction<unknown, any>;
     select: (data: any) => infer TData;
-} ? UseQueryResult<TData> : T extends {
+} ? GetDefinedOrUndefinedQueryResult<T, TData> : T extends {
     queryFn?: QueryFunction<infer TQueryFnData, any>;
-} ? UseQueryResult<TQueryFnData> : UseQueryResult;
+} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : UseQueryResult;
 /**
  * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
  */
-export declare type QueriesOptions<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? UseQueryOptionsForUseQueries[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[...Tail], [...Result, GetOptions<Head>], [...Depth, 1]> : unknown[] extends T ? T : T extends UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>[] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>[] : UseQueryOptionsForUseQueries[];
+export declare type QueriesOptions<T extends any[], TResult extends any[] = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? UseQueryOptionsForUseQueries[] : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[...Tail], [...TResult, GetOptions<Head>], [...TDepth, 1]> : unknown[] extends T ? T : T extends UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>[] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>[] : UseQueryOptionsForUseQueries[];
 /**
  * QueriesResults reducer recursively maps type param to results
  */
-export declare type QueriesResults<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? UseQueryResult[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[...Tail], [...Result, GetResults<Head>], [...Depth, 1]> : T extends UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, any>[] ? UseQueryResult<unknown extends TData ? TQueryFnData : TData, TError>[] : UseQueryResult[];
+export declare type QueriesResults<T extends any[], TResults extends any[] = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? UseQueryResult[] : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
+    ...Tail
+], [
+    ...TResults,
+    GetUseQueryResult<Head>
+], [
+    ...TDepth,
+    1
+]> : T extends UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, any>[] ? UseQueryResult<unknown extends TData ? TQueryFnData : TData, TError>[] : UseQueryResult[];
 export declare function useQueries<T extends any[]>({ queries, context, }: {
     queries: readonly [...QueriesOptions<T>];
     context?: UseQueryOptions['context'];

package/build/lib/useQuery.d.ts

@@ -1,24 +1,31 @@
-import type { QueryFunction, QueryKey } from '@tanstack/query-core';
+import type { DefinedInitialDataOptions, UndefinedInitialDataOptions } from './queryOptions';
+import type { InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryFunction, QueryKey } from '@tanstack/query-core';
 import type { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from './types';
-export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'initialData'> & {
-    initialData?: () => undefined;
-}): UseQueryResult<TData, TError>;
-export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'initialData'> & {
-    initialData: TQueryFnData | (() => TQueryFnData);
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedUseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'initialData'> & {
+    initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
 }): DefinedUseQueryResult<TData, TError>;
-export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UseQueryResult<TData, TError>;
-export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'initialData'> & {
-    initialData?: () => undefined;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'initialData'> & {
+    initialData?: undefined | InitialDataFunction<NonUndefinedGuard<TQueryFnData>> | NonUndefinedGuard<TQueryFnData>;
 }): UseQueryResult<TData, TError>;
-export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'initialData'> & {
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UseQueryResult<TData, TError>;
+/** @deprecated */
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'initialData'>): UseQueryResult<TData, TError>;
+/** @deprecated */
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'initialData'> & {
     initialData: TQueryFnData | (() => TQueryFnData);
 }): DefinedUseQueryResult<TData, TError>;
-export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'>): UseQueryResult<TData, TError>;
-export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'queryFn' | 'initialData'> & {
+/** @deprecated */
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'>): UseQueryResult<TData, TError>;
+/** @deprecated */
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'queryFn' | 'initialData'> & {
     initialData?: () => undefined;
 }): UseQueryResult<TData, TError>;
-export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'queryFn' | 'initialData'> & {
+/** @deprecated */
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'queryFn' | 'initialData'> & {
     initialData: TQueryFnData | (() => TQueryFnData);
 }): DefinedUseQueryResult<TData, TError>;
-export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'queryFn'>): UseQueryResult<TData, TError>;
+/** @deprecated */
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'queryFn'>): UseQueryResult<TData, TError>;
 //# sourceMappingURL=useQuery.d.ts.map

package/build/lib/useSuspenseQueries.d.ts

@@ -0,0 +1,66 @@
+import type { UseQueryOptions } from './types';
+import type { QueryFunction } from '@tanstack/query-core';
+import type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './useSuspenseQuery';
+declare type MAXIMUM_DEPTH = 20;
+declare type GetSuspenseOptions<T> = T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+    data: infer TData;
+} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseSuspenseQueryOptions<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryOptions<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+    select?: (data: any) => infer TData;
+} ? UseSuspenseQueryOptions<TQueryFnData, unknown, TData, TQueryKey> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+} ? UseSuspenseQueryOptions<TQueryFnData, unknown, TQueryFnData, TQueryKey> : UseSuspenseQueryOptions;
+declare type GetSuspenseResults<T> = T extends {
+    queryFnData: any;
+    error?: infer TError;
+    data: infer TData;
+} ? UseSuspenseQueryResult<TData, TError> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseSuspenseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseSuspenseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryResult<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any>;
+    select?: (data: any) => infer TData;
+} ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any>;
+} ? UseSuspenseQueryResult<TQueryFnData> : UseSuspenseQueryResult;
+/**
+ * SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+export declare type SuspenseQueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryOptions> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetSuspenseOptions<Head>] : T extends [infer Head, ...infer Tail] ? SuspenseQueriesOptions<[
+    ...Tail
+], [
+    ...TResult,
+    GetSuspenseOptions<Head>
+], [
+    ...TDepth,
+    1
+]> : Array<unknown> extends T ? T : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>> : Array<UseSuspenseQueryOptions>;
+/**
+ * SuspenseQueriesResults reducer recursively maps type param to results
+ */
+export declare type SuspenseQueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetSuspenseResults<Head>] : T extends [infer Head, ...infer Tail] ? SuspenseQueriesResults<[
+    ...Tail
+], [
+    ...TResult,
+    GetSuspenseResults<Head>
+], [
+    ...TDepth,
+    1
+]> : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, any>> ? Array<UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, TError>> : Array<UseSuspenseQueryResult>;
+export declare function useSuspenseQueries<T extends any[]>({ queries, context, }: {
+    queries: readonly [...SuspenseQueriesOptions<T>];
+    context?: UseQueryOptions['context'];
+}): SuspenseQueriesResults<T>;
+export {};
+//# sourceMappingURL=useSuspenseQueries.d.ts.map

package/build/lib/useSuspenseQuery.d.ts

@@ -0,0 +1,8 @@
+import type { DefinedQueryObserverResult, OmitKeyof, QueryKey } from '@tanstack/query-core';
+import type { UseQueryOptions } from './types';
+declare type DistributiveOmit<TObject, TKey extends keyof TObject> = TObject extends any ? Omit<TObject, TKey> : never;
+export declare type UseSuspenseQueryResult<TData = unknown, TError = unknown> = DistributiveOmit<DefinedQueryObserverResult<TData, TError>, 'isPlaceholderData'>;
+export declare type UseSuspenseQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'enabled' | 'useErrorBoundary' | 'suspense' | 'placeholderData' | 'networkMode' | 'onSuccess' | 'onError' | 'onSettled' | 'getPreviousPageParam' | 'getNextPageParam'>;
+export declare function useSuspenseQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UseSuspenseQueryResult<TData, TError>;
+export {};
+//# sourceMappingURL=useSuspenseQuery.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/react-query",
-  "version": "4.35.7",
+  "version": "4.39.0",
   "description": "Hooks for managing, caching and syncing asynchronous and remote data in React",
   "author": "tannerlinsley",
   "license": "MIT",
@@ -51,7 +51,7 @@
   },
   "dependencies": {
     "use-sync-external-store": "^1.2.0",
-    "@tanstack/query-core": "4.35.7"
+    "@tanstack/query-core": "4.39.0"
   },
   "peerDependencies": {
     "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
@@ -66,12 +66,5 @@
       "optional": true
     }
   },
-  "scripts": {
-    "clean": "rimraf ./build",
-    "test:eslint": "eslint --ext .ts,.tsx ./src",
-    "test:types": "tsc",
-    "test:lib": "jest --config ./jest.config.ts",
-    "test:lib:dev": "pnpm run test:lib --watch",
-    "build:types": "tsc --build"
-  }
+  "scripts": {}
 }

package/src/__tests__/queryOptions.types.test.tsx

@@ -0,0 +1,270 @@
+import { expectTypeOf } from 'expect-type'
+import {
+  QueryCache,
+  type UseQueryResult,
+  useQueries,
+  useQuery,
+  useQueryClient,
+} from '@tanstack/react-query'
+import { queryOptions } from '..'
+import { useSuspenseQueries, useSuspenseQuery } from '..'
+import { type UseSuspenseQueryResult } from '../useSuspenseQuery'
+import { doNotExecute } from './utils'
+import type { DefinedUseQueryResult } from '@tanstack/react-query'
+
+const queryKey = ['key'] as const
+const queryFn = () => Promise.resolve({ field: 'success' })
+
+describe('queryOptions', () => {
+  it('should be used with useQuery', () => {
+    doNotExecute(() => {
+      const dd = useQuery(
+        queryOptions({
+          queryKey,
+          queryFn,
+        }),
+      )
+      expectTypeOf(dd).toEqualTypeOf<UseQueryResult<{ field: string }>>()
+      expectTypeOf(
+        useQuery({
+          ...queryOptions({
+            queryKey,
+            queryFn,
+          }),
+          select: (data) => data.field,
+        }),
+      ).toEqualTypeOf<UseQueryResult<string>>()
+      expectTypeOf(
+        useQuery({
+          ...queryOptions({
+            queryKey,
+            queryFn,
+            select: (data) => data.field,
+          }),
+        }),
+      ).toEqualTypeOf<UseQueryResult<string>>()
+      expectTypeOf(
+        useQuery({
+          ...queryOptions({
+            queryKey,
+            queryFn,
+          }),
+          initialData: { field: 'success' },
+        }),
+      ).toEqualTypeOf<DefinedUseQueryResult<{ field: string }>>()
+      expectTypeOf(
+        useQuery({
+          ...queryOptions({
+            queryKey,
+            queryFn,
+          }),
+          initialData: { field: 'success' },
+          select: (data) => data.field,
+        }),
+      ).toEqualTypeOf<DefinedUseQueryResult<string>>()
+      expectTypeOf(
+        useQuery({
+          ...queryOptions({
+            queryKey,
+            queryFn,
+          }),
+          initialData: undefined,
+          select: (data) => data.field,
+        }),
+      ).toEqualTypeOf<UseQueryResult<string>>()
+      expectTypeOf(
+        useQuery({
+          ...queryOptions({
+            queryKey,
+            queryFn,
+          }),
+          initialData: () => undefined,
+          select: (data) => data.field,
+        }),
+      ).toEqualTypeOf<UseQueryResult<string>>()
+      expectTypeOf(
+        useQuery({
+          ...queryOptions({
+            queryKey,
+            queryFn,
+            select: (data) => data.field,
+          }),
+          refetchInterval: 1000,
+        }),
+      ).toEqualTypeOf<UseQueryResult<string>>()
+    })
+  })
+  it('should be used with useSuspenseQuery', () => {
+    doNotExecute(() => {
+      expectTypeOf(
+        useSuspenseQuery(
+          queryOptions({
+            queryKey,
+            queryFn,
+          }),
+        ),
+      ).toEqualTypeOf<UseSuspenseQueryResult<{ field: string }>>()
+
+      expectTypeOf(
+        useSuspenseQuery({
+          ...queryOptions({
+            queryKey,
+            queryFn,
+          }),
+          select: (data) => data.field,
+        }),
+      ).toEqualTypeOf<UseSuspenseQueryResult<string>>()
+      expectTypeOf(
+        useSuspenseQuery({
+          ...queryOptions({
+            queryKey,
+            queryFn,
+          }),
+          initialData: { field: 'success' },
+        }),
+      ).toEqualTypeOf<UseSuspenseQueryResult<{ field: string }>>()
+      expectTypeOf(
+        useSuspenseQuery({
+          ...queryOptions({
+            queryKey,
+            queryFn,
+          }),
+          initialData: undefined,
+          select: (data) => data.field,
+        }),
+      ).toEqualTypeOf<UseSuspenseQueryResult<string>>()
+      expectTypeOf(
+        useSuspenseQuery({
+          ...queryOptions({
+            queryKey,
+            queryFn,
+          }),
+          initialData: { field: 'success' },
+          select: (data) => data.field,
+        }),
+      ).toEqualTypeOf<UseSuspenseQueryResult<string>>()
+      expectTypeOf(
+        useSuspenseQuery({
+          ...queryOptions({
+            queryKey,
+            queryFn,
+            select: (data) => data.field,
+          }),
+          refetchInterval: 1000,
+        }),
+      ).toEqualTypeOf<UseSuspenseQueryResult<string>>()
+    })
+  })
+  it('should be used with useQueries', () => {
+    doNotExecute(() => {
+      const [query1, query2, query3, query4] = useQueries({
+        queries: [
+          queryOptions({
+            queryKey,
+            queryFn,
+          }),
+          queryOptions({
+            queryKey,
+            queryFn,
+            initialData: { field: 'success' },
+          }),
+          {
+            ...queryOptions({
+              queryKey,
+              queryFn,
+            }),
+            initialData: { field: 'success' },
+          },
+          {
+            ...queryOptions({
+              queryKey,
+              queryFn,
+            }),
+            initialData: undefined,
+          },
+        ],
+      })
+      expectTypeOf(query1).toEqualTypeOf<UseQueryResult<{ field: string }>>()
+      expectTypeOf(query2).toEqualTypeOf<
+        DefinedUseQueryResult<{ field: string }>
+      >()
+      expectTypeOf(query3).toEqualTypeOf<
+        DefinedUseQueryResult<{ field: string }>
+      >()
+      expectTypeOf(query4).toEqualTypeOf<UseQueryResult<{ field: string }>>()
+    })
+  })
+  it('should be used with useSuspenseQueries', () => {
+    doNotExecute(() => {
+      const [query1, query2, query3, query4, query5] = useSuspenseQueries({
+        queries: [
+          queryOptions({
+            queryKey,
+            queryFn,
+          }),
+          queryOptions({
+            queryKey,
+            queryFn,
+            initialData: { field: 'success' },
+          }),
+          {
+            ...queryOptions({
+              queryKey,
+              queryFn,
+            }),
+            initialData: { field: 'success' },
+          },
+          {
+            ...queryOptions({
+              queryKey,
+              queryFn,
+            }),
+            initialData: undefined,
+          },
+          {
+            ...queryOptions({
+              queryKey,
+              queryFn,
+              select: (data) => data.field,
+            }),
+          },
+        ],
+      })
+      expectTypeOf(query1).toEqualTypeOf<
+        UseSuspenseQueryResult<{ field: string }>
+      >()
+      expectTypeOf(query2).toEqualTypeOf<
+        UseSuspenseQueryResult<{ field: string }>
+      >()
+      expectTypeOf(query3).toEqualTypeOf<
+        UseSuspenseQueryResult<{ field: string }>
+      >()
+      expectTypeOf(query4).toEqualTypeOf<
+        UseSuspenseQueryResult<{ field: string }>
+      >()
+      expectTypeOf(query5).toEqualTypeOf<UseSuspenseQueryResult<string>>()
+    })
+  })
+  it('should be used with useQueryClient', () => {
+    doNotExecute(async () => {
+      const queryClient = useQueryClient()
+      queryClient.invalidateQueries(queryOptions({ queryKey, queryFn }))
+      queryClient.resetQueries(queryOptions({ queryKey, queryFn }))
+      queryClient.removeQueries(queryOptions({ queryKey, queryFn }))
+      queryClient.cancelQueries(queryOptions({ queryKey, queryFn }))
+      queryClient.prefetchQuery(queryOptions({ queryKey, queryFn }))
+      queryClient.refetchQueries(queryOptions({ queryKey, queryFn }))
+      expectTypeOf(
+        await queryClient.fetchQuery(queryOptions({ queryKey, queryFn })),
+      ).toEqualTypeOf<{ field: string }>()
+    })
+  })
+  it('should be used with queryCache', () => {
+    doNotExecute(() => {
+      const queryCache = new QueryCache()
+      queryCache.find({ queryKey: [] })
+      queryCache.find(queryOptions({ queryKey, queryFn }))
+      queryCache.find(queryKey)
+    })
+  })
+})

package/src/__tests__/useQuery.types.test.tsx

@@ -1,4 +1,5 @@
 import { useQuery } from '../useQuery'
+import { doNotExecute } from './utils'
 
 export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
   T,
@@ -8,8 +9,6 @@ export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
 
 export type Expect<T extends true> = T
 
-const doNotExecute = (_func: () => void) => true
-
 describe('initialData', () => {
   describe('Config object overload', () => {
     it('TData should always be defined when initialData is provided as an object', () => {