@tanstack/query-core 4.29.19 → 4.29.23

package/build/umd/index.development.js

@@ -406,9 +406,10 @@
     }
 
     setFocused(focused) {
-      this.focused = focused;
+      const changed = this.focused !== focused;
 
-      if (focused) {
+      if (changed) {
+        this.focused = focused;
         this.onFocus();
       }
     }
@@ -494,9 +495,10 @@
     }
 
     setOnline(online) {
-      this.online = online;
+      const changed = this.online !== online;
 
-      if (online) {
+      if (changed) {
+        this.online = online;
         this.onOnline();
       }
     }
@@ -2324,7 +2326,30 @@
 
     getOptimisticResult(options) {
       const query = this.client.getQueryCache().build(this.client, options);
-      return this.createResult(query, options);
+      const result = this.createResult(query, options);
+
+      if (shouldAssignObserverCurrentProperties(this, result, options)) {
+        // this assigns the optimistic result to the current Observer
+        // because if the query function changes, useQuery will be performing
+        // an effect where it would fetch again.
+        // When the fetch finishes, we perform a deep data cloning in order
+        // to reuse objects references. This deep data clone is performed against
+        // the `observer.currentResult.data` property
+        // When QueryKey changes, we refresh the query and get new `optimistic`
+        // result, while we leave the `observer.currentResult`, so when new data
+        // arrives, it finds the old `observer.currentResult` which is related
+        // to the old QueryKey. Which means that currentResult and selectData are
+        // out of sync already.
+        // To solve this, we move the cursor of the currentResult everytime
+        // an observer reads an optimistic value.
+        // When keeping the previous data, the result doesn't change until new
+        // data arrives.
+        this.currentResult = result;
+        this.currentResultOptions = this.options;
+        this.currentResultState = this.currentQuery.state;
+      }
+
+      return result;
     }
 
     getCurrentResult() {
@@ -2740,6 +2765,38 @@
 
   function isStale(query, options) {
     return query.isStaleByTime(options.staleTime);
+  } // this function would decide if we will update the observer's 'current'
+  // properties after an optimistic reading via getOptimisticResult
+
+
+  function shouldAssignObserverCurrentProperties(observer, optimisticResult, options) {
+    // it is important to keep this condition like this for three reasons:
+    // 1. It will get removed in the v5
+    // 2. it reads: don't update the properties if we want to keep the previous
+    // data.
+    // 3. The opposite condition (!options.keepPreviousData) would fallthrough
+    // and will result in a bad decision
+    if (options.keepPreviousData) {
+      return false;
+    } // this means we want to put some placeholder data when pending and queryKey
+    // changed.
+
+
+    if (options.placeholderData !== undefined) {
+      // re-assign properties only if current data is placeholder data
+      // which means that data did not arrive yet, so, if there is some cached data
+      // we need to "prepare" to receive it
+      return optimisticResult.isPlaceholderData;
+    } // if the newly created result isn't what the observer is holding as current,
+    // then we'll need to update the properties as well
+
+
+    if (observer.getCurrentResult() !== optimisticResult) {
+      return true;
+    } // basically, just keep previous properties if nothing changed
+
+
+    return false;
   }
 
   class QueriesObserver extends Subscribable {