@tanstack/query-core 4.24.10 → 5.0.0-alpha.1

package/package.json

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

package/src/focusManager.ts

@@ -6,26 +6,24 @@ type SetupFn = (
 ) => (() => void) | undefined
 
 export class FocusManager extends Subscribable {
-  private focused?: boolean
-  private cleanup?: () => void
+  #focused?: boolean
+  #cleanup?: () => void
 
-  private setup: SetupFn
+  #setup: SetupFn
 
   constructor() {
     super()
-    this.setup = (onFocus) => {
+    this.#setup = (onFocus) => {
       // addEventListener does not exist in React Native, but window does
       // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       if (!isServer && window.addEventListener) {
         const listener = () => onFocus()
-        // Listen to visibillitychange and focus
+        // Listen to visibilitychange
         window.addEventListener('visibilitychange', listener, false)
-        window.addEventListener('focus', listener, false)
 
         return () => {
           // Be sure to unsubscribe if a new handler is set
           window.removeEventListener('visibilitychange', listener)
-          window.removeEventListener('focus', listener)
         }
       }
       return
@@ -33,22 +31,22 @@ export class FocusManager extends Subscribable {
   }
 
   protected onSubscribe(): void {
-    if (!this.cleanup) {
-      this.setEventListener(this.setup)
+    if (!this.#cleanup) {
+      this.setEventListener(this.#setup)
     }
   }
 
   protected onUnsubscribe() {
     if (!this.hasListeners()) {
-      this.cleanup?.()
-      this.cleanup = undefined
+      this.#cleanup?.()
+      this.#cleanup = undefined
     }
   }
 
   setEventListener(setup: SetupFn): void {
-    this.setup = setup
-    this.cleanup?.()
-    this.cleanup = setup((focused) => {
+    this.#setup = setup
+    this.#cleanup?.()
+    this.#cleanup = setup((focused) => {
       if (typeof focused === 'boolean') {
         this.setFocused(focused)
       } else {
@@ -58,7 +56,7 @@ export class FocusManager extends Subscribable {
   }
 
   setFocused(focused?: boolean): void {
-    this.focused = focused
+    this.#focused = focused
 
     if (focused) {
       this.onFocus()
@@ -72,18 +70,13 @@ export class FocusManager extends Subscribable {
   }
 
   isFocused(): boolean {
-    if (typeof this.focused === 'boolean') {
-      return this.focused
+    if (typeof this.#focused === 'boolean') {
+      return this.#focused
     }
 
     // document global can be unavailable in react native
-    if (typeof document === 'undefined') {
-      return true
-    }
-
-    return [undefined, 'visible', 'prerender'].includes(
-      document.visibilityState,
-    )
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    return globalThis.document?.visibilityState !== 'hidden'
   }
 }
 

package/src/index.ts

@@ -11,16 +11,7 @@ export { MutationObserver } from './mutationObserver'
 export { notifyManager } from './notifyManager'
 export { focusManager } from './focusManager'
 export { onlineManager } from './onlineManager'
-export {
-  hashQueryKey,
-  replaceEqualDeep,
-  isError,
-  isServer,
-  parseQueryArgs,
-  parseFilterArgs,
-  parseMutationFilterArgs,
-  parseMutationArgs,
-} from './utils'
+export { hashKey, replaceEqualDeep, isServer, keepPreviousData } from './utils'
 export type { MutationFilters, QueryFilters, Updater } from './utils'
 export { isCancelledError } from './retryer'
 export {
@@ -34,7 +25,6 @@ export {
 export * from './types'
 export type { Query, QueryState } from './query'
 export type { Mutation } from './mutation'
-export type { Logger } from './logger'
 export type {
   DehydrateOptions,
   DehydratedState,

package/src/infiniteQueryBehavior.ts

@@ -1,10 +1,10 @@
 import type { QueryBehavior } from './query'
-
+import { addToEnd, addToStart } from './utils'
 import type {
   InfiniteData,
+  InfiniteQueryPageParamsOptions,
   QueryFunctionContext,
-  QueryOptions,
-  RefetchQueryFilters,
+  QueryKey,
 } from './types'
 
 export function infiniteQueryBehavior<
@@ -15,12 +15,8 @@ export function infiniteQueryBehavior<
   return {
     onFetch: (context) => {
       context.fetchFn = () => {
-        const refetchPage: RefetchQueryFilters['refetchPage'] | undefined =
-          context.fetchOptions?.meta?.refetchPage
-        const fetchMore = context.fetchOptions?.meta?.fetchMore
-        const pageParam = fetchMore?.pageParam
-        const isFetchingNextPage = fetchMore?.direction === 'forward'
-        const isFetchingPreviousPage = fetchMore?.direction === 'backward'
+        const options = context.options as InfiniteQueryPageParamsOptions<TData>
+        const direction = context.fetchOptions?.meta?.fetchMore?.direction
         const oldPages = context.state.data?.pages || []
         const oldPageParams = context.state.data?.pageParams || []
         let newPageParams = oldPageParams
@@ -30,10 +26,10 @@ export function infiniteQueryBehavior<
           Object.defineProperty(object, 'signal', {
             enumerable: true,
             get: () => {
-              if (context.signal?.aborted) {
+              if (context.signal.aborted) {
                 cancelled = true
               } else {
-                context.signal?.addEventListener('abort', () => {
+                context.signal.addEventListener('abort', () => {
                   cancelled = true
                 })
               }
@@ -44,7 +40,8 @@ export function infiniteQueryBehavior<
 
         // Get query function
         const queryFn =
-          context.options.queryFn || (() => Promise.reject('Missing queryFn'))
+          context.options.queryFn ||
+          (() => Promise.reject(new Error('Missing queryFn')))
 
         const buildNewPages = (
           pages: unknown[],
@@ -52,28 +49,35 @@ export function infiniteQueryBehavior<
           page: unknown,
           previous?: boolean,
         ) => {
-          newPageParams = previous
-            ? [param, ...newPageParams]
-            : [...newPageParams, param]
-          return previous ? [page, ...pages] : [...pages, page]
+          const { maxPages } = context.options
+
+          if (previous) {
+            newPageParams = addToStart(newPageParams, param, maxPages)
+            return addToStart(pages, page, maxPages)
+          }
+
+          newPageParams = addToEnd(newPageParams, param, maxPages)
+          return addToEnd(pages, page, maxPages)
         }
 
         // Create function to fetch a page
         const fetchPage = (
           pages: unknown[],
-          manual?: boolean,
-          param?: unknown,
+          param: unknown,
           previous?: boolean,
         ): Promise<unknown[]> => {
           if (cancelled) {
-            return Promise.reject('Cancelled')
+            return Promise.reject()
           }
 
-          if (typeof param === 'undefined' && !manual && pages.length) {
+          if (typeof param === 'undefined' && pages.length) {
             return Promise.resolve(pages)
           }
 
-          const queryFnContext: QueryFunctionContext = {
+          const queryFnContext: Omit<
+            QueryFunctionContext<QueryKey, unknown>,
+            'signal'
+          > = {
             queryKey: context.queryKey,
             pageParam: param,
             meta: context.options.meta,
@@ -81,7 +85,9 @@ export function infiniteQueryBehavior<
 
           addSignalProperty(queryFnContext)
 
-          const queryFnResult = queryFn(queryFnContext)
+          const queryFnResult = queryFn(
+            queryFnContext as QueryFunctionContext<QueryKey, unknown>,
+          )
 
           const promise = Promise.resolve(queryFnResult).then((page) =>
             buildNewPages(pages, param, page, previous),
@@ -94,60 +100,30 @@ export function infiniteQueryBehavior<
 
         // Fetch first page?
         if (!oldPages.length) {
-          promise = fetchPage([])
+          promise = fetchPage([], options.defaultPageParam)
         }
 
-        // Fetch next page?
-        else if (isFetchingNextPage) {
-          const manual = typeof pageParam !== 'undefined'
-          const param = manual
-            ? pageParam
-            : getNextPageParam(context.options, oldPages)
-          promise = fetchPage(oldPages, manual, param)
-        }
-
-        // Fetch previous page?
-        else if (isFetchingPreviousPage) {
-          const manual = typeof pageParam !== 'undefined'
-          const param = manual
-            ? pageParam
-            : getPreviousPageParam(context.options, oldPages)
-          promise = fetchPage(oldPages, manual, param, true)
+        // fetch next / previous page?
+        else if (direction) {
+          const previous = direction === 'backward'
+          const param = previous
+            ? getPreviousPageParam(options, oldPages)
+            : getNextPageParam(options, oldPages)
+          promise = fetchPage(oldPages, param, previous)
         }
 
         // Refetch pages
         else {
           newPageParams = []
 
-          const manual = typeof context.options.getNextPageParam === 'undefined'
-
-          const shouldFetchFirstPage =
-            refetchPage && oldPages[0]
-              ? refetchPage(oldPages[0], 0, oldPages)
-              : true
-
           // Fetch first page
-          promise = shouldFetchFirstPage
-            ? fetchPage([], manual, oldPageParams[0])
-            : Promise.resolve(buildNewPages([], oldPageParams[0], oldPages[0]))
+          promise = fetchPage([], oldPageParams[0])
 
           // Fetch remaining pages
           for (let i = 1; i < oldPages.length; i++) {
             promise = promise.then((pages) => {
-              const shouldFetchNextPage =
-                refetchPage && oldPages[i]
-                  ? refetchPage(oldPages[i], i, oldPages)
-                  : true
-
-              if (shouldFetchNextPage) {
-                const param = manual
-                  ? oldPageParams[i]
-                  : getNextPageParam(context.options, pages)
-                return fetchPage(pages, manual, param)
-              }
-              return Promise.resolve(
-                buildNewPages(pages, oldPageParams[i], oldPages[i]),
-              )
+              const param = getNextPageParam(options, pages)
+              return fetchPage(pages, param)
             })
           }
         }
@@ -163,15 +139,15 @@ export function infiniteQueryBehavior<
   }
 }
 
-export function getNextPageParam(
-  options: QueryOptions<any, any>,
+function getNextPageParam(
+  options: InfiniteQueryPageParamsOptions<any>,
   pages: unknown[],
 ): unknown | undefined {
-  return options.getNextPageParam?.(pages[pages.length - 1], pages)
+  return options.getNextPageParam(pages[pages.length - 1], pages)
 }
 
-export function getPreviousPageParam(
-  options: QueryOptions<any, any>,
+function getPreviousPageParam(
+  options: InfiniteQueryPageParamsOptions<any>,
   pages: unknown[],
 ): unknown | undefined {
   return options.getPreviousPageParam?.(pages[0], pages)
@@ -179,38 +155,22 @@ export function getPreviousPageParam(
 
 /**
  * Checks if there is a next page.
- * Returns `undefined` if it cannot be determined.
  */
 export function hasNextPage(
-  options: QueryOptions<any, any, any, any>,
-  pages?: unknown,
-): boolean | undefined {
-  if (options.getNextPageParam && Array.isArray(pages)) {
-    const nextPageParam = getNextPageParam(options, pages)
-    return (
-      typeof nextPageParam !== 'undefined' &&
-      nextPageParam !== null &&
-      nextPageParam !== false
-    )
-  }
-  return
+  options: InfiniteQueryPageParamsOptions<any>,
+  pages?: unknown[],
+): boolean {
+  if (!pages) return false
+  return typeof getNextPageParam(options, pages) !== 'undefined'
 }
 
 /**
  * Checks if there is a previous page.
- * Returns `undefined` if it cannot be determined.
  */
 export function hasPreviousPage(
-  options: QueryOptions<any, any, any, any>,
-  pages?: unknown,
-): boolean | undefined {
-  if (options.getPreviousPageParam && Array.isArray(pages)) {
-    const previousPageParam = getPreviousPageParam(options, pages)
-    return (
-      typeof previousPageParam !== 'undefined' &&
-      previousPageParam !== null &&
-      previousPageParam !== false
-    )
-  }
-  return
+  options: InfiniteQueryPageParamsOptions<any>,
+  pages?: unknown[],
+): boolean {
+  if (!pages || !options.getPreviousPageParam) return false
+  return typeof getPreviousPageParam(options, pages) !== 'undefined'
 }

package/src/infiniteQueryObserver.ts

@@ -6,6 +6,7 @@ import type {
   InfiniteQueryObserverOptions,
   InfiniteQueryObserverResult,
   QueryKey,
+  RegisteredError,
 } from './types'
 import type { QueryClient } from './queryClient'
 import type { NotifyOptions, ObserverFetchOptions } from './queryObserver'
@@ -23,14 +24,14 @@ type InfiniteQueryObserverListener<TData, TError> = (
 
 export class InfiniteQueryObserver<
   TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
+  TError = RegisteredError,
+  TData = InfiniteData<TQueryFnData>,
   TQueryData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 > extends QueryObserver<
   TQueryFnData,
   TError,
-  InfiniteData<TData>,
+  TData,
   InfiniteData<TQueryData>,
   TQueryKey
 > {
@@ -102,27 +103,24 @@ export class InfiniteQueryObserver<
     >
   }
 
-  fetchNextPage({ pageParam, ...options }: FetchNextPageOptions = {}): Promise<
-    InfiniteQueryObserverResult<TData, TError>
-  > {
+  fetchNextPage(
+    options: FetchNextPageOptions = {},
+  ): Promise<InfiniteQueryObserverResult<TData, TError>> {
     return this.fetch({
       ...options,
       meta: {
-        fetchMore: { direction: 'forward', pageParam },
+        fetchMore: { direction: 'forward' },
       },
     })
   }
 
-  fetchPreviousPage({
-    pageParam,
-    ...options
-  }: FetchPreviousPageOptions = {}): Promise<
+  fetchPreviousPage({ ...options }: FetchPreviousPageOptions = {}): Promise<
     InfiniteQueryObserverResult<TData, TError>
   > {
     return this.fetch({
       ...options,
       meta: {
-        fetchMore: { direction: 'backward', pageParam },
+        fetchMore: { direction: 'backward' },
       },
     })
   }