@tanstack/react-query 4.40.2 → 4.41.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/react-query",
-  "version": "4.40.2",
+  "version": "4.41.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.40.0"
+    "@tanstack/query-core": "4.41.0"
   },
   "peerDependencies": {
     "react": "^16.8.0 || ^17.0.0 || ^18.0.0",

package/src/__tests__/infiniteQueryOptions.test.tsx

@@ -0,0 +1,13 @@
+import { infiniteQueryOptions } from '../infiniteQueryOptions'
+
+describe('infiniteQueryOptions', () => {
+  it('should return the object received as a parameter without any modification.', () => {
+    const object = {
+      queryKey: ['key'],
+      queryFn: () => Promise.resolve(5),
+      getNextPageParam: () => null,
+    } as const
+
+    expect(infiniteQueryOptions(object)).toStrictEqual(object)
+  })
+})

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

@@ -0,0 +1,111 @@
+import { expectTypeOf } from 'expect-type'
+import {
+  type InfiniteData,
+  type UseInfiniteQueryResult,
+  useInfiniteQuery,
+  useQueryClient,
+} from '@tanstack/react-query'
+
+import { useSuspenseInfiniteQuery } from '../useSuspenseInfiniteQuery'
+import { infiniteQueryOptions } from '../infiniteQueryOptions'
+import { doNotExecute } from './utils'
+import type {
+  DefinedUseInfiniteQueryResult,
+  UseSuspenseInfiniteQueryResult,
+} from '../types'
+
+const infiniteQuery = {
+  options: () =>
+    infiniteQueryOptions({
+      queryKey: ['key', 1] as const,
+      queryFn: () => Promise.resolve({ field: 'success' }),
+    }),
+  optionsWithInitialData: () =>
+    infiniteQueryOptions({
+      queryKey: ['key', 2] as const,
+      queryFn: () => Promise.resolve({ field: 'success' }),
+      initialData: () => ({ pageParams: [], pages: [{ field: 'success' }] }),
+    }),
+}
+
+describe('infiniteQueryOptions', () => {
+  it('should be used with useInfiniteQuery', () => {
+    doNotExecute(() => {
+      expectTypeOf(useInfiniteQuery(infiniteQuery.options())).toEqualTypeOf<
+        UseInfiniteQueryResult<{ field: string }>
+      >()
+
+      expectTypeOf(
+        useInfiniteQuery({
+          ...infiniteQuery.options(),
+          select: (data) => ({
+            pages: data.pages.map(({ field }) => field),
+            pageParams: data.pageParams,
+          }),
+        }),
+      ).toEqualTypeOf<UseInfiniteQueryResult<string>>()
+
+      expectTypeOf(
+        useInfiniteQuery(infiniteQuery.optionsWithInitialData()),
+      ).toEqualTypeOf<DefinedUseInfiniteQueryResult<{ field: string }>>()
+
+      expectTypeOf(
+        useInfiniteQuery({
+          ...infiniteQuery.optionsWithInitialData(),
+          select: (data) => ({
+            pages: data.pages.map(({ field }) => field),
+            pageParams: data.pageParams,
+          }),
+        }),
+      ).toEqualTypeOf<DefinedUseInfiniteQueryResult<string>>()
+
+      expectTypeOf(
+        useInfiniteQuery({
+          queryKey: ['key', 2] as const,
+          queryFn: () => Promise.resolve({ field: 'success' }),
+          initialData: () => ({
+            pages: [{ field: 'success' }],
+            pageParams: [],
+          }),
+          select: (data) => ({
+            pages: data.pages.map(({ field }) => field),
+            pageParams: data.pageParams,
+          }),
+        }),
+      ).toEqualTypeOf<DefinedUseInfiniteQueryResult<string>>()
+    })
+  })
+  it('should be used with useSuspenseInfiniteQuery', () => {
+    doNotExecute(() => {
+      expectTypeOf(
+        useSuspenseInfiniteQuery(infiniteQuery.options()),
+      ).toEqualTypeOf<UseSuspenseInfiniteQueryResult<{ field: string }>>()
+
+      expectTypeOf(
+        useSuspenseInfiniteQuery({
+          ...infiniteQuery.options(),
+          select: (data) => ({
+            pages: data.pages.map(({ field }) => field),
+            pageParams: data.pageParams,
+          }),
+        }),
+      ).toEqualTypeOf<UseSuspenseInfiniteQueryResult<string>>()
+    })
+  })
+  it('should be used with useQueryClient', () => {
+    doNotExecute(async () => {
+      const queryClient = useQueryClient()
+
+      queryClient.invalidateQueries(infiniteQuery.options())
+      queryClient.resetQueries(infiniteQuery.options())
+      queryClient.removeQueries(infiniteQuery.options())
+      queryClient.cancelQueries(infiniteQuery.options())
+      queryClient.prefetchQuery(infiniteQuery.options())
+      queryClient.refetchQueries(infiniteQuery.options())
+
+      expectTypeOf(
+        await queryClient.fetchQuery(infiniteQuery.options()),
+      ).toEqualTypeOf<InfiniteData<{ field: string }>>()
+    })
+  })
+})

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

@@ -19,13 +19,14 @@ 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,
+          }),
+        ),
+      ).toEqualTypeOf<UseQueryResult<{ field: string }>>()
       expectTypeOf(
         useQuery({
           ...queryOptions({

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

@@ -0,0 +1,115 @@
+import { expectTypeOf } from 'expect-type'
+import { infiniteQueryOptions, useSuspenseInfiniteQuery } from '..'
+import { doNotExecute, sleep } from './utils'
+import type { UseSuspenseInfiniteQueryResult } from '..'
+
+import type { InfiniteData } from '@tanstack/react-query'
+
+const queryKey = ['key'] as const
+const queryFn = () => sleep(10).then(() => ({ text: 'response' }))
+
+describe('useSuspenseInfiniteQuery', () => {
+  it('type check', () => {
+    doNotExecute(() => {
+      // @ts-expect-error no arg
+      useSuspenseInfiniteQuery()
+
+      useSuspenseInfiniteQuery({
+        queryKey,
+        queryFn,
+        // @ts-expect-error no suspense
+        suspense: boolean,
+      })
+      useSuspenseInfiniteQuery({
+        queryKey,
+        queryFn,
+        // @ts-expect-error no useErrorBoundary
+        useErrorBoundary: boolean,
+      })
+      useSuspenseInfiniteQuery({
+        queryKey,
+        queryFn,
+        // @ts-expect-error no enabled
+        enabled: boolean,
+      })
+      useSuspenseInfiniteQuery({
+        queryKey,
+        queryFn,
+        // @ts-expect-error no placeholderData
+        placeholderData: 'placeholder',
+      })
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+      useSuspenseInfiniteQuery({
+        queryKey,
+        queryFn,
+        // @ts-expect-error no isPlaceholderData
+      }).isPlaceholderData
+      useSuspenseInfiniteQuery({
+        queryKey,
+        queryFn,
+        //@ts-expect-error no networkMode
+        networkMode: 'always',
+      })
+
+      const infiniteQuery = useSuspenseInfiniteQuery({ queryKey, queryFn })
+      expectTypeOf(infiniteQuery).toEqualTypeOf<
+        UseSuspenseInfiniteQueryResult<{ text: string }>
+      >()
+      expectTypeOf(infiniteQuery.data).toEqualTypeOf<
+        InfiniteData<{ text: string }>
+      >()
+      expectTypeOf(infiniteQuery.status).toEqualTypeOf<'error' | 'success'>()
+
+      const selectedInfiniteQuery = useSuspenseInfiniteQuery({
+        queryKey,
+        queryFn,
+        select: (data) => ({
+          pages: data.pages.map(({ text }) => text),
+          pageParams: data.pageParams,
+        }),
+      })
+      expectTypeOf(selectedInfiniteQuery).toEqualTypeOf<
+        UseSuspenseInfiniteQueryResult<string>
+      >()
+      expectTypeOf(selectedInfiniteQuery.data).toEqualTypeOf<
+        InfiniteData<string>
+      >()
+      expectTypeOf(selectedInfiniteQuery.status).toEqualTypeOf<
+        'error' | 'success'
+      >()
+
+      const options = infiniteQueryOptions({
+        queryKey,
+        queryFn,
+      })
+
+      const infiniteQueryWithOptions = useSuspenseInfiniteQuery(options)
+      expectTypeOf(infiniteQueryWithOptions).toEqualTypeOf<
+        UseSuspenseInfiniteQueryResult<{ text: string }>
+      >()
+      expectTypeOf(infiniteQueryWithOptions.data).toEqualTypeOf<
+        InfiniteData<{ text: string }>
+      >()
+      expectTypeOf(infiniteQueryWithOptions.status).toEqualTypeOf<
+        'error' | 'success'
+      >()
+
+      const selectedInfiniteQueryWithOptions = useSuspenseInfiniteQuery({
+        ...options,
+        select: (data) => ({
+          pages: data.pages.map(({ text }) => text),
+          pageParams: data.pageParams,
+        }),
+      })
+      expectTypeOf(selectedInfiniteQueryWithOptions).toEqualTypeOf<
+        UseSuspenseInfiniteQueryResult<string>
+      >()
+      expectTypeOf(selectedInfiniteQueryWithOptions.data).toEqualTypeOf<
+        InfiniteData<string>
+      >()
+      expectTypeOf(selectedInfiniteQueryWithOptions.status).toEqualTypeOf<
+        'error' | 'success'
+      >()
+    })
+  })
+})

package/src/index.ts

@@ -12,6 +12,7 @@ export { useQueries } from './useQueries'
 export type { QueriesResults, QueriesOptions } from './useQueries'
 export { useQuery } from './useQuery'
 export { useSuspenseQuery } from './useSuspenseQuery'
+export { useSuspenseInfiniteQuery } from './useSuspenseInfiniteQuery'
 export { useSuspenseQueries } from './useSuspenseQueries'
 export type {
   SuspenseQueriesResults,
@@ -22,6 +23,11 @@ export type {
   DefinedInitialDataOptions,
   UndefinedInitialDataOptions,
 } from './queryOptions'
+export { infiniteQueryOptions } from './infiniteQueryOptions'
+export type {
+  DefinedInitialDataInfiniteOptions,
+  UndefinedInitialDataInfiniteOptions,
+} from './infiniteQueryOptions'
 export {
   defaultContext,
   QueryClientProvider,

package/src/infiniteQueryOptions.ts

@@ -0,0 +1,95 @@
+import type { UseInfiniteQueryOptions } from './types'
+import type {
+  InfiniteData,
+  NonUndefinedGuard,
+  OmitKeyof,
+  QueryKey,
+  WithRequired,
+} from '@tanstack/query-core'
+
+type UseInfiniteQueryOptionsOmitted<
+  TQueryFnData = unknown,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = OmitKeyof<
+  UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
+  'onSuccess' | 'onError' | 'onSettled' | 'refetchInterval'
+>
+
+type ProhibitedInfiniteQueryOptionsKeyInV5 = keyof Pick<
+  UseInfiniteQueryOptionsOmitted,
+  'useErrorBoundary' | 'suspense'
+>
+
+export type UndefinedInitialDataInfiniteOptions<
+  TQueryFnData,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = UseInfiniteQueryOptionsOmitted<TQueryFnData, TError, TData, TQueryKey> & {
+  initialData?: undefined
+}
+
+export type DefinedInitialDataInfiniteOptions<
+  TQueryFnData,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = UseInfiniteQueryOptionsOmitted<TQueryFnData, TError, TData, TQueryKey> & {
+  initialData:
+    | NonUndefinedGuard<InfiniteData<TQueryFnData>>
+    | (() => NonUndefinedGuard<InfiniteData<TQueryFnData>>)
+    | undefined
+}
+
+export function infiniteQueryOptions<
+  TQueryFnData,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  options: WithRequired<
+    OmitKeyof<
+      DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey>,
+      ProhibitedInfiniteQueryOptionsKeyInV5
+    >,
+    'queryKey'
+  >,
+): WithRequired<
+  OmitKeyof<
+    DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey>,
+    ProhibitedInfiniteQueryOptionsKeyInV5
+  >,
+  'queryKey'
+>
+
+export function infiniteQueryOptions<
+  TQueryFnData,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  options: WithRequired<
+    OmitKeyof<
+      UndefinedInitialDataInfiniteOptions<
+        TQueryFnData,
+        TError,
+        TData,
+        TQueryKey
+      >,
+      ProhibitedInfiniteQueryOptionsKeyInV5
+    >,
+    'queryKey'
+  >,
+): WithRequired<
+  OmitKeyof<
+    UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey>,
+    ProhibitedInfiniteQueryOptionsKeyInV5
+  >,
+  'queryKey'
+>
+
+export function infiniteQueryOptions(options: unknown) {
+  return options
+}

package/src/queryOptions.ts

@@ -59,7 +59,10 @@ export function queryOptions<
     'queryKey'
   >,
 ): WithRequired<
-  DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+  OmitKeyof<
+    DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+    ProhibitedQueryOptionsKeyInV5
+  >,
   'queryKey'
 >
 
@@ -77,7 +80,10 @@ export function queryOptions<
     'queryKey'
   >,
 ): WithRequired<
-  UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+  OmitKeyof<
+    UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+    ProhibitedQueryOptionsKeyInV5
+  >,
   'queryKey'
 >
 

package/src/types.ts

@@ -2,6 +2,7 @@
 
 import type * as React from 'react'
 import type {
+  DefinedInfiniteQueryObserverResult,
   DefinedQueryObserverResult,
   DistributiveOmit,
   InfiniteQueryObserverOptions,
@@ -120,6 +121,19 @@ export type UseInfiniteQueryResult<
   TError = unknown,
 > = InfiniteQueryObserverResult<TData, TError>
 
+export type DefinedUseInfiniteQueryResult<
+  TData = unknown,
+  TError = unknown,
+> = DefinedInfiniteQueryObserverResult<TData, TError>
+
+export type UseSuspenseInfiniteQueryResult<
+  TData = unknown,
+  TError = unknown,
+> = OmitKeyof<
+  DefinedInfiniteQueryObserverResult<TData, TError>,
+  'isPlaceholderData'
+>
+
 export interface UseMutationOptions<
   TData = unknown,
   TError = unknown,

package/src/useInfiniteQuery.ts

@@ -2,14 +2,39 @@
 import { InfiniteQueryObserver, parseQueryArgs } from '@tanstack/query-core'
 import { useBaseQuery } from './useBaseQuery'
 import type {
+  InfiniteData,
+  NonUndefinedGuard,
   QueryFunction,
   QueryKey,
   QueryObserver,
 } from '@tanstack/query-core'
-import type { UseInfiniteQueryOptions, UseInfiniteQueryResult } from './types'
+import type {
+  DefinedUseInfiniteQueryResult,
+  UseInfiniteQueryOptions,
+  UseInfiniteQueryResult,
+} from './types'
 
 // HOOK
 
+export function useInfiniteQuery<
+  TQueryFnData = unknown,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  options: UseInfiniteQueryOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryFnData,
+    TQueryKey
+  > & {
+    initialData:
+      | NonUndefinedGuard<InfiniteData<TQueryFnData>>
+      | (() => NonUndefinedGuard<InfiniteData<TQueryFnData>>)
+      | undefined
+  },
+): DefinedUseInfiniteQueryResult<TData, TError>
 export function useInfiniteQuery<
   TQueryFnData = unknown,
   TError = unknown,
@@ -24,6 +49,7 @@ export function useInfiniteQuery<
     TQueryKey
   >,
 ): UseInfiniteQueryResult<TData, TError>
+/** @deprecated This function overload will be removed in the next major version. */
 export function useInfiniteQuery<
   TQueryFnData = unknown,
   TError = unknown,
@@ -42,6 +68,7 @@ export function useInfiniteQuery<
     'queryKey'
   >,
 ): UseInfiniteQueryResult<TData, TError>
+/** @deprecated This function overload will be removed in the next major version. */
 export function useInfiniteQuery<
   TQueryFnData = unknown,
   TError = unknown,

package/src/useQuery.ts

@@ -55,7 +55,7 @@ export function useQuery<
   options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
 ): UseQueryResult<TData, TError>
 
