Merge branch 'main' into fix/retry-background-focus-issue

Author: Hellol77

docs/framework/react/community/tkdodos-blog.md

@@ -84,3 +84,47 @@ TanStack Query maintainer [TkDodo](https://bsky.app/profile/tkdodo.eu) has a ser
 ## [#19: Type-safe React Query](https://tkdodo.eu/blog/type-safe-react-query)
 
 > There's a big difference between "having types" and "being type-safe". This article tries to outline those differences and shows how you can get the best possible type-safety when using React Query together with TypeScript [Read more...](https://tkdodo.eu/blog/type-safe-react-query)
+
+## [#20: You Might Not Need React Query](https://tkdodo.eu/blog/you-might-not-need-react-query)
+
+> If your application doesn’t rely on client-side data fetching, especially when using frameworks like Next.js or Remix with built-in server components, React Query may be unnecessary. That said, it still shines in hybrid use cases (like infinite scrolling or offline support) where its smart caching and revalidation can be invaluable. [Read more...](https://tkdodo.eu/blog/you-might-not-need-react-query)
+
+## [#21: Thinking in React Query](https://tkdodo.eu/blog/thinking-in-react-query)
+
+> React Query isn’t a data-fetching library - it's an async state manager designed to treat parameters as dependencies, optimize refetch behavior via `staleTime`, and encourage declarative patterns where `queryKey` drives cache and updates. A small shift in mindset can dramatically streamline how you use React Query. [Read more...](https://tkdodo.eu/blog/thinking-in-react-query)
+
+## [#22: React Query and React Context](https://tkdodo.eu/blog/react-query-and-react-context)
+
+> React Query lets components independently manage their own data, making them self-sufficient and resilient, but when shared data (like user info fetched higher up) is needed deeper in the tree, React Context can make that implicit dependency explicit and safer. [Read more...](https://tkdodo.eu/blog/react-query-and-react-context)
+
+## [#23: Why You Want React Query](https://tkdodo.eu/blog/why-you-want-react-query)
+
+> While fetching data with `fetch` inside `useEffect` may seem simple, it quickly gets tangled with bugs like race conditions, missing loading states, stale data, and Strict Mode quirks—making async state management far more complex than it appears. [Read more...](https://tkdodo.eu/blog/why-you-want-react-query)
+
+## [#24: The Query Options API](https://tkdodo.eu/blog/the-query-options-api)
+
+> React Query v5 introduces a unified "Query Options" API - where all functions like `useQuery`, `invalidateQueries`, and imperative calls accept a single object - simplifying the interface and making reuse across different query contexts much easier while at the same time improving type-safety. [Read more...](https://tkdodo.eu/blog/the-query-options-api)
+
+## [#25: Automatic Query Invalidation after Mutations](https://tkdodo.eu/blog/automatic-query-invalidation-after-mutations)
+
+> React Query doesn’t automatically tie mutations to queries - but you can leverage "global cache callbacks" in a central `MutationCache` to define shared behaviors like invalidating queries on every mutation. [Read more...](https://tkdodo.eu/blog/automatic-query-invalidation-after-mutations)
+
+## [#26: How Infinite Queries work](https://tkdodo.eu/blog/how-infinite-queries-work)
+
+> This blog post is a deep dive into how Infinite Queries are designed and work under the hood. Interestingly, there is no distinct InfiniteQuery representation - just a different "behaviour" attached to regular Queries. [Read more...](https://tkdodo.eu/blog/how-infinite-queries-work)
+
+## [#27: React Query API Design - Lessons Learned](https://tkdodo.eu/blog/react-query-api-design-lessons-learned)
+
+> In this talk, Dominik walks us through some of the API design choices that were made in React Query to get to its arguably good developer experience. You'll hear stories about things that went well, but also about tradeoffs and mistakes that were made, and what lessons we can all learn from those. [Read more...](https://tkdodo.eu/blog/react-query-api-design-lessons-learned)
+
+## [#28: React Query - The Bad Parts](https://tkdodo.eu/blog/react-query-the-bad-parts)
+
+> In this talk, Dominik explores the less favorable aspects of React Query and situations where it may not be the best fit. No library is perfect; every choice involves trade-offs. By the end of this talk, you'll have a better understanding of React Query's limitations and why it remains a compelling choice despite them. [Read more...](https://tkdodo.eu/blog/react-query-the-bad-parts)
+
+## [#29: Concurrent Optimistic Updates in React Query](https://tkdodo.eu/blog/concurrent-optimistic-updates-in-react-query)
+
+> Optimistic updates in React Query can cause race conditions when multiple mutations run at once, leading to inconsistent UI states. Cancelling in-flight queries helps, but overlapping invalidations may still overwrite newer updates. [Read more...](https://tkdodo.eu/blog/concurrent-optimistic-updates-in-react-query)
+
+## [#30: React Query Selectors, Supercharged](https://tkdodo.eu/blog/react-query-selectors-supercharged)
+
+> React Query’s `select` option enables components to subscribe only to the specific part of a query’s data they care about - so updating one field won’t cause unrelated UI to re-render unnecessarily. This fine-grained approach keeps full responses in the cache while optimizing component updates for performance. [Read more...](https://tkdodo.eu/blog/react-query-selectors-supercharged)

docs/framework/react/guides/advanced-ssr.md

@@ -621,3 +621,11 @@ If you value DX/iteration/shipping speed with low code complexity over performan
 Server Components and streaming are still fairly new concepts and we are still figuring out how React Query fits in and what improvements we can make to the API. We welcome suggestions, feedback and bug reports!
 
 Similarly, it would be impossible to teach all the intricacies of this new paradigm all in one guide, on the first try. If you are missing some piece of information here or have suggestions on how to improve this content, also get in touch, or even better, click the "Edit on GitHub" button below and help us out.
+
+[//]: # 'Materials'
+
+## Further reading
+
+To understand if your application can benefit from React Query when also using Server Components, have a look at [You Might Not Need React Query](../../community/tkdodos-blog.md#20-you-might-not-need-react-query) from the Community Resources.
+
+[//]: # 'Materials'

docs/framework/react/guides/important-defaults.md

@@ -44,5 +44,6 @@ Have a look at the following articles from our Community Resources for further e
 
 - [Practical React Query](../../community/tkdodos-blog.md#1-practical-react-query)
 - [React Query as a State Manager](../../community/tkdodos-blog.md#10-react-query-as-a-state-manager)
+- [Thinking in React Query](../../community/tkdodos-blog.md#21-thinking-in-react-query)
 
 [//]: # 'Materials'

docs/framework/react/guides/infinite-queries.md

@@ -257,3 +257,11 @@ return useInfiniteQuery({
 ```
 
 [//]: # 'Example9'
+[//]: # 'Materials'
+
+## Further reading
+
+To get a better understanding of how Infinite Queries work under the hood, read [How Infinite Queries work](../../community/tkdodos-blog.md#26-how-infinite-queries-work) from
+the Community Resources.
+
+[//]: # 'Materials'

docs/framework/react/guides/invalidations-from-mutations.md

@@ -37,3 +37,12 @@ const mutation = useMutation({
 [//]: # 'Example2'
 
 You can wire up your invalidations to happen using any of the callbacks available in the [`useMutation` hook](../mutations.md)
+
+[//]: # 'Materials'
+
+## Further reading
+
+For a technique to automatically invalidate Queries after Mutations, have a look at [Automatic Query Invalidation after Mutations](../../community/tkdodos-blog.md#25-automatic-query-invalidation-after-mutations) from
+the Community Resources.
+
+[//]: # 'Materials'

docs/framework/react/guides/optimistic-updates.md

@@ -185,3 +185,11 @@ useMutation({
 If you only have one place where the optimistic result should be shown, using `variables` and updating the UI directly is the approach that requires less code and is generally easier to reason about. For example, you don't need to handle rollbacks at all.
 
 However, if you have multiple places on the screen that would require to know about the update, manipulating the cache directly will take care of this for you automatically.
+
+[//]: # 'Materials'
+
+## Further reading
+
+Have a look at the Community Resources for a guide on [Concurrent Optimistic Updates](../../community/tkdodos-blog.md#29-concurrent-optimistic-updates-in-react-query).
+
+[//]: # 'Materials'

docs/framework/react/guides/render-optimizations.md

@@ -73,4 +73,4 @@ export const useTodoCount = () => {
 ## Further Reading
 
 For an in-depth guide about these topics, read [React Query Render Optimizations](../../community/tkdodos-blog.md#3-react-query-render-optimizations) from
-the Community Resources.
+the Community Resources. To learn how to best optimize the `select` option, read [React Query Selectors, Supercharged](../../community/tkdodos-blog.md#30-react-query-selectors-supercharged)

docs/framework/react/overview.md

@@ -97,5 +97,6 @@ function Example() {
 
 - Consider taking the official [TanStack Query Course](https://query.gg?s=tanstack) (or buying it for your whole team!)
 - Learn TanStack Query at your own pace with our amazingly thorough [Walkthrough Guide](../installation.md) and [API Reference](../reference/useQuery.md)
+- Have a read at [Why You Want React Query](../community/tkdodos-blog.md#23-why-you-want-react-query) from the Community Resources.
 
 [//]: # 'Materials'

docs/framework/react/reference/queryOptions.md

@@ -22,3 +22,11 @@ You can generally pass everything to `queryOptions` that you can also pass to [`
   - Defaults to `false`
   - When set to `true`, queries will be prefetched during render, which can be useful for certain optimization scenarios
   - Needs to be turned on for the experimental `useQuery().promise` functionality
+
+[//]: # 'Materials'
+
+## Further reading
+
+To learn more about `QueryOptions`, have a look at [The Query Options API](../../community/tkdodos-blog.md#24-the-query-options-api) from the Community Resources.
+
+[//]: # 'Materials'

docs/framework/react/typescript.md

@@ -236,9 +236,6 @@ Without `queryOptions`, the type of `data` would be `unknown`, unless we'd pass
 const data = queryClient.getQueryData<Group[]>(['groups'])
 ```
 
-[//]: # 'TypingQueryOptions'
-[//]: # 'Materials'
-
 ## Typing Mutation Options
 
 Similarly to `queryOptions`, you can use `mutationOptions` to extract mutation options into a separate function:
@@ -259,14 +256,18 @@ useIsMutating(groupMutationOptions())
 queryClient.isMutating(groupMutationOptions())
 ```
 
-## Further Reading
-
-For tips and tricks around type inference, have a look at [React Query and TypeScript](../community/tkdodos-blog.md#6-react-query-and-typescript) from
-the Community Resources. To find out how to get the best possible type-safety, you can read [Type-safe React Query](../community/tkdodos-blog.md#19-type-safe-react-query).
-
-[//]: # 'Materials'
+[//]: # 'TypingQueryOptions'
 
 ## Typesafe disabling of queries using `skipToken`
 
 If you are using TypeScript, you can use the `skipToken` to disable a query. This is useful when you want to disable a query based on a condition, but you still want to keep the query to be type safe.
 Read more about it in the [Disabling Queries](../guides/disabling-queries.md) guide.
+
+[//]: # 'Materials'
+
+## Further Reading
+
+For tips and tricks around type inference, have a look at [React Query and TypeScript](../community/tkdodos-blog.md#6-react-query-and-typescript) from
+the Community Resources. To find out how to get the best possible type-safety, you can read [Type-safe React Query](../community/tkdodos-blog.md#19-type-safe-react-query). [The Query Options API](../community/tkdodos-blog.md#24-the-query-options-api) outlines how type inference works with the `queryOptions` helper function.
+
+[//]: # 'Materials'