TanStack/query

This system is the TanStack Query library, a data-fetching and caching solution for modern frontend frameworks including React, Angular, Vue, Svelte, Solid, Lit, and Preact. It provides framework-specific adapters that enable features such as automatic background refetching, pagination, infinite scrolling, optimistic updates, and server-side rendering hydration. The repository also includes developer tooling like ESLint plugins, devtools panels, and persistence utilities to manage cache state across sessions and tabs.

54 changes.

The project underwent a comprehensive restructuring to align with TanStack Query v5, migrating the build toolchain to Vite and tsdown while renaming the core package. This period saw the introduction of new APIs for hydration, suspense, and options, alongside the release of official adapters for Solid.js and Vue. The ecosystem was further expanded with new examples, devtools enhancements, and a refined persistence strategy.

52 changes.

The Svelte adapter and all associated examples were rewritten to support Svelte 5 runes, replacing legacy reactivity with modern primitives. This period also saw the introduction of experimental Angular and Solid integrations, alongside new devtools and persistence packages for multiple frameworks.

44 changes.

This period focused on expanding framework support by adding comprehensive examples and integration scaffolds for Angular, Solid, Svelte, and Next.js versions 14 through 16. It also significantly enhanced developer tooling through new ESLint rules, codemods for migration, and improved devtools configuration across adapters.

23 changes.

This period focused on expanding framework support by introducing official adapters and comprehensive examples for Preact and Lit, including core query hooks, devtools, and persistence providers. The work also involved adding test coverage for these new integrations and enhancing existing React and Solid examples to demonstrate advanced patterns like optimistic updates and offline-first strategies.

This change introduces a new integration scaffold for Angular CLI version 20.0.0-rc.2, providing the foundational project structure including configuration files (angular.json, tsconfig.json) and VS Code development settings. The scaffold is configured to use the new zoneless change detection mechanism via \provideZonelessChangeDetection\ and includes a demonstration component that utilizes TanStack Query for data fetching, ensuring the integration is ready for immediate development and testing.

integrations/angular-cli-20 · high confidence

The Angular example in this location now demonstrates an autocomplete search feature using RxJS for debouncing and distincting input changes, integrated with TanStack Query for data fetching. It includes a mock HTTP interceptor to simulate network latency and a service layer for API calls, while the application configuration enables TanStack Query devtools for debugging.

examples/angular/rxjs/src/app · high confidence

Added a new example application demonstrating TanStack Query with Angular and RxJS, including the entry point (main.ts) and root HTML template (index.html).

examples/angular/rxjs/src · high confidence

This location introduces a new Angular example application that demonstrates how to persist TanStack Query cache data to the browser's local storage. The example configures the Angular application with \withPersistQueryClient\ using an \AsyncStoragePersister\ backed by \window.localStorage\, allowing users to mock offline behavior and retain cached data across sessions. It includes a simple post-listing UI with navigation, leveraging Angular's standalone components and signals.

examples/angular/basic-persister · high confidence

This location introduces a new Angular example demonstrating how to define and reuse TanStack Query options via an injectable service. The example includes a \QueriesService\ that returns \queryOptions\ for fetching posts, which are consumed by standalone components using \injectQuery\. It also configures the application with \provideTanStackQuery\ and enables devtools via \withDevtools\, providing a complete reference for structuring data fetching logic in Angular applications.

examples/angular/query-options-from-a-service · high confidence

The \examples/angular/infinite-query-with-max-pages\ directory now contains a complete, standalone Angular application demonstrating TanStack Query's infinite query capabilities. The example showcases fetching paginated data with a maximum page limit (\maxPages: 3\), using \injectInfiniteQuery\ to manage forward and backward navigation, and includes a mock HTTP interceptor to simulate network latency. It is configured as a modern Angular standalone application using the new \app.config\ provider pattern, \provideHttpClient\ with interceptors, and the \withDevtools\ integration for debugging.

(repo-wide) · high confidence

A new Angular pagination example has been added to the repository, demonstrating how to implement paginated data fetching with TanStack Query. The example showcases key features such as preserving previous data during page transitions using \keepPreviousData\, prefetching the next page in the background via an \effect\, and integrating the Angular Query Devtools for debugging. It is configured as a standalone Angular application using the \Bundler\ module resolution and runs on Node.js 22.

examples/angular/pagination · high confidence

A new example application has been added to \examples/angular/router\ that demonstrates integrating TanStack Query with Angular's router. The example uses lazy-loaded routes (\loadComponent\) for a posts list and individual post details, leveraging \withComponentInputBinding\ to automatically bind route parameters to component inputs. It showcases query caching and background refetching behavior, where previously visited posts load instantly from cache while refreshing in the background, and highlights cached items by styling their links in bold green.

examples/angular/router, integrations/solid-vite, integrations/svelte-vite · high confidence

This change introduces a new Server-Side Rendering (SSR) example for Lit (\examples/lit/ssr\) and a Vite integration demo (\integrations/lit-vite\). The SSR example demonstrates how to hydrate query state from the server using \@tanstack/lit-query\, including a custom \SsrApp\ component and bootstrap logic that reads dehydrated state. The Vite integration provides a minimal setup with custom elements (\lit-query-provider\, \lit-query-app\) to showcase basic query fetching and rendering within a Vite-built Lit application.

examples/lit/ssr, integrations/lit-vite · high confidence

A new Lit-based pagination example has been added to the examples directory, demonstrating how to use TanStack Query's \createQueryController\ and \createMutationController\ for paginated data fetching and mutations. The example includes a complete API layer (\api.ts\) that interacts with a local server on port 4184, handling project listing, creation, and favorite toggling, along with a Lit component (\main.ts\) that manages query state, caching, and optimistic updates for mutations.

examples/lit/pagination · high confidence

This change introduces a new example integration for Next.js 13+ using the App Router, demonstrating how to use React Query v5 with server components, client components, and server actions. The example includes a root layout, a client component that fetches data using React Query, a server action that triggers a revalidation, and a route handler. It also sets up a QueryClient with custom serialization using tupleson and the Temporal polyfill for date handling. The integration uses the new \environmentManager.isServer()\ API to determine the execution environment, replacing the deprecated \isServer\ property.

integrations/react-next-16 · high confidence

This location introduces a new Next.js 15 example application that demonstrates integrating TanStack Query with Next.js App Router features. The example showcases server-side data prefetching and hydration using \dehydrate\ and \HydrationBoundary\, custom serialization via \tupleson\ for complex types like \Temporal.PlainDate\, and proper client/server query client instantiation using \environmentManager.isServer()\. It also includes a server action example for revalidation and a route for fetching count data, providing a complete pattern for using React Query in a Next.js 15 environment.

integrations/react-next-15 · high confidence

The Next.js Suspense Streaming example has been migrated to the Next.js App Router, introducing a new project structure with \src/app\ directories. The example now demonstrates server-side data fetching using \useSuspenseQuery\ combined with React's \Suspense\ boundaries to stream content progressively. It includes a dedicated API route (\/api/wait\) to simulate network latency, a \Providers\ component that initializes the React Query client and integrates \ReactQueryStreamedHydration\ for efficient hydration, and a \next.config.js\ that disables module concatenation for the server build to ensure correct streaming behavior.

examples/react/nextjs-suspense-streaming · high confidence

A new example project in \examples/react/nextjs-app-optimistic-updates\ demonstrates optimistic updates with TanStack Query v5 in a Next.js 14 App Router application. It provides a todo list interface that showcases two distinct implementation strategies: rendering pending items directly via \mutation.variables\ (UI Variables approach) and manually managing the cache with \onMutate\ snapshots and rollback logic (Cache Manipulation approach). The example includes a simulated API endpoint that randomly fails to illustrate automatic rollback behavior.

examples/react/nextjs-app-optimistic-updates · high confidence

This location introduces a new Next.js example demonstrating how to integrate React Query with Next.js data fetching methods. The example includes a Home page that uses \getStaticProps\ to prefetch queries and hydrate them in the browser, as well as a Client-Only page that loads data directly on the client side. It provides the necessary configuration files (\next.config.js\, \tsconfig.json\), layout components, and hooks to showcase these patterns.

examples/react/nextjs · high confidence

New Next.js-based React examples have been added to demonstrate data-fetching patterns with TanStack Query. The auto-refetching example shows how to periodically poll an API endpoint and invalidate queries on mutations, while the infinite scroll example demonstrates paginated data loading using \useInfiniteQuery\ and \react-intersection-observer\ to trigger fetches as the user scrolls. Both examples include necessary configuration files (Next.js config, TypeScript config with Bundler module resolution) and API routes to support the demonstrations.

examples/react/load-more-infinite-scroll · high confidence

Added a new Nuxt 3 example demonstrating how to integrate @tanstack/vue-query with server-side rendering. The example includes a plugin that manages query state hydration and dehydration using Nuxt's useState and import.meta properties, along with a minimal app component that fetches data and waits for suspense resolution.

