@tanstack/query-core 5.0.0-alpha.85 → 5.0.0-alpha.87

package/build/lib/queryObserver.legacy.js

@@ -1,559 +0,0 @@
-import { classPrivateFieldLooseBase as _classPrivateFieldLooseBase, classPrivateFieldLooseKey as _classPrivateFieldLooseKey } from './_virtual/_rollupPluginBabelHelpers.legacy.js';
-import { shallowEqualObjects, replaceData, noop, isServer, isValidTimeout, timeUntilStale } from './utils.legacy.js';
-import { notifyManager } from './notifyManager.legacy.js';
-import { focusManager } from './focusManager.legacy.js';
-import { Subscribable } from './subscribable.legacy.js';
-import { canFetch } from './retryer.legacy.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 _lastQueryWithDefinedData = /*#__PURE__*/_classPrivateFieldLooseKey("lastQueryWithDefinedData");
-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 _updateQuery = /*#__PURE__*/_classPrivateFieldLooseKey("updateQuery");
-var _notify = /*#__PURE__*/_classPrivateFieldLooseKey("notify");
-class QueryObserver extends Subscribable {
-  constructor(client, options) {
-    super();
-    Object.defineProperty(this, _notify, {
-      value: _notify2
-    });
-    Object.defineProperty(this, _updateQuery, {
-      value: _updateQuery2
-    });
-    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
-    });
-    // 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.
-    Object.defineProperty(this, _lastQueryWithDefinedData, {
-      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;
-    _classPrivateFieldLooseBase(this, _selectError)[_selectError] = null;
-    this.bindMethods();
-    this.setOptions(options);
-  }
-  bindMethods() {
-    this.refetch = this.refetch.bind(this);
-  }
-  onSubscribe() {
-    if (this.listeners.size === 1) {
-      _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery].addObserver(this);
-      if (shouldFetchOnMount(_classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery], this.options)) {
-        _classPrivateFieldLooseBase(this, _executeFetch)[_executeFetch]();
-      }
-      _classPrivateFieldLooseBase(this, _updateTimers)[_updateTimers]();
-    }
-  }
-  onUnsubscribe() {
-    if (!this.hasListeners()) {
-      this.destroy();
-    }
-  }
-  shouldFetchOnReconnect() {
-    return shouldFetchOn(_classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery], this.options, this.options.refetchOnReconnect);
-  }
-  shouldFetchOnWindowFocus() {
-    return shouldFetchOn(_classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery], this.options, this.options.refetchOnWindowFocus);
-  }
-  destroy() {
-    this.listeners = new Set();
-    _classPrivateFieldLooseBase(this, _clearStaleTimeout)[_clearStaleTimeout]();
-    _classPrivateFieldLooseBase(this, _clearRefetchInterval)[_clearRefetchInterval]();
-    _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery].removeObserver(this);
-  }
-  setOptions(options, notifyOptions) {
-    const prevOptions = this.options;
-    const prevQuery = _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery];
-    this.options = _classPrivateFieldLooseBase(this, _client)[_client].defaultQueryOptions(options);
-    if (!shallowEqualObjects(prevOptions, this.options)) {
-      _classPrivateFieldLooseBase(this, _client)[_client].getQueryCache().notify({
-        type: 'observerOptionsUpdated',
-        query: _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery],
-        observer: this
-      });
-    }
-    if (typeof this.options.enabled !== 'undefined' && typeof this.options.enabled !== 'boolean') {
-      throw new Error('Expected enabled to be a boolean');
-    }
-
-    // Keep previous query key if the user does not supply one
-    if (!this.options.queryKey) {
-      this.options.queryKey = prevOptions.queryKey;
-    }
-    _classPrivateFieldLooseBase(this, _updateQuery)[_updateQuery]();
-    const mounted = this.hasListeners();
-
-    // Fetch if there are subscribers
-    if (mounted && shouldFetchOptionally(_classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery], prevQuery, this.options, prevOptions)) {
-      _classPrivateFieldLooseBase(this, _executeFetch)[_executeFetch]();
-    }
-
-    // Update result
-    this.updateResult(notifyOptions);
-
-    // Update stale interval if needed
-    if (mounted && (_classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery] !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {
-      _classPrivateFieldLooseBase(this, _updateStaleTimeout)[_updateStaleTimeout]();
-    }
-    const nextRefetchInterval = _classPrivateFieldLooseBase(this, _computeRefetchInterval)[_computeRefetchInterval]();
-
-    // Update refetch interval if needed
-    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 = _classPrivateFieldLooseBase(this, _client)[_client].getQueryCache().build(_classPrivateFieldLooseBase(this, _client)[_client], options);
-    const result = this.createResult(query, options);
-    if (shouldAssignObserverCurrentProperties(this, result)) {
-      // 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.
-      _classPrivateFieldLooseBase(this, _currentResult)[_currentResult] = result;
-      _classPrivateFieldLooseBase(this, _currentResultOptions)[_currentResultOptions] = this.options;
-      _classPrivateFieldLooseBase(this, _currentResultState)[_currentResultState] = _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery].state;
-    }
-    return result;
-  }
-  getCurrentResult() {
-    return _classPrivateFieldLooseBase(this, _currentResult)[_currentResult];
-  }
-  trackResult(result) {
-    const trackedResult = {};
-    Object.keys(result).forEach(key => {
-      Object.defineProperty(trackedResult, key, {
-        configurable: false,
-        enumerable: true,
-        get: () => {
-          _classPrivateFieldLooseBase(this, _trackedProps)[_trackedProps].add(key);
-          return result[key];
-        }
-      });
-    });
-    return trackedResult;
-  }
-  getCurrentQuery() {
-    return _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery];
-  }
-  refetch({
-    ...options
-  } = {}) {
-    return this.fetch({
-      ...options
-    });
-  }
-  fetchOptimistic(options) {
-    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) {
-    var _fetchOptions$cancelR;
-    return _classPrivateFieldLooseBase(this, _executeFetch)[_executeFetch]({
-      ...fetchOptions,
-      cancelRefetch: (_fetchOptions$cancelR = fetchOptions.cancelRefetch) != null ? _fetchOptions$cancelR : true
-    }).then(() => {
-      this.updateResult();
-      return _classPrivateFieldLooseBase(this, _currentResult)[_currentResult];
-    });
-  }
-  createResult(query, options) {
-    const prevQuery = _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery];
-    const prevOptions = this.options;
-    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 : _classPrivateFieldLooseBase(this, _currentQueryInitialState)[_currentQueryInitialState];
-    const {
-      state
-    } = query;
-    let {
-      error,
-      errorUpdatedAt,
-      fetchStatus,
-      status
-    } = state;
-    let isPlaceholderData = false;
-    let data;
-
-    // Optimistically set result in fetching state if needed
-    if (options._optimisticResults) {
-      const mounted = this.hasListeners();
-      const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
-      const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
-      if (fetchOnMount || fetchOptionally) {
-        fetchStatus = canFetch(query.options.networkMode) ? 'fetching' : 'paused';
-        if (!state.dataUpdatedAt) {
-          status = 'pending';
-        }
-      }
-      if (options._optimisticResults === 'isRestoring') {
-        fetchStatus = 'idle';
-      }
-    }
-
-    // Select data if needed
-    if (options.select && typeof state.data !== 'undefined') {
-      // Memoize select result
-      if (prevResult && state.data === (prevResultState == null ? void 0 : prevResultState.data) && options.select === _classPrivateFieldLooseBase(this, _selectFn)[_selectFn]) {
-        data = _classPrivateFieldLooseBase(this, _selectResult)[_selectResult];
-      } else {
-        try {
-          _classPrivateFieldLooseBase(this, _selectFn)[_selectFn] = options.select;
-          data = options.select(state.data);
-          data = replaceData(prevResult == null ? void 0 : prevResult.data, data, options);
-          _classPrivateFieldLooseBase(this, _selectResult)[_selectResult] = data;
-          _classPrivateFieldLooseBase(this, _selectError)[_selectError] = null;
-        } catch (selectError) {
-          _classPrivateFieldLooseBase(this, _selectError)[_selectError] = selectError;
-        }
-      }
-    }
-    // Use query data
-    else {
-      data = state.data;
-    }
-
-    // Show placeholder data if needed
-    if (typeof options.placeholderData !== 'undefined' && typeof data === 'undefined' && status === 'pending') {
-      let placeholderData;
-
-      // Memoize placeholder data
-      if (prevResult != null && prevResult.isPlaceholderData && options.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {
-        placeholderData = prevResult.data;
-      } else {
-        var _classPrivateFieldLoo;
-        placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData((_classPrivateFieldLoo = _classPrivateFieldLooseBase(this, _lastQueryWithDefinedData)[_lastQueryWithDefinedData]) == null ? void 0 : _classPrivateFieldLoo.state.data, _classPrivateFieldLooseBase(this, _lastQueryWithDefinedData)[_lastQueryWithDefinedData]) : options.placeholderData;
-        if (options.select && typeof placeholderData !== 'undefined') {
-          try {
-            placeholderData = options.select(placeholderData);
-            _classPrivateFieldLooseBase(this, _selectError)[_selectError] = null;
-          } catch (selectError) {
-            _classPrivateFieldLooseBase(this, _selectError)[_selectError] = selectError;
-          }
-        }
-      }
-      if (typeof placeholderData !== 'undefined') {
-        status = 'success';
-        data = replaceData(prevResult == null ? void 0 : prevResult.data, placeholderData, options);
-        isPlaceholderData = true;
-      }
-    }
-    if (_classPrivateFieldLooseBase(this, _selectError)[_selectError]) {
-      error = _classPrivateFieldLooseBase(this, _selectError)[_selectError];
-      data = _classPrivateFieldLooseBase(this, _selectResult)[_selectResult];
-      errorUpdatedAt = Date.now();
-      status = 'error';
-    }
-    const isFetching = fetchStatus === 'fetching';
-    const isPending = status === 'pending';
-    const isError = status === 'error';
-    const isLoading = isPending && isFetching;
-    const result = {
-      status,
-      fetchStatus,
-      isPending,
-      isSuccess: status === 'success',
-      isError,
-      isInitialLoading: isLoading,
-      isLoading,
-      data,
-      dataUpdatedAt: state.dataUpdatedAt,
-      error,
-      errorUpdatedAt,
-      failureCount: state.fetchFailureCount,
-      failureReason: state.fetchFailureReason,
-      errorUpdateCount: state.errorUpdateCount,
-      isFetched: state.dataUpdateCount > 0 || state.errorUpdateCount > 0,
-      isFetchedAfterMount: state.dataUpdateCount > queryInitialState.dataUpdateCount || state.errorUpdateCount > queryInitialState.errorUpdateCount,
-      isFetching,
-      isRefetching: isFetching && !isPending,
-      isLoadingError: isError && state.dataUpdatedAt === 0,
-      isPaused: fetchStatus === 'paused',
-      isPlaceholderData,
-      isRefetchError: isError && state.dataUpdatedAt !== 0,
-      isStale: isStale(query, options),
-      refetch: this.refetch
-    };
-    return result;
-  }
-  updateResult(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;
-
-    // Only notify and update result if something has changed
-    if (shallowEqualObjects(nextResult, prevResult)) {
-      return;
-    }
-    if (_classPrivateFieldLooseBase(this, _currentResultState)[_currentResultState].data !== undefined) {
-      _classPrivateFieldLooseBase(this, _lastQueryWithDefinedData)[_lastQueryWithDefinedData] = _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery];
-    }
-    _classPrivateFieldLooseBase(this, _currentResult)[_currentResult] = nextResult;
-
-    // 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.throwOnError) {
-        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
-    });
-  }
-  onQueryUpdate() {
-    this.updateResult();
-    if (this.hasListeners()) {
-      _classPrivateFieldLooseBase(this, _updateTimers)[_updateTimers]();
-    }
-  }
-}
-function _executeFetch2(fetchOptions) {
-  // Make sure we reference the latest query as the current one might have been removed
-  _classPrivateFieldLooseBase(this, _updateQuery)[_updateQuery]();
-
-  // Fetch
-  let promise = _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery].fetch(this.options, fetchOptions);
-  if (!(fetchOptions != null && fetchOptions.throwOnError)) {
-    promise = promise.catch(noop);
-  }
-  return promise;
-}
-function _updateStaleTimeout2() {
-  _classPrivateFieldLooseBase(this, _clearStaleTimeout)[_clearStaleTimeout]();
-  if (isServer || _classPrivateFieldLooseBase(this, _currentResult)[_currentResult].isStale || !isValidTimeout(this.options.staleTime)) {
-    return;
-  }
-  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) {
-      this.updateResult();
-    }
-  }, timeout);
-}
-function _computeRefetchInterval2() {
-  var _ref;
-  return (_ref = typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(_classPrivateFieldLooseBase(this, _currentResult)[_currentResult].data, _classPrivateFieldLooseBase(this, _currentQuery)[_currentQuery]) : this.options.refetchInterval) != null ? _ref : 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;
-  }
-}
-function _clearRefetchInterval2() {
-  if (_classPrivateFieldLooseBase(this, _refetchIntervalId)[_refetchIntervalId]) {
-    clearInterval(_classPrivateFieldLooseBase(this, _refetchIntervalId)[_refetchIntervalId]);
-    _classPrivateFieldLooseBase(this, _refetchIntervalId)[_refetchIntervalId] = undefined;
-  }
-}
-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);
-}
-function shouldFetchOnMount(query, options) {
-  return shouldLoadOnMount(query, options) || query.state.dataUpdatedAt > 0 && shouldFetchOn(query, options, options.refetchOnMount);
-}
-function shouldFetchOn(query, options, field) {
-  if (options.enabled !== false) {
-    const value = typeof field === 'function' ? field(query) : field;
-    return value === 'always' || value !== false && isStale(query, options);
-  }
-  return false;
-}
-function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
-  return options.enabled !== false && (query !== prevQuery || prevOptions.enabled === false) && (!options.suspense || query.state.status !== 'error') && isStale(query, options);
-}
-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) {
-  // 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;
-}
-
-export { QueryObserver };
-//# sourceMappingURL=queryObserver.legacy.js.map