@tanstack/query-core 5.0.0-alpha.2 → 5.0.0-alpha.21

package/build/lib/queryObserver.esm.js

@@ -1,29 +1,129 @@
-import { shallowEqualObjects, noop, isServer, isValidTimeout, timeUntilStale, replaceData } from './utils.esm.js';
+import { classPrivateFieldLooseBase as _classPrivateFieldLooseBase, classPrivateFieldLooseKey as _classPrivateFieldLooseKey } from './_virtual/_rollupPluginBabelHelpers.esm.js';
+import { shallowEqualObjects, replaceData, noop, isServer, isValidTimeout, timeUntilStale } from './utils.esm.js';
 import { notifyManager } from './notifyManager.esm.js';
 import { focusManager } from './focusManager.esm.js';
 import { Subscribable } from './subscribable.esm.js';
-import { canFetch, isCancelledError } from './retryer.esm.js';
+import { canFetch } from './retryer.esm.js';
 
+var _client = /*#__PURE__*/_classPrivateFieldLooseKey("client");
+var _currentQuery = /*#__PURE__*/_classPrivateFieldLooseKey("currentQuery");
+var _currentQueryInitialState = /*#__PURE__*/_classPrivateFieldLooseKey("currentQueryInitialState");
+var _currentResult = /*#__PURE__*/_classPrivateFieldLooseKey("currentResult");
+var _currentResultState = /*#__PURE__*/_classPrivateFieldLooseKey("currentResultState");
+var _currentResultOptions = /*#__PURE__*/_classPrivateFieldLooseKey("currentResultOptions");
+var _selectError = /*#__PURE__*/_classPrivateFieldLooseKey("selectError");
+var _selectFn = /*#__PURE__*/_classPrivateFieldLooseKey("selectFn");
+var _selectResult = /*#__PURE__*/_classPrivateFieldLooseKey("selectResult");
+var _lastDefinedQueryData = /*#__PURE__*/_classPrivateFieldLooseKey("lastDefinedQueryData");
+var _staleTimeoutId = /*#__PURE__*/_classPrivateFieldLooseKey("staleTimeoutId");
+var _refetchIntervalId = /*#__PURE__*/_classPrivateFieldLooseKey("refetchIntervalId");
+var _currentRefetchInterval = /*#__PURE__*/_classPrivateFieldLooseKey("currentRefetchInterval");
+var _trackedProps = /*#__PURE__*/_classPrivateFieldLooseKey("trackedProps");
+var _executeFetch = /*#__PURE__*/_classPrivateFieldLooseKey("executeFetch");
+var _updateStaleTimeout = /*#__PURE__*/_classPrivateFieldLooseKey("updateStaleTimeout");
+var _computeRefetchInterval = /*#__PURE__*/_classPrivateFieldLooseKey("computeRefetchInterval");
+var _updateRefetchInterval = /*#__PURE__*/_classPrivateFieldLooseKey("updateRefetchInterval");
+var _updateTimers = /*#__PURE__*/_classPrivateFieldLooseKey("updateTimers");
+var _clearStaleTimeout = /*#__PURE__*/_classPrivateFieldLooseKey("clearStaleTimeout");
+var _clearRefetchInterval = /*#__PURE__*/_classPrivateFieldLooseKey("clearRefetchInterval");
+var _updateResult = /*#__PURE__*/_classPrivateFieldLooseKey("updateResult");
+var _updateQuery = /*#__PURE__*/_classPrivateFieldLooseKey("updateQuery");
+var _notify = /*#__PURE__*/_classPrivateFieldLooseKey("notify");
 class QueryObserver extends Subscribable {
-  #client;
-  #currentQuery = undefined;
-  #currentQueryInitialState = undefined;
-  #currentResult = undefined;
-  #currentResultState;
-  #currentResultOptions;
-  #previousQueryResult;
-  #selectError;
-  #selectFn;
-  #selectResult;
-  #staleTimeoutId;
-  #refetchIntervalId;
-  #currentRefetchInterval;
-  #trackedProps = new Set();
+  // This property keeps track of the last defined query data.
+  // It will be used to pass the previous data to the placeholder function between renders.
+
   constructor(client, options) {
     super();
-    this.#client = client;
+    Object.defineProperty(this, _notify, {
+      value: _notify2
+    });
+    Object.defineProperty(this, _updateQuery, {
+      value: _updateQuery2
+    });
+    Object.defineProperty(this, _updateResult, {
+      value: _updateResult2
+    });
+    Object.defineProperty(this, _clearRefetchInterval, {
+      value: _clearRefetchInterval2
+    });
+    Object.defineProperty(this, _clearStaleTimeout, {
+      value: _clearStaleTimeout2
+    });
+    Object.defineProperty(this, _updateTimers, {
+      value: _updateTimers2
+    });
+    Object.defineProperty(this, _updateRefetchInterval, {
+      value: _updateRefetchInterval2
+    });
+    Object.defineProperty(this, _computeRefetchInterval, {
+      value: _computeRefetchInterval2
+    });
+    Object.defineProperty(this, _updateStaleTimeout, {
+      value: _updateStaleTimeout2
+    });
+    Object.defineProperty(this, _executeFetch, {
+      value: _executeFetch2
+    });
+    Object.defineProperty(this, _client, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _currentQuery, {
+      writable: true,
+      value: undefined
+    });
+    Object.defineProperty(this, _currentQueryInitialState, {
+      writable: true,
+      value: undefined
+    });
+    Object.defineProperty(this, _currentResult, {
+      writable: true,
+      value: undefined
+    });
+    Object.defineProperty(this, _currentResultState, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _currentResultOptions, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _selectError, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _selectFn, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _selectResult, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _lastDefinedQueryData, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _staleTimeoutId, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _refetchIntervalId, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _currentRefetchInterval, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _trackedProps, {
+      writable: true,
+      value: new Set()
+    });
+    _classPrivateFieldLooseBase(this, _client)[_client] = client;
     this.options = options;
-    this.#selectError = null;
+    _classPrivateFieldLooseBase(this, _selectError)[_selectError] = null;
     this.bindMethods();
     this.setOptions(options);
   }
@@ -32,11 +132,11 @@ class QueryObserver extends Subscribable {
   }
   onSubscribe() {
     if (this.listeners.length === 1) {
-      this.#currentQuery.addObserver(this);
-      if (shouldFetchOnMount(this.#currentQuery, this.options)) {
-        this.#executeFetch();
+      _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery].addObserver(this);
+      if (shouldFetchOnMount(_classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery], this.options)) {
+        _classPrivateFieldLooseBase(this, _executeFetch)[_executeFetch]();
       }
-      this.#updateTimers();
+      _classPrivateFieldLooseBase(this, _updateTimers)[_updateTimers]();
     }
   }
   onUnsubscribe() {
@@ -45,25 +145,25 @@ class QueryObserver extends Subscribable {
     }
   }
   shouldFetchOnReconnect() {
-    return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnReconnect);
+    return shouldFetchOn(_classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery], this.options, this.options.refetchOnReconnect);
   }
   shouldFetchOnWindowFocus() {
-    return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnWindowFocus);
+    return shouldFetchOn(_classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery], this.options, this.options.refetchOnWindowFocus);
   }
   destroy() {
     this.listeners = [];
-    this.#clearStaleTimeout();
-    this.#clearRefetchInterval();
-    this.#currentQuery.removeObserver(this);
+    _classPrivateFieldLooseBase(this, _clearStaleTimeout)[_clearStaleTimeout]();
+    _classPrivateFieldLooseBase(this, _clearRefetchInterval)[_clearRefetchInterval]();
+    _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery].removeObserver(this);
   }
   setOptions(options, notifyOptions) {
     const prevOptions = this.options;
-    const prevQuery = this.#currentQuery;
-    this.options = this.#client.defaultQueryOptions(options);
+    const prevQuery = _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery];
+    this.options = _classPrivateFieldLooseBase(this, _client)[_client].defaultQueryOptions(options);
     if (!shallowEqualObjects(prevOptions, this.options)) {
-      this.#client.getQueryCache().notify({
+      _classPrivateFieldLooseBase(this, _client)[_client].getQueryCache().notify({
         type: 'observerOptionsUpdated',
-        query: this.#currentQuery,
+        query: _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery],
         observer: this
       });
     }
