@tanstack/query-core 5.0.0-beta.18 → 5.0.0-beta.23

package/src/queriesObserver.ts

@@ -10,37 +10,37 @@ import type {
 import type { QueryClient } from './queryClient'
 import type { NotifyOptions } from './queryObserver'
 
-function difference<T>(array1: T[], array2: T[]): T[] {
+function difference<T>(array1: Array<T>, array2: Array<T>): Array<T> {
   return array1.filter((x) => !array2.includes(x))
 }
 
-function replaceAt<T>(array: T[], index: number, value: T): T[] {
+function replaceAt<T>(array: Array<T>, index: number, value: T): Array<T> {
   const copy = array.slice(0)
   copy[index] = value
   return copy
 }
 
-type QueriesObserverListener = (result: QueryObserverResult[]) => void
+type QueriesObserverListener = (result: Array<QueryObserverResult>) => void
 
 export interface QueriesObserverOptions<
-  TCombinedResult = QueryObserverResult[],
+  TCombinedResult = Array<QueryObserverResult>,
 > {
-  combine?: (result: QueryObserverResult[]) => TCombinedResult
+  combine?: (result: Array<QueryObserverResult>) => TCombinedResult
 }
 
 export class QueriesObserver<
-  TCombinedResult = QueryObserverResult[],
+  TCombinedResult = Array<QueryObserverResult>,
 > extends Subscribable<QueriesObserverListener> {
   #client: QueryClient
-  #result!: QueryObserverResult[]
-  #queries: QueryObserverOptions[]
-  #observers: QueryObserver[]
+  #result!: Array<QueryObserverResult>
+  #queries: Array<QueryObserverOptions>
+  #observers: Array<QueryObserver>
   #options?: QueriesObserverOptions<TCombinedResult>
   #combinedResult!: TCombinedResult
 
   constructor(
     client: QueryClient,
-    queries: QueryObserverOptions[],
+    queries: Array<QueryObserverOptions>,
     options?: QueriesObserverOptions<TCombinedResult>,
   ) {
     super()
@@ -53,7 +53,7 @@ export class QueriesObserver<
     this.setQueries(queries, options)
   }
 
-  #setResult(value: QueryObserverResult[]) {
+  #setResult(value: Array<QueryObserverResult>) {
     this.#result = value
     this.#combinedResult = this.#combineResult(value)
   }
@@ -82,7 +82,7 @@ export class QueriesObserver<
   }
 
   setQueries(
-    queries: QueryObserverOptions[],
+    queries: Array<QueryObserverOptions>,
     options?: QueriesObserverOptions<TCombinedResult>,
     notifyOptions?: NotifyOptions,
   ): void {
@@ -145,11 +145,11 @@ export class QueriesObserver<
   }
 
   getOptimisticResult(
-    queries: QueryObserverOptions[],
+    queries: Array<QueryObserverOptions>,
   ): [
-    rawResult: QueryObserverResult[],
-    combineResult: (r?: QueryObserverResult[]) => TCombinedResult,
-    trackResult: () => QueryObserverResult[],
+    rawResult: Array<QueryObserverResult>,
+    combineResult: (r?: Array<QueryObserverResult>) => TCombinedResult,
+    trackResult: () => Array<QueryObserverResult>,
   ] {
     const matches = this.#findMatchingObservers(queries)
     const result = matches.map((match) =>
@@ -158,7 +158,7 @@ export class QueriesObserver<
 
     return [
       result,
-      (r?: QueryObserverResult[]) => {
+      (r?: Array<QueryObserverResult>) => {
         return this.#combineResult(r ?? result)
       },
       () => {
@@ -172,7 +172,7 @@ export class QueriesObserver<
     ]
   }
 
-  #combineResult(input: QueryObserverResult[]): TCombinedResult {
+  #combineResult(input: Array<QueryObserverResult>): TCombinedResult {
     const combine = this.#options?.combine
     if (combine) {
       return replaceEqualDeep(this.#combinedResult, combine(input))
@@ -181,8 +181,8 @@ export class QueriesObserver<
   }
 
   #findMatchingObservers(
-    queries: QueryObserverOptions[],
-  ): QueryObserverMatch[] {
+    queries: Array<QueryObserverOptions>,
+  ): Array<QueryObserverMatch> {
     const prevObservers = this.#observers
     const prevObserversMap = new Map(
       prevObservers.map((observer) => [observer.options.queryHash, observer]),
@@ -192,7 +192,7 @@ export class QueriesObserver<
       this.#client.defaultQueryOptions(options),
     )
 
-    const matchingObservers: QueryObserverMatch[] =
+    const matchingObservers: Array<QueryObserverMatch> =
       defaultedQueryOptions.flatMap((defaultedOptions) => {
         const match = prevObserversMap.get(defaultedOptions.queryHash)
         if (match != null) {
@@ -218,14 +218,13 @@ export class QueriesObserver<
       )
     }
 
-    const newOrReusedObservers: QueryObserverMatch[] = unmatchedQueries.map(
-      (options) => {
+    const newOrReusedObservers: Array<QueryObserverMatch> =
+      unmatchedQueries.map((options) => {
         return {
           defaultedQueryOptions: options,
           observer: getObserver(options),
         }
-      },
-    )
+      })
 
     const sortMatchesByOrderOfQueries = (
       a: QueryObserverMatch,

package/src/query.ts

@@ -159,7 +159,7 @@ export class Query<
   #cache: QueryCache
   #promise?: Promise<TData>
   #retryer?: Retryer<TData>
-  #observers: QueryObserver<any, any, any, any, any>[]
+  #observers: Array<QueryObserver<any, any, any, any, any>>
   #defaultOptions?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>
   #abortSignalConsumed: boolean
 

package/src/queryCache.ts

@@ -168,7 +168,7 @@ export class QueryCache extends Subscribable<QueryCacheListener> {
       | undefined
   }
 
-  getAll(): Query[] {
+  getAll(): Array<Query> {
     return [...this.#queries.values()]
   }
 
@@ -182,7 +182,7 @@ export class QueryCache extends Subscribable<QueryCacheListener> {
     ) as Query<TQueryFnData, TError, TData> | undefined
   }
 
-  findAll(filters: QueryFilters = {}): Query[] {
+  findAll(filters: QueryFilters = {}): Array<Query> {
     const queries = this.getAll()
     return Object.keys(filters).length > 0
       ? queries.filter((query) => matchQuery(filters, query))

package/src/queryClient.ts

@@ -128,7 +128,7 @@ export class QueryClient {
 
   getQueriesData<TQueryFnData = unknown>(
     filters: QueryFilters,
-  ): [QueryKey, TQueryFnData | undefined][] {
+  ): Array<[QueryKey, TQueryFnData | undefined]> {
     return this.getQueryCache()
       .findAll(filters)
       .map(({ queryKey, state }) => {
@@ -167,7 +167,7 @@ export class QueryClient {
     filters: QueryFilters,
     updater: Updater<TQueryFnData | undefined, TQueryFnData | undefined>,
     options?: SetDataOptions,
-  ): [QueryKey, TQueryFnData | undefined][] {
+  ): Array<[QueryKey, TQueryFnData | undefined]> {
     return notifyManager.batch(() =>
       this.getQueryCache()
         .findAll(filters)

package/src/tests/hydration.test.tsx

@@ -69,7 +69,7 @@ describe('dehydration and rehydration', () => {
       key: [{ nestedKey: 1 }],
     })
 
-    const fetchDataAfterHydration = vi.fn<unknown[], unknown>()
+    const fetchDataAfterHydration = vi.fn<Array<unknown>, unknown>()
     await hydrationClient.prefetchQuery({
       queryKey: ['string'],
       queryFn: fetchDataAfterHydration,
@@ -196,7 +196,7 @@ describe('dehydration and rehydration', () => {
       })?.state.data,
     ).toBe('string')
 
-    const fetchDataAfterHydration = vi.fn<unknown[], unknown>()
+    const fetchDataAfterHydration = vi.fn<Array<unknown>, unknown>()
     await hydrationClient.prefetchQuery({
       queryKey: ['string', { key: ['string'], key2: 0 }],
       queryFn: fetchDataAfterHydration,

package/src/tests/infiniteQueryObserver.test.tsx

@@ -70,8 +70,8 @@ describe('InfiniteQueryObserver', () => {
 
   test('getNextPagParam and getPreviousPageParam should receive current pageParams', async () => {
     const key = queryKey()
-    let single: string[] = []
-    let all: string[] = []
+    let single: Array<string> = []
+    let all: Array<string> = []
     const observer = new InfiniteQueryObserver(queryClient, {
       queryKey: key,
       queryFn: ({ pageParam }) => String(pageParam),

package/src/tests/mutations.test.tsx

@@ -79,7 +79,7 @@ describe('mutations', () => {
       submittedAt: 0,
     })
 
-    const states: MutationState<string, unknown, string, string>[] = []
+    const states: Array<MutationState<string, unknown, string, string>> = []
 
     mutation.subscribe((state) => {
       states.push(state)
@@ -159,7 +159,7 @@ describe('mutations', () => {
       retryDelay: 1,
     })
 
-    const states: MutationState<string, unknown, string, string>[] = []
+    const states: Array<MutationState<string, unknown, string, string>> = []
 
     mutation.subscribe((state) => {
       states.push(state)

package/src/tests/queriesObserver.test.tsx

@@ -68,7 +68,7 @@ describe('queriesObserver', () => {
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
     ])
-    const results: QueryObserverResult[][] = []
+    const results: Array<Array<QueryObserverResult>> = []
     results.push(observer.getCurrentResult())
     const unsubscribe = observer.subscribe((result) => {
       results.push(result)
@@ -113,7 +113,7 @@ describe('queriesObserver', () => {
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
     ])
-    const results: QueryObserverResult[][] = []
+    const results: Array<Array<QueryObserverResult>> = []
     results.push(observer.getCurrentResult())
     const unsubscribe = observer.subscribe((result) => {
       results.push(result)
@@ -160,7 +160,7 @@ describe('queriesObserver', () => {
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
     ])
-    const results: QueryObserverResult[][] = []
+    const results: Array<Array<QueryObserverResult>> = []
     results.push(observer.getCurrentResult())
     const unsubscribe = observer.subscribe((result) => {
       results.push(result)
@@ -208,7 +208,7 @@ describe('queriesObserver', () => {
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
     ])
-    const results: QueryObserverResult[][] = []
+    const results: Array<Array<QueryObserverResult>> = []
     results.push(observer.getCurrentResult())
     const unsubscribe = observer.subscribe((result) => {
       results.push(result)

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)

package/src/tests/queryClient.test.tsx

@@ -851,7 +851,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 +865,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 +887,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 +913,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 +932,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 +952,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 +974,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 +993,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 +1012,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 +1031,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 +1071,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 +1085,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 +1101,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 +1120,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 +1139,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 +1161,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 +1185,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 +1307,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

@@ -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,
@@ -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)
     })