examples/vue/nuxt3 · high confidence

A new Preact example project has been added to the repository, providing a starter template for building applications with Preact and Vite. This includes the necessary configuration files such as \tsconfig.json\ (configured with \jsxImportSource: preact\ and path aliases for React compatibility), \vite.config.ts\ (using the \@preact/preset-vite\ plugin), and a basic \index.html\ entry point. The example also includes a README with instructions for installing dependencies and running the development server.

examples/preact · high confidence

Introduces the \PersistQueryClientProvider\ component for Preact applications, enabling automatic restoration and subscription of persisted query client state. This component wraps the standard \QueryClientProvider\ and manages the \isRestoring\ state, ensuring that child components wait for cached data to be restored from a persister before rendering, with support for custom \onSuccess\ and \onError\ callbacks.

packages/preact-query-persist-client/src · high confidence

The integrations/react-vite directory now contains a complete starter project for building React applications with Vite. This includes a Vite configuration using the React plugin, a TypeScript configuration with 'Bundler' module resolution and 'react-jsx' JSX mode, and an ESLint setup extending 'plugin:react/jsx-runtime' and 'plugin:react-hooks/recommended'. The application source demonstrates a React component utilizing TanStack Query for data fetching, wrapped in a QueryClientProvider with React Query Devtools enabled.

integrations/react-vite · high confidence

The \integrations/react-next-14\ directory now contains a complete Next.js 14 application setup. This integration demonstrates the App Router structure (including \app/layout.tsx\ and \app/page.tsx\), configures TypeScript with \moduleResolution: "Bundler"\, and integrates \@tanstack/react-query\ for client-side data fetching via a dedicated \Providers\ component. It also includes standard tooling files such as \.eslintrc.cjs\, \.gitignore\, and \next.config.js\ to support the development environment.

integrations/react-next-14 · high confidence

A new example application has been added to demonstrate the \ReactQueryDevtoolsPanel\ component from \@tanstack/react-query-devtools\. This example shows how to integrate the devtools panel into a React app, allowing users to toggle the panel's visibility via a button to inspect query data and state.

examples/react/devtools-panel, examples/vue/dependent-queries · high confidence

The React Router example now includes a complete contacts management application. This adds a data layer using localforage for persistent storage, a dedicated error page component, and a root entry point that configures a React Router v6 browser router with TanStack Query for data fetching and caching. The example demonstrates routing, loaders, actions, and error handling for a full CRUD workflow.

examples/react/react-router/src · high confidence

A new React Router example has been added to the repository, providing a reference implementation for integrating TanStack Query with React Router. The example includes a complete project setup with a Vite-based entry point (\index.html\), a TypeScript configuration (\tsconfig.json\) targeting ES2020 with \react-jsx\ support, and an ESLint configuration (\.eslintrc\) that enforces the \plugin:react/jsx-runtime\ and \plugin:react-hooks/recommended\ rules. It also includes standard project scaffolding such as a \.gitignore\ file and a public emblem asset.

examples/react/react-router · high confidence

Added a new example application in \examples/react/batching\ that demonstrates request batching with TanStack Query. The example uses \@tanstack/react-pacer\'s \AsyncBatcher\ to group multiple character requests into a single API call, allowing users to load multiple Rick and Morty characters simultaneously via a simple UI input.

examples/react/batching · high confidence

A new React chat example has been added to \examples/react/chat\ that showcases the \experimental\_streamedQuery\ API from TanStack Query. The application allows users to type questions and receive simulated responses streamed word-by-word, utilizing the \streamFn\ configuration within \queryOptions\. The example is built with Vite and Tailwind CSS, providing a functional UI to demonstrate real-time data streaming behavior in a React context.

examples/react/chat · high confidence

Added a new Next.js-based example demonstrating paginated data fetching with TanStack Query. The example includes a server-side API endpoint that simulates paginated project data and a client-side page that uses \keepPreviousData\ to maintain visibility of the previous page while fetching the next, along with prefetching logic for smoother navigation.

examples/react/pagination · high confidence

A new Next.js example has been added to demonstrate data prefetching with TanStack Query. The application lists characters from the Rick and Morty API and prefetches detailed data for a character when the user hovers over their name, displaying the details immediately upon click. The example uses the \queryClient.fetchQuery\ method (via \queryClient.query\) with a \staleTime\ to manage cache freshness and highlights prefetched items by changing their font weight.

examples/react/prefetching · high confidence

A new example project has been added at \examples/solid/astro\ that demonstrates integrating SolidJS with Astro using the \@astrojs/solid-js\ integration and Tailwind CSS. The application serves as a Pokemon viewer, utilizing \@tanstack/solid-query\ for data fetching and caching, and showcases server-side rendering capabilities alongside client-side navigation via a custom \Link\ component and history API usage.

examples/solid/astro · high confidence

A new example project has been added for Solid.js that demonstrates how to configure a default query function via the QueryClient. The example shows how to fetch data from a placeholder API using only query keys, while also including the Solid Query Devtools for debugging and a Vite-based build configuration.

examples/solid/default-query-function · high confidence

A new example application in \examples/solid/offline\ demonstrates offline-first patterns using Solid and TanStack Query. The app features optimistic UI updates for movie comments and persists mutations to \localStorage\ via \PersistQueryClientProvider\, allowing paused mutations to automatically resume when the network connection is restored. It includes a mock API service (MSW) to simulate network conditions and devtools for testing offline behavior.

examples/solid/offline · high confidence

A new basic example for Solid.js has been added to the repository, demonstrating how to integrate TanStack Query. The example includes a complete project structure with Vite configuration, TypeScript settings, and ESLint rules. It showcases fetching a list of posts and individual post details using the \useQuery\ hook, featuring loading states, error handling, background refetching, and caching visualization via the Solid Query Devtools.

examples/solid/basic · high confidence

New example projects for Solid.js have been added to demonstrate TanStack Query integration. The 'basic-graphql-request' example shows fetching posts from a GraphQL API using \graphql-request\, while the 'simple' example demonstrates fetching GitHub repository data via a standard REST API. Both examples include configuration for Vite with the Solid plugin, TypeScript, and ESLint, and feature the SolidQueryDevtools for debugging.

examples/solid/basic-graphql-request, examples/solid/simple · high confidence

The SolidStart streaming example now includes dedicated UI components (\Example\, \PostViewer\, \UserInfo\, and \QueryBoundary\) that demonstrate how to use \@tanstack/solid-query\ with server-side streaming features like \deferStream\, simulated network delays, and error handling with retry capabilities.

examples/solid/solid-start-streaming/src/components · high confidence

Introduces a new SolidStart streaming example located in examples/solid/solid-start-streaming. The example includes a README with setup and build instructions, a .gitignore for standard build and environment artifacts, and an app.config.ts using @solidjs/start/config. It provides src/utils/api.ts with fetchPost and fetchUser helpers that simulate latency and errors to demonstrate streaming behavior, and a tsconfig.json configured with moduleResolution Bundler, ESNext targets, and Vinxi/Vite client types.

examples/solid/solid-start-streaming · high confidence

A new 'simple' Svelte example has been added to the repository, providing a minimal Vite + TypeScript + Svelte setup that integrates with TanStack Query. The example demonstrates how to configure the Svelte adapter with runes enabled, set up a QueryClient provider in the root component, and fetch data from the GitHub API using the createQuery hook. It also includes a guard to ensure the \#app mount target exists before mounting the application.

examples/svelte/simple · high confidence

A new Star Wars example application has been added to the Svelte examples directory, providing a reference implementation for fetching data from the SWAPI. The project is configured as a SvelteKit application using Vite, Tailwind CSS, and TypeScript, and explicitly enables Svelte runes mode in the compiler options to demonstrate modern Svelte patterns.

examples/svelte/star-wars · high confidence

The load-more-infinite-scroll example now uses Svelte 5 runes syntax, as seen in the new +layout.svelte file which utilizes $props() for component composition. The layout sets up the TanStack Query client with browser-only execution and includes the Svelte Query Devtools, while the +page.svelte file serves as the entry point rendering the LoadMore component.

examples/svelte/basic/src/lib, examples/svelte/load-more-infinite-scroll/src/routes · high confidence

The auto-refetching example now includes the standard SvelteKit project structure, adding app.html, app.css, and app.d.ts files. This provides the necessary HTML entry point, global styling with dark/light mode support, and TypeScript declarations required to run the example as a complete SvelteKit application.

examples/svelte/auto-refetching/src · high confidence

A new React example application has been added to the \examples/react/eslint-legacy\ directory, demonstrating TanStack Query with \PersistQueryClientProvider\ and local storage persistence. The example includes a complete Vite-based setup (including \vite.config.ts\, \tsconfig.json\, and \index.html\) and is configured to use the legacy ESLint plugin via a dedicated \.eslintrc\ file extending \plugin:@tanstack/query/recommended\.