@@ -75,34 +175,34 @@ class QueryObserver extends Subscribable {
     if (!this.options.queryKey) {
       this.options.queryKey = prevOptions.queryKey;
     }
-    this.#updateQuery();
+    _classPrivateFieldLooseBase(this, _updateQuery)[_updateQuery]();
     const mounted = this.hasListeners();
 
     // Fetch if there are subscribers
-    if (mounted && shouldFetchOptionally(this.#currentQuery, prevQuery, this.options, prevOptions)) {
-      this.#executeFetch();
+    if (mounted && shouldFetchOptionally(_classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery], prevQuery, this.options, prevOptions)) {
+      _classPrivateFieldLooseBase(this, _executeFetch)[_executeFetch]();
     }
 
     // Update result
-    this.#updateResult(notifyOptions);
+    _classPrivateFieldLooseBase(this, _updateResult)[_updateResult](notifyOptions);
 
     // Update stale interval if needed
-    if (mounted && (this.#currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {
-      this.#updateStaleTimeout();
+    if (mounted && (_classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery] !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {
+      _classPrivateFieldLooseBase(this, _updateStaleTimeout)[_updateStaleTimeout]();
     }
-    const nextRefetchInterval = this.#computeRefetchInterval();
+    const nextRefetchInterval = _classPrivateFieldLooseBase(this, _computeRefetchInterval)[_computeRefetchInterval]();
 
     // Update refetch interval if needed
-    if (mounted && (this.#currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || nextRefetchInterval !== this.#currentRefetchInterval)) {
-      this.#updateRefetchInterval(nextRefetchInterval);
+    if (mounted && (_classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery] !== prevQuery || this.options.enabled !== prevOptions.enabled || nextRefetchInterval !== _classPrivateFieldLooseBase(this, _currentRefetchInterval)[_currentRefetchInterval])) {
+      _classPrivateFieldLooseBase(this, _updateRefetchInterval)[_updateRefetchInterval](nextRefetchInterval);
     }
   }
   getOptimisticResult(options) {
-    const query = this.#client.getQueryCache().build(this.#client, options);
+    const query = _classPrivateFieldLooseBase(this, _client)[_client].getQueryCache().build(_classPrivateFieldLooseBase(this, _client)[_client], options);
     return this.createResult(query, options);
   }
   getCurrentResult() {
-    return this.#currentResult;
+    return _classPrivateFieldLooseBase(this, _currentResult)[_currentResult];
   }
   trackResult(result) {
     const trackedResult = {};
@@ -111,7 +211,7 @@ class QueryObserver extends Subscribable {
         configurable: false,
         enumerable: true,
         get: () => {
-          this.#trackedProps.add(key);
+          _classPrivateFieldLooseBase(this, _trackedProps)[_trackedProps].add(key);
           return result[key];
         }
       });
@@ -119,7 +219,7 @@ class QueryObserver extends Subscribable {
     return trackedResult;
   }
   getCurrentQuery() {
-    return this.#currentQuery;
+    return _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery];
   }
   refetch({
     ...options
@@ -129,87 +229,29 @@ class QueryObserver extends Subscribable {
     });
   }
   fetchOptimistic(options) {
-    const defaultedOptions = this.#client.defaultQueryOptions(options);
-    const query = this.#client.getQueryCache().build(this.#client, defaultedOptions);
+    const defaultedOptions = _classPrivateFieldLooseBase(this, _client)[_client].defaultQueryOptions(options);
+    const query = _classPrivateFieldLooseBase(this, _client)[_client].getQueryCache().build(_classPrivateFieldLooseBase(this, _client)[_client], defaultedOptions);
     query.isFetchingOptimistic = true;
     return query.fetch().then(() => this.createResult(query, defaultedOptions));
   }
   fetch(fetchOptions) {
-    return this.#executeFetch({
+    var _fetchOptions$cancelR;
+    return _classPrivateFieldLooseBase(this, _executeFetch)[_executeFetch]({
       ...fetchOptions,
-      cancelRefetch: fetchOptions.cancelRefetch ?? true
+      cancelRefetch: (_fetchOptions$cancelR = fetchOptions.cancelRefetch) != null ? _fetchOptions$cancelR : true
     }).then(() => {
-      this.#updateResult();
-      return this.#currentResult;
+      _classPrivateFieldLooseBase(this, _updateResult)[_updateResult]();
+      return _classPrivateFieldLooseBase(this, _currentResult)[_currentResult];
     });
   }
-  #executeFetch(fetchOptions) {
-    // Make sure we reference the latest query as the current one might have been removed
-    this.#updateQuery();
-
-    // Fetch
-    let promise = this.#currentQuery.fetch(this.options, fetchOptions);
-    if (!fetchOptions?.throwOnError) {
-      promise = promise.catch(noop);
-    }
-    return promise;
-  }
-  #updateStaleTimeout() {
-    this.#clearStaleTimeout();
-    if (isServer || this.#currentResult.isStale || !isValidTimeout(this.options.staleTime)) {
-      return;
-    }
-    const time = timeUntilStale(this.#currentResult.dataUpdatedAt, this.options.staleTime);
-
-    // The timeout is sometimes triggered 1 ms before the stale time expiration.
-    // To mitigate this issue we always add 1 ms to the timeout.
-    const timeout = time + 1;
-    this.#staleTimeoutId = setTimeout(() => {
-      if (!this.#currentResult.isStale) {
-        this.#updateResult();
-      }
-    }, timeout);
-  }
-  #computeRefetchInterval() {
-    return typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.#currentResult.data, this.#currentQuery) : this.options.refetchInterval ?? false;
-  }
-  #updateRefetchInterval(nextInterval) {
-    this.#clearRefetchInterval();
-    this.#currentRefetchInterval = nextInterval;
-    if (isServer || this.options.enabled === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) {
-      return;
-    }
-    this.#refetchIntervalId = setInterval(() => {
-      if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
-        this.#executeFetch();
-      }
-    }, this.#currentRefetchInterval);
-  }
-  #updateTimers() {
-    this.#updateStaleTimeout();
-    this.#updateRefetchInterval(this.#computeRefetchInterval());
-  }
-  #clearStaleTimeout() {
-    if (this.#staleTimeoutId) {
-      clearTimeout(this.#staleTimeoutId);
-      this.#staleTimeoutId = undefined;
-    }
-  }
-  #clearRefetchInterval() {
-    if (this.#refetchIntervalId) {
-      clearInterval(this.#refetchIntervalId);
-      this.#refetchIntervalId = undefined;
-    }
-  }
   createResult(query, options) {
-    const prevQuery = this.#currentQuery;
+    const prevQuery = _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery];
     const prevOptions = this.options;
