Run yarn format to format all files

docs/api/createListenerMiddleware.mdx

@@ -488,7 +488,7 @@ To fix this, the middleware provides types for defining "pre-typed" versions of
 import { createListenerMiddleware, addListener } from '@reduxjs/toolkit'
 import type { RootState, AppDispatch } from './store'
 
-declare type ExtraArgument = {foo: string};
+declare type ExtraArgument = { foo: string }
 
 export const listenerMiddleware = createListenerMiddleware()
 

docs/rtk-query/api/created-api/hooks.mdx

@@ -419,7 +419,6 @@ selectFromResult: () => ({})
 :::
 
 - **Parameters**
-
   - `options`: A set of options that control the subscription behavior of the hook:
     - `selectFromResult`: A callback that can be used to customize the mutation result returned as the second item in the tuple
     - `fixedCacheKey`: An optional string used to enable shared results across hook instances
@@ -622,7 +621,6 @@ type UseLazyQueryLastPromiseInfo = {
 ```
 
 - **Parameters**
-
   - `options`: A set of options that control the fetching behavior and returned result value of the hook. Options affecting fetching behavior will only have an effect after the lazy query has been triggered at least once.
 
 - **Returns**: A tuple containing:
@@ -666,7 +664,6 @@ type PrefetchCallback = (arg: any, options?: UsePrefetchOptions) => void
 ```
 
 - **Parameters**
-
   - `endpointName`: The name of the endpoint to prefetch data for
   - `options`: A set of options that control whether the prefetch request should occur
 
@@ -734,7 +731,6 @@ type UseQueryStateResult<T> = {
 ```
 
 - **Parameters**
-
   - `arg`: The argument passed to the query defined in the endpoint.
     You can also pass in `skipToken` here as an alternative way of skipping the selection, see [skipToken](#skiptoken)
   - `options`: A set of options that control the return value for the hook
@@ -773,7 +769,6 @@ type UseQuerySubscriptionResult = {
 ```
 
 - **Parameters**
-
   - `arg`: The argument passed to the query defined in the endpoint.
     You can also pass in `skipToken` here as an alternative way of skipping the query, see [skipToken](#skiptoken)
   - `options`: A set of options that control the fetching behavior of the hook
@@ -829,7 +824,6 @@ type UseLazyQuerySubscriptionTrigger = (
 ```
 
 - **Parameters**
-
   - `options`: A set of options that control the fetching behavior of the hook. The options will only have an effect after the lazy query has been triggered at least once.
 
 - **Returns**: A tuple containing:

docs/rtk-query/comparison.md

@@ -75,8 +75,8 @@ This comparison table strives to be as accurate and as unbiased as possible. If
 | **API Definition**                     | declarative                             | on use, declarative      | GraphQL schema                                                                      | GraphQL schema                                                                                              |
 | **Cache by**                           | endpoint + serialized arguments         | user-defined query-key   | type/id                                                                             | type/id?                                                                                                    |
 | **Invalidation Strategy + Refetching** | declarative, by type and/or type/id     | manual by cache key      | automatic cache updates on per-entity level, manual query invalidation by cache key | declarative, by type OR automatic cache updates on per-entity level, manual query invalidation by cache key |
-| **Polling**                           | yes                                     | yes                      | yes                                                                                 | yes                                                                                                         |
-| **Parallel queries**                  | yes                                     | yes                      | yes                                                                                 | yes                                                                                                         |
+| **Polling**                            | yes                                     | yes                      | yes                                                                                 | yes                                                                                                         |
+| **Parallel queries**                   | yes                                     | yes                      | yes                                                                                 | yes                                                                                                         |
 | **Dependent queries**                  | yes                                     | yes                      | yes                                                                                 | yes                                                                                                         |
 | **Skip queries**                       | yes                                     | yes                      | yes                                                                                 | yes                                                                                                         |
 | **Lagged queries**                     | yes                                     | yes                      | no                                                                                  | ?                                                                                                           |

docs/rtk-query/usage/queries.mdx

@@ -287,7 +287,9 @@ function PostsList() {
 
   return (
     <ul>
-      {posts?.data?.map((post) => <PostById key={post.id} id={post.id} />)}
+      {posts?.data?.map((post) => (
+        <PostById key={post.id} id={post.id} />
+      ))}
     </ul>
   )
 }

errors.json

@@ -43,4 +43,4 @@
   "41": "getPreviousPageParam for endpoint '' must be a function if maxPages is used",
   "42": "Duplicate middleware references found when creating the store. Ensure that each middleware is only included once.",
   "43": "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`"
-}
+}

examples/action-listener/counter/src/index.css

@@ -1,15 +1,15 @@
 body {
   margin: 0;
-  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
-    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
-    sans-serif;
+  font-family:
+    -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu',
+    'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
   -webkit-font-smoothing: antialiased;
   -moz-osx-font-smoothing: grayscale;
 }
 
 code {
-  font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New',
-    monospace;
+  font-family:
+    source-code-pro, Menlo, Monaco, Consolas, 'Courier New', monospace;
 }
 
 h1 {

examples/publish-ci/cra4/src/index.css

@@ -1,13 +1,13 @@
 body {
   margin: 0;
-  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
-    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
-    sans-serif;
+  font-family:
+    -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu',
+    'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
   -webkit-font-smoothing: antialiased;
   -moz-osx-font-smoothing: grayscale;
 }
 
 code {
-  font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New',
-    monospace;
+  font-family:
+    source-code-pro, Menlo, Monaco, Consolas, 'Courier New', monospace;
 }

examples/publish-ci/cra5/src/index.css

@@ -1,13 +1,13 @@
 body {
   margin: 0;
-  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
-    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
-    sans-serif;
+  font-family:
+    -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu',
+    'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
   -webkit-font-smoothing: antialiased;
   -moz-osx-font-smoothing: grayscale;
 }
 
 code {
-  font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New',
-    monospace;
+  font-family:
+    source-code-pro, Menlo, Monaco, Consolas, 'Courier New', monospace;
 }

examples/publish-ci/vite/src/index.css

@@ -1,13 +1,13 @@
 body {
   margin: 0;
-  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
-    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
-    sans-serif;
+  font-family:
+    -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu',
+    'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
   -webkit-font-smoothing: antialiased;
   -moz-osx-font-smoothing: grayscale;
 }
 
 code {
-  font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New',
-    monospace;
+  font-family:
+    source-code-pro, Menlo, Monaco, Consolas, 'Courier New', monospace;
 }

examples/query/react/infinite-queries/src/App.test.tsx

@@ -1,105 +1,105 @@
-import { screen, waitFor } from "@testing-library/react"
-import App from "./App"
-import { renderWithProviders } from "./utils/test-utils"
+import { screen, waitFor } from '@testing-library/react'
+import App from './App'
+import { renderWithProviders } from './utils/test-utils'
 
-test("App should have correct initial render", () => {
+test('App should have correct initial render', () => {
   renderWithProviders(<App />)
 
   // The app should be rendered correctly
   expect(screen.getByText(/learn/i)).toBeInTheDocument()
 
   // Initial state: count should be 0, incrementValue should be 2
-  expect(screen.getByLabelText("Count")).toHaveTextContent("0")
-  expect(screen.getByLabelText("Set increment amount")).toHaveValue(2)
+  expect(screen.getByLabelText('Count')).toHaveTextContent('0')
+  expect(screen.getByLabelText('Set increment amount')).toHaveValue(2)
 })
 
-test("Increment value and Decrement value should work as expected", async () => {
+test('Increment value and Decrement value should work as expected', async () => {
   const { user } = renderWithProviders(<App />)
 
   // Click on "+" => Count should be 1
-  await user.click(screen.getByLabelText("Increment value"))
-  expect(screen.getByLabelText("Count")).toHaveTextContent("1")
+  await user.click(screen.getByLabelText('Increment value'))
+  expect(screen.getByLabelText('Count')).toHaveTextContent('1')
 
   // Click on "-" => Count should be 0
-  await user.click(screen.getByLabelText("Decrement value"))
-  expect(screen.getByLabelText("Count")).toHaveTextContent("0")
+  await user.click(screen.getByLabelText('Decrement value'))
+  expect(screen.getByLabelText('Count')).toHaveTextContent('0')
 })
 
-test("Add Amount should work as expected", async () => {
+test('Add Amount should work as expected', async () => {
   const { user } = renderWithProviders(<App />)
 
   // "Add Amount" button is clicked => Count should be 2
-  await user.click(screen.getByText("Add Amount"))
-  expect(screen.getByLabelText("Count")).toHaveTextContent("2")
+  await user.click(screen.getByText('Add Amount'))
+  expect(screen.getByLabelText('Count')).toHaveTextContent('2')
 
-  const incrementValueInput = screen.getByLabelText("Set increment amount")
+  const incrementValueInput = screen.getByLabelText('Set increment amount')
   // incrementValue is 2, click on "Add Amount" => Count should be 4
   await user.clear(incrementValueInput)
-  await user.type(incrementValueInput, "2")
-  await user.click(screen.getByText("Add Amount"))
-  expect(screen.getByLabelText("Count")).toHaveTextContent("4")
+  await user.type(incrementValueInput, '2')
+  await user.click(screen.getByText('Add Amount'))
+  expect(screen.getByLabelText('Count')).toHaveTextContent('4')
 
   // [Negative number] incrementValue is -1, click on "Add Amount" => Count should be 3
   await user.clear(incrementValueInput)
-  await user.type(incrementValueInput, "-1")
-  await user.click(screen.getByText("Add Amount"))
-  expect(screen.getByLabelText("Count")).toHaveTextContent("3")
+  await user.type(incrementValueInput, '-1')
+  await user.click(screen.getByText('Add Amount'))
+  expect(screen.getByLabelText('Count')).toHaveTextContent('3')
 })
 
-it("Add Async should work as expected", async () => {
+it('Add Async should work as expected', async () => {
   const { user } = renderWithProviders(<App />)
 
   // "Add Async" button is clicked => Count should be 2
-  await user.click(screen.getByText("Add Async"))
+  await user.click(screen.getByText('Add Async'))
 
   await waitFor(() =>
-    expect(screen.getByLabelText("Count")).toHaveTextContent("2"),
+    expect(screen.getByLabelText('Count')).toHaveTextContent('2'),
   )
 
-  const incrementValueInput = screen.getByLabelText("Set increment amount")
+  const incrementValueInput = screen.getByLabelText('Set increment amount')
   // incrementValue is 2, click on "Add Async" => Count should be 4
   await user.clear(incrementValueInput)
-  await user.type(incrementValueInput, "2")
+  await user.type(incrementValueInput, '2')
 
-  await user.click(screen.getByText("Add Async"))
+  await user.click(screen.getByText('Add Async'))
   await waitFor(() =>
-    expect(screen.getByLabelText("Count")).toHaveTextContent("4"),
+    expect(screen.getByLabelText('Count')).toHaveTextContent('4'),
   )
 
   // [Negative number] incrementValue is -1, click on "Add Async" => Count should be 3
   await user.clear(incrementValueInput)
-  await user.type(incrementValueInput, "-1")
-  await user.click(screen.getByText("Add Async"))
+  await user.type(incrementValueInput, '-1')
+  await user.click(screen.getByText('Add Async'))
   await waitFor(() =>
-    expect(screen.getByLabelText("Count")).toHaveTextContent("3"),
+    expect(screen.getByLabelText('Count')).toHaveTextContent('3'),
   )
 })
 
-test("Add If Odd should work as expected", async () => {
+test('Add If Odd should work as expected', async () => {
   const { user } = renderWithProviders(<App />)
 
   // "Add If Odd" button is clicked => Count should stay 0
-  await user.click(screen.getByText("Add If Odd"))
-  expect(screen.getByLabelText("Count")).toHaveTextContent("0")
+  await user.click(screen.getByText('Add If Odd'))
+  expect(screen.getByLabelText('Count')).toHaveTextContent('0')
 
   // Click on "+" => Count should be updated to 1
-  await user.click(screen.getByLabelText("Increment value"))
-  expect(screen.getByLabelText("Count")).toHaveTextContent("1")
+  await user.click(screen.getByLabelText('Increment value'))
+  expect(screen.getByLabelText('Count')).toHaveTextContent('1')
 
   // "Add If Odd" button is clicked => Count should be updated to 3
-  await user.click(screen.getByText("Add If Odd"))
-  expect(screen.getByLabelText("Count")).toHaveTextContent("3")
+  await user.click(screen.getByText('Add If Odd'))
+  expect(screen.getByLabelText('Count')).toHaveTextContent('3')
 
-  const incrementValueInput = screen.getByLabelText("Set increment amount")
+  const incrementValueInput = screen.getByLabelText('Set increment amount')
   // incrementValue is 1, click on "Add If Odd" => Count should be updated to 4
   await user.clear(incrementValueInput)
-  await user.type(incrementValueInput, "1")
-  await user.click(screen.getByText("Add If Odd"))
-  expect(screen.getByLabelText("Count")).toHaveTextContent("4")
+  await user.type(incrementValueInput, '1')
+  await user.click(screen.getByText('Add If Odd'))
+  expect(screen.getByLabelText('Count')).toHaveTextContent('4')
 
   // click on "Add If Odd" => Count should stay 4
   await user.clear(incrementValueInput)
-  await user.type(incrementValueInput, "-1")
-  await user.click(screen.getByText("Add If Odd"))
-  expect(screen.getByLabelText("Count")).toHaveTextContent("4")
+  await user.type(incrementValueInput, '-1')
+  await user.click(screen.getByText('Add If Odd'))
+  expect(screen.getByLabelText('Count')).toHaveTextContent('4')
 })

examples/query/react/infinite-queries/src/App.tsx

@@ -1,17 +1,17 @@
-import { BrowserRouter, Link, Route, Routes, useLocation } from "react-router"
-import "./App.css"
+import { BrowserRouter, Link, Route, Routes, useLocation } from 'react-router'
+import './App.css'
 
-import { Outlet } from "react-router"
-import BidirectionalCursorInfScroll from "./features/bidirectional-cursor-infinite-scroll/BidirectionalCursorInfScroll"
+import { Outlet } from 'react-router'
+import BidirectionalCursorInfScroll from './features/bidirectional-cursor-infinite-scroll/BidirectionalCursorInfScroll'
 import {
   InfiniteScrollAbout,
   InfiniteScrollExample,
-} from "./features/infinite-scroll/InfiniteScrollExample"
-import LimitOffsetExample from "./features/limit-offset/LimitOffsetExample"
-import { InfiniteScrollMaxPagesExample } from "./features/max-pages/InfiniteScrollMaxExample"
-import PaginationInfScrollExample from "./features/pagination-infinite-scroll/PaginationInfScrollExample"
-import { PaginationExample } from "./features/pagination/PaginationExample"
-import { FlatlistExample } from "./features/rn-flatlist/FlatlistExample"
+} from './features/infinite-scroll/InfiniteScrollExample'
+import LimitOffsetExample from './features/limit-offset/LimitOffsetExample'
+import { InfiniteScrollMaxPagesExample } from './features/max-pages/InfiniteScrollMaxExample'
+import PaginationInfScrollExample from './features/pagination-infinite-scroll/PaginationInfScrollExample'
+import { PaginationExample } from './features/pagination/PaginationExample'
+import { FlatlistExample } from './features/rn-flatlist/FlatlistExample'
 
 const Menu = () => {
   return (

examples/query/react/infinite-queries/src/app/createAppSlice.ts

@@ -1,4 +1,4 @@
-import { asyncThunkCreator, buildCreateSlice } from "@reduxjs/toolkit"
+import { asyncThunkCreator, buildCreateSlice } from '@reduxjs/toolkit'
 
 // `buildCreateSlice` allows us to create a slice with async thunks.
 export const createAppSlice = buildCreateSlice({

examples/query/react/infinite-queries/src/app/hooks.ts

@@ -4,8 +4,8 @@
 // We disable the ESLint rule here because this is the designated place
 // for importing and re-exporting the typed versions of hooks.
 /* eslint-disable @typescript-eslint/no-restricted-imports */
-import { useDispatch, useSelector } from "react-redux"
-import type { AppDispatch, RootState } from "./store"
+import { useDispatch, useSelector } from 'react-redux'
+import type { AppDispatch, RootState } from './store'
 
 // Use throughout your app instead of plain `useDispatch` and `useSelector`
 export const useAppDispatch = useDispatch.withTypes<AppDispatch>()

examples/query/react/infinite-queries/src/app/store.ts

@@ -1,7 +1,7 @@
-import type { Action, ThunkAction } from "@reduxjs/toolkit"
-import { combineSlices, configureStore } from "@reduxjs/toolkit"
-import { setupListeners } from "@reduxjs/toolkit/query"
-import { baseApi } from "../features/baseApi"
+import type { Action, ThunkAction } from '@reduxjs/toolkit'
+import { combineSlices, configureStore } from '@reduxjs/toolkit'
+import { setupListeners } from '@reduxjs/toolkit/query'
+import { baseApi } from '../features/baseApi'
 
 // `combineSlices` automatically combines the reducers using
 // their `reducerPath`s, therefore we no longer need to call `combineReducers`.
@@ -16,7 +16,7 @@ export const makeStore = (preloadedState?: Partial<RootState>) => {
     reducer: rootReducer,
     // Adding the api middleware enables caching, invalidation, polling,
     // and other useful features of `rtk-query`.
-    middleware: getDefaultMiddleware => {
+    middleware: (getDefaultMiddleware) => {
       return getDefaultMiddleware().concat(baseApi.middleware)
     },
     preloadedState,
@@ -32,7 +32,7 @@ export const store = makeStore()
 // Infer the type of `store`
 export type AppStore = typeof store
 // Infer the `AppDispatch` type from the store itself
-export type AppDispatch = AppStore["dispatch"]
+export type AppDispatch = AppStore['dispatch']
 export type AppThunk<ThunkReturnType = void> = ThunkAction<
   ThunkReturnType,
   RootState,