@tanstack/react-query 5.0.0-alpha.4 → 5.0.0-alpha.42

package/build/umd/index.development.js

@@ -25,19 +25,19 @@
 
   class Subscribable {
     constructor() {
-      this.listeners = [];
+      this.listeners = new Set();
       this.subscribe = this.subscribe.bind(this);
     }
     subscribe(listener) {
-      this.listeners.push(listener);
+      this.listeners.add(listener);
       this.onSubscribe();
       return () => {
-        this.listeners = this.listeners.filter(x => x !== listener);
+        this.listeners.delete(listener);
         this.onUnsubscribe();
       };
     }
     hasListeners() {
-      return this.listeners.length > 0;
+      return this.listeners.size > 0;
     }
     onSubscribe() {
       // Do nothing
@@ -406,6 +406,8 @@
   }
   const onlineManager = new OnlineManager();
 
+  // TYPES
+
   function defaultRetryDelay(failureCount) {
     return Math.min(1000 * 2 ** failureCount, 30000);
   }
@@ -926,7 +928,7 @@
             {
               console.error(`Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`);
             }
-            onError(new Error('undefined'));
+            onError(new Error(`${this.queryHash} data is undefined`));
             return;
           }
           this.setData(data);
@@ -1043,7 +1045,7 @@
       this.state = reducer(this.state);
       notifyManager.batch(() => {
         this.#observers.forEach(observer => {
-          observer.onQueryUpdate(action);
+          observer.onQueryUpdate();
         });
         this.#cache.notify({
           query: this,
@@ -1073,6 +1075,8 @@
     };
   }
 