-    const prevResult = this.#currentResult;
-    const prevResultState = this.#currentResultState;
-    const prevResultOptions = this.#currentResultOptions;
+    const prevResult = _classPrivateFieldLooseBase(this, _currentResult)[_currentResult];
+    const prevResultState = _classPrivateFieldLooseBase(this, _currentResultState)[_currentResultState];
+    const prevResultOptions = _classPrivateFieldLooseBase(this, _currentResultOptions)[_currentResultOptions];
     const queryChange = query !== prevQuery;
-    const queryInitialState = queryChange ? query.state : this.#currentQueryInitialState;
-    const prevQueryResult = queryChange ? this.#currentResult : this.#previousQueryResult;
+    const queryInitialState = queryChange ? query.state : _classPrivateFieldLooseBase(this, _currentQueryInitialState)[_currentQueryInitialState];
     const {
       state
     } = query;
@@ -241,17 +283,17 @@ class QueryObserver extends Subscribable {
     // Select data if needed
     if (options.select && typeof state.data !== 'undefined') {
       // Memoize select result
-      if (prevResult && state.data === prevResultState?.data && options.select === this.#selectFn) {
-        data = this.#selectResult;
+      if (prevResult && state.data === (prevResultState == null ? void 0 : prevResultState.data) && options.select === _classPrivateFieldLooseBase(this, _selectFn)[_selectFn]) {
+        data = _classPrivateFieldLooseBase(this, _selectResult)[_selectResult];
       } else {
         try {
-          this.#selectFn = options.select;
+          _classPrivateFieldLooseBase(this, _selectFn)[_selectFn] = options.select;
           data = options.select(state.data);
-          data = replaceData(prevResult?.data, data, options);
-          this.#selectResult = data;
-          this.#selectError = null;
+          data = replaceData(prevResult == null ? void 0 : prevResult.data, data, options);
+          _classPrivateFieldLooseBase(this, _selectResult)[_selectResult] = data;
+          _classPrivateFieldLooseBase(this, _selectError)[_selectError] = null;
         } catch (selectError) {
-          this.#selectError = selectError;
+          _classPrivateFieldLooseBase(this, _selectError)[_selectError] = selectError;
         }
       }
     }
@@ -265,28 +307,28 @@ class QueryObserver extends Subscribable {
       let placeholderData;
 
       // Memoize placeholder data
-      if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
+      if (prevResult != null && prevResult.isPlaceholderData && options.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {
         placeholderData = prevResult.data;
       } else {
-        placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData(prevQueryResult?.data) : options.placeholderData;
+        placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData(_classPrivateFieldLooseBase(this, _lastDefinedQueryData)[_lastDefinedQueryData]) : options.placeholderData;
         if (options.select && typeof placeholderData !== 'undefined') {
           try {
             placeholderData = options.select(placeholderData);
-            this.#selectError = null;
+            _classPrivateFieldLooseBase(this, _selectError)[_selectError] = null;
           } catch (selectError) {
-            this.#selectError = selectError;
+            _classPrivateFieldLooseBase(this, _selectError)[_selectError] = selectError;
           }
         }
       }
       if (typeof placeholderData !== 'undefined') {
         status = 'success';
-        data = replaceData(prevResult?.data, placeholderData, options);
+        data = replaceData(prevResult == null ? void 0 : prevResult.data, placeholderData, options);
         isPlaceholderData = true;
       }
     }
-    if (this.#selectError) {
-      error = this.#selectError;
-      data = this.#selectResult;
+    if (_classPrivateFieldLooseBase(this, _selectError)[_selectError]) {
+      error = _classPrivateFieldLooseBase(this, _selectError)[_selectError];
+      data = _classPrivateFieldLooseBase(this, _selectResult)[_selectResult];
       errorUpdatedAt = Date.now();
       status = 'error';
     }
@@ -322,100 +364,146 @@ class QueryObserver extends Subscribable {
     };
     return result;
   }
-  #updateResult(notifyOptions) {
-    const prevResult = this.#currentResult;
-    const nextResult = this.createResult(this.#currentQuery, this.options);
-    this.#currentResultState = this.#currentQuery.state;
-    this.#currentResultOptions = this.options;
-
-    // Only notify and update result if something has changed
-    if (shallowEqualObjects(nextResult, prevResult)) {
-      return;
+  onQueryUpdate() {
+    _classPrivateFieldLooseBase(this, _updateResult)[_updateResult]();
+    if (this.hasListeners()) {
+      _classPrivateFieldLooseBase(this, _updateTimers)[_updateTimers]();
     }
-    this.#currentResult = nextResult;
+  }
+}
+function _executeFetch2(fetchOptions) {
+  // Make sure we reference the latest query as the current one might have been removed
+  _classPrivateFieldLooseBase(this, _updateQuery)[_updateQuery]();
 
-    // Determine which callbacks to trigger
-    const defaultNotifyOptions = {};
-    const shouldNotifyListeners = () => {
-      if (!prevResult) {
-        return true;
-      }
-      const {
-        notifyOnChangeProps
-      } = this.options;
-      if (notifyOnChangeProps === 'all' || !notifyOnChangeProps && !this.#trackedProps.size) {
-        return true;
-      }
-      const includedProps = new Set(notifyOnChangeProps ?? this.#trackedProps);
-      if (this.options.throwErrors) {
-        includedProps.add('error');
-      }
-      return Object.keys(this.#currentResult).some(key => {
-        const typedKey = key;
-        const changed = this.#currentResult[typedKey] !== prevResult[typedKey];
-        return changed && includedProps.has(typedKey);
-      });
-    };
-    if (notifyOptions?.listeners !== false && shouldNotifyListeners()) {
-      defaultNotifyOptions.listeners = true;
-    }
-    this.#notify({
-      ...defaultNotifyOptions,
-      ...notifyOptions
-    });
+  // Fetch
+  let promise = _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery].fetch(this.options, fetchOptions);
+  if (!(fetchOptions != null && fetchOptions.throwOnError)) {
+    promise = promise.catch(noop);
   }
-  #updateQuery() {
-    const query = this.#client.getQueryCache().build(this.#client, this.options);
-    if (query === this.#currentQuery) {
-      return;
-    }
-    const prevQuery = this.#currentQuery;
-    this.#currentQuery = query;
-    this.#currentQueryInitialState = query.state;
-    this.#previousQueryResult = this.#currentResult;
-    if (this.hasListeners()) {
-      prevQuery?.removeObserver(this);
-      query.addObserver(this);
-    }
+  return promise;
+}
+function _updateStaleTimeout2() {
+  _classPrivateFieldLooseBase(this, _clearStaleTimeout)[_clearStaleTimeout]();
+  if (isServer || _classPrivateFieldLooseBase(this, _currentResult)[_currentResult].isStale || !isValidTimeout(this.options.staleTime)) {
+    return;
   }
-  onQueryUpdate(action) {
-    const notifyOptions = {};
-    if (action.type === 'success') {
-      notifyOptions.onSuccess = !action.manual;
-    } else if (action.type === 'error' && !isCancelledError(action.error)) {
-      notifyOptions.onError = true;
+  const time = timeUntilStale(_classPrivateFieldLooseBase(this, _currentResult)[_currentResult].dataUpdatedAt, this.options.staleTime);
+
+  // The timeout is sometimes triggered 1 ms before the stale time expiration.
+  // To mitigate this issue we always add 1 ms to the timeout.
+  const timeout = time + 1;
+  _classPrivateFieldLooseBase(this, _staleTimeoutId)[_staleTimeoutId] = setTimeout(() => {
+    if (!_classPrivateFieldLooseBase(this, _currentResult)[_currentResult].isStale) {
+      _classPrivateFieldLooseBase(this, _updateResult)[_updateResult]();
     }
-    this.#updateResult(notifyOptions);
-    if (this.hasListeners()) {
-      this.#updateTimers();
+  }, timeout);
+}
+function _computeRefetchInterval2() {
+  var _this$options$refetch;
+  return typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(_classPrivateFieldLooseBase(this, _currentResult)[_currentResult].data, _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery]) : (_this$options$refetch = this.options.refetchInterval) != null ? _this$options$refetch : false;
+}
+function _updateRefetchInterval2(nextInterval) {
+  _classPrivateFieldLooseBase(this, _clearRefetchInterval)[_clearRefetchInterval]();
+  _classPrivateFieldLooseBase(this, _currentRefetchInterval)[_currentRefetchInterval] = nextInterval;
+  if (isServer || this.options.enabled === false || !isValidTimeout(_classPrivateFieldLooseBase(this, _currentRefetchInterval)[_currentRefetchInterval]) || _classPrivateFieldLooseBase(this, _currentRefetchInterval)[_currentRefetchInterval] === 0) {
+    return;
+  }
+  _classPrivateFieldLooseBase(this, _refetchIntervalId)[_refetchIntervalId] = setInterval(() => {
+    if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
+      _classPrivateFieldLooseBase(this, _executeFetch)[_executeFetch]();
     }
+  }, _classPrivateFieldLooseBase(this, _currentRefetchInterval)[_currentRefetchInterval]);
+}
+function _updateTimers2() {
+  _classPrivateFieldLooseBase(this, _updateStaleTimeout)[_updateStaleTimeout]();
+  _classPrivateFieldLooseBase(this, _updateRefetchInterval)[_updateRefetchInterval](_classPrivateFieldLooseBase(this, _computeRefetchInterval)[_computeRefetchInterval]());
+}
+function _clearStaleTimeout2() {
+  if (_classPrivateFieldLooseBase(this, _staleTimeoutId)[_staleTimeoutId]) {
+    clearTimeout(_classPrivateFieldLooseBase(this, _staleTimeoutId)[_staleTimeoutId]);
+    _classPrivateFieldLooseBase(this, _staleTimeoutId)[_staleTimeoutId] = undefined;
   }
-  #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);
-      }
+}
+function _clearRefetchInterval2() {
+  if (_classPrivateFieldLooseBase(this, _refetchIntervalId)[_refetchIntervalId]) {
+    clearInterval(_classPrivateFieldLooseBase(this, _refetchIntervalId)[_refetchIntervalId]);
+    _classPrivateFieldLooseBase(this, _refetchIntervalId)[_refetchIntervalId] = undefined;
+  }
+}
+function _updateResult2(notifyOptions) {
+  const prevResult = _classPrivateFieldLooseBase(this, _currentResult)[_currentResult];
+  const nextResult = this.createResult(_classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery], this.options);
+  _classPrivateFieldLooseBase(this, _currentResultState)[_currentResultState] = _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery].state;
+  _classPrivateFieldLooseBase(this, _currentResultOptions)[_currentResultOptions] = this.options;
 
