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

package/build/lib/query.esm.js

@@ -1,71 +1,105 @@
+import { classPrivateFieldLooseBase as _classPrivateFieldLooseBase, classPrivateFieldLooseKey as _classPrivateFieldLooseKey } from './_virtual/_rollupPluginBabelHelpers.esm.js';
 import { replaceData, noop, timeUntilStale } from './utils.esm.js';
 import { notifyManager } from './notifyManager.esm.js';
 import { createRetryer, isCancelledError, canFetch } from './retryer.esm.js';
 import { Removable } from './removable.esm.js';
 
 // TYPES
-
+var _initialState = /*#__PURE__*/_classPrivateFieldLooseKey("initialState");
+var _revertState = /*#__PURE__*/_classPrivateFieldLooseKey("revertState");
+var _cache = /*#__PURE__*/_classPrivateFieldLooseKey("cache");
+var _promise = /*#__PURE__*/_classPrivateFieldLooseKey("promise");
+var _retryer = /*#__PURE__*/_classPrivateFieldLooseKey("retryer");
+var _observers = /*#__PURE__*/_classPrivateFieldLooseKey("observers");
+var _defaultOptions = /*#__PURE__*/_classPrivateFieldLooseKey("defaultOptions");
+var _abortSignalConsumed = /*#__PURE__*/_classPrivateFieldLooseKey("abortSignalConsumed");
+var _setOptions = /*#__PURE__*/_classPrivateFieldLooseKey("setOptions");
+var _dispatch = /*#__PURE__*/_classPrivateFieldLooseKey("dispatch");
 // CLASS
 
 class Query extends Removable {
-  #initialState;
-  #revertState;
-  #cache;
-  #promise;
-  #retryer;
-  #observers;
-  #defaultOptions;
-  #abortSignalConsumed;
   constructor(config) {
     super();
-    this.#abortSignalConsumed = false;
-    this.#defaultOptions = config.defaultOptions;
-    this.#setOptions(config.options);
-    this.#observers = [];
-    this.#cache = config.cache;
+    Object.defineProperty(this, _dispatch, {
+      value: _dispatch2
+    });
+    Object.defineProperty(this, _setOptions, {
+      value: _setOptions2
+    });
+    Object.defineProperty(this, _initialState, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _revertState, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _cache, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _promise, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _retryer, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _observers, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _defaultOptions, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _abortSignalConsumed, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _abortSignalConsumed)[_abortSignalConsumed] = false;
+    _classPrivateFieldLooseBase(this, _defaultOptions)[_defaultOptions] = config.defaultOptions;
+    _classPrivateFieldLooseBase(this, _setOptions)[_setOptions](config.options);
+    _classPrivateFieldLooseBase(this, _observers)[_observers] = [];
+    _classPrivateFieldLooseBase(this, _cache)[_cache] = config.cache;
     this.queryKey = config.queryKey;
     this.queryHash = config.queryHash;
-    this.#initialState = config.state || getDefaultState(this.options);
-    this.state = this.#initialState;
+    _classPrivateFieldLooseBase(this, _initialState)[_initialState] = config.state || getDefaultState(this.options);
+    this.state = _classPrivateFieldLooseBase(this, _initialState)[_initialState];
     this.scheduleGc();
   }
   get meta() {
     return this.options.meta;
   }
-  #setOptions(options) {
-    this.options = {
-      ...this.#defaultOptions,
-      ...options
-    };
-    this.updateGcTime(this.options.gcTime);
-  }
   optionalRemove() {
-    if (!this.#observers.length && this.state.fetchStatus === 'idle') {
-      this.#cache.remove(this);
+    if (!_classPrivateFieldLooseBase(this, _observers)[_observers].length && this.state.fetchStatus === 'idle') {
+      _classPrivateFieldLooseBase(this, _cache)[_cache].remove(this);
     }
   }
   setData(newData, options) {
     const data = replaceData(this.state.data, newData, this.options);
 
     // Set data and mark it as cached
-    this.#dispatch({
+    _classPrivateFieldLooseBase(this, _dispatch)[_dispatch]({
       data,
       type: 'success',
-      dataUpdatedAt: options?.updatedAt,
-      manual: options?.manual
+      dataUpdatedAt: options == null ? void 0 : options.updatedAt,
+      manual: options == null ? void 0 : options.manual
     });
     return data;
   }
   setState(state, setStateOptions) {
-    this.#dispatch({
+    _classPrivateFieldLooseBase(this, _dispatch)[_dispatch]({
       type: 'setState',
       state,
       setStateOptions
     });
   }
   cancel(options) {
-    const promise = this.#promise;
-    this.#retryer?.cancel(options);
+    var _classPrivateFieldLoo;
+    const promise = _classPrivateFieldLooseBase(this, _promise)[_promise];
+    (_classPrivateFieldLoo = _classPrivateFieldLooseBase(this, _retryer)[_retryer]) == null ? void 0 : _classPrivateFieldLoo.cancel(options);
     return promise ? promise.then(noop).catch(noop) : Promise.resolve();
   }
   destroy() {
@@ -76,45 +110,47 @@ class Query extends Removable {
   }
   reset() {
     this.destroy();
-    this.setState(this.#initialState);
+    this.setState(_classPrivateFieldLooseBase(this, _initialState)[_initialState]);
   }
   isActive() {
-    return this.#observers.some(observer => observer.options.enabled !== false);
+    return _classPrivateFieldLooseBase(this, _observers)[_observers].some(observer => observer.options.enabled !== false);
   }
   isDisabled() {
     return this.getObserversCount() > 0 && !this.isActive();
   }
   isStale() {
-    return this.state.isInvalidated || !this.state.dataUpdatedAt || this.#observers.some(observer => observer.getCurrentResult().isStale);
+    return this.state.isInvalidated || !this.state.dataUpdatedAt || _classPrivateFieldLooseBase(this, _observers)[_observers].some(observer => observer.getCurrentResult().isStale);
   }
   isStaleByTime(staleTime = 0) {
     return this.state.isInvalidated || !this.state.dataUpdatedAt || !timeUntilStale(this.state.dataUpdatedAt, staleTime);
   }
   onFocus() {
-    const observer = this.#observers.find(x => x.shouldFetchOnWindowFocus());
-    observer?.refetch({
+    var _classPrivateFieldLoo2;
+    const observer = _classPrivateFieldLooseBase(this, _observers)[_observers].find(x => x.shouldFetchOnWindowFocus());
+    observer == null ? void 0 : observer.refetch({
       cancelRefetch: false
     });
 
     // Continue fetch if currently paused
-    this.#retryer?.continue();
+    (_classPrivateFieldLoo2 = _classPrivateFieldLooseBase(this, _retryer)[_retryer]) == null ? void 0 : _classPrivateFieldLoo2.continue();
   }
   onOnline() {
-    const observer = this.#observers.find(x => x.shouldFetchOnReconnect());
-    observer?.refetch({
+    var _classPrivateFieldLoo3;
+    const observer = _classPrivateFieldLooseBase(this, _observers)[_observers].find(x => x.shouldFetchOnReconnect());
+    observer == null ? void 0 : observer.refetch({
       cancelRefetch: false
     });
 
     // Continue fetch if currently paused
-    this.#retryer?.continue();
+    (_classPrivateFieldLoo3 = _classPrivateFieldLooseBase(this, _retryer)[_retryer]) == null ? void 0 : _classPrivateFieldLoo3.continue();
   }
   addObserver(observer) {
-    if (this.#observers.indexOf(observer) === -1) {
-      this.#observers.push(observer);
+    if (_classPrivateFieldLooseBase(this, _observers)[_observers].indexOf(observer) === -1) {
+      _classPrivateFieldLooseBase(this, _observers)[_observers].push(observer);
 
       // Stop the query from being garbage collected
       this.clearGcTimeout();
-      this.#cache.notify({
+      _classPrivateFieldLooseBase(this, _cache)[_cache].notify({
         type: 'observerAdded',
         query: this,
         observer
@@ -122,23 +158,23 @@ class Query extends Removable {
     }
   }
   removeObserver(observer) {
-    if (this.#observers.indexOf(observer) !== -1) {
-      this.#observers = this.#observers.filter(x => x !== observer);
-      if (!this.#observers.length) {
+    if (_classPrivateFieldLooseBase(this, _observers)[_observers].indexOf(observer) !== -1) {
+      _classPrivateFieldLooseBase(this, _observers)[_observers] = _classPrivateFieldLooseBase(this, _observers)[_observers].filter(x => x !== observer);
+      if (!_classPrivateFieldLooseBase(this, _observers)[_observers].length) {
         // If the transport layer does not support cancellation
         // we'll let the query continue so the result can be cached
-        if (this.#retryer) {
-          if (this.#abortSignalConsumed) {
-            this.#retryer.cancel({
+        if (_classPrivateFieldLooseBase(this, _retryer)[_retryer]) {
+          if (_classPrivateFieldLooseBase(this, _abortSignalConsumed)[_abortSignalConsumed]) {
+            _classPrivateFieldLooseBase(this, _retryer)[_retryer].cancel({
               revert: true
             });
           } else {
-            this.#retryer.cancelRetry();
+            _classPrivateFieldLooseBase(this, _retryer)[_retryer].cancelRetry();
           }
         }
         this.scheduleGc();
       }
-      this.#cache.notify({
+      _classPrivateFieldLooseBase(this, _cache)[_cache].notify({
         type: 'observerRemoved',
         query: this,
         observer
@@ -146,41 +182,43 @@ class Query extends Removable {
     }
   }
   getObserversCount() {
-    return this.#observers.length;
+    return _classPrivateFieldLooseBase(this, _observers)[_observers].length;
   }
   invalidate() {
     if (!this.state.isInvalidated) {
-      this.#dispatch({
+      _classPrivateFieldLooseBase(this, _dispatch)[_dispatch]({
         type: 'invalidate'
       });
     }
   }
   fetch(options, fetchOptions) {
+    var _this$options$behavio, _context$fetchOptions;
     if (this.state.fetchStatus !== 'idle') {
-      if (this.state.dataUpdatedAt && fetchOptions?.cancelRefetch) {
+      if (this.state.dataUpdatedAt && fetchOptions != null && fetchOptions.cancelRefetch) {
         // Silently cancel current fetch if the user wants to cancel refetches
         this.cancel({
           silent: true
         });
-      } else if (this.#promise) {
+      } else if (_classPrivateFieldLooseBase(this, _promise)[_promise]) {
+        var _classPrivateFieldLoo4;
         // make sure that retries that were potentially cancelled due to unmounts can continue
-        this.#retryer?.continueRetry();
+        (_classPrivateFieldLoo4 = _classPrivateFieldLooseBase(this, _retryer)[_retryer]) == null ? void 0 : _classPrivateFieldLoo4.continueRetry();
         // Return current promise if we are already fetching
-        return this.#promise;
+        return _classPrivateFieldLooseBase(this, _promise)[_promise];
       }
     }
 
     // Update config if passed, otherwise the config from the last execution is used
     if (options) {
-      this.#setOptions(options);
+      _classPrivateFieldLooseBase(this, _setOptions)[_setOptions](options);
     }
 
     // Use the options from the first observer with a query function if no function is found.
     // This can happen when the query is hydrated or created with setQueryData.
     if (!this.options.queryFn) {
-      const observer = this.#observers.find(x => x.options.queryFn);
+      const observer = _classPrivateFieldLooseBase(this, _observers)[_observers].find(x => x.options.queryFn);
       if (observer) {
-        this.#setOptions(observer.options);
+        _classPrivateFieldLooseBase(this, _setOptions)[_setOptions](observer.options);
       }
     }
     if (process.env.NODE_ENV !== 'production') {
@@ -203,7 +241,7 @@ class Query extends Removable {
       Object.defineProperty(object, 'signal', {
         enumerable: true,
         get: () => {
-          this.#abortSignalConsumed = true;
+          _classPrivateFieldLooseBase(this, _abortSignalConsumed)[_abortSignalConsumed] = true;
           return abortController.signal;
         }
       });
@@ -215,7 +253,7 @@ class Query extends Removable {
       if (!this.options.queryFn) {
         return Promise.reject(new Error('Missing queryFn'));
       }
-      this.#abortSignalConsumed = false;
+      _classPrivateFieldLooseBase(this, _abortSignalConsumed)[_abortSignalConsumed] = false;
       return this.options.queryFn(queryFnContext);
     };
 
@@ -228,30 +266,32 @@ class Query extends Removable {
       fetchFn
     };
     addSignalProperty(context);
-    this.options.behavior?.onFetch(context);
+    (_this$options$behavio = this.options.behavior) == null ? void 0 : _this$options$behavio.onFetch(context);
 
     // Store state in case the current fetch needs to be reverted
-    this.#revertState = this.state;
+    _classPrivateFieldLooseBase(this, _revertState)[_revertState] = this.state;
 
     // Set to fetching state if not already in it
-    if (this.state.fetchStatus === 'idle' || this.state.fetchMeta !== context.fetchOptions?.meta) {
-      this.#dispatch({
+    if (this.state.fetchStatus === 'idle' || this.state.fetchMeta !== ((_context$fetchOptions = context.fetchOptions) == null ? void 0 : _context$fetchOptions.meta)) {
+      var _context$fetchOptions2;
+      _classPrivateFieldLooseBase(this, _dispatch)[_dispatch]({
         type: 'fetch',
-        meta: context.fetchOptions?.meta
+        meta: (_context$fetchOptions2 = context.fetchOptions) == null ? void 0 : _context$fetchOptions2.meta
       });
     }
     const onError = error => {
       // Optimistically update state if needed
       if (!(isCancelledError(error) && error.silent)) {
-        this.#dispatch({
+        _classPrivateFieldLooseBase(this, _dispatch)[_dispatch]({
           type: 'error',
           error: error
         });
       }
       if (!isCancelledError(error)) {
+        var _classPrivateFieldLoo5, _classPrivateFieldLoo6, _classPrivateFieldLoo7, _classPrivateFieldLoo8;
         // Notify cache callback
-        this.#cache.config.onError?.(error, this);
-        this.#cache.config.onSettled?.(this.state.data, error, this);
+        (_classPrivateFieldLoo5 = (_classPrivateFieldLoo6 = _classPrivateFieldLooseBase(this, _cache)[_cache].config).onError) == null ? void 0 : _classPrivateFieldLoo5.call(_classPrivateFieldLoo6, error, this);
+        (_classPrivateFieldLoo7 = (_classPrivateFieldLoo8 = _classPrivateFieldLooseBase(this, _cache)[_cache].config).onSettled) == null ? void 0 : _classPrivateFieldLoo7.call(_classPrivateFieldLoo8, this.state.data, error, this);
       }
       if (!this.isFetchingOptimistic) {
         // Schedule query gc after fetching
@@ -261,10 +301,11 @@ class Query extends Removable {
     };
 
     // Try to fetch the data
-    this.#retryer = createRetryer({
+    _classPrivateFieldLooseBase(this, _retryer)[_retryer] = createRetryer({
       fn: context.fetchFn,
       abort: abortController.abort.bind(abortController),
       onSuccess: data => {
+        var _classPrivateFieldLoo9, _classPrivateFieldLoo10, _classPrivateFieldLoo11, _classPrivateFieldLoo12;
         if (typeof data === 'undefined') {
           if (process.env.NODE_ENV !== 'production') {
             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}`);
@@ -275,8 +316,8 @@ class Query extends Removable {
         this.setData(data);
 
         // Notify cache callback
-        this.#cache.config.onSuccess?.(data, this);
-        this.#cache.config.onSettled?.(data, this.state.error, this);
+        (_classPrivateFieldLoo9 = (_classPrivateFieldLoo10 = _classPrivateFieldLooseBase(this, _cache)[_cache].config).onSuccess) == null ? void 0 : _classPrivateFieldLoo9.call(_classPrivateFieldLoo10, data, this);
+        (_classPrivateFieldLoo11 = (_classPrivateFieldLoo12 = _classPrivateFieldLooseBase(this, _cache)[_cache].config).onSettled) == null ? void 0 : _classPrivateFieldLoo11.call(_classPrivateFieldLoo12, data, this.state.error, this);
         if (!this.isFetchingOptimistic) {
           // Schedule query gc after fetching
           this.scheduleGc();
@@ -285,19 +326,19 @@ class Query extends Removable {
       },
       onError,
       onFail: (failureCount, error) => {
-        this.#dispatch({
+        _classPrivateFieldLooseBase(this, _dispatch)[_dispatch]({
           type: 'failed',
           failureCount,
           error
         });
       },
       onPause: () => {
-        this.#dispatch({
+        _classPrivateFieldLooseBase(this, _dispatch)[_dispatch]({
           type: 'pause'
         });
       },
       onContinue: () => {
-        this.#dispatch({
+        _classPrivateFieldLooseBase(this, _dispatch)[_dispatch]({
           type: 'continue'
         });
       },
@@ -305,96 +346,104 @@ class Query extends Removable {
       retryDelay: context.options.retryDelay,
       networkMode: context.options.networkMode
     });
-    this.#promise = this.#retryer.promise;
-    return this.#promise;
+    _classPrivateFieldLooseBase(this, _promise)[_promise] = _classPrivateFieldLooseBase(this, _retryer)[_retryer].promise;
+    return _classPrivateFieldLooseBase(this, _promise)[_promise];
   }
-  #dispatch(action) {
-    const reducer = state => {
-      switch (action.type) {
-        case 'failed':
-          return {
-            ...state,
-            fetchFailureCount: action.failureCount,
-            fetchFailureReason: action.error
-          };
-        case 'pause':
-          return {
-            ...state,
-            fetchStatus: 'paused'
-          };
-        case 'continue':
-          return {
-            ...state,
-            fetchStatus: 'fetching'
-          };
-        case 'fetch':
-          return {
-            ...state,
-            fetchFailureCount: 0,
-            fetchFailureReason: null,
-            fetchMeta: action.meta ?? null,
-            fetchStatus: canFetch(this.options.networkMode) ? 'fetching' : 'paused',
-            ...(!state.dataUpdatedAt && {
-              error: null,
-              status: 'pending'
-            })
-          };
-        case 'success':
-          return {
-            ...state,
-            data: action.data,
-            dataUpdateCount: state.dataUpdateCount + 1,
-            dataUpdatedAt: action.dataUpdatedAt ?? Date.now(),
+}
+function _setOptions2(options) {
+  this.options = {
+    ..._classPrivateFieldLooseBase(this, _defaultOptions)[_defaultOptions],
+    ...options
+  };
+  this.updateGcTime(this.options.gcTime);
+}
+function _dispatch2(action) {
+  const reducer = state => {
+    var _action$meta, _action$dataUpdatedAt;
+    switch (action.type) {
+      case 'failed':
+        return {
+          ...state,
+          fetchFailureCount: action.failureCount,
+          fetchFailureReason: action.error
+        };
+      case 'pause':
+        return {
+          ...state,
+          fetchStatus: 'paused'
+        };
+      case 'continue':
+        return {
+          ...state,
+          fetchStatus: 'fetching'
+        };
+      case 'fetch':
+        return {
+          ...state,
+          fetchFailureCount: 0,
+          fetchFailureReason: null,
+          fetchMeta: (_action$meta = action.meta) != null ? _action$meta : null,
+          fetchStatus: canFetch(this.options.networkMode) ? 'fetching' : 'paused',
+          ...(!state.dataUpdatedAt && {
             error: null,
-            isInvalidated: false,
-            status: 'success',
-            ...(!action.manual && {
-              fetchStatus: 'idle',
-              fetchFailureCount: 0,
-              fetchFailureReason: null
-            })
-          };
-        case 'error':
-          const error = action.error;
-          if (isCancelledError(error) && error.revert && this.#revertState) {
-            return {
-              ...this.#revertState
-            };
-          }
-          return {
-            ...state,
-            error: error,
-            errorUpdateCount: state.errorUpdateCount + 1,
-            errorUpdatedAt: Date.now(),
-            fetchFailureCount: state.fetchFailureCount + 1,
-            fetchFailureReason: error,
+            status: 'pending'
+          })
+        };
+      case 'success':
+        return {
+          ...state,
+          data: action.data,
+          dataUpdateCount: state.dataUpdateCount + 1,
+          dataUpdatedAt: (_action$dataUpdatedAt = action.dataUpdatedAt) != null ? _action$dataUpdatedAt : Date.now(),
+          error: null,
+          isInvalidated: false,
+          status: 'success',
+          ...(!action.manual && {
             fetchStatus: 'idle',
-            status: 'error'
-          };
-        case 'invalidate':
-          return {
-            ...state,
-            isInvalidated: true
-          };
-        case 'setState':
+            fetchFailureCount: 0,
+            fetchFailureReason: null
+          })
+        };
+      case 'error':
+        const error = action.error;
+        if (isCancelledError(error) && error.revert && _classPrivateFieldLooseBase(this, _revertState)[_revertState]) {
           return {
-            ...state,
-            ...action.state
+            ..._classPrivateFieldLooseBase(this, _revertState)[_revertState]
           };
-      }
-    };
-    this.state = reducer(this.state);
-    notifyManager.batch(() => {
-      this.#observers.forEach(observer => {
-        observer.onQueryUpdate(action);
-      });
-      this.#cache.notify({
-        query: this,
-        type: 'updated',
-        action
-      });
+        }
+        return {
+          ...state,
+          error: error,
+          errorUpdateCount: state.errorUpdateCount + 1,
+          errorUpdatedAt: Date.now(),
+          fetchFailureCount: state.fetchFailureCount + 1,
+          fetchFailureReason: error,
+          fetchStatus: 'idle',
+          status: 'error'
+        };
+      case 'invalidate':
+        return {
+          ...state,
+          isInvalidated: true
+        };
+      case 'setState':
+        return {
+          ...state,
+          ...action.state
+        };
+    }
+  };
+  this.state = reducer(this.state);
+  notifyManager.batch(() => {
+    _classPrivateFieldLooseBase(this, _observers)[_observers].forEach(observer => {
+      observer.onQueryUpdate();
     });
-  }
+    _classPrivateFieldLooseBase(this, _cache)[_cache].notify({
+      query: this,
+      type: 'updated',
+      action
+    });
+  });
 }
 function getDefaultState(options) {
   const data = typeof options.initialData === 'function' ? options.initialData() : options.initialData;
@@ -403,7 +452,7 @@ function getDefaultState(options) {
   return {
     data,
     dataUpdateCount: 0,
-    dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0,
+    dataUpdatedAt: hasData ? initialDataUpdatedAt != null ? initialDataUpdatedAt : Date.now() : 0,
     error: null,
     errorUpdateCount: 0,
     errorUpdatedAt: 0,