import * as React from 'react' import { useSyncExternalStore } from 'use-sync-external-store/shim' import { QueryKey, QueryFunction, notifyManager, QueriesObserver, } from '@tanstack/query-core' import { useQueryClient } from './QueryClientProvider' import { UseQueryOptions, UseQueryResult } from './types' import { useIsRestoring } from './isRestoring' // This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`. // - `context` is omitted as it is passed as a root-level option to `useQueries` instead. type UseQueryOptionsForUseQueries< TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, > = Omit, 'context'> // Avoid TS depth-limit error in case of large array literal type MAXIMUM_DEPTH = 20 type GetOptions = // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData } T extends { queryFnData: infer TQueryFnData error?: infer TError data: infer TData } ? UseQueryOptionsForUseQueries : T extends { queryFnData: infer TQueryFnData; error?: infer TError } ? UseQueryOptionsForUseQueries : T extends { data: infer TData; error?: infer TError } ? UseQueryOptionsForUseQueries : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData] T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided T extends { queryFn?: QueryFunction select: (data: any) => infer TData } ? UseQueryOptionsForUseQueries : T extends { queryFn?: QueryFunction } ? UseQueryOptionsForUseQueries< TQueryFnData, unknown, TQueryFnData, TQueryKey > : // Fallback UseQueryOptionsForUseQueries type GetResults = // Part 1: responsible for mapping explicit type parameter to function result, if object T extends { queryFnData: any; error?: infer TError; data: infer TData } ? UseQueryResult : T extends { queryFnData: infer TQueryFnData; error?: infer TError } ? UseQueryResult : T extends { data: infer TData; error?: infer TError } ? UseQueryResult : // Part 2: responsible for mapping explicit type parameter to function result, if tuple T extends [any, infer TError, infer TData] ? UseQueryResult : T extends [infer TQueryFnData, infer TError] ? UseQueryResult : T extends [infer TQueryFnData] ? UseQueryResult : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided T extends { queryFn?: QueryFunction select: (data: any) => infer TData } ? UseQueryResult : T extends { queryFn?: QueryFunction } ? UseQueryResult : // Fallback UseQueryResult /** * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param */ export type QueriesOptions< T extends any[], Result extends any[] = [], Depth extends ReadonlyArray = [], > = Depth['length'] extends MAXIMUM_DEPTH ? UseQueryOptionsForUseQueries[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetOptions] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[...Tail], [...Result, GetOptions], [...Depth, 1]> : unknown[] extends T ? T : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type! // use this to infer the param types in the case of Array.map() argument T extends UseQueryOptionsForUseQueries< infer TQueryFnData, infer TError, infer TData, infer TQueryKey >[] ? UseQueryOptionsForUseQueries[] : // Fallback UseQueryOptionsForUseQueries[] /** * QueriesResults reducer recursively maps type param to results */ export type QueriesResults< T extends any[], Result extends any[] = [], Depth extends ReadonlyArray = [], > = Depth['length'] extends MAXIMUM_DEPTH ? UseQueryResult[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetResults] : T extends [infer Head, ...infer Tail] ? QueriesResults<[...Tail], [...Result, GetResults], [...Depth, 1]> : T extends UseQueryOptionsForUseQueries< infer TQueryFnData, infer TError, infer TData, any >[] ? // Dynamic-size (homogenous) UseQueryOptions array: map directly to array of results UseQueryResult[] : // Fallback UseQueryResult[] export function useQueries({ queries, context, }: { queries: readonly [...QueriesOptions] context?: UseQueryOptions['context'] }): QueriesResults { const queryClient = useQueryClient({ context }) const isRestoring = useIsRestoring() const defaultedQueries = React.useMemo( () => queries.map((options) => { const defaultedOptions = queryClient.defaultQueryOptions(options) // Make sure the results are already in fetching state before subscribing or updating options defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic' return defaultedOptions }), [queries, queryClient, isRestoring], ) const [observer] = React.useState( () => new QueriesObserver(queryClient, defaultedQueries), ) const result = observer.getOptimisticResult(defaultedQueries) useSyncExternalStore( React.useCallback( (onStoreChange) => isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer, isRestoring], ), () => observer.getCurrentResult(), () => observer.getCurrentResult(), ) React.useEffect(() => { // Do not notify on updates because of changes in the options because // these changes should already be reflected in the optimistic result. observer.setQueries(defaultedQueries, { listeners: false }) }, [defaultedQueries, observer]) return result as QueriesResults }