@tanstack/query-core 5.8.1 → 5.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/query-core",
-  "version": "5.8.1",
+  "version": "5.8.2",
   "description": "The framework agnostic core that powers TanStack Query",
   "author": "tannerlinsley",
   "license": "MIT",

package/src/tests/queryObserver.types.test.tsx

@@ -0,0 +1,64 @@
+import { describe, it } from 'vitest'
+import { QueryObserver } from '..'
+import { createQueryClient, doNotExecute } from './utils'
+import type { Equal, Expect } from './utils'
+
+describe('placeholderData', () => {
+  describe('placeholderData function', () => {
+    it('previousQuery should have typed queryKey', () => {
+      doNotExecute(() => {
+        const queryKey = ['SomeQuery', 42, { foo: 'bar' }] as const
+        type QueryKey = typeof queryKey
+
+        new QueryObserver(createQueryClient(), {
+          queryKey,
+          placeholderData: (_, previousQuery) => {
+            const previousQueryKey = previousQuery?.queryKey
+
+            const result: Expect<
+              Equal<typeof previousQueryKey, QueryKey | undefined>
+            > = true
+            return result
+          },
+        })
+      })
+    })
+
+    it('previousQuery should have typed error', () => {
+      doNotExecute(() => {
+        class CustomError extends Error {
+          name = 'CustomError' as const
+        }
+
+        new QueryObserver<boolean, CustomError>(createQueryClient(), {
+          placeholderData: (_, previousQuery) => {
+            const error = previousQuery?.state.error
+
+            const result: Expect<
+              Equal<typeof error, CustomError | null | undefined>
+            > = true
+            return result
+          },
+        })
+      })
+    })
+
+    it('previousData should have the same type as query data', () => {
+      doNotExecute(() => {
+        const queryData = { foo: 'bar' } as const
+        type QueryData = typeof queryData
+
+        new QueryObserver(createQueryClient(), {
+          queryFn: () => queryData,
+          select: (data) => data.foo,
+          placeholderData: (previousData) => {
+            const result: Expect<
+              Equal<typeof previousData, QueryData | undefined>
+            > = true
+            return result ? previousData : undefined
+          },
+        })
+      })
+    })
+  })
+})

package/src/types.ts

@@ -140,6 +140,12 @@ export interface QueryOptions<
   retry?: RetryValue<TError>
   retryDelay?: RetryDelayValue<TError>
   networkMode?: NetworkMode
+  /**
+   * The time in milliseconds that unused/inactive cache data remains in memory.
+   * When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.
+   * When different garbage collection times are specified, the longest one will be used.
+   * Setting it to `Infinity` will disable garbage collection.
+   */
   gcTime?: number
   queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam>
   persister?: QueryPersister<
@@ -319,7 +325,12 @@ export interface QueryObserverOptions<
    */
   placeholderData?:
     | NonFunctionGuard<TQueryData>
-    | PlaceholderDataFunction<NonFunctionGuard<TQueryData>>
+    | PlaceholderDataFunction<
+        NonFunctionGuard<TQueryData>,
+        TError,
+        NonFunctionGuard<TQueryData>,
+        TQueryKey
+      >
 
   _optimisticResults?: 'optimistic' | 'isRestoring'
 }

package/src/utils.ts

@@ -297,9 +297,9 @@ function hasObjectPrototype(o: any): boolean {
   return Object.prototype.toString.call(o) === '[object Object]'
 }
 
-export function sleep(timeout: number): Promise<void> {
+export function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => {
-    setTimeout(resolve, timeout)
+    setTimeout(resolve, ms)
   })
 }