@suspensive/react-query-4 3.2.2 → 3.3.0

package/dist/useSuspenseQuery.d.ts

@@ -1,15 +1,34 @@
-import { QueryKey, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
-import { O as OmitKeyof } from './OmitKeyof-CFsZLI4k.js';
+import { useSuspenseQuery as useSuspenseQuery$1, UseSuspenseQueryOptions as UseSuspenseQueryOptions$1, UseSuspenseQueryResult as UseSuspenseQueryResult$1 } from '@tanstack/react-query';
 
-interface UseSuspenseQueryResult<TData = unknown, TError = unknown> extends OmitKeyof<UseQueryResult<TData, TError>, keyof Pick<UseQueryResult, 'isPlaceholderData'>> {
-    data: TData;
-    status: 'success';
-}
-type UseSuspenseQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'suspense' | 'useErrorBoundary' | 'enabled' | 'placeholderData' | 'networkMode'>;
 /**
- * This hook is wrapping `useQuery` of `@tanstack/react-query` v4 with default suspense option.
- * @see {@link https://suspensive.org/docs/react-query/useSuspenseQuery Suspensive Docs}
+ * This feature is officially supported in \@tanstack/react-query@^4.40.0, You can proceed with the migration.
+ * @deprecated Use `UseSuspenseQueryOptions` from \@tanstack/react-query@^4.40.0
+ * @example
+ * ```diff
+ * - import type { UseSuspenseQueryOptions } from '@suspensive/react-query'
+ * + import type { UseSuspenseQueryOptions } from '@tanstack/react-query'
+ * ```
  */
-declare function useSuspenseQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UseSuspenseQueryResult<TData, TError>;
+type UseSuspenseQueryOptions = UseSuspenseQueryOptions$1;
+/**
+ * This feature is officially supported in \@tanstack/react-query@^4.40.0, You can proceed with the migration.
+ * @deprecated Use `UseSuspenseQueryResult` from \@tanstack/react-query@^4.40.0
+ * @example
+ * ```diff
+ * - import type { UseSuspenseQueryResult } from '@suspensive/react-query'
+ * + import type { UseSuspenseQueryResult } from '@tanstack/react-query'
+ * ```
+ */
+type UseSuspenseQueryResult = UseSuspenseQueryResult$1;
+/**
+ * This feature is officially supported in \@tanstack/react-query@^4.40.0, You can proceed with the migration.
+ * @deprecated Use `useSuspenseQuery` from \@tanstack/react-query@^4.40.0
+ * @example
+ * ```diff
+ * - import { useSuspenseQuery } from '@suspensive/react-query'
+ * + import { useSuspenseQuery } from '@tanstack/react-query'
+ * ```
+ */
+declare const useSuspenseQuery: typeof useSuspenseQuery$1;
 
 export { type UseSuspenseQueryOptions, type UseSuspenseQueryResult, useSuspenseQuery };

package/dist/useSuspenseQuery.js

@@ -1,7 +1,7 @@
 "use client"
 import {
   useSuspenseQuery
-} from "./chunk-3E4WCXHQ.js";
+} from "./chunk-YFVQ7O2B.js";
 import "./chunk-QETBZSG5.js";
 export {
   useSuspenseQuery

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suspensive/react-query-4",
-  "version": "3.2.2",
+  "version": "3.3.0",
   "description": "Suspensive interfaces for @tanstack/react-query@4",
   "keywords": [
     "suspensive",
@@ -39,8 +39,8 @@
     "src"
   ],
   "devDependencies": {
-    "@tanstack/react-query": "^4.36.1",
-    "@types/react": "^19.1.2",
+    "@tanstack/react-query": "4.40.0",
+    "@types/react": "^19.1.6",
     "react": "^19.1.0",
     "@suspensive/eslint-config": "0.0.1",
     "@suspensive/tsconfig": "0.0.0-development",
@@ -58,9 +58,9 @@
     "ci:attw": "attw --pack",
     "ci:eslint": "eslint \"**/*.{ts,tsx,cts,mts}\"",
     "ci:publint": "publint --strict",
-    "ci:test": "vitest run --coverage --typecheck",
+    "ci:test": "vitest run",
     "ci:type": "tsc --noEmit",
     "clean": "rimraf ./dist ./coverage ./node_modules",
-    "test:ui": "vitest --ui --coverage --typecheck"
+    "test:ui": "vitest --ui"
   }
 }

