@tanstack/react-query 5.0.0-alpha.19 → 5.0.0-alpha.21

package/build/umd/index.development.js

@@ -1043,7 +1043,7 @@
       this.state = reducer(this.state);
       notifyManager.batch(() => {
         this.#observers.forEach(observer => {
-          observer.onQueryUpdate(action);
+          observer.onQueryUpdate();
         });
         this.#cache.notify({
           query: this,
@@ -2239,30 +2239,15 @@
         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);
@@ -2384,9 +2369,10 @@
     }
     #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,
@@ -2395,8 +2381,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);
@@ -2772,15 +2758,8 @@
   };
   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`.
@@ -2791,6 +2770,7 @@
   }, queryClient) {
     const client = useQueryClient(queryClient);
     const isRestoring = useIsRestoring();
+    const errorResetBoundary = useQueryErrorResetBoundary();
     const defaultedQueries = React__namespace.useMemo(() => queries.map(options => {
       const defaultedOptions = client.defaultQueryOptions(options);
 
@@ -2798,6 +2778,11 @@
       defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic';
       return defaultedOptions;
     }), [queries, client, isRestoring]);
+    defaultedQueries.forEach(query => {
+      ensureStaleTime(query);
+      ensurePreventErrorBoundaryRetry(query, errorResetBoundary);
+    });
+    useClearResetErrorBoundary(errorResetBoundary);
     const [observer] = React__namespace.useState(() => new QueriesObserver(client, defaultedQueries));
     const optimisticResult = observer.getOptimisticResult(defaultedQueries);
     React__namespace.useSyncExternalStore(React__namespace.useCallback(onStoreChange => isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
@@ -2808,12 +2793,6 @@
         listeners: false
       });
     }, [defaultedQueries, observer]);
-    const errorResetBoundary = useQueryErrorResetBoundary();
-    defaultedQueries.forEach(query => {
-      ensurePreventErrorBoundaryRetry(query, errorResetBoundary);
-      ensureStaleTime(query);
-    });
-    useClearResetErrorBoundary(errorResetBoundary);
     const shouldAtLeastOneSuspend = optimisticResult.some((result, index) => shouldSuspend(defaultedQueries[index], result, isRestoring));
     const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
       const options = defaultedQueries[index];
@@ -2830,11 +2809,12 @@
     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]
+      query: observerQueries[index]
     }));
     if (firstSingleResultWhichShouldThrow?.error) {
       throw firstSingleResultWhichShouldThrow.error;
@@ -2850,17 +2830,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);