examples/react/eslint-legacy · high confidence

This change introduces a new Vue + Vite integration scaffold that sets up a TypeScript-based project using Vite and the Vue Query library. The integration includes a Vite configuration using the official Vue plugin, a TypeScript configuration targeting ES2020 with strict linting rules, and a sample application demonstrating data fetching with Vue Query. The entry point mounts the Vue app with the VueQueryPlugin, and the main component displays loading, error, and success states for a simulated async query.

integrations/vue-vite · high confidence

A new Vue example application has been added to showcase the \experimental\_createQueryPersister\ from \@tanstack/query-persist-client-core\. The app demonstrates how to persist query data to \localStorage\ for a list view and to \idb-keyval\ (IndexedDB) for individual post details, allowing visited posts to load instantly from cache while the list benefits from background refetching.

examples/vue/persister · high confidence

A new basic example has been added to the Vue examples directory, demonstrating how to integrate TanStack Query with a Vue application using Vite. The example includes a full project structure with Vue components for listing and viewing posts, TypeScript configuration, and Vite build settings. It specifically showcases the use of the VueQueryPlugin for data fetching and includes the VueQueryDevtools component in the app layout, allowing users to inspect query states directly in the browser.

examples/vue/basic · high confidence

The Query Devtools now includes a dedicated set of SVG icons (such as Search, Trash, Chevron, Arrows, and Sun/Moon) to support its user interface components, enabling features like theme toggling and navigation within the devtools panel.

packages/query-devtools/src/icons · high confidence

This location introduces a Next.js example demonstrating how to use \useInfiniteQuery\ with a \maxPages\ constraint to limit the number of cached pages. The example includes a backend API endpoint that simulates paginated data and a frontend page that allows users to load older and newer pages while respecting the maximum page limit, along with standard configuration files for TypeScript and Next.js.

examples/react/infinite-query-with-max-pages · high confidence

Introduces a new ESLint rule that flags when the direct result of TanStack Query hooks (such as useQuery, useMutation, etc.) is passed into the dependency array of React hooks like useEffect, useCallback, or useMemo. This prevents bugs caused by referential instability, guiding users to destructure the hook results before using them in dependency arrays. The rule also supports tracking custom query hook wrappers and handles specific cases like useQueries with a combine property.

packages/eslint-plugin-query/src/rules/no-unstable-deps · high confidence

The Angular Query experimental package now exposes an \injectDevtoolsPanel\ function, allowing developers to programmatically inject and control a TanStack Query devtools panel within their application. This feature supports configuration via a computed options function, including custom \QueryClient\ instances, error types, CSP nonces, shadow DOM targets, and a close callback. The implementation handles browser-only rendering, dynamic loading of the \@tanstack/query-devtools\ package, and proper cleanup via Angular's \DestroyRef\. A stub implementation is provided for production builds to ensure zero runtime overhead when devtools are not needed.

packages/angular-query-experimental/src/devtools-panel · high confidence

The \examples/angular/simple\ directory now contains a complete, runnable Angular application demonstrating the experimental \@tanstack/angular-query-experimental\ adapter. The example showcases modern Angular practices, including standalone components, \inject()\ for dependency injection, and \ChangeDetectionStrategy.OnPush\. It configures TanStack Query with \provideTanStackQuery\ and includes the \withDevtools\ provider for development tooling, while fetching data from the GitHub API using RxJS's \lastValueFrom\ within a query function.

examples/angular/simple · high confidence

A new 'simple' example has been added to the Vue examples directory, demonstrating a basic TanStack Query setup using Vue 3 and Vite. The example includes a minimal application that fetches repository data from the GitHub API, displays loading and error states, and integrates VueQueryDevtools. It also provides configuration files for TypeScript (using moduleResolution: Bundler), Vite, and package managers including Bun.

examples/preact/simple, examples/vue/2.6-basic, examples/vue/simple · high confidence

The \examples/lit/basic\ directory now includes a comprehensive set of Lit components demonstrating the \@tanstack/lit-query\ adapter. This includes a basic query example (\basic-query.ts\), a dedicated mutation example (\mutation.ts\), and a full E2E demo (\main.ts\) showcasing query and mutation controllers, cache invalidation, and status tracking. Additionally, \lifecycle-contract.ts\ provides a fixture for verifying that query consumers correctly bind to their provider's \QueryClient\ instance even when moved between different provider contexts or detached from the DOM.

examples/lit/basic · high confidence

The offline React example now includes a generated Mock Service Worker (MSW v2.1.7) file in the public directory. This addition enables the application to intercept and mock network requests during development, facilitating offline testing and consistent API simulation without requiring a live backend.

examples/react/offline/public · high confidence

A new SolidStart example application has been added to demonstrate streaming capabilities, including routes for streamed, deferred, mixed, error handling, hydration, and prefetching. The example is configured with TanStack Solid Query for data fetching and includes the necessary entry points for client and server rendering.

examples/solid/solid-start-streaming/src · high confidence

The basic SvelteKit example now includes the standard entry-point files: app.html (the HTML shell), app.css (global styles with light/dark mode support), and app.d.ts (TypeScript declarations). These files provide the foundational structure required to run the SvelteKit application.

examples/svelte/basic/src · high confidence

The media directory now includes two new SVG files: \emblem-light.svg\, a light-themed logo asset generated from Sketch, and \partner\_logo.svg\, a branded graphic featuring the text 'QUERY YOU?' with specific styling. These assets are available for use in documentation or UI components requiring these specific visual identities.

media · high confidence

The React ESLint plugin demo now includes examples demonstrating the new \allowlist\ option for the \exhaustive-deps\ rule (allowing specific variables like \api\ and types like \AnalyticsClient\ to be ignored) and the new \prefer-query-options\ rule (encouraging the use of \queryOptions\ for co-locating query keys and functions).

examples/react/eslint-plugin-demo · high confidence

The \infinite-query-property-order\ ESLint rule now ensures that properties in \infiniteQueryOptions\, \useInfiniteQuery\, and \useSuspenseInfiniteQuery\ follow a specific order: \queryFn\ must appear before \getPreviousPageParam\ and \getNextPageParam\. This helps prevent inference issues in infinite query configurations.

packages/eslint-plugin-query/src/rules/infinite-query-property-order · high confidence

This entry introduces the new \@tanstack/preact-query-devtools\ package, providing a dedicated developer tools integration for Preact applications. The diff establishes the package's foundational build and test infrastructure, including configuration for the \tsdown\ bundler to target both modern and legacy environments, ESLint rules tailored for Preact and TypeScript, and a Vitest test setup that integrates with Preact Testing Library. It also includes a changelog tracking version updates relative to the core \@tanstack/preact-query\ and \@tanstack/query-devtools\ packages.

packages/preact-query-devtools, packages/preact-query-persist-client, packages/solid-query-devtools · high confidence

This entry introduces the new \@tanstack/query-broadcast-client-experimental\ package, which enables cross-tab query state synchronization. The package is built using Vite 8 and includes a test setup that integrates React Testing Library with React Query's notification manager. It depends on \@tanstack/query-core\ (currently at version 5.104.0) and provides the infrastructure for broadcasting query client updates across browser tabs.

packages/query-broadcast-client-experimental · high confidence

Adds the new @tanstack/lit-query package, providing a Lit adapter for TanStack Query that uses Lit reactive controllers. This enables Lit developers to integrate query and mutation primitives directly into their components via controllers like createQueryController and createMutationController, along with supporting utilities such as QueryClientProvider and query options helpers. The package includes build configuration (tsdown), test setup, and example applications to demonstrate usage.

packages/lit-query · high confidence

The \angular-query-persist-client\ package is now available, providing the \withPersistQueryClient\ function to enable query state persistence in Angular applications. This feature integrates with the core persistence logic via \@tanstack/query-persist-client-core\ and uses Angular's \ENVIRONMENT\_INITIALIZER\ to restore query state on the browser side, exposing \onSuccess\ and \onError\ callbacks for restoration completion handling.

packages/angular-query-persist-client/src · high confidence

A new \@tanstack/preact-query-devtools\ package is added, providing \PreactQueryDevtools\ and \PreactQueryDevtoolsPanel\ components to inspect and debug TanStack Query state within Preact applications. The devtools are automatically disabled in production builds (returning null), while the panel supports configuration for positioning, theming, custom error types, and Shadow DOM rendering, wrapping the underlying \@tanstack/query-devtools\ engine.

packages/preact-query-devtools/src · high confidence

Adds the \@tanstack/preact-query\ package, providing a full-featured Preact adapter for TanStack Query. This includes Preact-specific implementations of core hooks (\useQuery\, \useMutation\, \useInfiniteQuery\, \useSuspenseQuery\, etc.), context providers (\QueryClientProvider\), and utilities for hydration (\HydrationBoundary\) and error boundaries (\QueryErrorResetBoundary\).

packages/preact-query/src · high confidence