-      // Then trigger the listeners
-      if (notifyOptions.listeners) {
-        this.listeners.forEach(listener => {
-          listener(this.#currentResult);
-        });
-      }
+  // Only notify and update result if something has changed
+  if (shallowEqualObjects(nextResult, prevResult)) {
+    return;
+  }
+  if (_classPrivateFieldLooseBase(this, _currentResultState)[_currentResultState].data !== undefined) {
+    _classPrivateFieldLooseBase(this, _lastDefinedQueryData)[_lastDefinedQueryData] = _classPrivateFieldLooseBase(this, _currentResultState)[_currentResultState].data;
+  }
+  _classPrivateFieldLooseBase(this, _currentResult)[_currentResult] = nextResult;
 
-      // Then the cache listeners
-      this.#client.getQueryCache().notify({
-        query: this.#currentQuery,
-        type: 'observerResultsUpdated'
-      });
+  // Determine which callbacks to trigger
+  const defaultNotifyOptions = {};
+  const shouldNotifyListeners = () => {
+    if (!prevResult) {
+      return true;
+    }
+    const {
+      notifyOnChangeProps
+    } = this.options;
+    if (notifyOnChangeProps === 'all' || !notifyOnChangeProps && !_classPrivateFieldLooseBase(this, _trackedProps)[_trackedProps].size) {
+      return true;
+    }
+    const includedProps = new Set(notifyOnChangeProps != null ? notifyOnChangeProps : _classPrivateFieldLooseBase(this, _trackedProps)[_trackedProps]);
+    if (this.options.throwErrors) {
+      includedProps.add('error');
+    }
+    return Object.keys(_classPrivateFieldLooseBase(this, _currentResult)[_currentResult]).some(key => {
+      const typedKey = key;
+      const changed = _classPrivateFieldLooseBase(this, _currentResult)[_currentResult][typedKey] !== prevResult[typedKey];
+      return changed && includedProps.has(typedKey);
     });
+  };
+  if ((notifyOptions == null ? void 0 : notifyOptions.listeners) !== false && shouldNotifyListeners()) {
+    defaultNotifyOptions.listeners = true;
+  }
+  _classPrivateFieldLooseBase(this, _notify)[_notify]({
+    ...defaultNotifyOptions,
+    ...notifyOptions
+  });
+}
+function _updateQuery2() {
+  const query = _classPrivateFieldLooseBase(this, _client)[_client].getQueryCache().build(_classPrivateFieldLooseBase(this, _client)[_client], this.options);
+  if (query === _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery]) {
+    return;
+  }
+  const prevQuery = _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery];
+  _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery] = query;
+  _classPrivateFieldLooseBase(this, _currentQueryInitialState)[_currentQueryInitialState] = query.state;
+  if (this.hasListeners()) {
+    prevQuery == null ? void 0 : prevQuery.removeObserver(this);
+    query.addObserver(this);
   }
 }
+function _notify2(notifyOptions) {
+  notifyManager.batch(() => {
+    // First, trigger the listeners
+    if (notifyOptions.listeners) {
+      this.listeners.forEach(listener => {
+        listener(_classPrivateFieldLooseBase(this, _currentResult)[_currentResult]);
+      });
+    }
+
+    // Then the cache listeners
+    _classPrivateFieldLooseBase(this, _client)[_client].getQueryCache().notify({
+      query: _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery],
+      type: 'observerResultsUpdated'
+    });
+  });
+}
 function shouldLoadOnMount(query, options) {
   return options.enabled !== false && !query.state.dataUpdatedAt && !(query.state.status === 'error' && options.retryOnMount === false);
 }