+  // TYPES
+
   // CLASS
 
   class QueryCache extends Subscribable {
@@ -1080,7 +1084,7 @@
     constructor(config = {}) {
       super();
       this.config = config;
-      this.#queries = config.createStore?.() ?? new Map();
+      this.#queries = new Map();
     }
     build(client, options, state) {
       const queryKey = options.queryKey;
@@ -1135,10 +1139,11 @@
       return [...this.#queries.values()];
     }
     find(filters) {
-      if (typeof filters.exact === 'undefined') {
-        filters.exact = true;
-      }
-      return this.getAll().find(query => matchQuery(filters, query));
+      const defaultedFilters = {
+        exact: true,
+        ...filters
+      };
+      return this.getAll().find(query => matchQuery(defaultedFilters, query));
     }
     findAll(filters = {}) {
       const queries = this.getAll();
@@ -1444,10 +1449,11 @@
       return this.#mutations;
     }
     find(filters) {
-      if (typeof filters.exact === 'undefined') {
-        filters.exact = true;
-      }
-      return this.#mutations.find(mutation => matchMutation(filters, mutation));
+      const defaultedFilters = {
+        exact: true,
+        ...filters
+      };
+      return this.#mutations.find(mutation => matchMutation(defaultedFilters, mutation));
     }
     findAll(filters = {}) {
       return this.#mutations.filter(mutation => matchMutation(filters, mutation));
@@ -1473,12 +1479,15 @@
   function infiniteQueryBehavior() {
     return {
       onFetch: context => {
-        context.fetchFn = () => {
+        context.fetchFn = async () => {
           const options = context.options;
           const direction = context.fetchOptions?.meta?.fetchMore?.direction;
           const oldPages = context.state.data?.pages || [];
           const oldPageParams = context.state.data?.pageParams || [];
-          let newPageParams = oldPageParams;
+          const empty = {
+            pages: [],
+            pageParams: []
+          };
           let cancelled = false;
           const addSignalProperty = object => {
             Object.defineProperty(object, 'signal', {
@@ -1498,97 +1507,99 @@
 
           // Get query function
           const queryFn = context.options.queryFn || (() => Promise.reject(new Error('Missing queryFn')));
-          const buildNewPages = (pages, param, page, previous) => {
-            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, param, previous) => {
+          const fetchPage = async (data, param, previous) => {
             if (cancelled) {
               return Promise.reject();
             }
-            if (typeof param === 'undefined' && pages.length) {
-              return Promise.resolve(pages);
+            if (typeof param === 'undefined' && data.pages.length) {
+              return Promise.resolve(data);
             }
             const queryFnContext = {
               queryKey: context.queryKey,
               pageParam: param,
+              direction: previous ? 'backward' : 'forward',
               meta: context.options.meta
             };
             addSignalProperty(queryFnContext);
-            const queryFnResult = queryFn(queryFnContext);
-            const promise = Promise.resolve(queryFnResult).then(page => buildNewPages(pages, param, page, previous));
-            return promise;
+            const page = await queryFn(queryFnContext);
+            const {
+              maxPages
+            } = context.options;
+            const addTo = previous ? addToStart : addToEnd;
+            return {
+              pages: addTo(data.pages, page, maxPages),
+              pageParams: addTo(data.pageParams, param, maxPages)
+            };
           };
-          let promise;
+          let result;
 
           // Fetch first page?
           if (!oldPages.length) {
-            promise = fetchPage([], options.defaultPageParam);
+            result = await fetchPage(empty, options.defaultPageParam);
           }
 
           // 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);
+            const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
+            const oldData = {
+              pages: oldPages,
+              pageParams: oldPageParams
+            };
+            const param = pageParamFn(options, oldData);
+            result = await fetchPage(oldData, param, previous);
           }
 
           // Refetch pages
           else {
-            newPageParams = [];
-
             // Fetch first page
-            promise = fetchPage([], oldPageParams[0]);
+            result = await fetchPage(empty, oldPageParams[0]);
 
             // Fetch remaining pages
             for (let i = 1; i < oldPages.length; i++) {
-              promise = promise.then(pages => {
-                const param = getNextPageParam(options, pages);
-                return fetchPage(pages, param);
-              });
+              const param = getNextPageParam(options, result);
+              result = await fetchPage(result, param);
             }
           }
-          const finalPromise = promise.then(pages => ({
-            pages,
-            pageParams: newPageParams
-          }));
-          return finalPromise;
+          return result;
         };
       }
     };
   }
-  function getNextPageParam(options, pages) {
-    return options.getNextPageParam(pages[pages.length - 1], pages);
+  function getNextPageParam(options, {
+    pages,
+    pageParams
+  }) {
+    const lastIndex = pages.length - 1;
+    return options.getNextPageParam(pages[lastIndex], pages, pageParams[lastIndex], pageParams);
   }
-  function getPreviousPageParam(options, pages) {
-    return options.getPreviousPageParam?.(pages[0], pages);
+  function getPreviousPageParam(options, {
+    pages,
+    pageParams
+  }) {
+    return options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams);
   }
 
   /**
    * Checks if there is a next page.
    */
-  function hasNextPage(options, pages) {
-    if (!pages) return false;
-    return typeof getNextPageParam(options, pages) !== 'undefined';
+  function hasNextPage(options, data) {
+    if (!data) return false;
+    return typeof getNextPageParam(options, data) !== 'undefined';
   }
 
   /**
    * Checks if there is a previous page.
    */
-  function hasPreviousPage(options, pages) {
-    if (!pages || !options.getPreviousPageParam) return false;
-    return typeof getPreviousPageParam(options, pages) !== 'undefined';
+  function hasPreviousPage(options, data) {
+    if (!data || !options.getPreviousPageParam) return false;
+    return typeof getPreviousPageParam(options, data) !== 'undefined';
   }
 
+  // TYPES
+
   // CLASS
 
   class QueryClient {
@@ -1711,10 +1722,11 @@
       });
     }
     cancelQueries(filters = {}, cancelOptions = {}) {
-      if (typeof cancelOptions.revert === 'undefined') {
-        cancelOptions.revert = true;
-      }
-      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).map(query => query.cancel(cancelOptions)));
+      const defaultedCancelOptions = {
+        revert: true,
+        ...cancelOptions
+      };
+      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).map(query => query.cancel(defaultedCancelOptions)));
       return Promise.all(promises).then(noop$1).catch(noop$1);
     }
     invalidateQueries(filters = {}, options = {}) {
@@ -1733,15 +1745,18 @@
       });
     }
     refetchQueries(filters = {}, options) {
-      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => query.fetch(undefined, {
+      const fetchOptions = {
         ...options,
         cancelRefetch: options?.cancelRefetch ?? true
-      })));
-      let promise = Promise.all(promises).then(noop$1);
-      if (!options?.throwOnError) {
-        promise = promise.catch(noop$1);
-      }
-      return promise;
+      };
+      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => {
+        let promise = query.fetch(undefined, fetchOptions);
+        if (!fetchOptions.throwOnError) {
+          promise = promise.catch(noop$1);
+        }
+        return query.state.fetchStatus === 'paused' ? Promise.resolve() : promise;
+      }));
+      return Promise.all(promises).then(noop$1);
     }
     fetchQuery(options) {
       const defaultedOptions = this.defaultQueryOptions(options);
@@ -1834,8 +1849,8 @@
       if (typeof defaultedOptions.refetchOnReconnect === 'undefined') {
         defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== 'always';
       }
-      if (typeof defaultedOptions.throwErrors === 'undefined') {
-        defaultedOptions.throwErrors = !!defaultedOptions.suspense;
+      if (typeof defaultedOptions.throwOnError === 'undefined') {
+        defaultedOptions.throwOnError = !!defaultedOptions.suspense;
       }
       return defaultedOptions;
     }
@@ -1863,10 +1878,12 @@
     #currentResult = undefined;
     #currentResultState;
     #currentResultOptions;
-    #previousQueryResult;
     #selectError;
     #selectFn;
     #selectResult;
+    // This property keeps track of the last query with defined data.
+    // It will be used to pass the previous data and query to the placeholder function between renders.
+    #lastQueryWithDefinedData;
     #staleTimeoutId;
     #refetchIntervalId;
     #currentRefetchInterval;
@@ -1883,7 +1900,7 @@
       this.refetch = this.refetch.bind(this);
     }
     onSubscribe() {
-      if (this.listeners.length === 1) {
+      if (this.listeners.size === 1) {
         this.#currentQuery.addObserver(this);
         if (shouldFetchOnMount(this.#currentQuery, this.options)) {
           this.#executeFetch();
@@ -1892,7 +1909,7 @@
       }
     }
     onUnsubscribe() {
-      if (!this.listeners.length) {
+      if (!this.hasListeners()) {
         this.destroy();
       }
     }
@@ -1903,7 +1920,7 @@
       return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnWindowFocus);
     }
     destroy() {
-      this.listeners = [];
+      this.listeners = new Set();
       this.#clearStaleTimeout();
       this.#clearRefetchInterval();
       this.#currentQuery.removeObserver(this);
@@ -2023,7 +2040,7 @@
       }, timeout);
     }
     #computeRefetchInterval() {