Added the \SolidQueryDevtools\ and \SolidQueryDevtoolsPanel\ components to the \solid-query-devtools\ package. These components wrap the core TanStack Query Devtools, exposing configuration options for positioning, theming, error types, CSP nonces, and shadow DOM targeting. To ensure compatibility with server-side rendering, the devtools are loaded exclusively on the client using a \clientOnly\ utility that bypasses server-side execution, returning null during SSR.

packages/solid-query-devtools/src · high confidence

The \@tanstack/solid-query\ package now provides a complete Solid.js adapter for TanStack Query. It introduces \useQuery\, \useInfiniteQuery\, \useMutation\, \useQueries\, \useIsFetching\, \useIsMutating\, and \useMutationState\ as the primary primitives, while maintaining \createQuery\, \createInfiniteQuery\, \createMutation\, etc. as aliases for compatibility. The adapter includes \QueryClient\ and \QueryClientProvider\ for context management, and adds \queryOptions\, \infiniteQueryOptions\, and \mutationOptions\ for sharing configuration. It also introduces a \reconcile\ option in query options to handle Solid's reactivity model for data updates.

packages/solid-query/src · high confidence

Added a new \PersistQueryClientProvider\ component in the \solid-query-persist-client\ package, enabling Solid.js applications to persist query client state. The provider manages the restoration lifecycle by calling \persistQueryClientRestore\ and subscribing to updates via \persistQueryClientSubscribe\ from the core persistence library, exposing \onSuccess\ and \onError\ callbacks to consumers while wrapping children in an \IsRestoringProvider\ to signal restoration status.

packages/solid-query-persist-client/src · high confidence

The TanStack Query DevTools have been rewritten in Solid.js, replacing the previous React implementation. This change introduces new entry points, \TanstackQueryDevtools\ and \TanstackQueryDevtoolsPanel\, which manage the devtools UI via a class-based API that mounts to a DOM element. The new implementation supports configuration options such as \theme\, \shadowDOMTarget\, and \styleNonce\, and includes features like picture-in-picture mode, light/dark theme support, and query/mutation editing capabilities within the devtools panel.

packages/query-devtools/src · high confidence

Adds the \@tanstack/svelte-query-persist-client\ package, providing a \PersistQueryClientProvider\ component that automatically restores and persists query cache state in Svelte applications. The implementation leverages Svelte 5 runes (such as \$state\ and \$effect\) to manage the restoration lifecycle, exposing \onSuccess\ and \onError\ callbacks to handle the asynchronous cache hydration process. The package includes a full test suite covering cache restoration, initial data handling, and error scenarios, alongside build configurations for Vite 8 and TypeScript.

packages/svelte-query-persist-client · high confidence

The \@tanstack/vue-query-devtools\ package is now available, providing Vue-specific components (\VueQueryDevtools\ and \VueQueryDevtoolsPanel\) that wrap the core TanStack Query Devtools. This allows Vue developers to easily integrate the debugging interface into their applications with support for configuration options such as theme, position, and shadow DOM targeting. The package is built with Vite 8 and includes its own ESLint configuration and TypeScript setup.

packages/vue-query-devtools · high confidence

Added the \query-async-storage-persister\ package, providing a \createAsyncStoragePersister\ function that persists React Query cache to an asynchronous storage backend (such as AsyncStorage or IndexedDB). The implementation includes an \asyncThrottle\ utility to limit the frequency of write operations, configurable via the \throttleTime\ option, and supports custom serialization, deserialization, and retry logic for failed saves.

packages/query-async-storage-persister/src · high confidence

Added new context files (PiPContext, QueryDevtoolsContext, ThemeContext) and their shared types to manage Picture-in-Picture window state, devtools props, and theme selection. The PiPContext handles opening and closing the devtools popup, including resetting the 'pip\_open' local storage state on programmatic close to prevent auto-reopening, and copying parent window styles to the popup. The QueryDevtoolsContext exposes core devtools configuration like client, position, and theme. The ThemeContext provides a default 'dark' theme accessor. These contexts are exported via index.ts for use by devtools components.

packages/query-devtools/src/contexts · high confidence

TanStack Query now exposes \environmentManager\, \focusManager\, and \onlineManager\ in \query-core\, allowing you to override how the library detects the server environment, browser focus, and network connectivity. This is essential for non-standard runtimes (like Service Workers or React Native) where the default \window\ checks may fail, and enables manual control over these states to better manage refetching and scheduling behavior.

packages/query-core/src · high confidence

The \@tanstack/angular-query-experimental\ package is now available, providing a native Angular integration for TanStack Query. It introduces signal-based injection functions such as \injectQuery\, \injectMutation\, \injectInfiniteQuery\, and \injectQueries\, allowing developers to manage data fetching and mutations using Angular's reactive primitives. The package includes providers like \provideAngularQuery\ for setup, utilities for tracking fetching and mutation states (\injectIsFetching\, \injectIsMutating\), and support for Angular v19+ PendingTasks to integrate with \whenStable()\. This experimental adapter is designed to align with React Query's API while leveraging Angular's dependency injection and change detection mechanisms.

packages/angular-query-experimental/src · high confidence

Adds a new \broadcastQueryClient\ utility that synchronizes TanStack Query state across browser tabs and windows using the BroadcastChannel API. This feature allows queries updated in one tab to automatically reflect in others, while also handling edge cases such as preventing data overwrites on 'added' messages, recovering from errors during cross-tab message application, and providing an \onBroadcastError\ callback to handle serialization failures (e.g., for non-cloneable objects like streams or functions).

packages/query-broadcast-client-experimental/src · high confidence

This change adds the \@tanstack/lit-query\ package, providing a native adapter for Lit elements. It introduces a \QueryClientProvider\ component that shares a \QueryClient\ via Lit context, and a suite of reactive controllers (\createQueryController\, \createInfiniteQueryController\, \createMutationController\, \createQueriesController\) that integrate TanStack Query with Lit's lifecycle. The adapter supports reactive options through an \Accessor\ type, allowing query keys and filters to depend on host state, and includes utility hooks like \useIsFetching\ and \useIsMutating\ for tracking cache status.

packages/lit-query/src · high confidence

The persistence logic has been split into a new \query-persist-client-core\ package, providing two distinct persistence approaches. First, \experimental\_createQueryPersister\ enables fine-grained, per-query persistence with support for async serialization/deserialization, configurable \refetchOnRestore\ behavior, and automatic cleanup of corrupted or expired entries. Second, the existing \persistQueryClient\ functions (\persist\, \restore\, \subscribe\) are retained for whole-client cache persistence, now featuring improved error handling that discards the persisted cache on restore failure. This separation allows users to choose between granular query control and simple client-wide caching.

packages/query-persist-client-core/src · high confidence

The \react-query-next-experimental\ package now includes \ReactQueryStreamedHydration\, a new component that streams dehydrated query data from the server to the client using \useServerInsertedHTML\ to avoid unnecessary suspensions. This implementation adds a \nonce\ prop to support Content Security Policy (CSP) enforcement by allowing inline scripts to execute safely, and utilizes an HTML-escaping utility to mitigate potential XSS injection risks during data serialization.

packages/react-query-next-experimental/src · high confidence

Added a new Angular example application that demonstrates how to integrate the TanStack Query devtools panel. The example includes a basic implementation using \injectDevtoolsPanel\ for programmatic panel toggling, as well as a lazy-loading variant that dynamically imports the devtools module on demand. The project is configured for Angular 19+ using standalone components, the \@angular/build\ builder, and \moduleResolution: Bundler\.

examples/angular/devtools-panel · high confidence

The repository now includes several new scripts to automate documentation generation, release creation, and CI maintenance. The \generate-docs\ script handles TypeDoc-based reference documentation, including logic to redirect old flat URLs and render property lists as tables. The \create-github-release\ script automates changelog generation by parsing conventional commits and resolving PR authors. Additionally, \verify-links\ checks for broken relative links in documentation, \generate-labeler-config\ creates GitHub labeler configurations, and \getTsdownConfig\ provides build configurations for the new \tsdown\ bundler.

scripts · high confidence

The \stable-query-client\ rule has been added to the ESLint plugin to detect when a \QueryClient\ is instantiated directly inside a React component or hook, which causes unnecessary re-creation on every render. When this pattern is detected, the rule reports an error and offers an automatic fix that wraps the instantiation in \React.useState\ to ensure stability across renders.

packages/eslint-plugin-query/src/rules/stable-query-client · high confidence

Added the \no-void-query-fn\ rule to the \eslint-plugin-query\ package. This rule flags \queryFn\ implementations that return \void\ or \undefined\, ensuring that query functions always resolve to a defined value. The rule uses TypeScript's type checker to analyze the return type of the function, including awaited types, and reports an error if the return type is illegal.

packages/eslint-plugin-query/src/rules/no-void-query-fn · high confidence