-/** @deprecated */
+/** @deprecated This function overload will be removed in the next major version. */
 export function useQuery<
   TQueryFnData = unknown,
   TError = unknown,
@@ -68,7 +68,7 @@ export function useQuery<
     'queryKey' | 'initialData'
   >,
 ): UseQueryResult<TData, TError>
-/** @deprecated */
+/** @deprecated This function overload will be removed in the next major version. */
 export function useQuery<
   TQueryFnData = unknown,
   TError = unknown,
@@ -81,7 +81,7 @@ export function useQuery<
     'queryKey' | 'initialData'
   > & { initialData: TQueryFnData | (() => TQueryFnData) },
 ): DefinedUseQueryResult<TData, TError>
-/** @deprecated */
+/** @deprecated This function overload will be removed in the next major version. */
 export function useQuery<
   TQueryFnData = unknown,
   TError = unknown,
@@ -94,7 +94,7 @@ export function useQuery<
     'queryKey'
   >,
 ): UseQueryResult<TData, TError>
-/** @deprecated */
+/** @deprecated This function overload will be removed in the next major version. */
 export function useQuery<
   TQueryFnData = unknown,
   TError = unknown,
@@ -108,7 +108,7 @@ export function useQuery<
     'queryKey' | 'queryFn' | 'initialData'
   > & { initialData?: () => undefined },
 ): UseQueryResult<TData, TError>
