@tanstack/vue-query 5.0.0-alpha.4 → 5.0.0-alpha.42

package/build/umd/index.development.js

@@ -6,19 +6,19 @@
 
   class Subscribable {
     constructor() {
-      this.listeners = [];
+      this.listeners = new Set();
       this.subscribe = this.subscribe.bind(this);
     }
     subscribe(listener) {
-      this.listeners.push(listener);
+      this.listeners.add(listener);
       this.onSubscribe();
       return () => {
-        this.listeners = this.listeners.filter(x => x !== listener);
+        this.listeners.delete(listener);
         this.onUnsubscribe();
       };
     }
     hasListeners() {
-      return this.listeners.length > 0;
+      return this.listeners.size > 0;
     }
     onSubscribe() {
       // Do nothing
@@ -387,6 +387,8 @@
   }
   const onlineManager = new OnlineManager();
 
+  // TYPES
+
   function defaultRetryDelay(failureCount) {
     return Math.min(1000 * 2 ** failureCount, 30000);
   }
@@ -907,7 +909,7 @@
             {
               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}`);
             }
-            onError(new Error('undefined'));
+            onError(new Error(`${this.queryHash} data is undefined`));
             return;
           }
           this.setData(data);
@@ -1024,7 +1026,7 @@
       this.state = reducer(this.state);
       notifyManager.batch(() => {
         this.#observers.forEach(observer => {
-          observer.onQueryUpdate(action);
+          observer.onQueryUpdate();
         });
         this.#cache.notify({
           query: this,
@@ -1054,6 +1056,8 @@
     };
   }
 
+  // TYPES
+
   // CLASS
 
   let QueryCache$1 = class QueryCache extends Subscribable {
@@ -1061,7 +1065,7 @@
     constructor(config = {}) {
       super();
       this.config = config;
-      this.#queries = config.createStore?.() ?? new Map();
+      this.#queries = new Map();
     }
     build(client, options, state) {
       const queryKey = options.queryKey;
@@ -1116,10 +1120,11 @@
       return [...this.#queries.values()];
     }
     find(filters) {
-      if (typeof filters.exact === 'undefined') {
-        filters.exact = true;
-      }
-      return this.getAll().find(query => matchQuery(filters, query));
+      const defaultedFilters = {
+        exact: true,
+        ...filters
+      };
+      return this.getAll().find(query => matchQuery(defaultedFilters, query));
     }
     findAll(filters = {}) {
       const queries = this.getAll();
@@ -1425,10 +1430,11 @@
       return this.#mutations;
     }
     find(filters) {
-      if (typeof filters.exact === 'undefined') {
-        filters.exact = true;
-      }
-      return this.#mutations.find(mutation => matchMutation(filters, mutation));
+      const defaultedFilters = {
+        exact: true,
+        ...filters
+      };
+      return this.#mutations.find(mutation => matchMutation(defaultedFilters, mutation));
     }
     findAll(filters = {}) {
       return this.#mutations.filter(mutation => matchMutation(filters, mutation));
@@ -1454,12 +1460,15 @@
   function infiniteQueryBehavior() {
     return {
       onFetch: context => {
-        context.fetchFn = () => {
+        context.fetchFn = async () => {
           const options = context.options;
           const direction = context.fetchOptions?.meta?.fetchMore?.direction;
           const oldPages = context.state.data?.pages || [];
           const oldPageParams = context.state.data?.pageParams || [];
-          let newPageParams = oldPageParams;
+          const empty = {
+            pages: [],
+            pageParams: []
+          };
           let cancelled = false;
           const addSignalProperty = object => {
             Object.defineProperty(object, 'signal', {
@@ -1479,97 +1488,99 @@
 
           // Get query function
           const queryFn = context.options.queryFn || (() => Promise.reject(new Error('Missing queryFn')));
-          const buildNewPages = (pages, param, page, previous) => {
-            const {
-              maxPages
-            } = context.options;
-            if (previous) {
-              newPageParams = addToStart(newPageParams, param, maxPages);
-              return addToStart(pages, page, maxPages);
-            }
-            newPageParams = addToEnd(newPageParams, param, maxPages);
-            return addToEnd(pages, page, maxPages);
-          };
 
           // Create function to fetch a page
-          const fetchPage = (pages, param, previous) => {
+          const fetchPage = async (data, param, previous) => {
             if (cancelled) {
               return Promise.reject();
             }
-            if (typeof param === 'undefined' && pages.length) {
-              return Promise.resolve(pages);
+            if (typeof param === 'undefined' && data.pages.length) {
+              return Promise.resolve(data);
             }
             const queryFnContext = {
               queryKey: context.queryKey,
               pageParam: param,
+              direction: previous ? 'backward' : 'forward',
               meta: context.options.meta
             };
             addSignalProperty(queryFnContext);
-            const queryFnResult = queryFn(queryFnContext);
-            const promise = Promise.resolve(queryFnResult).then(page => buildNewPages(pages, param, page, previous));
-            return promise;
+            const page = await queryFn(queryFnContext);
+            const {
+              maxPages
+            } = context.options;
+            const addTo = previous ? addToStart : addToEnd;
+            return {
+              pages: addTo(data.pages, page, maxPages),
+              pageParams: addTo(data.pageParams, param, maxPages)
+            };
           };
-          let promise;
+          let result;
 
           // Fetch first page?
           if (!oldPages.length) {
-            promise = fetchPage([], options.defaultPageParam);
+            result = await fetchPage(empty, options.defaultPageParam);
           }
 
           // fetch next / previous page?
           else if (direction) {
             const previous = direction === 'backward';
-            const param = previous ? getPreviousPageParam(options, oldPages) : getNextPageParam(options, oldPages);
-            promise = fetchPage(oldPages, param, previous);
+            const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
+            const oldData = {
+              pages: oldPages,
+              pageParams: oldPageParams
+            };
+            const param = pageParamFn(options, oldData);
+            result = await fetchPage(oldData, param, previous);
           }
 
           // Refetch pages
           else {
-            newPageParams = [];
-
             // Fetch first page
-            promise = fetchPage([], oldPageParams[0]);
+            result = await fetchPage(empty, oldPageParams[0]);
 
             // Fetch remaining pages
             for (let i = 1; i < oldPages.length; i++) {
-              promise = promise.then(pages => {
-                const param = getNextPageParam(options, pages);
-                return fetchPage(pages, param);
-              });
+              const param = getNextPageParam(options, result);
+              result = await fetchPage(result, param);
             }
           }
-          const finalPromise = promise.then(pages => ({
-            pages,
-            pageParams: newPageParams
-          }));
-          return finalPromise;
+          return result;
         };
       }
     };
   }
-  function getNextPageParam(options, pages) {
-    return options.getNextPageParam(pages[pages.length - 1], pages);
+  function getNextPageParam(options, {
+    pages,
+    pageParams
+  }) {
+    const lastIndex = pages.length - 1;
+    return options.getNextPageParam(pages[lastIndex], pages, pageParams[lastIndex], pageParams);
   }
-  function getPreviousPageParam(options, pages) {
-    return options.getPreviousPageParam?.(pages[0], pages);
+  function getPreviousPageParam(options, {
+    pages,
+    pageParams
+  }) {
+    return options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams);
   }
 
   /**
    * Checks if there is a next page.
    */
-  function hasNextPage(options, pages) {
-    if (!pages) return false;
-    return typeof getNextPageParam(options, pages) !== 'undefined';
+  function hasNextPage(options, data) {
+    if (!data) return false;
+    return typeof getNextPageParam(options, data) !== 'undefined';
   }
 
   /**
    * Checks if there is a previous page.
    */
-  function hasPreviousPage(options, pages) {
-    if (!pages || !options.getPreviousPageParam) return false;
-    return typeof getPreviousPageParam(options, pages) !== 'undefined';
+  function hasPreviousPage(options, data) {
+    if (!data || !options.getPreviousPageParam) return false;
+    return typeof getPreviousPageParam(options, data) !== 'undefined';
   }
 
+  // TYPES
+
   // CLASS
 
   let QueryClient$1 = class QueryClient {
@@ -1692,10 +1703,11 @@
       });
     }
     cancelQueries(filters = {}, cancelOptions = {}) {
-      if (typeof cancelOptions.revert === 'undefined') {
-        cancelOptions.revert = true;
-      }
-      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).map(query => query.cancel(cancelOptions)));
+      const defaultedCancelOptions = {
+        revert: true,
+        ...cancelOptions
+      };
+      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).map(query => query.cancel(defaultedCancelOptions)));
       return Promise.all(promises).then(noop).catch(noop);
     }
     invalidateQueries(filters = {}, options = {}) {
@@ -1714,15 +1726,18 @@
       });
     }
     refetchQueries(filters = {}, options) {
-      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => query.fetch(undefined, {
+      const fetchOptions = {
         ...options,
         cancelRefetch: options?.cancelRefetch ?? true
-      })));
-      let promise = Promise.all(promises).then(noop);
-      if (!options?.throwOnError) {
-        promise = promise.catch(noop);
-      }
-      return promise;
+      };
+      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => {
+        let promise = query.fetch(undefined, fetchOptions);
+        if (!fetchOptions.throwOnError) {
+          promise = promise.catch(noop);
+        }
+        return query.state.fetchStatus === 'paused' ? Promise.resolve() : promise;
+      }));
+      return Promise.all(promises).then(noop);
     }
     fetchQuery(options) {
       const defaultedOptions = this.defaultQueryOptions(options);
@@ -1815,8 +1830,8 @@
       if (typeof defaultedOptions.refetchOnReconnect === 'undefined') {
         defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== 'always';
       }
-      if (typeof defaultedOptions.throwErrors === 'undefined') {
-        defaultedOptions.throwErrors = !!defaultedOptions.suspense;
+      if (typeof defaultedOptions.throwOnError === 'undefined') {
+        defaultedOptions.throwOnError = !!defaultedOptions.suspense;
       }
       return defaultedOptions;
     }
@@ -1844,10 +1859,12 @@
     #currentResult = undefined;
     #currentResultState;
     #currentResultOptions;
-    #previousQueryResult;
     #selectError;
     #selectFn;
     #selectResult;
+    // 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.
+    #lastQueryWithDefinedData;
     #staleTimeoutId;
     #refetchIntervalId;
     #currentRefetchInterval;
@@ -1864,7 +1881,7 @@
       this.refetch = this.refetch.bind(this);
     }
     onSubscribe() {
-      if (this.listeners.length === 1) {
+      if (this.listeners.size === 1) {
         this.#currentQuery.addObserver(this);
         if (shouldFetchOnMount(this.#currentQuery, this.options)) {
           this.#executeFetch();
@@ -1873,7 +1890,7 @@
       }
     }
     onUnsubscribe() {
-      if (!this.listeners.length) {
+      if (!this.hasListeners()) {
         this.destroy();
       }
     }
@@ -1884,7 +1901,7 @@
       return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnWindowFocus);
     }
     destroy() {
-      this.listeners = [];
+      this.listeners = new Set();
       this.#clearStaleTimeout();
       this.#clearRefetchInterval();
       this.#currentQuery.removeObserver(this);
@@ -2004,7 +2021,7 @@
       }, timeout);
     }
     #computeRefetchInterval() {
-      return typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.#currentResult.data, this.#currentQuery) : this.options.refetchInterval ?? false;
+      return (typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.#currentResult.data, this.#currentQuery) : this.options.refetchInterval) ?? false;
     }
     #updateRefetchInterval(nextInterval) {
       this.#clearRefetchInterval();
@@ -2042,7 +2059,6 @@
       const prevResultOptions = this.#currentResultOptions;
       const queryChange = query !== prevQuery;
       const queryInitialState = queryChange ? query.state : this.#currentQueryInitialState;
-      const prevQueryResult = queryChange ? this.#currentResult : this.#previousQueryResult;
       const {
         state
       } = query;
@@ -2101,7 +2117,7 @@
         if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
           placeholderData = prevResult.data;
         } else {
-          placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData(prevQueryResult?.data) : options.placeholderData;
+          placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData(this.#lastQueryWithDefinedData?.state.data, this.#lastQueryWithDefinedData) : options.placeholderData;
           if (options.select && typeof placeholderData !== 'undefined') {
             try {
               placeholderData = options.select(placeholderData);
@@ -2165,6 +2181,9 @@
       if (shallowEqualObjects(nextResult, prevResult)) {
         return;
       }
+      if (this.#currentResultState.data !== undefined) {
+        this.#lastQueryWithDefinedData = this.#currentQuery;
+      }
       this.#currentResult = nextResult;
 
       // Determine which callbacks to trigger
@@ -2180,7 +2199,7 @@
           return true;
         }
         const includedProps = new Set(notifyOnChangeProps ?? this.#trackedProps);
-        if (this.options.throwErrors) {
+        if (this.options.throwOnError) {
           includedProps.add('error');
         }
         return Object.keys(this.#currentResult).some(key => {
@@ -2205,36 +2224,20 @@
       const prevQuery = this.#currentQuery;
       this.#currentQuery = query;
       this.#currentQueryInitialState = query.state;
-      this.#previousQueryResult = this.#currentResult;
       if (this.hasListeners()) {
         prevQuery?.removeObserver(this);
         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);
@@ -2282,18 +2285,22 @@
     #result;
     #queries;
     #observers;
-    constructor(client, queries) {
+    #options;
+    #combinedResult;
+    constructor(client, queries, options) {
       super();
       this.#client = client;
       this.#queries = [];
-      this.#result = [];
       this.#observers = [];
-      if (queries) {
-        this.setQueries(queries);
-      }
+      this.#setResult([]);
+      this.setQueries(queries, options);
+    }
+    #setResult(value) {
+      this.#result = value;
+      this.#combinedResult = this.#combineResult(value);
     }
     onSubscribe() {
-      if (this.listeners.length === 1) {
+      if (this.listeners.size === 1) {
         this.#observers.forEach(observer => {
           observer.subscribe(result => {
             this.#onUpdate(observer, result);
@@ -2302,18 +2309,19 @@
       }
     }
     onUnsubscribe() {
-      if (!this.listeners.length) {
+      if (!this.listeners.size) {
         this.destroy();
       }
     }
     destroy() {
-      this.listeners = [];
+      this.listeners = new Set();
       this.#observers.forEach(observer => {
         observer.destroy();
       });
     }
-    setQueries(queries, notifyOptions) {
+    setQueries(queries, options, notifyOptions) {
       this.#queries = queries;
+      this.#options = options;
       notifyManager.batch(() => {
         const prevObservers = this.#observers;
         const newObserverMatches = this.#findMatchingObservers(this.#queries);
@@ -2327,7 +2335,7 @@
           return;
         }
         this.#observers = newObservers;
-        this.#result = newResult;
+        this.#setResult(newResult);
         if (!this.hasListeners()) {
           return;
         }
@@ -2343,7 +2351,7 @@
       });
     }
     getCurrentResult() {
-      return this.#result;
+      return this.#combinedResult;
     }
     getQueries() {
       return this.#observers.map(observer => observer.getCurrentQuery());
@@ -2352,13 +2360,30 @@
       return this.#observers;
     }
     getOptimisticResult(queries) {
-      return this.#findMatchingObservers(queries).map(match => match.observer.getOptimisticResult(match.defaultedQueryOptions));
+      const matches = this.#findMatchingObservers(queries);
+      const result = matches.map(match => match.observer.getOptimisticResult(match.defaultedQueryOptions));
+      return [result, r => {
+        return this.#combineResult(r ?? result);
+      }, () => {
+        return matches.map((match, index) => {
+          const observerResult = result[index];
+          return !match.defaultedQueryOptions.notifyOnChangeProps ? match.observer.trackResult(observerResult) : observerResult;
+        });
+      }];
+    }
+    #combineResult(input) {
+      const combine = this.#options?.combine;
+      if (combine) {
+        return replaceEqualDeep(this.#combinedResult, combine(input));
+      }
+      return input;
     }
     #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,
@@ -2367,8 +2392,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);
@@ -2386,7 +2411,7 @@
     #onUpdate(observer, result) {
       const index = this.#observers.indexOf(observer);
       if (index !== -1) {
-        this.#result = replaceAt(this.#result, index, result);
+        this.#setResult(replaceAt(this.#result, index, result));
         this.#notify();
       }
     }
@@ -2425,7 +2450,7 @@
       options.behavior = infiniteQueryBehavior();
       return super.getOptimisticResult(options);
     }
-    fetchNextPage(options = {}) {
+    fetchNextPage(options) {
       return this.fetch({
         ...options,
         meta: {
@@ -2435,9 +2460,7 @@
         }
       });
     }
-    fetchPreviousPage({
-      ...options
-    } = {}) {
+    fetchPreviousPage(options) {
       return this.fetch({
         ...options,
         meta: {
@@ -2462,8 +2485,8 @@
         ...result,
         fetchNextPage: this.fetchNextPage,
         fetchPreviousPage: this.fetchPreviousPage,
-        hasNextPage: hasNextPage(options, state.data?.pages),
-        hasPreviousPage: hasPreviousPage(options, state.data?.pages),
+        hasNextPage: hasNextPage(options, state.data),
+        hasPreviousPage: hasPreviousPage(options, state.data),
         isFetchingNextPage,
         isFetchingPreviousPage,
         isRefetching: isRefetching && !isFetchingNextPage && !isFetchingPreviousPage
@@ -2504,7 +2527,7 @@
       this.#currentMutation?.setOptions(this.options);
     }
     onUnsubscribe() {
-      if (!this.listeners.length) {
+      if (!this.hasListeners()) {
         this.#currentMutation?.removeObserver(this);
       }
     }
@@ -2589,24 +2612,10 @@
     return query.state.status === 'success';
   }
   function dehydrate(client, options = {}) {
-    const mutations = [];
-    const queries = [];
-    if (options.dehydrateMutations !== false) {
-      const shouldDehydrateMutation = options.shouldDehydrateMutation || defaultShouldDehydrateMutation;
-      client.getMutationCache().getAll().forEach(mutation => {
-        if (shouldDehydrateMutation(mutation)) {
-          mutations.push(dehydrateMutation(mutation));
-        }
-      });
-    }
-    if (options.dehydrateQueries !== false) {
-      const shouldDehydrateQuery = options.shouldDehydrateQuery || defaultShouldDehydrateQuery;
-      client.getQueryCache().getAll().forEach(query => {
-        if (shouldDehydrateQuery(query)) {
-          queries.push(dehydrateQuery(query));
-        }
-      });
-    }
+    const filterMutation = options.shouldDehydrateMutation ?? defaultShouldDehydrateMutation;
+    const mutations = client.getMutationCache().getAll().flatMap(mutation => filterMutation(mutation) ? [dehydrateMutation(mutation)] : []);
+    const filterQuery = options.shouldDehydrateQuery ?? defaultShouldDehydrateQuery;
+    const queries = client.getQueryCache().getAll().flatMap(query => filterQuery(query) ? [dehydrateQuery(query)] : []);
     return {
       mutations,
       queries
@@ -3674,16 +3683,15 @@
     };
   }
 
-  /* istanbul ignore file */
   // eslint-disable-next-line no-shadow
-  var QueryState;
-  (function (QueryState) {
+  var QueryState = /*#__PURE__*/function (QueryState) {
     QueryState[QueryState["Fetching"] = 0] = "Fetching";
     QueryState[QueryState["Fresh"] = 1] = "Fresh";
     QueryState[QueryState["Stale"] = 2] = "Stale";
     QueryState[QueryState["Inactive"] = 3] = "Inactive";
     QueryState[QueryState["Paused"] = 4] = "Paused";
-  })(QueryState || (QueryState = {}));
+    return QueryState;
+  }(QueryState || {});
   function getQueryState(query) {
     if (query.state.fetchStatus === 'fetching') {
       return QueryState.Fetching;
@@ -3752,7 +3760,6 @@
     'Last Updated': dateSort
   };
 
-  /* istanbul ignore file */
   const pluginId = 'vue-query';
   const pluginName = 'Vue Query';
   function setupDevtools(app, queryClient) {
@@ -3760,8 +3767,8 @@
       id: pluginId,
       label: pluginName,
       packageName: 'vue-query',
-      homepage: 'https://tanstack.com/query/v4',
-      logo: 'https://vue-query.vercel.app/vue-query.svg',
+      homepage: 'https://tanstack.com/query/latest',
+      logo: 'https://raw.githubusercontent.com/TanStack/query/main/packages/vue-query/media/vue-query.svg',
       app,
       settings: {
         baseSort: {
@@ -3785,16 +3792,31 @@
             value: key
           })),
           defaultValue: Object.keys(sortFns)[0]
+        },
+        onlineMode: {
+          type: 'choice',
+          component: 'button-group',
+          label: 'Online mode',
+          options: [{
+            label: 'Online',
+            value: 1
+          }, {
+            label: 'Offline',
+            value: 0
+          }],
+          defaultValue: 1
         }
       }
     }, api => {
+      const initialSettings = api.getSettings();
+      onlineManager.setOnline(Boolean(initialSettings.onlineMode.valueOf()));
       const queryCache = queryClient.getQueryCache();
       api.addInspector({
         id: pluginId,
         label: pluginName,
         icon: 'api',
         nodeActions: [{
-          icon: 'cloud_download',
+          icon: 'file_download',
           tooltip: 'Refetch',
           action: queryHash => {
             queryCache.get(queryHash)?.fetch();
@@ -3819,6 +3841,27 @@
             const query = queryCache.get(queryHash);
             queryCache.remove(query);
           }
+        }, {
+          icon: 'hourglass_empty',
+          tooltip: 'Force loading',
+          action: queryHash => {
+            const query = queryCache.get(queryHash);
+            query.setState({
+              data: undefined,
+              status: 'pending'
+            });
+          }
+        }, {
+          icon: 'error_outline',
+          tooltip: 'Force error',
+          action: queryHash => {
+            const query = queryCache.get(queryHash);
+            query.setState({
+              data: undefined,
+              status: 'error',
+              error: new Error('Unknown error from devtools')
+            });
+          }
         }]
       });
       api.addTimelineLayer({
@@ -3829,9 +3872,7 @@
       queryCache.subscribe(event => {
         api.sendInspectorTree(pluginId);
         api.sendInspectorState(pluginId);
-        if (
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        event && ['queryAdded', 'queryRemoved', 'queryUpdated'].includes(event.type)) {
+        if (['added', 'removed', 'updated'].includes(event.type)) {
           api.addTimelineEvent({
             layerId: pluginId,
             event: {
@@ -3846,6 +3887,11 @@
           });
         }
       });
+      api.on.setPluginSettings(payload => {
+        if (payload.key === 'onlineMode') {
+          onlineManager.setOnline(Boolean(payload.newValue));
+        }
+      });
       api.on.getInspectorTree(payload => {
         if (payload.inspectorId === pluginId) {
           const queries = queryCache.getAll();
@@ -3938,8 +3984,6 @@
           originalUnmount();
         };
       }
-
-      /* istanbul ignore next */
       if (vueDemi.isVue2) {
         app.mixin({
           beforeCreate() {
@@ -4038,35 +4082,49 @@
   }
 
   /* eslint-disable @typescript-eslint/no-explicit-any */
+
+  // This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
+  // `placeholderData` function does not have a parameter
+  // Avoid TS depth-limit error in case of large array literal
+  /**
+   * UseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+   */
+  /**
+   * UseQueriesResults reducer recursively maps type param to results
+   */
   function useQueries({
-    queries
+    queries,
+    ...options
   }, queryClient) {
     const client = queryClient || useQueryClient();
-    const defaultedQueries = vueDemi.computed(() => cloneDeepUnref(queries).map(options => {
-      const defaulted = client.defaultQueryOptions(options);
+    const defaultedQueries = vueDemi.computed(() => cloneDeepUnref(queries).map(queryOptions => {
+      const defaulted = client.defaultQueryOptions(queryOptions);
       defaulted._optimisticResults = client.isRestoring.value ? 'isRestoring' : 'optimistic';
       return defaulted;
     }));
-    const observer = new QueriesObserver(client, defaultedQueries.value);
-    const state = vueDemi.ref(observer.getCurrentResult());
+    const observer = new QueriesObserver(client, defaultedQueries.value, options);
+    const [, getCombinedResult] = observer.getOptimisticResult(defaultedQueries.value);
+    const state = vueDemi.ref(getCombinedResult());
     const unsubscribe = vueDemi.ref(() => {
       // noop
     });
     vueDemi.watch(client.isRestoring, isRestoring => {
       if (!isRestoring) {
         unsubscribe.value();
-        unsubscribe.value = observer.subscribe(result => {
-          state.value.splice(0, result.length, ...result);
+        unsubscribe.value = observer.subscribe(() => {
+          const [, getCombinedResultRestoring] = observer.getOptimisticResult(defaultedQueries.value);
+          state.value = getCombinedResultRestoring();
         });
         // Subscription would not fire for persisted results
-        state.value.splice(0, state.value.length, ...observer.getOptimisticResult(defaultedQueries.value));
+        const [, getCombinedResultPersisted] = observer.getOptimisticResult(defaultedQueries.value);
+        state.value = getCombinedResultPersisted();
       }
     }, {
       immediate: true
     });
-    vueDemi.watch(defaultedQueries, () => {
-      observer.setQueries(defaultedQueries.value);
-      state.value.splice(0, state.value.length, ...observer.getCurrentResult());
+    vueDemi.watch([defaultedQueries], () => {
+      observer.setQueries(defaultedQueries.value, options);
+      state.value = observer.getCurrentResult();
     }, {
       deep: true
     });
@@ -4139,22 +4197,31 @@
     return isFetching;
   }
 
-  function useIsMutating(mutationFilters = {}, queryClient) {
-    const filters = vueDemi.computed(() => cloneDeepUnref(mutationFilters));
+  function useIsMutating(filters = {}, queryClient) {
     const client = queryClient || useQueryClient();
-    const isMutating = vueDemi.ref(client.isMutating(filters));
-    const unsubscribe = client.getMutationCache().subscribe(() => {
-      isMutating.value = client.isMutating(filters);
-    });
-    vueDemi.watch(filters, () => {
-      isMutating.value = client.isMutating(filters);
-    }, {
-      deep: true
+    const unreffedFilters = vueDemi.computed(() => ({
+      ...cloneDeepUnref(filters),
+      status: 'pending'
+    }));
+    const length = vueDemi.computed(() => useMutationState({
+      filters: unreffedFilters
+    }, client).value.length);
+    return length;
+  }
+  function getResult(mutationCache, options) {
+    return mutationCache.findAll(options.filters).map(mutation => options.select ? options.select(mutation) : mutation.state);
+  }
+  function useMutationState(options = {}, queryClient) {
+    const mutationCache = (queryClient || useQueryClient()).getMutationCache();
+    const state = vueDemi.ref(getResult(mutationCache, options));
+    const unsubscribe = mutationCache.subscribe(() => {
+      const result = getResult(mutationCache, options);
+      state.value = result;
     });
     vueDemi.onScopeDispose(() => {
       unsubscribe();
     });
-    return isMutating;
+    return vueDemi.readonly(state);
   }
 
   exports.CancelledError = CancelledError;
@@ -4184,6 +4251,7 @@
   exports.useIsFetching = useIsFetching;
   exports.useIsMutating = useIsMutating;
   exports.useMutation = useMutation;
+  exports.useMutationState = useMutationState;
   exports.useQueries = useQueries;
   exports.useQuery = useQuery;
   exports.useQueryClient = useQueryClient;