The examples/lit directory now includes three runnable demo applications: a basic query example, a pagination example with a Node.js mock API server, and a server-side rendering (SSR) example using @lit-labs/ssr. Each example is configured with Vite, TypeScript, and environment-based port settings, and depends on @tanstack/lit-query@0.2.0. These examples demonstrate how to integrate TanStack Query with Lit components in standard, paginated, and SSR contexts.

examples/lit · high confidence

The react-query-persist-client package now exposes a PersistQueryClientProvider component that manages the restoration of persisted query data. This provider wraps the standard QueryClientProvider and uses an IsRestoringProvider to signal when data is being restored from storage. It handles the restoration process asynchronously, calling onSuccess or onError callbacks based on the result, and subscribes to query updates after restoration completes. The component is marked with 'use client' to ensure it runs in the browser environment.

packages/react-query-persist-client/src · high confidence

Added a new example demonstrating how to integrate TanStack Query with Algolia for search functionality. The example includes a React application using Vite, featuring an infinite query implementation via \useInfiniteQuery\ and \skipToken\ to handle search inputs and pagination. It provides a complete setup with ESLint configuration, TypeScript settings, and styling to showcase querying the Algolia 'bestbuy' index.

examples/react/algolia · high confidence

This location introduces a complete React Native example application demonstrating React Query integration. The app features a movie-listing interface with navigation, utilizing hooks like useAppState and useOnlineManager to handle platform-specific behaviors (such as focus-based refetching and online status) and React Query's QueryClientProvider for data management. It includes UI components for lists, details, loading states, and error handling, along with configuration files for Expo, TypeScript, and ESLint to support the development environment.

examples/react/react-native · high confidence

The suspense example has been migrated to Vite and updated to use modern React patterns, including the \react-jsx\ compiler mode and \useTransition\ for non-blocking UI updates. It demonstrates TanStack Query's \useSuspenseQuery\ hook within a \React.Suspense\ boundary, featuring lazy-loaded components, an error boundary for recovery, and manual query prefetching to improve navigation performance.

examples/react/suspense · high confidence

Added a new example in \examples/react/shadow-dom\ that shows how to mount a React application inside a Shadow DOM. The example configures a Vite + React + TypeScript project where the root element attaches a shadow root, and passes this shadow root to the \ReactQueryDevtools\ via the \shadowDOMTarget\ prop to ensure the devtools render correctly within the isolated DOM scope.

examples/react/shadow-dom · high confidence

The \@tanstack/solid-query-persist-client\ package is introduced, providing a Solid.js implementation for client-side data persistence. This new capability allows Solid.js applications to persist query cache data, leveraging the shared \@tanstack/query-persist-client-core\ and \@tanstack/solid-query\ dependencies. The package includes its own build configuration (using tsdown), test setup (Vitest with jsdom), and TypeScript configuration to support this integration.

packages/solid-query-persist-client · high confidence

The SolidStart streaming example application now includes a comprehensive set of new route pages demonstrating various Solid Query behaviors in a server-side rendering context. These additions include a 404 handler, a home page, and specific examples for deferred rendering, hydration state comparison, mixed streaming strategies, link prefetching, error handling, and batched method scheduling. These routes serve as a practical reference for implementing streaming SSR with Solid Query.

examples/solid/solid-start-streaming/src/routes · high confidence

The \exhaustive-deps\ rule is now available in \eslint-plugin-query\ to enforce that all variables used in \queryFn\ are included in the \queryKey\. The rule analyzes the function body to detect external references, filters out irrelevant ones (such as function call targets, \instanceof\ operands, or global imports), and supports an \allowlist\ configuration for variables and types. It provides auto-fix suggestions to add missing dependencies to the query key, helping prevent stale data issues.

packages/eslint-plugin-query/src/rules/exhaustive-deps · high confidence

Added a new Svelte component example demonstrating infinite scrolling with \@tanstack/svelte-query\. The \LoadMore.svelte\ component uses the \createInfiniteQuery\ hook with the \initialPageParam\ option to fetch paginated data from the SWAPI endpoint, rendering a list of planets and a button to load more items as the user scrolls.

examples/svelte/load-more-infinite-scroll/src/lib · high confidence

The \@tanstack/query-persist-client-core\ package has been introduced as a separate core package for persistence logic, initially released at version 5.104.0. This new package includes a complete build and test setup using \tsdown\ for bundling (supporting both modern and legacy configurations via \tsconfig.legacy.json\ and \tsconfig.prod.json\), \vitest\ for testing with coverage and type-checking, and ESLint for code quality. The package depends on \@tanstack/query-core\ and includes a changelog documenting its history and dependency updates.

packages/angular-query-experimental, packages/query-persist-client-core · high confidence

The React Query DevTools package has been updated to expose new configuration options and a new component. Users can now customize the devtools appearance by passing a \theme\ prop (light, dark, or system) and choose to hide disabled queries using the \hideDisabledQueries\ option. A new \ReactQueryDevtoolsPanel\ component is available for embedding the devtools UI directly into the application layout, offering additional controls like custom styling, an \onClose\ callback, and shadow DOM support. The main \ReactQueryDevtools\ component also supports these options, along with \styleNonce\ and \shadowDOMTarget\ for enhanced compatibility with strict security policies. Additionally, the devtools are now strictly limited to development mode in the main entry point, ensuring they do not run in production builds.

packages/react-query-devtools/src · high confidence

The \packages/query-codemods\ package has been updated with a new v4 codemod that automatically migrates code from the legacy \react-query\ API to the new \@tanstack/react-query\ structure. This codemod transforms query keys from string literals into arrays (e.g., \useQuery('todos')\ becomes \useQuery(\['todos'\])\), updates \useQueries\ to accept an object with a \queries\ property, and rewrites import statements to point to the new \@tanstack/react-query\ and \@tanstack/react-query-devtools\ packages. It also handles \QueryClient\ and \QueryCache\ method calls, ensuring that methods like \cancelQueries\ and \getQueryData\ receive the new array-based keys.

packages/query-codemods/src · high confidence

This release introduces a major overhaul of the React Query API. The \HydrationBoundary\ component is now available to handle server-side rendering hydration, intelligently merging new queries during render and existing ones in an effect. Suspense behavior is enhanced with a 1-second minimum \staleTime\ to prevent unnecessary refetches, and \useQueries\ now supports suspense and error boundary handling. A new typed \queryOptions\ and \infiniteQueryOptions\ API allows sharing options across hooks and imperative APIs, while \mutationOptions\ provides similar type safety for mutations. The library now supports React 19, includes \usePrefetchQuery\ and \usePrefetchInfiniteQuery\ for data prefetching, and adds a \subscribed\ option to allow hooks to unsubscribe from the query cache.

packages/react-query/src · high confidence

The @tanstack/solid-query package is released (starting at version 5.100.8 and progressing to 5.104.0), providing the Solid.js adapter for TanStack Query. This release includes a new build system using tsdown to generate ESM and CJS bundles, alongside updated Vite and Vitest configurations for testing and coverage. The package also incorporates several upstream fixes from query-core, including a fix for an Astro SSR crash, improved type propagation for mutation state, and the removal of experimental render-time prefetching.

packages/solid-query · high confidence

The Star Wars example now includes dedicated routes for browsing films and viewing individual film details. The new +page.svelte components in the films directory use @tanstack/svelte-query to fetch data from the Star Wars API, displaying loading and error states alongside lists of films and their associated characters.

examples/svelte/star-wars/src/routes/films · high confidence

The @tanstack/preact-query package has been added, providing Preact-specific hooks for data fetching, caching, and mutations. This release includes the core implementation, a test setup configured with Vitest and jsdom, and build tooling that utilizes tsdown for bundling and Vite for testing. The package is designed to work with the @tanstack/query-core library, as indicated by the dependency updates in the changelog.

packages/preact-query · high confidence

The legacy \ReactQueryProvider\ context provider and the \useQuery\ hook implementation have been removed from \src/index.js\. This change eliminates the previous context-based state management and query execution logic, indicating a migration to a different architecture or library version for data fetching.

src · high confidence

The \@tanstack/angular-query-persist-client\ package has been initialized with a new build and test infrastructure. It now uses Vite for testing and \tsdown\ for bundling, replacing previous tooling. The configuration includes specific TypeScript setups for production (\tsconfig.prod.json\) and legacy TypeScript versions (\tsconfig.legacy.json\), alongside a Vite test configuration that integrates Angular's testing utilities via \test-setup.ts\. Additionally, an \.attw.json\ file is added to ignore the \cjs-resolves-to-esm\ rule, and ESLint is configured with JSDoc and spell-checking rules.

packages/angular-query-persist-client · high confidence