-/** @deprecated */
+/** @deprecated This function overload will be removed in the next major version. */
 export function useQuery<
   TQueryFnData = unknown,
   TError = unknown,
@@ -122,7 +122,7 @@ export function useQuery<
     'queryKey' | 'queryFn' | 'initialData'
   > & { initialData: TQueryFnData | (() => TQueryFnData) },
 ): DefinedUseQueryResult<TData, TError>
-/** @deprecated */
+/** @deprecated This function overload will be removed in the next major version. */
 export function useQuery<
   TQueryFnData = unknown,
   TError = unknown,

package/src/useSuspenseInfiniteQuery.ts

@@ -0,0 +1,62 @@
+import { InfiniteQueryObserver } from '@tanstack/query-core'
+import { useBaseQuery } from './useBaseQuery'
+import type {
+  InfiniteQueryObserverSuccessResult,
+  OmitKeyof,
+  QueryKey,
+  QueryObserver,
+  WithRequired,
+} from '@tanstack/query-core'
+import type {
+  UseInfiniteQueryOptions,
+  UseSuspenseInfiniteQueryResult,
+} from './types'
+
+export type UseSuspenseInfiniteQueryOptions<
+  TQueryFnData = unknown,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = WithRequired<
+  OmitKeyof<
+    UseInfiniteQueryOptions<
+      TQueryFnData,
+      TError,
+      TData,
+      TQueryFnData,
+      TQueryKey
+    >,
+    | 'suspense'
+    | 'useErrorBoundary'
+    | 'enabled'
+    | 'placeholderData'
+    | 'networkMode'
+    | 'initialData'
+  >,
+  'queryKey'
+>
+
+export function useSuspenseInfiniteQuery<
+  TQueryFnData = unknown,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  options: UseSuspenseInfiniteQueryOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey
+  >,
+): UseSuspenseInfiniteQueryResult<TData, TError> {
+  return useBaseQuery(
+    {
+      ...options,
+      enabled: true,
+      suspense: true,
+      useErrorBoundary: true,
+      networkMode: 'always',
+    },
+    InfiniteQueryObserver as typeof QueryObserver,
+  ) as InfiniteQueryObserverSuccessResult<TData, TError>
+}

