Utility Functions

function matchQuery(
  filters: QueryFilters,
  query: Query<any, any, any, any>,
): boolean

function matchMutation(
  filters: MutationFilters,
  mutation: Mutation<any, any>,
): boolean

function hashKey(queryKey: QueryKey | MutationKey): string

import { hashKey } from '@tanstack/react-query'

const hash1 = hashKey(['posts', { userId: 1, sort: 'desc' }])
const hash2 = hashKey(['posts', { sort: 'desc', userId: 1 }])

// Both produce the same hash due to key sorting
console.log(hash1 === hash2) // true

function hashQueryKeyByOptions<TQueryKey extends QueryKey = QueryKey>(
  queryKey: TQueryKey,
  options?: Pick<QueryOptions<any, any, any, any>, 'queryKeyHashFn'>,
): string

function partialMatchKey(a: QueryKey, b: QueryKey): boolean

import { partialMatchKey } from '@tanstack/react-query'

partialMatchKey(
  ['posts', { userId: 1, status: 'published' }],
  ['posts', { userId: 1 }]
) // true

partialMatchKey(
  ['posts', { userId: 1 }],
  ['posts', { userId: 2 }]
) // false

function replaceEqualDeep<T>(a: unknown, b: T, depth?: number): T

import { replaceEqualDeep } from '@tanstack/react-query'

const oldData = { user: { id: 1, name: 'John' }, posts: [1, 2, 3] }
const newData = { user: { id: 1, name: 'John' }, posts: [1, 2, 3] }

const result = replaceEqualDeep(oldData, newData)

// result.user === oldData.user (same reference)
// result.posts === oldData.posts (same reference)

function replaceData<
  TData,
  TOptions extends QueryOptions<any, any, any, any>,
>(
  prevData: TData | undefined,
  data: TData,
  options: TOptions,
): TData

function keepPreviousData<T>(previousData: T | undefined): T | undefined

import { keepPreviousData } from '@tanstack/react-query'
import { useQuery } from '@tanstack/react-query'

function Component({ page }) {
  const { data } = useQuery({
    queryKey: ['posts', page],
    queryFn: () => fetchPosts(page),
    placeholderData: keepPreviousData,
  })
  
  // Previous page data is shown while new page loads
}

function shallowEqualObjects<T extends Record<string, any>>(
  a: T,
  b: T | undefined,
): boolean

function isPlainArray(value: unknown): value is Array<unknown>

function isPlainObject(o: any): o is Record<PropertyKey, unknown>

function isValidTimeout(value: unknown): value is number

function timeUntilStale(updatedAt: number, staleTime?: number): number

function resolveStaleTime<
  TQueryFnData = unknown,
  TError = DefaultError,
  TData = TQueryFnData,
  TQueryKey extends QueryKey = QueryKey,
>(
  staleTime:
    | undefined
    | StaleTimeFunction<TQueryFnData, TError, TData, TQueryKey>,
  query: Query<TQueryFnData, TError, TData, TQueryKey>,
): StaleTime | undefined

function resolveEnabled<
  TQueryFnData = unknown,
  TError = DefaultError,
  TData = TQueryFnData,
  TQueryKey extends QueryKey = QueryKey,
>(
  enabled: undefined | Enabled<TQueryFnData, TError, TData, TQueryKey>,
  query: Query<TQueryFnData, TError, TData, TQueryKey>,
): boolean | undefined

function sleep(timeout: number): Promise<void>

function addToEnd<T>(items: Array<T>, item: T, max = 0): Array<T>

function addToStart<T>(items: Array<T>, item: T, max = 0): Array<T>

function functionalUpdate<TInput, TOutput>(
  updater: Updater<TInput, TOutput>,
  input: TInput,
): TOutput

function noop(): void

import { noop } from '@tanstack/react-query'

// Useful for avoiding unhandled promise rejections
promise.catch(noop)

function ensureQueryFn<
  TQueryFnData = unknown,
  TQueryKey extends QueryKey = QueryKey,
>(
  options: {
    queryFn?: QueryFunction<TQueryFnData, TQueryKey> | SkipToken
    queryHash?: string
  },
  fetchOptions?: FetchOptions<TQueryFnData>,
): QueryFunction<TQueryFnData, TQueryKey>

function shouldThrowError<T extends (...args: Array<any>) => boolean>(
  throwOnError: boolean | T | undefined,
  params: Parameters<T>,
): boolean

const skipToken: unique symbol
type SkipToken = typeof skipToken

import { useQuery, skipToken } from '@tanstack/react-query'

function Component({ userId }: { userId?: string }) {
  const { data } = useQuery({
    queryKey: ['user', userId],
    queryFn: userId ? () => fetchUser(userId) : skipToken,
  })
  
  // Query is skipped when userId is undefined
}

const isServer: boolean

interface QueryFilters<TQueryKey extends QueryKey = QueryKey> {
  type?: 'all' | 'active' | 'inactive'
  exact?: boolean
  predicate?: (query: Query) => boolean
  queryKey?: TQueryKey
  stale?: boolean
  fetchStatus?: 'fetching' | 'paused' | 'idle'
}

interface MutationFilters<
  TData = unknown,
  TError = DefaultError,
  TVariables = unknown,
  TOnMutateResult = unknown,
> {
  exact?: boolean
  predicate?: (mutation: Mutation<TData, TError, TVariables, TOnMutateResult>) => boolean
  mutationKey?: MutationKey
  status?: 'idle' | 'pending' | 'success' | 'error'
}

type Updater<TInput, TOutput> = TOutput | ((input: TInput) => TOutput)