The \packages/eslint-plugin-query/src/utils\ directory has been restructured with new utility modules to support more robust rule implementation. \ast-utils.ts\ introduces helpers for traversing the AST (such as \traverseUpMemberExpression\ and \getFunctionAncestor\) and extracting external references, which improves how the plugin identifies dependencies and scopes. \detect-react-query-imports.ts\ centralizes the logic for detecting TanStack Query imports, allowing rules to accurately scope their checks to relevant code. Additionally, \create-property-order-rule.ts\ provides a factory for generating rules that enforce property ordering in configuration objects, while \sort-data-by-order.ts\ and \unique-by.ts\ offer generic data manipulation utilities used by these rules.

packages/eslint-plugin-query/src/utils · high confidence

The Next.js App Router example in examples/react/nextjs-app-prefetching has been modernized to use React Query v5, replacing the deprecated prefetchQuery and fetchQuery APIs with the new query() method for data fetching and hydration. The example now uses environmentManager.isServer() to determine the execution environment and implements promise dehydration to include pending queries in the hydration state, ensuring a smoother user experience during server-side rendering.

examples/react/nextjs-app-prefetching · high confidence

The react-nodenext integration now includes a tsconfig.json that configures TypeScript for NodeNext module resolution and declaration emission, alongside new hook files (hooks.cts and hooks.ts) that serve as test fixtures using @tanstack/react-query to verify the integration's behavior under this module system.

integrations/react-nodenext · high confidence

The auto-refetching example in the SvelteKit integration has been updated to use Svelte runes (e.g., $state, $props) and the new adapter APIs (createQuery, createMutation). The example now demonstrates periodic data fetching with a configurable interval and includes mutations for adding and clearing items, providing a modern reference for implementing auto-refetching behavior in Svelte applications.

examples/svelte/auto-refetching/src/routes · high confidence

The devtools integration has been restructured to support conditional loading and new configuration options. By default, the devtools panel loads lazily only in development mode, but this behavior can be overridden using the new \loadDevtools\ option (accepting \auto\, \true\, or \false\) to force loading in production or disable it in development. A new \theme\ option allows users to set the panel's appearance to 'light', 'dark', or 'system'. The implementation uses a stub for production builds to ensure zero runtime overhead, and the feature is now exposed via a dedicated \withDevtools\ provider function that handles dynamic mounting and configuration updates.

packages/angular-query-experimental/src/devtools · high confidence

The basic Angular example has been converted to use the Angular CLI project structure and standalone components, replacing the previous module-based setup. The application now uses the \app.config.ts\ for provider configuration, including TanStack Query with devtools, and leverages Angular's signal-based APIs and \inject()\ for dependency injection. The example demonstrates fetching posts with background updates and caching, using the new \@tanstack/angular-query-experimental\ package.

examples/angular/basic · high confidence

The basic Svelte example has been rewritten to use Svelte runes (e.g., $props) and now includes query data persistence via localStorage. The layout component sets up a QueryClient with browser-only execution and wraps the application in a PersistQueryClientProvider, ensuring that cached query data survives page reloads.

examples/svelte/basic/src/routes · high confidence

The @tanstack/query-async-storage-persister and @tanstack/query-sync-storage-persister packages have been updated to use tsdown for bundling (replacing tsup) and now generate both modern and legacy builds. The build configuration now relies on a custom resolution condition (@tanstack/custom-condition) for both standard and SSR environments, and TypeScript type-checking is enabled in the test runner. Additionally, ESLint has been migrated to the flat config format, and legacy TypeScript configuration files have been added to support older TypeScript versions.

packages/query-async-storage-persister, packages/query-sync-storage-persister · high confidence

The eslint-plugin-query package has migrated its build infrastructure to use Vite 8 and the tsdown bundler. This change updates the build configuration to produce both modern and legacy builds, ensuring compatibility with newer tooling versions while maintaining support for older environments. Users benefit from improved build performance and alignment with the latest ecosystem standards.

packages/eslint-plugin-query, packages/query-core · high confidence

The \createSyncStoragePersister\ function in the \@tanstack/query-sync-storage-persister\ package is now deprecated. Users are advised to migrate to \createAsyncStoragePersister\ from the \@tanstack/query-async-storage-persister\ package instead. The implementation remains available but signals that synchronous storage is no longer the recommended approach.

packages/query-sync-storage-persister/src · high confidence

The \@tanstack/eslint-plugin-query\ has been reorganized to support ESLint's modern flat configuration format, exposing dedicated \flat/recommended\ and \flat/recommended-strict\ configs alongside the legacy ones. This update introduces two new linting rules: \mutation-property-order\, which enforces the correct order of inference-sensitive properties in \useMutation()\, and \prefer-query-options\, which encourages co-locating \queryKey\ and \queryFn\ using \queryOptions()\ builders. The plugin's internal structure has been refactored to use \ESLintUtils.RuleCreator\ and improved TypeScript typing for exported interfaces.

packages/eslint-plugin-query/src · high confidence

The \no-rest-destructuring\ rule has been expanded to cover \useSuspenseQuery\, \useSuspenseQueries\, and \useSuspenseInfiniteQuery\, ensuring developers are warned against excessive re-renders when using rest destructuring on these hooks. Additionally, the rule now detects when a query result variable is spread elsewhere in the code and can identify rest destructuring on custom query hooks by analyzing return types, providing more comprehensive linting coverage for TanStack Query usage.

packages/eslint-plugin-query/src/rules/no-rest-destructuring · high confidence

The example application has been refactored to import the React Query library from the external 'react-query' package instead of using the local 'react-query.js' implementation. This change removes the local query client code and configuration files (such as .eslintrc, .prettierrc, and .rescriptsrc.js) from the example directory, simplifying the setup to rely on the standard library for data fetching and caching.

example · high confidence

The Svelte playground example has been restructured to use the SvelteKit framework, introducing standard project files such as \app.d.ts\ for TypeScript declarations and \app.html\ for the HTML entry point. The application's visual presentation has been updated with a dark theme, applying a dark background and white text to the body, while also refining the font-family definitions in the CSS.

examples/svelte/playground/src · high confidence

The React simple example in examples/react/simple has been migrated from its previous build setup to Vite. This change introduces a new project structure including a Vite configuration (vite.config.ts), an HTML entry point (index.html), and updated TypeScript settings (tsconfig.json) to support modern module resolution and JSX runtime. The application code (src/index.tsx) now uses the standard React 18 createRoot API, and the example includes specific ESLint rules for the JSX runtime and React hooks to ensure correct linting in the new environment.

(repo-wide) · high confidence

The React Star Wars example has been rebuilt using Vite as the build tool, replacing the previous setup. This update upgrades the application to use React 18's concurrent rendering features (via \ReactDOM.createRoot\) and adopts the modern \react-jsx\ runtime for JSX transformation. The UI styling has been migrated to Tailwind CSS v4, utilizing its new import syntax and theme configuration. Additionally, the example now includes a dedicated ESLint configuration extending \plugin:react/jsx-runtime\ to align with the new React version requirements.

examples/react/star-wars · high confidence

The basic GraphQL request example has been modernized to use Vite as the build tool, replacing the previous setup. This includes a new Vite-compatible project structure with an \index.html\ entry point, a \tsconfig.json\ configured for ES2020 and bundler mode, and a flat \eslint.config.js\ using the new TanStack and React ESLint plugins. The application code in \src/index.tsx\ now uses \ReactDOM.createRoot\ for rendering and demonstrates TanStack Query features like background refetching and caching via \graphql-request\.

examples/react/basic-graphql-request · high confidence

The @tanstack/react-query-next-experimental package now builds using Vite 8 and the tsdown bundler, replacing the previous toolchain. This change updates the build configuration (vite.config.ts, tsdown.config.ts) and ensures compatibility with the latest React hooks linting rules via the new eslint.config.js setup. Users benefit from faster builds and alignment with the core react-query v5.104.0 release, which also adopted Vite 8.

packages/react-query-next-experimental · high confidence

The query-devtools package has switched its build system from tsup to tsdown, introducing a new tsdown.config.ts that bundles the Solid.js runtime for the compiled output while keeping type declarations external. This change is accompanied by the addition of legacy and production-specific tsconfig files to support different TypeScript versions and build targets, as well as a new ESLint configuration. Additionally, the test setup has been updated to use @solidjs/testing-library with Vitest, ensuring consistent testing behavior for the Solid-based devtools components.

packages/query-devtools · high confidence

The query-codemods package has been updated to use the new ESLint flat configuration format (eslint.config.js) and upgraded to Vitest v4 for testing. This change introduces a dedicated ESLint configuration that extends the root config while disabling specific rules (such as spell-checking and import ordering) suitable for a codemod package, and configures Vitest with Istanbul coverage, type-checking, and mock restoration. Users running the codemods will benefit from consistent linting and more robust test execution, though the underlying codemod logic remains unchanged.

packages/query-codemods · high confidence

The optimistic updates example in the Svelte adapter has been rewritten to use Svelte Runes. This update enables the use of modern Svelte reactivity primitives like $state and $props, and configures the project with the runes compiler option to ensure compatibility with the latest Svelte features.