package/build/lib/Hydrate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Hydrate.d.ts","sourceRoot":"","sources":["../../src/Hydrate.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,wBAAgB,UAAU,CACxB,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,cAAc,GAAG,cAAmB,QAgB9C;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,OAAO,CAAC,EAAE,cAAc,CAAA;IACxB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAC3B;AAED,eAAO,MAAM,OAAO,iCAAkC,YAAY,uEAGjE,CAAA"}

package/build/lib/QueryClientProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClientProvider.d.ts","sourceRoot":"","sources":["../../src/QueryClientProvider.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,uBAAuB,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAA;KACjE;CACF;AAED,eAAO,MAAM,cAAc,wCAE1B,CAAA;AA4BD,eAAO,MAAM,cAAc,iBAAiB,cAAc,gBAUzD,CAAA;AAED,aAAK,4BAA4B,GAAG;IAClC,MAAM,EAAE,WAAW,CAAA;IACnB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAC3B,CAAA;AACD,aAAK,mCAAmC,GAAG,cAAc,GAAG;IAC1D,cAAc,CAAC,EAAE,KAAK,CAAA;CACvB,GAAG,4BAA4B,CAAA;AAChC,aAAK,0CAA0C,GAAG;IAChD,OAAO,CAAC,EAAE,KAAK,CAAA;IACf,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB,GAAG,4BAA4B,CAAA;AAEhC,oBAAY,wBAAwB,GAChC,mCAAmC,GACnC,0CAA0C,CAAA;AAE9C,eAAO,MAAM,mBAAmB,mDAK7B,wBAAwB,KAAG,WAuB7B,CAAA"}