package/src/PrefetchQuery.test-d.tsx

@@ -1,7 +1,7 @@
+import { queryOptions } from '@tanstack/react-query'
 import type { ReactNode } from 'react'
 import { describe, expectTypeOf, it } from 'vitest'
 import { PrefetchQuery } from './PrefetchQuery'
-import { queryOptions } from './queryOptions'
 import { queryFn, queryKey } from './test-utils'
 
 describe('<PrefetchQuery/>', () => {

package/src/SuspenseQueries.test-d.tsx

@@ -1,9 +1,8 @@
+import { type UseSuspenseQueryResult, queryOptions } from '@tanstack/react-query'
 import type { ReactNode } from 'react'
 import { describe, expectTypeOf, it } from 'vitest'
-import { queryOptions } from './queryOptions'
 import { SuspenseQueries } from './SuspenseQueries'
 import { queryFn, queryKey } from './test-utils'
-import type { UseSuspenseQueryResult } from './useSuspenseQuery'
 
 describe('<SuspenseQueries/>', () => {
   it('type check', () => {
@@ -27,7 +26,6 @@ describe('<SuspenseQueries/>', () => {
       <SuspenseQueries queries={[{ queryKey, queryFn }, queryOptions({ queryKey, queryFn })]}>
         {([
           query1,
-
           query2,
           // @ts-expect-error Tuple type '[UseSuspenseQueryResult<{ text: string; }, unknown>]' of length '1' has no element at index '2'.
           query3,

package/src/SuspenseQueries.tsx

@@ -1,5 +1,5 @@
+import { type SuspenseQueriesOptions, type SuspenseQueriesResults, useSuspenseQueries } from '@tanstack/react-query'
 import type { ReactNode } from 'react'
-import { type SuspenseQueriesOptions, type SuspenseQueriesResults, useSuspenseQueries } from './useSuspenseQueries'
 
 /**
  * We provide these components to clearly express what causes suspense at the same depth.

package/src/SuspenseQuery.test-d.tsx

@@ -1,9 +1,8 @@
+import { type UseSuspenseQueryResult, queryOptions } from '@tanstack/react-query'
 import type { ReactNode } from 'react'
 import { describe, expectTypeOf, it } from 'vitest'
-import { queryOptions } from './queryOptions'
 import { SuspenseQuery } from './SuspenseQuery'
 import { queryFn, queryKey } from './test-utils'
-import type { UseSuspenseQueryResult } from './useSuspenseQuery'
 
 describe('<SuspenseQuery/>', () => {
   it('type check', () => {
@@ -72,7 +71,7 @@ describe('<SuspenseQuery/>', () => {
         {(query) => {
           expectTypeOf(query).toEqualTypeOf<UseSuspenseQueryResult<{ text: string }>>()
           expectTypeOf(query.data).toEqualTypeOf<{ text: string }>()
-          expectTypeOf(query.status).toEqualTypeOf<'success'>()
+          expectTypeOf(query.status).toEqualTypeOf<'success' | 'error'>()
           return <></>
         }}
       </SuspenseQuery>
@@ -82,7 +81,7 @@ describe('<SuspenseQuery/>', () => {
         {(selectedQuery) => {
           expectTypeOf(selectedQuery).toEqualTypeOf<UseSuspenseQueryResult<string>>()
           expectTypeOf(selectedQuery.data).toEqualTypeOf<string>()
-          expectTypeOf(selectedQuery.status).toEqualTypeOf<'success'>()
+          expectTypeOf(selectedQuery.status).toEqualTypeOf<'error' | 'success'>()
           return <></>
         }}
       </SuspenseQuery>
@@ -98,7 +97,7 @@ describe('<SuspenseQuery/>', () => {
         {(query) => {
           expectTypeOf(query).toEqualTypeOf<UseSuspenseQueryResult<{ text: string }>>()
           expectTypeOf(query.data).toEqualTypeOf<{ text: string }>()
-          expectTypeOf(query.status).toEqualTypeOf<'success'>()
+          expectTypeOf(query.status).toEqualTypeOf<'error' | 'success'>()
           return <></>
         }}
       </SuspenseQuery>
@@ -108,7 +107,7 @@ describe('<SuspenseQuery/>', () => {
         {(selectedQuery) => {
           expectTypeOf(selectedQuery).toEqualTypeOf<UseSuspenseQueryResult<string>>()
           expectTypeOf(selectedQuery.data).toEqualTypeOf<string>()
-          expectTypeOf(selectedQuery.status).toEqualTypeOf<'success'>()
+          expectTypeOf(selectedQuery.status).toEqualTypeOf<'error' | 'success'>()
           return <></>
         }}
       </SuspenseQuery>

package/src/SuspenseQuery.tsx

@@ -1,6 +1,10 @@
-import type { QueryKey } from '@tanstack/react-query'
+import {
+  type QueryKey,
+  type UseSuspenseQueryOptions,
+  type UseSuspenseQueryResult,
+  useSuspenseQuery,
+} from '@tanstack/react-query'
 import type { ReactNode } from 'react'
-import { type UseSuspenseQueryOptions, type UseSuspenseQueryResult, useSuspenseQuery } from './useSuspenseQuery'
 
 /**
  * We provide these components to clearly express what causes suspense at the same depth.

package/src/infiniteQueryOptions.ts

@@ -1,6 +1,9 @@
 import type { InfiniteData, QueryKey, UseInfiniteQueryOptions } from '@tanstack/react-query'
 import type { OmitKeyof, RequiredKeyof } from './utility-types'
 
+/**
+ * @deprecated There is no `SelectedInfiniteOptions` in \@tanstack/react-query@^4.40.0.
+ */
 export type SelectedInfiniteOptions<
   TQueryFnData,
   TError = unknown,
@@ -27,6 +30,9 @@ export type SelectedInfiniteOptions<
   select: (data: InfiniteData<TQueryFnData>) => InfiniteData<TData>
 }
 
+/**
+ * @deprecated There is no `UnSelectedInfiniteOptions` in \@tanstack/react-query@^4.40.0.
+ */
 export type UnSelectedInfiniteOptions<
   TQueryFnData,
   TError = unknown,

package/src/queryOptions.test-d.tsx

@@ -1,11 +1,17 @@
-import { type UseQueryResult, useQueries, useQuery, useQueryClient } from '@tanstack/react-query'
+import {
+  type UseQueryResult,
+  type UseSuspenseQueryResult,
+  queryOptions,
+  useQueries,
+  useQuery,
+  useQueryClient,
+  useSuspenseQueries,
+  useSuspenseQuery,
+} from '@tanstack/react-query'
 import { describe, expectTypeOf, it } from 'vitest'
-import { queryOptions } from './queryOptions'
 import { SuspenseQuery } from './SuspenseQuery'
 import { queryKey } from './test-utils'
 import { usePrefetchQuery } from './usePrefetchQuery'
-import { useSuspenseQueries } from './useSuspenseQueries'
-import { type UseSuspenseQueryResult, useSuspenseQuery } from './useSuspenseQuery'
 
 const query = {
   options1: () =>
@@ -58,26 +64,30 @@ describe('queryOptions', () => {
     ))()
   })
   it('should be used with useQueries', () => {
-    const [query1, query2, query3] = useQueries({
+    const [
+      query1,
+      query2,
+      // query3
+    ] = useQueries({
       queries: [
         query.options1(),
         { ...query.options2() },
-        queryOptions({
-          queryKey: [...queryKey, 4] as const,
-          queryFn: () => Promise.resolve({ field: 'success' }),
-          select: (data) => {
-            expectTypeOf(data).toEqualTypeOf<{ field: string }>()
-            return data.field
-          },
-        }),
+        // queryOptions({
+        //   queryKey: [...queryKey, 4] as const,
+        //   queryFn: () => Promise.resolve({ field: 'success' }),
+        //   select: (data) => {
+        //     expectTypeOf(data).toEqualTypeOf<{ field: string }>()
+        //     return data.field
+        //   },
+        // }),
       ],
     })
     expectTypeOf(query1).toEqualTypeOf<UseQueryResult<{ field: string }>>()
     expectTypeOf(query1.data).toEqualTypeOf<{ field: string } | undefined>()
     expectTypeOf(query2).toEqualTypeOf<UseQueryResult<{ field: string }>>()
     expectTypeOf(query2.data).toEqualTypeOf<{ field: string } | undefined>()
-    expectTypeOf(query3).toEqualTypeOf<UseQueryResult<string>>()
-    expectTypeOf(query3.data).toEqualTypeOf<string | undefined>()
+    // expectTypeOf(query3).toEqualTypeOf<UseQueryResult<string>>()
+    // expectTypeOf(query3.data).toEqualTypeOf<string | undefined>()
   })
   it('should be used with useSuspenseQueries', () => {
     const [query1, query2, query3] = useSuspenseQueries({

package/src/queryOptions.ts

@@ -1,6 +1,9 @@
-import type { QueryKey, UseQueryOptions } from '@tanstack/react-query'
+import { type QueryKey, type UseQueryOptions, queryOptions as original_queryOptions } from '@tanstack/react-query'
 import type { OmitKeyof, RequiredKeyof } from './utility-types'
 
+/**
+ * @deprecated There is no `SelectedQueryOptions` in \@tanstack/react-query@^4.40.0.
+ */
 export type SelectedQueryOptions<
   TQueryFnData = unknown,
   TError = unknown,
@@ -29,6 +32,9 @@ export type SelectedQueryOptions<
   select: (data: TQueryFnData) => TData
 }
 
+/**
+ * @deprecated There is no `UnSelectedQueryOptions` in \@tanstack/react-query@^4.40.0.
+ */
 export type UnSelectedQueryOptions<
   TQueryFnData = unknown,
   TError = unknown,
@@ -58,29 +64,12 @@ export type UnSelectedQueryOptions<
 }
 
 /**
- * Creates a reusable query options object that can be used across different query hooks.
- * Provides better type inference and easier query key management.
- *
- * @see {@link https://suspensive.org/docs/react-query/queryOptions Suspensive Docs}
+ * This feature is officially supported in \@tanstack/react-query@^4.40.0, You can proceed with the migration.
+ * @deprecated Use `queryOptions` from \@tanstack/react-query@^4.40.0
+ * @example
+ * ```diff
+ * - import { queryOptions } from '@suspensive/react-query'
+ * + import { queryOptions } from '@tanstack/react-query'
+ * ```
  */
-export function queryOptions<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: SelectedQueryOptions<TQueryFnData, TError, TData, TQueryKey>
-): SelectedQueryOptions<TQueryFnData, TError, TData, TQueryKey>
-
-export function queryOptions<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: UnSelectedQueryOptions<TQueryFnData, TError, TData, TQueryKey>
-): UnSelectedQueryOptions<TQueryFnData, TError, TData, TQueryKey>
-
-export function queryOptions(options: unknown) {
-  return options
-}
+export const queryOptions = original_queryOptions

package/src/usePrefetchQuery.test-d.tsx

@@ -1,4 +1,4 @@
-import { queryOptions } from './queryOptions'
+import { queryOptions } from '@tanstack/react-query'
 import { queryFn, queryKey } from './test-utils'
 import { usePrefetchQuery } from './usePrefetchQuery'
 

package/src/useSuspenseQueries.test-d.ts

@@ -1,8 +1,6 @@
+import { type UseSuspenseQueryResult, queryOptions, useSuspenseQueries } from '@tanstack/react-query'
 import { describe, expectTypeOf, it } from 'vitest'
-import { queryOptions } from './queryOptions'
 import { queryFn, queryKey, select } from './test-utils'
-import { useSuspenseQueries } from './useSuspenseQueries'
-import type { UseSuspenseQueryResult } from './useSuspenseQuery'
 
 describe('useSuspenseQueries', () => {
   it('type check', () => {
@@ -66,15 +64,15 @@ describe('useSuspenseQueries', () => {
     })
 
     expectTypeOf(query).toEqualTypeOf<UseSuspenseQueryResult<{ text: string }>>()
-    expectTypeOf(query.status).toEqualTypeOf<`success`>()
+    expectTypeOf(query.status).toEqualTypeOf<'error' | 'success'>()
     expectTypeOf(query.data).toEqualTypeOf<{ text: string }>()
 
     expectTypeOf(selectedQuery).toEqualTypeOf<UseSuspenseQueryResult<string>>()
-    expectTypeOf(selectedQuery.status).toEqualTypeOf<`success`>()
+    expectTypeOf(selectedQuery.status).toEqualTypeOf<'error' | 'success'>()
     expectTypeOf(selectedQuery.data).toEqualTypeOf<string>()
 
     expectTypeOf(selectedQueryByQueryOptions).toEqualTypeOf<UseSuspenseQueryResult<string>>()
-    expectTypeOf(selectedQueryByQueryOptions.status).toEqualTypeOf<`success`>()
+    expectTypeOf(selectedQueryByQueryOptions.status).toEqualTypeOf<'error' | 'success'>()
     expectTypeOf(selectedQueryByQueryOptions.data).toEqualTypeOf<string>()
   })
 })

package/src/useSuspenseQueries.ts

@@ -1,131 +1,46 @@
-import { type QueryFunction, type UseQueryOptions, useQueries } from '@tanstack/react-query'
-import type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './useSuspenseQuery'
-
-// Avoid TS depth-limit error in case of large array literal
-type MAXIMUM_DEPTH = 20
-
-type GetSuspenseOptions<T> =
-  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
-  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>
-        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, 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>
-              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
-                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>
-                  : // Fallback
-                    UseSuspenseQueryOptions
-
-type GetSuspenseResults<T> =
-  // Part 1: responsible for mapping explicit type parameter to function result, if object
-  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>
-        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple
-          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>
-              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
-                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>
-                  : // Fallback
-                    UseSuspenseQueryResult
+import {
+  type SuspenseQueriesOptions as original_SuspenseQueriesOptions,
+  type SuspenseQueriesResults as original_SuspenseQueriesResults,
+  useSuspenseQueries as original_useSuspenseQueries,
+} from '@tanstack/react-query'
 
 /**
- * SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ * This feature is officially supported in \@tanstack/react-query@^4.40.0, You can proceed with the migration.
+ * @deprecated Use `SuspenseQueriesOptions` from \@tanstack/react-query@^4.40.0
+ * @example
+ * ```diff
+ * - import type { SuspenseQueriesOptions } from '@suspensive/react-query'
+ * + import type { SuspenseQueriesOptions } from '@tanstack/react-query'
+ * ```
  */
 export 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
-          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
-            // use this to infer the param types in the case of Array.map() argument
-            T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>>
-            ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>>
-            : // Fallback
-              Array<UseSuspenseQueryOptions>
+> = original_SuspenseQueriesOptions<T, TResult, TDepth>
 
 /**
- * SuspenseQueriesResults reducer recursively maps type param to results
+ * This feature is officially supported in \@tanstack/react-query@^4.40.0, You can proceed with the migration.
+ * @deprecated Use `SuspenseQueriesResults` from \@tanstack/react-query@^4.40.0
+ * @example
+ * ```diff
+ * - import type { SuspenseQueriesResults } from '@suspensive/react-query'
+ * + import type { SuspenseQueriesResults } from '@tanstack/react-query'
+ * ```
  */
 export 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>>
-          ? // Dynamic-size (homogenous) UseQueryOptions array: map directly to array of results
-            Array<UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, TError>>
-          : // Fallback
-            Array<UseSuspenseQueryResult>
+> = original_SuspenseQueriesResults<T, TResult, TDepth>
 
 /**
- * This hook is wrapping `useQueries` of `@tanstack/react-query` v4 with default suspense option.
- * @see {@link https://suspensive.org/docs/react-query/useSuspenseQueries Suspensive Docs}
+ * This feature is officially supported in \@tanstack/react-query@^4.40.0, You can proceed with the migration.
+ * @deprecated Use `useSuspenseQueries` from \@tanstack/react-query@^4.40.0
+ * @example
+ * ```diff
+ * - import { useSuspenseQueries } from '@suspensive/react-query'
+ * + import { useSuspenseQueries } from '@tanstack/react-query'
+ * ```
  */
-export function useSuspenseQueries<T extends any[]>({
-  queries,
-  context,
-}: {
-  queries: readonly [...SuspenseQueriesOptions<T>]
-  context?: UseQueryOptions['context']
-}): SuspenseQueriesResults<T> {
-  return useQueries({
-    queries: queries.map((query: typeof queries) => ({
-      // eslint-disable-next-line @typescript-eslint/no-misused-spread
-      ...query,
-      suspense: true,
-    })),
-    context,
-  }) as SuspenseQueriesResults<T>
-}
+export const useSuspenseQueries = original_useSuspenseQueries

package/src/useSuspenseQuery.test-d.ts

@@ -1,7 +1,6 @@
+import { type UseSuspenseQueryResult, queryOptions, useSuspenseQuery } from '@tanstack/react-query'
 import { describe, expectTypeOf, it } from 'vitest'
-import { queryOptions } from './queryOptions'
 import { queryFn, queryKey } from './test-utils'
-import { type UseSuspenseQueryResult, useSuspenseQuery } from './useSuspenseQuery'
 
 describe('useSuspenseQuery', () => {
   it('type check', () => {
@@ -47,12 +46,12 @@ describe('useSuspenseQuery', () => {
     const result = useSuspenseQuery({ queryKey, queryFn })
     expectTypeOf(result).toEqualTypeOf<UseSuspenseQueryResult<{ text: string }>>()
     expectTypeOf(result.data).toEqualTypeOf<{ text: string }>()
-    expectTypeOf(result.status).toEqualTypeOf<'success'>()
+    expectTypeOf(result.status).toEqualTypeOf<'error' | 'success'>()
 
     const selectedResult = useSuspenseQuery({ queryKey, queryFn, select: (data) => data.text })
     expectTypeOf(selectedResult).toEqualTypeOf<UseSuspenseQueryResult<string>>()
     expectTypeOf(selectedResult.data).toEqualTypeOf<string>()
-    expectTypeOf(selectedResult.status).toEqualTypeOf<'success'>()
+    expectTypeOf(selectedResult.status).toEqualTypeOf<'error' | 'success'>()
 
     const options = queryOptions({
       queryKey,
@@ -62,7 +61,7 @@ describe('useSuspenseQuery', () => {
     const resultWithOptions = useSuspenseQuery(options)
     expectTypeOf(resultWithOptions).toEqualTypeOf<UseSuspenseQueryResult<{ text: string }>>()
     expectTypeOf(resultWithOptions.data).toEqualTypeOf<{ text: string }>()
-    expectTypeOf(resultWithOptions.status).toEqualTypeOf<'success'>()
+    expectTypeOf(resultWithOptions.status).toEqualTypeOf<'error' | 'success'>()
 
     const selectedResultWithOptions = useSuspenseQuery({
       ...options,
@@ -70,6 +69,6 @@ describe('useSuspenseQuery', () => {
     })
     expectTypeOf(selectedResultWithOptions).toEqualTypeOf<UseSuspenseQueryResult<string>>()
     expectTypeOf(selectedResultWithOptions.data).toEqualTypeOf<string>()
-    expectTypeOf(selectedResultWithOptions.status).toEqualTypeOf<'success'>()
+    expectTypeOf(selectedResultWithOptions.status).toEqualTypeOf<'error' | 'success'>()
   })
 })

package/src/useSuspenseQuery.ts

@@ -1,37 +1,38 @@
-import { type QueryKey, type UseQueryOptions, type UseQueryResult, useQuery } from '@tanstack/react-query'
-import type { OmitKeyof } from './utility-types'
+import {
+  type UseSuspenseQueryOptions as original_UseSuspenseQueryOptions,
+  type UseSuspenseQueryResult as original_UseSuspenseQueryResult,
+  useSuspenseQuery as original_useSuspenseQuery,
+} from '@tanstack/react-query'
 
-export interface UseSuspenseQueryResult<TData = unknown, TError = unknown>
-  extends OmitKeyof<UseQueryResult<TData, TError>, keyof Pick<UseQueryResult, 'isPlaceholderData'>> {
-  data: TData
-  status: 'success'
-}
+/**
+ * This feature is officially supported in \@tanstack/react-query@^4.40.0, You can proceed with the migration.
+ * @deprecated Use `UseSuspenseQueryOptions` from \@tanstack/react-query@^4.40.0
+ * @example
+ * ```diff
+ * - import type { UseSuspenseQueryOptions } from '@suspensive/react-query'
+ * + import type { UseSuspenseQueryOptions } from '@tanstack/react-query'
+ * ```
+ */
+export type UseSuspenseQueryOptions = original_UseSuspenseQueryOptions
 
-export type UseSuspenseQueryOptions<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
-> = OmitKeyof<
-  UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-  'suspense' | 'useErrorBoundary' | 'enabled' | 'placeholderData' | 'networkMode'
->
+/**
+ * This feature is officially supported in \@tanstack/react-query@^4.40.0, You can proceed with the migration.
+ * @deprecated Use `UseSuspenseQueryResult` from \@tanstack/react-query@^4.40.0
+ * @example
+ * ```diff
+ * - import type { UseSuspenseQueryResult } from '@suspensive/react-query'
+ * + import type { UseSuspenseQueryResult } from '@tanstack/react-query'
+ * ```
+ */
+export type UseSuspenseQueryResult = original_UseSuspenseQueryResult
 
 /**
- * This hook is wrapping `useQuery` of `@tanstack/react-query` v4 with default suspense option.
- * @see {@link https://suspensive.org/docs/react-query/useSuspenseQuery Suspensive Docs}
+ * This feature is officially supported in \@tanstack/react-query@^4.40.0, You can proceed with the migration.
+ * @deprecated Use `useSuspenseQuery` from \@tanstack/react-query@^4.40.0
+ * @example
+ * ```diff
+ * - import { useSuspenseQuery } from '@suspensive/react-query'
+ * + import { useSuspenseQuery } from '@tanstack/react-query'
+ * ```
  */
-export function useSuspenseQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>) {
-  return useQuery<TQueryFnData, TError, TData, TQueryKey>({
-    ...options,
-    enabled: true,
-    useErrorBoundary: true,
-    suspense: true,
-    networkMode: 'always',
-  }) as UseSuspenseQueryResult<TData, TError>
-}
+export const useSuspenseQuery = original_useSuspenseQuery