-      return typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.#currentResult.data, this.#currentQuery) : this.options.refetchInterval ?? false;
+      return (typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.#currentResult.data, this.#currentQuery) : this.options.refetchInterval) ?? false;
     }
     #updateRefetchInterval(nextInterval) {
       this.#clearRefetchInterval();
@@ -2061,7 +2078,6 @@
       const prevResultOptions = this.#currentResultOptions;
       const queryChange = query !== prevQuery;
       const queryInitialState = queryChange ? query.state : this.#currentQueryInitialState;
-      const prevQueryResult = queryChange ? this.#currentResult : this.#previousQueryResult;
       const {
         state
       } = query;
@@ -2120,7 +2136,7 @@
         if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
           placeholderData = prevResult.data;
         } else {
-          placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData(prevQueryResult?.data) : options.placeholderData;
+          placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData(this.#lastQueryWithDefinedData?.state.data, this.#lastQueryWithDefinedData) : options.placeholderData;
           if (options.select && typeof placeholderData !== 'undefined') {
             try {
               placeholderData = options.select(placeholderData);
@@ -2184,6 +2200,9 @@
       if (shallowEqualObjects(nextResult, prevResult)) {
         return;
       }
+      if (this.#currentResultState.data !== undefined) {
+        this.#lastQueryWithDefinedData = this.#currentQuery;
+      }
       this.#currentResult = nextResult;
 
       // Determine which callbacks to trigger
@@ -2199,7 +2218,7 @@
           return true;
         }
         const includedProps = new Set(notifyOnChangeProps ?? this.#trackedProps);
-        if (this.options.throwErrors) {
+        if (this.options.throwOnError) {
           includedProps.add('error');
         }
         return Object.keys(this.#currentResult).some(key => {
@@ -2224,36 +2243,20 @@
       const prevQuery = this.#currentQuery;
       this.#currentQuery = query;
       this.#currentQueryInitialState = query.state;
-      this.#previousQueryResult = this.#currentResult;
       if (this.hasListeners()) {
         prevQuery?.removeObserver(this);
         query.addObserver(this);
       }
     }
-    onQueryUpdate(action) {
-      const notifyOptions = {};
-      if (action.type === 'success') {
-        notifyOptions.onSuccess = !action.manual;
-      } else if (action.type === 'error' && !isCancelledError(action.error)) {
-        notifyOptions.onError = true;
-      }
-      this.#updateResult(notifyOptions);
+    onQueryUpdate() {
+      this.#updateResult();
       if (this.hasListeners()) {
         this.#updateTimers();
       }
     }
     #notify(notifyOptions) {
       notifyManager.batch(() => {
-        // First trigger the configuration callbacks
-        if (notifyOptions.onSuccess) {
-          this.options.onSuccess?.(this.#currentResult.data);
-          this.options.onSettled?.(this.#currentResult.data, null);
-        } else if (notifyOptions.onError) {
-          this.options.onError?.(this.#currentResult.error);
-          this.options.onSettled?.(undefined, this.#currentResult.error);
-        }
-
-        // Then trigger the listeners
+        // First, trigger the listeners
         if (notifyOptions.listeners) {
           this.listeners.forEach(listener => {
             listener(this.#currentResult);
@@ -2301,18 +2304,22 @@
     #result;
     #queries;
     #observers;
-    constructor(client, queries) {
+    #options;
+    #combinedResult;
+    constructor(client, queries, options) {
       super();
       this.#client = client;
       this.#queries = [];
-      this.#result = [];
       this.#observers = [];
-      if (queries) {
-        this.setQueries(queries);
-      }
+      this.#setResult([]);
+      this.setQueries(queries, options);
+    }
+    #setResult(value) {
+      this.#result = value;
+      this.#combinedResult = this.#combineResult(value);
     }
     onSubscribe() {
-      if (this.listeners.length === 1) {
+      if (this.listeners.size === 1) {
         this.#observers.forEach(observer => {
           observer.subscribe(result => {
             this.#onUpdate(observer, result);
@@ -2321,18 +2328,19 @@
       }
     }
     onUnsubscribe() {
-      if (!this.listeners.length) {
+      if (!this.listeners.size) {
         this.destroy();
       }
     }
     destroy() {
-      this.listeners = [];
+      this.listeners = new Set();
       this.#observers.forEach(observer => {
         observer.destroy();
       });
     }
-    setQueries(queries, notifyOptions) {
+    setQueries(queries, options, notifyOptions) {
       this.#queries = queries;
+      this.#options = options;
       notifyManager.batch(() => {
         const prevObservers = this.#observers;
         const newObserverMatches = this.#findMatchingObservers(this.#queries);
@@ -2346,7 +2354,7 @@
           return;
         }
         this.#observers = newObservers;
-        this.#result = newResult;
+        this.#setResult(newResult);
         if (!this.hasListeners()) {
           return;
         }
@@ -2362,7 +2370,7 @@
       });
     }
     getCurrentResult() {
-      return this.#result;
+      return this.#combinedResult;
     }
     getQueries() {
       return this.#observers.map(observer => observer.getCurrentQuery());
@@ -2371,13 +2379,30 @@
       return this.#observers;
     }
     getOptimisticResult(queries) {
-      return this.#findMatchingObservers(queries).map(match => match.observer.getOptimisticResult(match.defaultedQueryOptions));
+      const matches = this.#findMatchingObservers(queries);
+      const result = matches.map(match => match.observer.getOptimisticResult(match.defaultedQueryOptions));
+      return [result, r => {
+        return this.#combineResult(r ?? result);
+      }, () => {
+        return matches.map((match, index) => {
+          const observerResult = result[index];
+          return !match.defaultedQueryOptions.notifyOnChangeProps ? match.observer.trackResult(observerResult) : observerResult;
+        });
+      }];
+    }
+    #combineResult(input) {
+      const combine = this.#options?.combine;
+      if (combine) {
+        return replaceEqualDeep(this.#combinedResult, combine(input));
+      }
+      return input;
     }
     #findMatchingObservers(queries) {
       const prevObservers = this.#observers;
+      const prevObserversMap = new Map(prevObservers.map(observer => [observer.options.queryHash, observer]));
       const defaultedQueryOptions = queries.map(options => this.#client.defaultQueryOptions(options));
       const matchingObservers = defaultedQueryOptions.flatMap(defaultedOptions => {
-        const match = prevObservers.find(observer => observer.options.queryHash === defaultedOptions.queryHash);
+        const match = prevObserversMap.get(defaultedOptions.queryHash);
         if (match != null) {
           return [{
             defaultedQueryOptions: defaultedOptions,
@@ -2386,8 +2411,8 @@
         }
         return [];
       });
-      const matchedQueryHashes = matchingObservers.map(match => match.defaultedQueryOptions.queryHash);
-      const unmatchedQueries = defaultedQueryOptions.filter(defaultedOptions => !matchedQueryHashes.includes(defaultedOptions.queryHash));
+      const matchedQueryHashes = new Set(matchingObservers.map(match => match.defaultedQueryOptions.queryHash));
+      const unmatchedQueries = defaultedQueryOptions.filter(defaultedOptions => !matchedQueryHashes.has(defaultedOptions.queryHash));
       const getObserver = options => {
         const defaultedOptions = this.#client.defaultQueryOptions(options);
         const currentObserver = this.#observers.find(o => o.options.queryHash === defaultedOptions.queryHash);
@@ -2405,7 +2430,7 @@
     #onUpdate(observer, result) {
       const index = this.#observers.indexOf(observer);
       if (index !== -1) {
-        this.#result = replaceAt(this.#result, index, result);
+        this.#setResult(replaceAt(this.#result, index, result));
         this.#notify();
       }
     }
@@ -2444,7 +2469,7 @@
       options.behavior = infiniteQueryBehavior();
       return super.getOptimisticResult(options);
     }
-    fetchNextPage(options = {}) {
+    fetchNextPage(options) {
       return this.fetch({
         ...options,
         meta: {
@@ -2454,9 +2479,7 @@
         }
       });
     }
-    fetchPreviousPage({
-      ...options
-    } = {}) {
+    fetchPreviousPage(options) {
       return this.fetch({
         ...options,
         meta: {
@@ -2481,8 +2504,8 @@
         ...result,
         fetchNextPage: this.fetchNextPage,
         fetchPreviousPage: this.fetchPreviousPage,
-        hasNextPage: hasNextPage(options, state.data?.pages),
-        hasPreviousPage: hasPreviousPage(options, state.data?.pages),
+        hasNextPage: hasNextPage(options, state.data),
+        hasPreviousPage: hasPreviousPage(options, state.data),
         isFetchingNextPage,
         isFetchingPreviousPage,
         isRefetching: isRefetching && !isFetchingNextPage && !isFetchingPreviousPage
@@ -2523,7 +2546,7 @@
       this.#currentMutation?.setOptions(this.options);
     }
     onUnsubscribe() {
-      if (!this.listeners.length) {
+      if (!this.hasListeners()) {
         this.#currentMutation?.removeObserver(this);
       }
     }
@@ -2608,24 +2631,10 @@
     return query.state.status === 'success';
   }
   function dehydrate(client, options = {}) {
-    const mutations = [];
-    const queries = [];
-    if (options.dehydrateMutations !== false) {
-      const shouldDehydrateMutation = options.shouldDehydrateMutation || defaultShouldDehydrateMutation;
-      client.getMutationCache().getAll().forEach(mutation => {
-        if (shouldDehydrateMutation(mutation)) {
-          mutations.push(dehydrateMutation(mutation));
-        }
-      });
-    }
-    if (options.dehydrateQueries !== false) {
-      const shouldDehydrateQuery = options.shouldDehydrateQuery || defaultShouldDehydrateQuery;
-      client.getQueryCache().getAll().forEach(query => {
-        if (shouldDehydrateQuery(query)) {
-          queries.push(dehydrateQuery(query));
-        }
-      });
-    }
+    const filterMutation = options.shouldDehydrateMutation ?? defaultShouldDehydrateMutation;
+    const mutations = client.getMutationCache().getAll().flatMap(mutation => filterMutation(mutation) ? [dehydrateMutation(mutation)] : []);
+    const filterQuery = options.shouldDehydrateQuery ?? defaultShouldDehydrateQuery;
+    const queries = client.getQueryCache().getAll().flatMap(query => filterQuery(query) ? [dehydrateQuery(query)] : []);
     return {
       mutations,
       queries
@@ -2747,7 +2756,7 @@
   }
 
   const ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
-    if (options.suspense || options.throwErrors) {
+    if (options.suspense || options.throwOnError) {
       // Prevent retrying failed query if the error boundary has not been reset yet
       if (!errorResetBoundary.isReset()) {
         options.retryOnMount = false;
@@ -2762,10 +2771,10 @@
   const getHasError = ({
     result,
     errorResetBoundary,
-    throwErrors,
+    throwOnError,
     query
   }) => {
-    return result.isError && !errorResetBoundary.isReset() && !result.isFetching && shouldThrowError(throwErrors, [result.error, query]);
+    return result.isError && !errorResetBoundary.isReset() && !result.isFetching && shouldThrowError(throwOnError, [result.error, query]);
   };
 
   const ensureStaleTime = defaultedOptions => {
@@ -2779,57 +2788,57 @@
   };
   const willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
   const shouldSuspend = (defaultedOptions, result, isRestoring) => defaultedOptions?.suspense && willFetch(result, isRestoring);
-  const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).then(({
-    data
-  }) => {
-    defaultedOptions.onSuccess?.(data);
-    defaultedOptions.onSettled?.(data, null);
-  }).catch(error => {
+  const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
     errorResetBoundary.clearReset();
-    defaultedOptions.onError?.(error);
-    defaultedOptions.onSettled?.(undefined, error);
   });
 
   // This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
   // `placeholderData` function does not have a parameter
-
+  // Avoid TS depth-limit error in case of large array literal
+  /**
+   * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+   */
+  /**
+   * QueriesResults reducer recursively maps type param to results
+   */
   function useQueries({
-    queries
+    queries,
+    ...options
   }, queryClient) {
     const client = useQueryClient(queryClient);
     const isRestoring = useIsRestoring();
-    const defaultedQueries = React__namespace.useMemo(() => queries.map(options => {
-      const defaultedOptions = client.defaultQueryOptions(options);
+    const errorResetBoundary = useQueryErrorResetBoundary();
+    const defaultedQueries = React__namespace.useMemo(() => queries.map(opts => {
+      const defaultedOptions = client.defaultQueryOptions(opts);
 
       // Make sure the results are already in fetching state before subscribing or updating options
       defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic';
       return defaultedOptions;
     }), [queries, client, isRestoring]);
-    const [observer] = React__namespace.useState(() => new QueriesObserver(client, defaultedQueries));
-    const optimisticResult = observer.getOptimisticResult(defaultedQueries);
+    defaultedQueries.forEach(query => {
+      ensureStaleTime(query);
+      ensurePreventErrorBoundaryRetry(query, errorResetBoundary);
+    });
+    useClearResetErrorBoundary(errorResetBoundary);
+    const [observer] = React__namespace.useState(() => new QueriesObserver(client, defaultedQueries, options));
+    const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(defaultedQueries);
     React__namespace.useSyncExternalStore(React__namespace.useCallback(onStoreChange => isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
     React__namespace.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, {
+      observer.setQueries(defaultedQueries, options, {
         listeners: false
       });
-    }, [defaultedQueries, observer]);
-    const errorResetBoundary = useQueryErrorResetBoundary();
-    defaultedQueries.forEach(query => {
-      ensurePreventErrorBoundaryRetry(query, errorResetBoundary);
-      ensureStaleTime(query);
-    });
-    useClearResetErrorBoundary(errorResetBoundary);
+    }, [defaultedQueries, options, observer]);
     const shouldAtLeastOneSuspend = optimisticResult.some((result, index) => shouldSuspend(defaultedQueries[index], result, isRestoring));
     const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
-      const options = defaultedQueries[index];
+      const opts = defaultedQueries[index];
       const queryObserver = observer.getObservers()[index];
-      if (options && queryObserver) {
-        if (shouldSuspend(options, result, isRestoring)) {
-          return fetchOptimistic(options, queryObserver, errorResetBoundary);
+      if (opts && queryObserver) {
+        if (shouldSuspend(opts, result, isRestoring)) {
+          return fetchOptimistic(opts, queryObserver, errorResetBoundary);
         } else if (willFetch(result, isRestoring)) {
-          void fetchOptimistic(options, queryObserver, errorResetBoundary);
+          void fetchOptimistic(opts, queryObserver, errorResetBoundary);
         }
       }
       return [];
@@ -2837,16 +2846,17 @@
     if (suspensePromises.length > 0) {
       throw Promise.all(suspensePromises);
     }
+    const observerQueries = observer.getQueries();
     const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => getHasError({
       result,
       errorResetBoundary,
-      throwErrors: defaultedQueries[index]?.throwErrors ?? false,
-      query: observer.getQueries()[index]
+      throwOnError: defaultedQueries[index]?.throwOnError ?? false,
+      query: observerQueries[index]
     }));
     if (firstSingleResultWhichShouldThrow?.error) {
       throw firstSingleResultWhichShouldThrow.error;
     }
-    return optimisticResult;
+    return getCombinedResult(trackResult());
   }
 
   function useBaseQuery(options, Observer, queryClient) {
@@ -2857,17 +2867,6 @@
 
     // Make sure results are optimistically set in fetching state before subscribing or updating options
     defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic';
-
-    // Include callbacks in batch renders
-    if (defaultedOptions.onError) {
-      defaultedOptions.onError = notifyManager.batchCalls(defaultedOptions.onError);
-    }
-    if (defaultedOptions.onSuccess) {
-      defaultedOptions.onSuccess = notifyManager.batchCalls(defaultedOptions.onSuccess);
-    }
-    if (defaultedOptions.onSettled) {
-      defaultedOptions.onSettled = notifyManager.batchCalls(defaultedOptions.onSettled);
-    }
     ensureStaleTime(defaultedOptions);
     ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
     useClearResetErrorBoundary(errorResetBoundary);
@@ -2891,7 +2890,7 @@
     if (getHasError({
       result,
       errorResetBoundary,
-      throwErrors: defaultedOptions.throwErrors,
+      throwOnError: defaultedOptions.throwOnError,
       query: observer.getCurrentQuery()
     })) {
       throw result.error;
@@ -2901,6 +2900,10 @@
     return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
   }
 
+  function queryOptions(options) {
+    return options;
+  }
+
   // HOOK
 
   function useQuery(options, queryClient) {
@@ -2978,7 +2981,7 @@
     const mutate = React__namespace.useCallback((variables, mutateOptions) => {
       observer.mutate(variables, mutateOptions).catch(noop);
     }, [observer]);
-    if (result.error && shouldThrowError(observer.options.throwErrors, [result.error])) {
+    if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) {
       throw result.error;
     }
     return {
@@ -3023,6 +3026,7 @@
   exports.matchQuery = matchQuery;
   exports.notifyManager = notifyManager;
   exports.onlineManager = onlineManager;
+  exports.queryOptions = queryOptions;
   exports.replaceEqualDeep = replaceEqualDeep;
   exports.useInfiniteQuery = useInfiniteQuery;
   exports.useIsFetching = useIsFetching;