package/build/lib/QueryErrorResetBoundary.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryErrorResetBoundary.d.ts","sourceRoot":"","sources":["../../src/QueryErrorResetBoundary.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,MAAM,WAAW,4BAA4B;IAC3C,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,OAAO,EAAE,MAAM,OAAO,CAAA;IACtB,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAqBD,eAAO,MAAM,0BAA0B,oCACW,CAAA;AAIlD,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EACJ,CAAC,CAAC,KAAK,EAAE,4BAA4B,KAAK,KAAK,CAAC,SAAS,CAAC,GAC1D,KAAK,CAAC,SAAS,CAAA;CACpB;AAED,eAAO,MAAM,uBAAuB,kBAEjC,4BAA4B,gBAS9B,CAAA"}

package/build/lib/__tests__/Hydrate.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Hydrate.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/Hydrate.test.tsx"],"names":[],"mappings":""}

package/build/lib/__tests__/QueryClientProvider.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryClientProvider.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/QueryClientProvider.test.tsx"],"names":[],"mappings":""}

package/build/lib/__tests__/QueryResetErrorBoundary.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryResetErrorBoundary.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/QueryResetErrorBoundary.test.tsx"],"names":[],"mappings":"AAQA,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,8BAA8B;QACtC,QAAQ,EAAE,GAAG,CAAA;KACd;CACF"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"queryOptions.types.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/queryOptions.types.test.tsx"],"names":[],"mappings":""}

package/build/lib/__tests__/ssr-hydration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssr-hydration.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/ssr-hydration.test.tsx"],"names":[],"mappings":""}

package/build/lib/__tests__/ssr.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssr.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/ssr.test.tsx"],"names":[],"mappings":"AAAA;;GAEG"}

package/build/lib/__tests__/suspense.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"suspense.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/suspense.test.tsx"],"names":[],"mappings":""}

package/build/lib/__tests__/useInfiniteQuery.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useInfiniteQuery.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/useInfiniteQuery.test.tsx"],"names":[],"mappings":""}

package/build/lib/__tests__/useIsFetching.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useIsFetching.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/useIsFetching.test.tsx"],"names":[],"mappings":""}

package/build/lib/__tests__/useIsMutating.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useIsMutating.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/useIsMutating.test.tsx"],"names":[],"mappings":""}

package/build/lib/__tests__/useMutation.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useMutation.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/useMutation.test.tsx"],"names":[],"mappings":"AACA,OAAO,2BAA2B,CAAA"}

package/build/lib/__tests__/useQueries.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useQueries.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/useQueries.test.tsx"],"names":[],"mappings":""}