examples/svelte/load-more-infinite-scroll, examples/svelte/optimistic-updates · high confidence

The \packages/react-query-devtools\ directory has been initialized with the necessary configuration files to support the package's build and test lifecycle. This includes a \tsdown.config.ts\ for bundling, \vite.config.ts\ for Vitest testing with JSDOM and Istanbul coverage, and ESLint configurations (\eslint.config.js\) enforcing React Hooks rules. Additionally, \tsconfig.json\ variants are provided for modern, legacy, and production builds, alongside a \test-setup.ts\ to handle React Query notification wrapping during tests. A \.attw.json\ file is also added to ignore resolution rules for analysis tools.

packages/react-query-devtools · high confidence

The @tanstack/react-query-persist-client package has been updated to version 5.104.0, which includes a build migration to Vite 8. This release also introduces a new ESLint configuration using the flat config format with specific React Hooks rules, switches the build tooling from tsup to tsdown for generating both modern and legacy builds, and establishes a new Vitest test setup that integrates with React Testing Library and enables type checking and coverage reporting.

packages/react-query-persist-client · high confidence

This release upgrades the build toolchain to Vite 8, which may require your project to align with Vite 8 compatibility. It also changes how prefetching hooks work: \usePrefetchQuery\ and \usePrefetchInfiniteQuery\ now use \queryClient.query\ and \queryClient.infiniteQuery\ under the hood, and the experimental render-time prefetching along with the \promise\ property on query results have been removed. Several type and behavior fixes are included: \useQueries\ and \useSuspenseQueries\ now throw falsy errors to the error boundary, \useMutationState\'s \select\ callback correctly propagates generic type parameters, \queryOptions\ and \infiniteQueryOptions\ return types no longer leak internal data tag symbols, \TData\ defaults for infinite query options now match their hook generics, mutation variables are optional when \undefined\ is part of \TVariables\, optimistic fetching is suppressed for unsubscribed \useQueries\, and \placeholderData\ is removed from suspense infinite queries.

packages/react-query · high confidence

The React offline example has been modernized by migrating from its previous build setup to Vite, introducing a new \vite.config.ts\ and \index.html\ entry point. The project now uses the \react-jsx\ runtime (configured via \.eslintrc\ extending \plugin:react/jsx-runtime\ and \tsconfig.json\), aligning with React 17+ conventions. The example demonstrates offline persistence using \@tanstack/react-query-persist-client\ with \createAsyncStoragePersister\ and includes MSW for mocking API responses, providing a complete, runnable demonstration of handling offline mutations and cache restoration.

examples/react/offline · high confidence

The repository has been completely restructured to align with TanStack Query v5. The project now uses pnpm v11 with a strict workspace configuration (including \blockExoticSubdeps\ and \trustPolicy\), replaces the legacy Travis CI with Nx Cloud, and migrates from Rollup/Babel to tsdown for building. ESLint has been upgraded to flat config, and the package has been renamed from \react-query\ to \@tanstack/react-query\. New contributor guidelines include a dedicated AI Policy and instructions for AI agents, while the README has been updated to reflect the new ecosystem and branding.

(repo-wide) · high confidence

The Svelte playground example in \examples/svelte/playground/src/routes\ has been completely rewritten to leverage Svelte's new runes API (such as \$state\, \$derived\, and \$props\) and the updated TanStack Query Svelte adapter. This change updates the demo application's components (\+layout.svelte\, \+page.svelte\, \App.svelte\, \AddTodo.svelte\, \EditTodo.svelte\, and \TodosList.svelte\) to use modern Svelte syntax for reactivity and state management, replacing the previous component-based approach. Users viewing this example will now see code that aligns with Svelte's latest runtime features, providing an up-to-date reference for implementing data fetching and mutations with TanStack Query in a SvelteKit environment.

examples/svelte/playground/src/routes · high confidence

The React Rick and Morty example has been rebuilt using Vite as the build tool and Tailwind CSS for styling, replacing the previous setup. The application now uses \react-router-dom\ for navigation between Home, Episodes, and Characters pages, leveraging TanStack Query for data fetching and caching. Configuration files such as \vite.config.ts\, \tsconfig.json\, and \.eslintrc\ are included to support this modern stack, and the entry point has been updated to use \ReactDOM.createRoot\ for rendering.

examples/react/rick-morty · high confidence

The SvelteKit SSR example in examples/svelte/ssr/src/routes has been rewritten to align with modern Svelte practices. The layout component now uses Svelte runes ($props) to access props, and the page load functions utilize the new queryClient.query() method instead of the deprecated prefetchQuery/fetchQuery calls. This ensures the example correctly demonstrates current best practices for server-side rendering with TanStack Query in a SvelteKit application.

examples/svelte/ssr/src/routes · high confidence

The Star Wars example application's character listing and detail views have been updated to use the TanStack Svelte Query adapter. The character list page now fetches and displays character data using \createQuery\, while the individual character detail page utilizes the same pattern to load character specifics, homeworld information, and associated films, replacing the previous implementation with a standardized data-fetching approach.

examples/svelte/star-wars/src/routes/characters · high confidence

The Star Wars example in the Svelte kit has been updated to use Svelte runes (specifically $props) and TanStack Query. The layout component now wraps the application in a QueryClientProvider, enabling data fetching capabilities via TanStack Query instead of previous state management approaches.

examples/svelte/star-wars/src/routes · high confidence

The Star Wars example has been migrated to a SvelteKit structure, introducing standard application entry points (app.html, app.d.ts) and styling via Tailwind CSS. This change provides a modern, standardized foundation for the example, replacing previous setup with SvelteKit's default configuration and Tailwind's utility-first approach for consistent theming.

examples/svelte/star-wars/src · high confidence

The Svelte Query Devtools component has been rewritten to use Svelte Runes (via $props and $state) and now supports additional configuration options including theme, shadowDOMTarget, and hideDisabledQueries. The devtools instance is now properly updated when options change after mount, and the component includes comprehensive tests for all prop forwarding and lifecycle behaviors.

packages/svelte-query-devtools · high confidence

The Svelte Query adapter has been rewritten to use Svelte runes, requiring Svelte 5+ and changing how reactive state is handled internally. The package now ships with a Vite 8 build, includes a dedicated ESLint configuration for Svelte files, and provides a \svelte.config.js\ that enables runes by default. Additionally, the adapter has been decoupled from SvelteKit, making it usable in any Svelte application.

packages/svelte-query · high confidence

The Svelte example projects (basic, auto-refetching, and ssr) have been updated to enable the new Svelte runes mode. This is configured in \svelte.config.js\ by setting \compilerOptions.runes\ to \true\, which changes how reactivity is handled in Svelte components, requiring developers to use the new runes API instead of the legacy reactive declarations.

examples/svelte/basic · high confidence

The Svelte adapter has been completely rewritten to leverage Svelte's new runes-based reactivity system ($state, $derived, $props, etc.), replacing the previous implementation. This change introduces new Svelte components for dependency injection and hydration, specifically QueryClientProvider and HydrationBoundary, and adds new utility functions for sharing options across calls: queryOptions, infiniteQueryOptions, and mutationOptions. The core hooks (createQuery, createMutation, createQueries, etc.) now use Svelte's native reactivity primitives internally, and the adapter no longer depends on SvelteKit, making it compatible with NodeNext and other non-SvelteKit environments.

packages/svelte-query/src · high confidence

The React Router example in the \examples/react/react-router/src/routes\ directory has been rewritten to align with modern best practices. The routes now utilize \@tanstack/react-query\ v5, specifically adopting the \queryOptions\ and \useSuspenseQuery\ APIs for data fetching and rendering. The implementation also reflects the TypeScript 5.7 update, evidenced by the use of advanced type inference patterns such as \Awaited\<ReturnType\<...\>\>\ for loader data. Additionally, the example now includes dedicated route files for contact details, editing, creation, and deletion, providing a more complete demonstration of React Router's routing capabilities integrated with React Query.

examples/react/react-router/src/routes · high confidence

The React integration examples in the \react-webpack-4\ and \react-webpack-5\ directories have been updated to use \react-scripts\ as the build tool, replacing the previous custom Webpack configurations. These examples now include standard React application structures with \index.html\, \App.js\, and \index.js\ files, leveraging \@tanstack/react-query\ for data fetching and \@tanstack/react-query-devtools\ for development. The \webpack.config.js\ files have been removed as \react-scripts\ handles the build process internally, simplifying the setup for users testing React integrations.

integrations/react-webpack-4, integrations/react-webpack-5 · high confidence

The SvelteKit SSR example in \examples/svelte/ssr/src/lib\ has been rewritten to leverage Svelte's new runes syntax (specifically \$props\) and the \createQuery\ API from \@tanstack/svelte-query\. This change updates the \Post.svelte\ and \Posts.svelte\ components to use modern reactivity patterns, replacing previous implementation details with a cleaner, rune-based approach for fetching and displaying post data.

