Merge branch 'main' into beta

# Conflicts:
#	docs/config.json
#	docs/react/guides/queries.md
#	docs/react/typescript.md
#	docs/vue/typescript.md
#	examples/vue/dependent-queries/src/Post.vue
#	package.json
#	packages/eslint-plugin-query/package.json
#	packages/query-async-storage-persister/package.json
#	packages/query-broadcast-client-experimental/package.json
#	packages/query-core/package.json
#	packages/query-core/src/index.ts
#	packages/query-core/src/query.ts
#	packages/query-core/src/types.ts
#	packages/query-persist-client-core/package.json
#	packages/query-sync-storage-persister/package.json
#	packages/react-query-devtools/package.json
#	packages/react-query-persist-client/package.json
#	packages/react-query/package.json
#	packages/solid-query/package.json
#	packages/svelte-query/package.json
#	packages/vue-query/package.json
#	packages/vue-query/src/__tests__/useQuery.test.ts
#	packages/vue-query/src/types.ts
#	packages/vue-query/src/useBaseQuery.ts
#	packages/vue-query/src/useInfiniteQuery.ts
#	packages/vue-query/src/useIsFetching.ts
#	packages/vue-query/src/useIsMutating.ts
#	packages/vue-query/src/useMutation.ts
#	packages/vue-query/src/useQueries.ts
#	packages/vue-query/src/useQuery.ts
#	packages/vue-query/src/useQueryClient.ts
#	pnpm-lock.yaml
#	scripts/config.ts

Author: TkDodo

docs/react/guides/dependent-queries.md

@@ -3,6 +3,8 @@ id: dependent-queries
 title: Dependent Queries
 ---
 
+## useQuery dependent Query
+
 Dependent (or serial) queries depend on previous ones to finish before they can execute. To achieve this, it's as easy as using the `enabled` option to tell a query when it is ready to run:
 
 [//]: # 'Example'
@@ -54,3 +56,34 @@ status: 'success'
 isPending: false
 fetchStatus: 'idle'
 ```
+
+## useQueries dependent Query
+
+Dynamic parallel query - `useQueries` can depend on a previous query also, here's how to achieve this:
+
+[//]: # 'Example2'
+
+```tsx
+// Get the users ids
+const { data: userIds } = useQuery({
+  queryKey: ['users'],
+  queryFn: getUsersData,
+  select: users => users.map(user => user.id),
+})
+
+// Then get the users messages
+const usersMessages = useQueries({
+  queries: users
+    ? usersId.map(id => {
+        return {
+          queryKey: ['messages', id],
+          queryFn: () => getMessagesByUsers(id),
+        };
+      })
+  : [], // if users is undefined, an empty array will be returned
+})
+```
+
+[//]: # 'Example2'
+
+**Note** that `useQueries` return an **array of query results**

docs/react/plugins/persistQueryClient.md

@@ -265,7 +265,7 @@ import { PersistedClient, Persister } from "@tanstack/react-query-persist-client
 export function createIDBPersister(idbValidKey: IDBValidKey = "reactQuery") {
   return {
     persistClient: async (client: PersistedClient) => {
-      set(idbValidKey, client);
+      await set(idbValidKey, client);
     },
     restoreClient: async () => {
       return await get<PersistedClient>(idbValidKey);

docs/react/typescript.md

@@ -88,6 +88,8 @@ The type for error defaults to `Error`, because that is what most users expect.
 
 [//]: # 'TypingError'
 
+[//]: # 'TypingError'
+
 ```tsx
 const { error } = useQuery({ queryKey: ['groups'], queryFn: fetchGroups })
 //      ^? const error: Error

packages/query-core/src/query.ts

@@ -570,7 +570,7 @@ export class Query<
           const error = action.error as unknown
 
           if (isCancelledError(error) && error.revert && this.#revertState) {
-            return { ...this.#revertState }
+            return { ...this.#revertState, fetchStatus: 'idle' }
           }
 
           return {

packages/query-core/src/tests/query.test.tsx

@@ -864,4 +864,56 @@ describe('query', () => {
 
     unsubscribe()
   })
+
+  test('should always revert to idle state (#5958)', async () => {
+    let mockedData = [1]
+
+    const key = queryKey()
+
+    const queryFn = jest.fn<
+      Promise<unknown>,
+      [QueryFunctionContext<ReturnType<typeof queryKey>>]
+    >()
+
+    queryFn.mockImplementation(({ signal }) => {
+      return new Promise((resolve, reject) => {
+        const abortListener = () => {
+          clearTimeout(timerId)
+          reject(signal!.reason)
+        }
+        signal!.addEventListener('abort', abortListener)
+
+        const timerId = setTimeout(() => {
+          signal!.removeEventListener('abort', abortListener)
+          resolve(mockedData.join(' - '))
+        }, 50)
+      })
+    })
+
+    const observer = new QueryObserver(queryClient, {
+      queryKey: key,
+      queryFn,
+    })
+    const unsubscribe = observer.subscribe(() => undefined)
+    await sleep(60) // let it resolve
+
+    mockedData = [1, 2] // update "server" state in the background
+
+    queryClient.invalidateQueries(key)
+    await sleep(1)
+    queryClient.invalidateQueries(key)
+    await sleep(1)
+    unsubscribe() // unsubscribe to simulate unmount
+
+    // set up a new observer to simulate a mount of new component
+    const newObserver = new QueryObserver(queryClient, {
+      queryKey: key,
+      queryFn,
+    })
+
+    const spy = jest.fn()
+    newObserver.subscribe(({ data }) => spy(data))
+    await sleep(60) // let it resolve
+    expect(spy).toHaveBeenCalledWith('1 - 2')
+  })
 })

packages/vue-query/src/__tests__/useQueryClient.test.ts

@@ -20,15 +20,15 @@ describe('useQueryClient', () => {
 
     expect(queryClient).toStrictEqual(queryClientMock)
     expect(injectSpy).toHaveBeenCalledTimes(1)
-    expect(injectSpy).toHaveBeenCalledWith(VUE_QUERY_CLIENT)
+    expect(injectSpy).toHaveBeenCalledWith(VUE_QUERY_CLIENT, null)
   })
 
   test('should throw an error when queryClient does not exist in the context', () => {
     injectSpy.mockReturnValueOnce(undefined)
 
     expect(useQueryClient).toThrowError()
     expect(injectSpy).toHaveBeenCalledTimes(1)
-    expect(injectSpy).toHaveBeenCalledWith(VUE_QUERY_CLIENT)
+    expect(injectSpy).toHaveBeenCalledWith(VUE_QUERY_CLIENT, null)
   })
 
   test('should throw an error when used outside of setup function', () => {
@@ -46,6 +46,6 @@ describe('useQueryClient', () => {
 
     useQueryClient(queryClientKey)
 
-    expect(injectSpy).toHaveBeenCalledWith(expectedKeyParameter)
+    expect(injectSpy).toHaveBeenCalledWith(expectedKeyParameter, null)
   })
 })