@tanstack/query-core 5.0.0-beta.6 → 5.0.0-rc.0

package/src/tests/query.test.tsx

@@ -325,7 +325,7 @@ describe('query', () => {
   test('should not continue if explicitly cancelled', async () => {
     const key = queryKey()
 
-    const queryFn = vi.fn<unknown[], unknown>()
+    const queryFn = vi.fn<Array<unknown>, unknown>()
 
     queryFn.mockImplementation(async () => {
       await sleep(10)
@@ -357,7 +357,7 @@ describe('query', () => {
   test('should not error if reset while pending', async () => {
     const key = queryKey()
 
-    const queryFn = vi.fn<unknown[], unknown>()
+    const queryFn = vi.fn<Array<unknown>, unknown>()
 
     queryFn.mockImplementation(async () => {
       await sleep(10)
@@ -384,7 +384,7 @@ describe('query', () => {
   test('should be able to refetch a cancelled query', async () => {
     const key = queryKey()
 
-    const queryFn = vi.fn<unknown[], unknown>()
+    const queryFn = vi.fn<Array<unknown>, unknown>()
 
     queryFn.mockImplementation(async () => {
       await sleep(50)
@@ -864,4 +864,56 @@ describe('query', () => {
 
     unsubscribe()
   })
+
+  test('should always revert to idle state (#5958)', async () => {
+    let mockedData = [1]
+
+    const key = queryKey()
+
+    const queryFn = vi
+      .fn<
+        [QueryFunctionContext<ReturnType<typeof queryKey>>],
+        Promise<unknown>
+      >()
+      .mockImplementation(({ signal }) => {
+        return new Promise((resolve, reject) => {
+          const abortListener = () => {
+            clearTimeout(timerId)
+            reject(signal.reason)
+          }
+          signal.addEventListener('abort', abortListener)
+
+          const timerId = setTimeout(() => {
+            signal.removeEventListener('abort', abortListener)
+            resolve(mockedData.join(' - '))
+          }, 50)
+        })
+      })
+
+    const observer = new QueryObserver(queryClient, {
+      queryKey: key,
+      queryFn,
+    })
+    const unsubscribe = observer.subscribe(() => undefined)
+    await sleep(60) // let it resolve
+
+    mockedData = [1, 2] // update "server" state in the background
+
+    queryClient.invalidateQueries({ queryKey: key })
+    await sleep(1)
+    queryClient.invalidateQueries({ queryKey: key })
+    await sleep(1)
+    unsubscribe() // unsubscribe to simulate unmount
+
+    // set up a new observer to simulate a mount of new component
+    const newObserver = new QueryObserver(queryClient, {
+      queryKey: key,
+      queryFn,
+    })
+
+    const spy = vi.fn()
+    newObserver.subscribe(({ data }) => spy(data))
+    await sleep(60) // let it resolve
+    expect(spy).toHaveBeenCalledWith('1 - 2')
+  })
 })

package/src/tests/queryClient.test.tsx

@@ -150,6 +150,45 @@ describe('queryClient', () => {
     })
   })
 
+  describe('defaultQueryOptions', () => {
+    test('should default networkMode when persister is present', async () => {
+      expect(
+        createQueryClient({
+          defaultOptions: {
+            queries: {
+              persister: 'ignore' as any,
+            },
+          },
+        }).defaultQueryOptions({ queryKey: queryKey() }).networkMode,
+      ).toBe('offlineFirst')
+    })
+
+    test('should not default networkMode without persister', async () => {
+      expect(
+        createQueryClient({
+          defaultOptions: {
+            queries: {
+              staleTime: 1000,
+            },
+          },
+        }).defaultQueryOptions({ queryKey: queryKey() }).networkMode,
+      ).toBe(undefined)
+    })
+
+    test('should not default networkMode when already present', async () => {
+      expect(
+        createQueryClient({
+          defaultOptions: {
+            queries: {
+              persister: 'ignore' as any,
+              networkMode: 'always',
+            },
+          },
+        }).defaultQueryOptions({ queryKey: queryKey() }).networkMode,
+      ).toBe('always')
+    })
+  })
+
   describe('setQueryData', () => {
     test('should not crash if query could not be found', () => {
       const key = queryKey()
@@ -584,7 +623,7 @@ describe('queryClient', () => {
           StrictData,
           StrictQueryKey,
           number
-        >({ queryKey: key, queryFn: fetchFn, defaultPageParam: 0 }),
+        >({ queryKey: key, queryFn: fetchFn, initialPageParam: 0 }),
       ).resolves.toEqual(data)
     })
 
@@ -592,7 +631,7 @@ describe('queryClient', () => {
       const key = queryKey()
       const result = await queryClient.fetchInfiniteQuery({
         queryKey: key,
-        defaultPageParam: 10,
+        initialPageParam: 10,
         queryFn: ({ pageParam }) => Number(pageParam),
       })
       const result2 = queryClient.getQueryData(key)
@@ -622,7 +661,7 @@ describe('queryClient', () => {
         StrictData,
         StrictQueryKey,
         number
-      >({ queryKey: key, queryFn: fetchFn, defaultPageParam: 0 })
+      >({ queryKey: key, queryFn: fetchFn, initialPageParam: 0 })
 
       const result = queryClient.getQueryData(key)
 
@@ -638,7 +677,7 @@ describe('queryClient', () => {
       await queryClient.prefetchInfiniteQuery({
         queryKey: key,
         queryFn: ({ pageParam }) => Number(pageParam),
-        defaultPageParam: 10,
+        initialPageParam: 10,
       })
 
       const result = queryClient.getQueryData(key)
@@ -657,7 +696,7 @@ describe('queryClient', () => {
         queryFn: ({ pageParam }) => String(pageParam),
         getNextPageParam: (_lastPage, _pages, lastPageParam) =>
           lastPageParam + 5,
-        defaultPageParam: 10,
+        initialPageParam: 10,
         pages: 3,
       })
 
@@ -677,7 +716,7 @@ describe('queryClient', () => {
         queryFn: ({ pageParam }) => String(pageParam),
         getNextPageParam: (_lastPage, _pages, lastPageParam) =>
           lastPageParam >= 20 ? undefined : lastPageParam + 5,
-        defaultPageParam: 10,
+        initialPageParam: 10,
         pages: 5,
       })
 
@@ -851,7 +890,7 @@ describe('queryClient', () => {
   describe('refetchQueries', () => {
     test('should not refetch if all observers are disabled', async () => {
       const key = queryKey()
-      const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
+      const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
       await queryClient.fetchQuery({ queryKey: key, queryFn })
       const observer1 = new QueryObserver(queryClient, {
         queryKey: key,
@@ -865,7 +904,7 @@ describe('queryClient', () => {
     })
     test('should refetch if at least one observer is enabled', async () => {
       const key = queryKey()
-      const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
+      const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
       await queryClient.fetchQuery({ queryKey: key, queryFn })
       const observer1 = new QueryObserver(queryClient, {
         queryKey: key,
@@ -887,8 +926,8 @@ describe('queryClient', () => {
     test('should refetch all queries when no arguments are given', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer1 = new QueryObserver(queryClient, {
@@ -913,8 +952,8 @@ describe('queryClient', () => {
     test('should be able to refetch all fresh queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -932,8 +971,8 @@ describe('queryClient', () => {
     test('should be able to refetch all stale queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -952,8 +991,8 @@ describe('queryClient', () => {
     test('should be able to refetch all stale and active queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       queryClient.invalidateQueries({ queryKey: key1 })
@@ -974,8 +1013,8 @@ describe('queryClient', () => {
     test('should be able to refetch all active and inactive queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -993,8 +1032,8 @@ describe('queryClient', () => {
     test('should be able to refetch all active and inactive queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1012,8 +1051,8 @@ describe('queryClient', () => {
     test('should be able to refetch only active queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1031,8 +1070,8 @@ describe('queryClient', () => {
     test('should be able to refetch only inactive queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1071,7 +1110,7 @@ describe('queryClient', () => {
 
     test('should resolve Promise immediately if query is paused', async () => {
       const key1 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       const onlineMock = mockOnlineManagerIsOnline(false)
 
@@ -1085,7 +1124,7 @@ describe('queryClient', () => {
     test('should refetch if query we are offline but query networkMode is always', async () => {
       const key1 = queryKey()
       queryClient.setQueryDefaults(key1, { networkMode: 'always' })
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       const onlineMock = mockOnlineManagerIsOnline(false)
 
@@ -1101,8 +1140,8 @@ describe('queryClient', () => {
     test('should refetch active queries by default', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1120,8 +1159,8 @@ describe('queryClient', () => {
     test('should not refetch inactive queries by default', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1139,8 +1178,8 @@ describe('queryClient', () => {
     test('should not refetch active queries when "refetch" is "none"', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1161,8 +1200,8 @@ describe('queryClient', () => {
     test('should refetch inactive queries when "refetch" is "inactive"', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1185,8 +1224,8 @@ describe('queryClient', () => {
     test('should refetch active and inactive queries when "refetch" is "all"', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1307,8 +1346,8 @@ describe('queryClient', () => {
     test('should refetch all active queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
-      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<Array<unknown>, string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<Array<unknown>, string>().mockReturnValue('data2')
       const observer1 = new QueryObserver(queryClient, {
         queryKey: key1,
         queryFn: queryFn1,

package/src/tests/queryObserver.test.tsx

@@ -1,6 +1,6 @@
 import { vi } from 'vitest'
 import { QueryObserver, focusManager } from '..'
-import { createQueryClient, expectType, queryKey, sleep } from './utils'
+import { createQueryClient, queryKey, sleep } from './utils'
 import type { QueryClient, QueryObserverResult } from '..'
 
 describe('queryObserver', () => {
@@ -17,7 +17,7 @@ describe('queryObserver', () => {
 
   test('should trigger a fetch when subscribed', async () => {
     const key = queryKey()
-    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
+    const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
     const observer = new QueryObserver(queryClient, { queryKey: key, queryFn })
     const unsubscribe = observer.subscribe(() => undefined)
     await sleep(1)
@@ -28,7 +28,7 @@ describe('queryObserver', () => {
   test('should notify when switching query', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const results: QueryObserverResult[] = []
+    const results: Array<QueryObserverResult> = []
     const observer = new QueryObserver(queryClient, {
       queryKey: key1,
       queryFn: () => 1,
@@ -56,7 +56,7 @@ describe('queryObserver', () => {
     })
     let observerResult
     const unsubscribe = observer.subscribe((result) => {
-      expectType<QueryObserverResult<{ myCount: number }>>(result)
+      expectTypeOf<QueryObserverResult<{ myCount: number }>>(result)
       observerResult = result
     })
     await sleep(1)
@@ -72,7 +72,7 @@ describe('queryObserver', () => {
       select: (data) => ({ myCount: data.count }),
     })
     const observerResult = await observer.refetch()
-    expectType<{ myCount: number } | undefined>(observerResult.data)
+    expectTypeOf<{ myCount: number } | undefined>(observerResult.data)
     expect(observerResult.data).toMatchObject({ myCount: 1 })
   })
 
@@ -113,7 +113,7 @@ describe('queryObserver', () => {
   test('should run the selector again if the selector changed', async () => {
     const key = queryKey()
     let count = 0
-    const results: QueryObserverResult[] = []
+    const results: Array<QueryObserverResult> = []
     const queryFn = () => ({ count: 1 })
     const select1 = (data: ReturnType<typeof queryFn>) => {
       count++
@@ -172,7 +172,7 @@ describe('queryObserver', () => {
   test('should not run the selector again if the data and selector did not change', async () => {
     const key = queryKey()
     let count = 0
-    const results: QueryObserverResult[] = []
+    const results: Array<QueryObserverResult> = []
     const queryFn = () => ({ count: 1 })
     const select = (data: ReturnType<typeof queryFn>) => {
       count++
@@ -239,7 +239,7 @@ describe('queryObserver', () => {
 
   test('should always run the selector again if selector throws an error and selector is not referentially stable', async () => {
     const key = queryKey()
-    const results: QueryObserverResult[] = []
+    const results: Array<QueryObserverResult> = []
     const queryFn = async () => {
       await sleep(10)
       return { count: 1 }
@@ -281,7 +281,7 @@ describe('queryObserver', () => {
 
   test('should return stale data if selector throws an error', async () => {
     const key = queryKey()
-    const results: QueryObserverResult[] = []
+    const results: Array<QueryObserverResult> = []
     let shouldError = false
     const error = new Error('select error')
     const observer = new QueryObserver(queryClient, {
@@ -349,7 +349,7 @@ describe('queryObserver', () => {
 
   test('should not trigger a fetch when subscribed and disabled', async () => {
     const key = queryKey()
-    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
+    const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
     const observer = new QueryObserver(queryClient, {
       queryKey: key,
       queryFn,
@@ -363,7 +363,7 @@ describe('queryObserver', () => {
 
   test('should not trigger a fetch when not subscribed', async () => {
     const key = queryKey()
-    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
+    const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
     new QueryObserver(queryClient, { queryKey: key, queryFn })
     await sleep(1)
     expect(queryFn).toHaveBeenCalledTimes(0)
@@ -371,7 +371,7 @@ describe('queryObserver', () => {
 
   test('should be able to watch a query without defining a query function', async () => {
     const key = queryKey()
-    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
+    const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
     const callback = vi.fn()
     const observer = new QueryObserver(queryClient, {
       queryKey: key,
@@ -386,12 +386,12 @@ describe('queryObserver', () => {
 
   test('should accept unresolved query config in update function', async () => {
     const key = queryKey()
-    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
+    const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
     const observer = new QueryObserver(queryClient, {
       queryKey: key,
       enabled: false,
     })
-    const results: QueryObserverResult<unknown>[] = []
+    const results: Array<QueryObserverResult<unknown>> = []
     const unsubscribe = observer.subscribe((x) => {
       results.push(x)
     })
@@ -408,13 +408,13 @@ describe('queryObserver', () => {
 
   test('should be able to handle multiple subscribers', async () => {
     const key = queryKey()
-    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
+    const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
     const observer = new QueryObserver<string>(queryClient, {
       queryKey: key,
       enabled: false,
     })
-    const results1: QueryObserverResult<string>[] = []
-    const results2: QueryObserverResult<string>[] = []
+    const results1: Array<QueryObserverResult<string>> = []
+    const results2: Array<QueryObserverResult<string>> = []
     const unsubscribe1 = observer.subscribe((x) => {
       results1.push(x)
     })
@@ -490,7 +490,7 @@ describe('queryObserver', () => {
       data: 'placeholder',
     })
 
-    const results: QueryObserverResult<unknown>[] = []
+    const results: Array<QueryObserverResult<unknown>> = []
 
     const unsubscribe = observer.subscribe((x) => {
       results.push(x)
@@ -568,7 +568,7 @@ describe('queryObserver', () => {
 
   test('should not refetch in background if refetchIntervalInBackground is false', async () => {
     const key = queryKey()
-    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
+    const queryFn = vi.fn<Array<unknown>, string>().mockReturnValue('data')
 
     focusManager.setFocused(false)
     const observer = new QueryObserver(queryClient, {
@@ -692,8 +692,8 @@ describe('queryObserver', () => {
   })
 
   test('should pass the correct previous queryKey (from prevQuery) to placeholderData function params with select', async () => {
-    const results: QueryObserverResult[] = []
-    const keys: Array<readonly unknown[] | null> = []
+    const results: Array<QueryObserverResult> = []
+    const keys: Array<ReadonlyArray<unknown> | null> = []
 
     const key1 = queryKey()
     const key2 = queryKey()
@@ -758,7 +758,7 @@ describe('queryObserver', () => {
   })
 
   test('should pass the correct previous data to placeholderData function params when select function is used in conjunction', async () => {
-    const results: QueryObserverResult[] = []
+    const results: Array<QueryObserverResult> = []
 
     const key1 = queryKey()
     const key2 = queryKey()

package/src/tests/utils.test.tsx

@@ -173,8 +173,8 @@ describe('core/utils', () => {
     })
 
     it('should return the previous value when the next value is an equal empty array', () => {
-      const prev: any[] = []
-      const next: any[] = []
+      const prev: Array<any> = []
+      const next: Array<any> = []
       expect(replaceEqualDeep(prev, next)).toBe(prev)
     })
 

package/src/tests/utils.ts

@@ -41,11 +41,6 @@ export function setActTimeout(fn: () => void, ms?: number) {
   }, ms)
 }
 
-/**
- * Assert the parameter is of a specific type.
- */
-export const expectType = <T>(_: T): void => undefined
-
 export const executeMutation = <TVariables>(
   queryClient: QueryClient,
   options: MutationOptions<any, any, TVariables, any>,