examples/svelte/ssr/src/lib · high confidence

The SvelteKit SSR example in the examples directory has been updated to use the latest default project templates. This includes a new app.html shell with SvelteKit preload attributes, a global app.d.ts for type definitions, and a comprehensive app.css stylesheet featuring modern CSS variables, dark/light mode support via prefers-color-scheme, and updated styling for buttons and layout elements.

examples/svelte/ssr/src · high confidence

The example project has been updated to use the standard SvelteKit template structure. This includes adding the default app.css styles (with light/dark mode support), the app.html entry point, and the app.d.ts type definitions, ensuring the example aligns with current SvelteKit conventions.

examples/svelte/load-more-infinite-scroll/src · high confidence

The prepack script has been updated to prepare the package for publishing by stripping 'dist/' prefixes from file paths in package.json fields (types, module, exports) and removing build-related fields (devDependencies, files, publishConfig, scripts). This ensures that type declarations and other assets are correctly referenced at the package root or sub-paths, supporting applications using moduleResolution: node.

packages/angular-query-experimental/scripts · high confidence

Add Vue Query declaration emit integration tests; Added ErrorBoundary component for Preact; Added Svelte-specific test suite for query options and internal utilities; Added comprehensive test coverage for Angular Query experimental hooks; Added comprehensive test coverage for Query Devtools components and utilities; Added comprehensive test coverage for Solid Query; Added comprehensive test suite for Preact Query adapter; Added comprehensive test suite for createQuery; Added comprehensive test suite for lit-query controllers and context; Added comprehensive tests for Svelte createMutation; Added test coverage for ReactQueryDevtools and ReactQueryDevtoolsPanel components; Added test coverage for Solid Query Devtools components; Added test coverage for eslint-plugin-query rules; Added test coverage for query-devtools context providers; Added test coverage for query-persist-client-core; Added tests for HydrationBoundary context hydration; Added tests for PersistQueryClientProvider; Added tests for PersistQueryClientProvider and useQueries with persistence; Added tests for PreactQueryDevtools prop wiring and behavior; Added tests for Svelte Query context utilities; Added tests for asyncThrottle behavior; Added tests for createQueries behavior and type inference; Added tests for cross-tab query synchronization and error handling; Added tests for mutationOptions; Added tests for storage quota handling in sync storage persister; Added tests for useIsFetching and useIsMutating hooks; Added tests for useMutationState filtering and selection; Added tests for withPersistQueryClient persistence behavior; Added type and runtime tests for query-core internals; Expanded test coverage for React Query components and options helpers; New @tanstack/query-test-utils package and expanded Vue Query test coverage.

The example applications have been updated to use the latest major versions of their underlying frameworks and build tools. Angular examples now target Angular 20, React examples target React 19 and Next.js 16, and Vite-based examples use Vite 8. Additionally, TypeScript has been updated to version 5.8.3 across the examples, and TanStack Query packages have been bumped to version 5.104.0.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 37 → 59 (+21.9)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 84 → 82 (-2.3)
• Architecture 96 (new)
• Maturity 57 → 66 (+9.9)
• Readiness 23 → 49 (+26.2)
• Security 37 → 76 (+38.4)
• Accessibility 79 (new)
• Performance 60 (new)

• Boundary-crossing change coupling: vite.config.ts ↔ vite.config.ts (packages/query-persist-client-core/vite.config.ts)
• Boundary-crossing change coupling: vite.config.ts ↔ vite.config.ts (packages/query-persist-client-core/vite.config.ts)
• Boundary-crossing change coupling: vite.config.ts ↔ vite.config.ts (packages/query-persist-client-core/vite.config.ts)
• Boundary-crossing change coupling: vite.config.ts ↔ vite.config.ts (packages/query-persist-client-core/vite.config.ts)
• Boundary-crossing change coupling: vite.config.ts ↔ vite.config.ts (packages/query-sync-storage-persister/vite.config.ts)
• Boundary-crossing change coupling: vite.config.ts ↔ vite.config.ts (packages/query-sync-storage-persister/vite.config.ts)
• Boundary-crossing change coupling: vite.config.ts ↔ vite.config.ts (packages/query-sync-storage-persister/vite.config.ts)
• Boundary-crossing change coupling: vite.config.ts ↔ vite.config.ts (packages/query-sync-storage-persister/vite.config.ts)
• Boundary-crossing change coupling: vite.config.ts ↔ vite.config.ts (packages/query-sync-storage-persister/vite.config.ts)
• Boundary-crossing change coupling: vite.config.ts ↔ vite.config.ts (packages/react-query-devtools/vite.config.ts)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Dimension evaluation failed
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• …and 56 more

• Boundary-crossing change coupling: useQueries.ts ↔ useQueries.ts (packages/solid-query/src/useQueries.ts)
• Change coupling: create-base-query.ts ↔ inject-mutation.ts (packages/angular-query-experimental/src/create-base-query.ts)
• ClassTooLong: QueryClient (packages/query-core/src/queryClient.ts)
• ClassTooLong: QueryClient (packages/vue-query/src/queryClient.ts)
• ClassTooLong: QueryObserver (packages/query-core/src/queryObserver.ts)
• Devtools.ContentView (cognitive 43) (packages/query-devtools/src/Devtools.tsx)
• Devtools.ContentView (cyclomatic 46) (packages/query-devtools/src/Devtools.tsx)
• Devtools.Devtools (cognitive 22) (packages/query-devtools/src/Devtools.tsx)
• Devtools.Devtools (cyclomatic 21) (packages/query-devtools/src/Devtools.tsx)
• Devtools.DraggablePanel (cognitive 73) (packages/query-devtools/src/Devtools.tsx)
• Devtools.DraggablePanel (cyclomatic 51) (packages/query-devtools/src/Devtools.tsx)
• Devtools.QueryDetails (cognitive 26) (packages/query-devtools/src/Devtools.tsx)
• Devtools.QueryDetails (cyclomatic 24) (packages/query-devtools/src/Devtools.tsx)
• Documentation: no usage examples (examples/angular/auto-refetching/README.md)
• Explorer.Explorer (cognitive 30) (packages/query-devtools/src/Explorer.tsx)
• Explorer.Explorer (cyclomatic 39) (packages/query-devtools/src/Explorer.tsx)
• FileTooLong: icons/index.tsx (packages/query-devtools/src/icons/index.tsx)
• FileTooLong: src/Devtools.tsx (packages/query-devtools/src/Devtools.tsx)
• FileTooLong: src/Explorer.tsx (packages/query-devtools/src/Explorer.tsx)
• FileTooLong: src/query.ts (packages/query-core/src/query.ts)
• …and 1871 more

• 300 commits — 275 feature/other, 25 fixes

• docs/framework — 89 commits
• packages/query-core — 40 commits
• packages/vue-query — 30 commits
• packages/lit-query — 29 commits
• packages/angular-query-experimental — 19 commits
• packages/svelte-query — 17 commits
• packages/preact-query — 16 commits
• (root) — 14 commits
• examples/react — 11 commits
• packages/solid-query — 7 commits
• examples/svelte — 4 commits
• packages/react-query — 3 commits
• scripts/generate-docs.ts — 3 commits
• docs/config.json — 2 commits
• packages/query-devtools — 2 commits
• packages/vue-query-devtools — 2 commits
• .changeset/heavy-donuts-do.md — 1 commit
• .changeset/perky-jars-flow.md — 1 commit
• .changeset/svelte-devtools-theme-option.md — 1 commit
• .changeset/thin-bugs-change.md — 1 commit

• fix: ci: apply automated fixes
• fix: ci: apply automated fixes
• fix: ci: apply automated fixes
• fix: ci: apply automated fixes
• fix: ci: apply automated fixes
• fix: fix(broadcast-client): don't overwrite an existing query's data on an incoming 'added' message (#11392)
• fix: fix(codemods): update codemods build script (#11647)
• fix: fix(preact-query): propagate falsy errors to the error boundary (#11309)
• fix: fix(preact-query/useQueries): keep unsubscribed idle (#11315)
• fix: fix(query-core): Avoid scheduling stale timeouts for disabled query observers (#11293)
• fix: fix(query-core): handle plain objects with constructor fields (#11512)
• fix: fix(query-core): ignore stale query removals (#11524)
• fix: fix(query-core): preserve null streamed query results (#11510)
• fix: fix(query-core): reject longer partial array keys (#11502)
• fix: fix(query-devtools): remove solid-js import from declarations (#11300)
• fix: fix(query-persist-client-core): restore falsy storage values (#11509)
• fix: fix(react-query): propagate falsy errors to the error boundary (#11305)
• fix: fix(solid-query): useBaseQuery SSR cleanup (#11628)
• fix: fix(svelte-query-devtools): update the devtools instance when options change after mount (#11009)
• fix: fix(svelte-query/{createQuery,queryOptions}): correct the overload selected for 'initialData' (#11592)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

TanStack/query was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.