Merge branch 'v2.0-integration' into v2.0-docs

Author: EskiMojo14

docs/api/configureStore.mdx

@@ -20,9 +20,9 @@ to the store setup for a better development experience.
 
 interface ConfigureStoreOptions<
   S = any,
-  A extends Action = AnyAction,
-  M extends Middlewares<S> = Middlewares<S>,
-  E extends Enhancers = Enhancers,
+  A extends Action = UnknownAction,
+  M extends Tuple<Middlewares<S>> = Tuple<Middlewares<S>>
+  E extends Tuple<Enhancers> = Tuple<Enhancers>,
   P = S
 > {
   /**
@@ -63,8 +63,11 @@ interface ConfigureStoreOptions<
 
 function configureStore<
   S = any,
-  A extends Action = AnyAction,
-  M extends Middlewares<S> = Middlewares<S>,
+  A extends Action = UnknownAction,
+  M extends Tuple<Middlewares<S>> = Tuple<Middlewares<S>>
+  E extends Tuple<Enhancers> = Tuple<Enhancers>,
+  P = S
+>(options: ConfigureStoreOptions<S, A, M, E, P>): EnhancedStore<S, A, M, E>
 ```
 
 ### `reducer`

docs/api/createDynamicMiddleware.mdx

@@ -80,7 +80,7 @@ The "dynamic middleware instance" returned from `createDynamicMiddleware` is an
 ```ts no-transpile
 export type DynamicMiddlewareInstance<
   State = unknown,
-  Dispatch extends ReduxDispatch<AnyAction> = ReduxDispatch<AnyAction>
+  Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>
 > = {
   middleware: DynamicMiddleware<State, Dispatch>
   addMiddleware: AddMiddleware<State, Dispatch>
@@ -131,7 +131,7 @@ _These depend on having `react-redux` installed._
 ```ts no-transpile
 interface ReactDynamicMiddlewareInstance<
   State = any,
-  Dispatch extends ReduxDispatch<AnyAction> = ReduxDispatch<AnyAction>
+  Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>
 > extends DynamicMiddlewareInstance<State, Dispatch> {
   createDispatchWithMiddlewareHook: CreateDispatchWithMiddlewareHook<
     State,

docs/api/createEntityAdapter.mdx

@@ -120,19 +120,11 @@ export type Comparer<T> = (a: T, b: T) => number
 
 export type IdSelector<T> = (model: T) => EntityId
 
-export interface DictionaryNum<T> {
-  [id: number]: T | undefined
-}
-
-export interface Dictionary<T> extends DictionaryNum<T> {
-  [id: string]: T | undefined
-}
-
 export type Update<T> = { id: EntityId; changes: Partial<T> }
 
 export interface EntityState<T> {
   ids: EntityId[]
-  entities: Dictionary<T>
+  entities: Record<EntityId, T>
 }
 
 export interface EntityDefinition<T> {
@@ -185,7 +177,7 @@ export interface EntityStateAdapter<T> {
 
 export interface EntitySelectors<T, V> {
   selectIds: (state: V) => EntityId[]
-  selectEntities: (state: V) => Dictionary<T>
+  selectEntities: (state: V) => Record<EntityId, T>
   selectAll: (state: V) => T[]
   selectTotal: (state: V) => number
   selectById: (state: V, id: EntityId) => T | undefined
@@ -287,9 +279,35 @@ The entity adapter will contain a `getSelectors()` function that returns a set o
 
 Each selector function will be created using the `createSelector` function from Reselect, to enable memoizing calculation of the results.
 
+:::tip
+
+The `createSelector` instance used can be replaced, by passing it as part of the options object (second parameter):
+
+```js
+import {
+  createDraftSafeSelectorCreator,
+  weakMapMemoize,
+} from '@reduxjs/toolkit'
+
+const createWeakMapDraftSafeSelector =
+  createDraftSafeSelectorCreator(weakMapMemoize)
+
+const simpleSelectors = booksAdapter.getSelectors(undefined, {
+  createSelector: createWeakMapDraftSafeSelector,
+})
+
+const globalizedSelectors = booksAdapter.getSelectors((state) => state.books, {
+  createSelector: createWeakMapDraftSafeSelector,
+})
+```
+
+If no instance is passed, it will default to [`createDraftSafeSelector`](./createSelector#createDraftSafeSelector).
+
+:::
+
 Because selector functions are dependent on knowing where in the state tree this specific entity state object is kept, `getSelectors()` can be called in two ways:
 
-- If called without any arguments, it returns an "unglobalized" set of selector functions that assume their `state` argument is the actual entity state object to read from.
+- If called without any arguments (or with undefined as the first parameter), it returns an "unglobalized" set of selector functions that assume their `state` argument is the actual entity state object to read from.
 - It may also be called with a selector function that accepts the entire Redux state tree and returns the correct entity state object.
 
 For example, the entity state for a `Book` type might be kept in the Redux state tree as `state.books`. You can use `getSelectors()` to read from that state in two ways:

docs/api/createListenerMiddleware.mdx

@@ -120,10 +120,10 @@ The "listener middleware instance" returned from `createListenerMiddleware` is a
 ```ts no-transpile
 interface ListenerMiddlewareInstance<
   State = unknown,
-  Dispatch extends ThunkDispatch<State, unknown, AnyAction> = ThunkDispatch<
+  Dispatch extends ThunkDispatch<State, unknown, UnknownAction> = ThunkDispatch<
     State,
     unknown,
-    AnyAction
+    UnknownAction
   >,
   ExtraArgument = unknown
 > {
@@ -181,7 +181,7 @@ interface AddListenerOptions {
   effect: (action: Action, listenerApi: ListenerApi) => void | Promise<void>
 }
 
-type ListenerPredicate<Action extends AnyAction, State> = (
+type ListenerPredicate<Action extends ReduxAction, State> = (
   action: Action,
   currentState?: State,
   originalState?: State
@@ -321,7 +321,7 @@ The `listenerApi` object is the second argument to each listener callback. It co
 ```ts no-transpile
 export interface ListenerEffectAPI<
   State,
-  Dispatch extends ReduxDispatch<AnyAction>,
+  Dispatch extends ReduxDispatch<UnknownAction>,
   ExtraArgument = unknown
 > extends MiddlewareAPI<Dispatch, State> {
   // NOTE: MiddlewareAPI contains `dispatch` and `getState` already
@@ -572,12 +572,12 @@ Listeners can use the `condition` and `take` methods in `listenerApi` to wait un
 The signatures are:
 
 ```ts no-transpile
-type ConditionFunction<Action extends AnyAction, State> = (
+type ConditionFunction<Action extends ReduxAction, State> = (
   predicate: ListenerPredicate<Action, State> | (() => boolean),
   timeout?: number
 ) => Promise<boolean>
 
-type TakeFunction<Action extends AnyAction, State> = (
+type TakeFunction<Action extends ReduxAction, State> = (
   predicate: ListenerPredicate<Action, State> | (() => boolean),
   timeout?: number
 ) => Promise<[Action, State, State] | null>

docs/api/createSelector.mdx

@@ -39,7 +39,7 @@ All selectors created by `entityAdapter.getSelectors` are "draft safe" selectors
 
 Example:
 
-```js
+```ts no-transpile
 const selectSelf = (state: State) => state
 const unsafeSelector = createSelector(selectSelf, (state) => state.value)
 const draftSafeSelector = createDraftSafeSelector(
@@ -64,3 +64,25 @@ After executing that, `unsafe1` and `unsafe2` will be of the same value, because
 executed on the same object - but `safe2` will actually be different from `safe1` (with the updated value of `2`),
 because the safe selector detected that it was executed on a Immer draft object and recalculated using the current
 value instead of returning a cached value.
+
+:::tip `createDraftSafeSelectorCreator`
+
+RTK also exports a `createDraftSafeSelectorCreator` function, the "draft safe" equivalent of [`createSelectorCreator`](https://github.com/reduxjs/reselect#createselectorcreatormemoize-memoizeoptions).
+
+```ts no-transpile
+import {
+  createDraftSafeSelectorCreator,
+  weakMapMemoize,
+} from '@reduxjs/toolkit'
+
+const createWeakMapDraftSafeSelector =
+  createDraftSafeSelectorCreator(weakMapMemoize)
+
+const selectSelf = (state: State) => state
+const draftSafeSelector = createWeakMapDraftSafeSelector(
+  selectSelf,
+  (state) => state.value
+)
+```
+
+:::

docs/api/matching-utilities.mdx

@@ -60,12 +60,12 @@ A higher-order function that returns a type guard function that may be used to c
 
 ```ts title="isAsyncThunkAction usage"
 import { isAsyncThunkAction } from '@reduxjs/toolkit'
-import type { AnyAction } from '@reduxjs/toolkit'
+import type { UnknownAction } from '@reduxjs/toolkit'
 import { requestThunk1, requestThunk2 } from '@virtual/matchers'
 
 const isARequestAction = isAsyncThunkAction(requestThunk1, requestThunk2)
 
-function handleRequestAction(action: AnyAction) {
+function handleRequestAction(action: UnknownAction) {
   if (isARequestAction(action)) {
     // action is an action dispatched by either `requestThunk1` or `requestThunk2`
   }
@@ -78,12 +78,12 @@ A higher-order function that returns a type guard function that may be used to c
 
 ```ts title="isPending usage"
 import { isPending } from '@reduxjs/toolkit'
-import type { AnyAction } from '@reduxjs/toolkit'
+import type { UnknownAction } from '@reduxjs/toolkit'
 import { requestThunk1, requestThunk2 } from '@virtual/matchers'
 
 const isAPendingAction = isPending(requestThunk1, requestThunk2)
 
-function handlePendingAction(action: AnyAction) {
+function handlePendingAction(action: UnknownAction) {
   if (isAPendingAction(action)) {
     // action is a pending action dispatched by either `requestThunk1` or `requestThunk2`
   }
@@ -96,12 +96,12 @@ A higher-order function that returns a type guard function that may be used to c
 
 ```ts title="isFulfilled usage"
 import { isFulfilled } from '@reduxjs/toolkit'
-import type { AnyAction } from '@reduxjs/toolkit'
+import type { UnknownAction } from '@reduxjs/toolkit'
 import { requestThunk1, requestThunk2 } from '@virtual/matchers'
 
 const isAFulfilledAction = isFulfilled(requestThunk1, requestThunk2)
 
-function handleFulfilledAction(action: AnyAction) {
+function handleFulfilledAction(action: UnknownAction) {
   if (isAFulfilledAction(action)) {
     // action is a fulfilled action dispatched by either `requestThunk1` or `requestThunk2`
   }
@@ -114,12 +114,12 @@ A higher-order function that returns a type guard function that may be used to c
 
 ```ts title="isRejected usage"
 import { isRejected } from '@reduxjs/toolkit'
-import type { AnyAction } from '@reduxjs/toolkit'
+import type { UnknownAction } from '@reduxjs/toolkit'
 import { requestThunk1, requestThunk2 } from '@virtual/matchers'
 
 const isARejectedAction = isRejected(requestThunk1, requestThunk2)
 
-function handleRejectedAction(action: AnyAction) {
+function handleRejectedAction(action: UnknownAction) {
   if (isARejectedAction(action)) {
     // action is a rejected action dispatched by either `requestThunk1` or `requestThunk2`
   }
@@ -132,15 +132,15 @@ A higher-order function that returns a type guard function that may be used to c
 
 ```ts title="isRejectedWithValue usage"
 import { isRejectedWithValue } from '@reduxjs/toolkit'
-import type { AnyAction } from '@reduxjs/toolkit'
+import type { UnknownAction } from '@reduxjs/toolkit'
 import { requestThunk1, requestThunk2 } from '@virtual/matchers'
 
 const isARejectedWithValueAction = isRejectedWithValue(
   requestThunk1,
   requestThunk2
 )
 
-function handleRejectedWithValueAction(action: AnyAction) {
+function handleRejectedWithValueAction(action: UnknownAction) {
   if (isARejectedWithValueAction(action)) {
     // action is a rejected action dispatched by either `requestThunk1` or `requestThunk2`
     // where rejectWithValue was used

docs/rtk-query/api/createApi.mdx

@@ -57,7 +57,7 @@ export const { useGetPokemonByNameQuery } = pokemonApi
   baseQuery(args: InternalQueryArgs, api: BaseQueryApi, extraOptions?: DefinitionExtraOptions): any;
   endpoints(build: EndpointBuilder<InternalQueryArgs, TagTypes>): Definitions;
   extractRehydrationInfo?: (
-    action: AnyAction,
+    action: UnknownAction,
     {
       reducerPath,
     }: {
@@ -88,7 +88,7 @@ export const { useGetPokemonByNameQuery } = pokemonApi
   - `dispatch` - The `store.dispatch` method for the corresponding Redux store
   - `getState` - A function that may be called to access the current store state
   - `extra` - Provided as thunk.extraArgument to the configureStore getDefaultMiddleware option.
-  - `endpoint` - The name of the endpoint. 
+  - `endpoint` - The name of the endpoint.
   - `type` - Type of request (`query` or `mutation`).
   - `forced` - Indicates if a query has been forced.
 - `extraOptions` - The value of the optional `extraOptions` property provided for a given endpoint

docs/rtk-query/api/created-api/api-slice-utils.mdx

@@ -30,7 +30,7 @@ const updateQueryData = (
   endpointName: string,
   args: any,
   updateRecipe: (draft: Draft<CachedState>) => void
-) => ThunkAction<PatchCollection, PartialState, any, AnyAction>;
+) => ThunkAction<PatchCollection, PartialState, any, UnknownAction>;
 
 interface PatchCollection {
   patches: Patch[];
@@ -119,7 +119,7 @@ const upsertQueryData = <T>(
   endpointName: string,
   args: any,
   newEntryData: T
-) => ThunkAction<Promise<CacheEntry<T>>, PartialState, any, AnyAction>;
+) => ThunkAction<Promise<CacheEntry<T>>, PartialState, any, UnknownAction>;
 ```
 
 - **Parameters**
@@ -156,7 +156,7 @@ const patchQueryData = (
   endpointName: string,
   args: any
   patches: Patch[]
-) => ThunkAction<void, PartialState, any, AnyAction>;
+) => ThunkAction<void, PartialState, any, UnknownAction>;
 ```
 
 - **Parameters**
@@ -203,7 +203,7 @@ const prefetch = (
   endpointName: string,
   arg: any,
   options: PrefetchOptions
-) => ThunkAction<void, any, any, AnyAction>;
+) => ThunkAction<void, any, any, UnknownAction>;
 ```
 
 - **Parameters**
@@ -229,42 +229,44 @@ dispatch(api.util.prefetch('getPosts', undefined, { force: true }))
 ```
 
 ### `selectInvalidatedBy`
- 
+
 #### Signature
- 
+
 ```ts no-transpile
- function selectInvalidatedBy(
-   state: RootState,
-   tags: ReadonlyArray<TagDescription<string>>
- ): Array<{
-   endpointName: string
-   originalArgs: any
-   queryCacheKey: QueryCacheKey
- }>
+function selectInvalidatedBy(
+  state: RootState,
+  tags: ReadonlyArray<TagDescription<string>>
+): Array<{
+  endpointName: string
+  originalArgs: any
+  queryCacheKey: QueryCacheKey
+}>
 ```
- 
+
 - **Parameters**
   - `state`: the root state
   - `tags`: a readonly array of invalidated tags, where the provided `TagDescription` is one of the strings provided to the [`tagTypes`](../createApi.mdx#tagtypes) property of the api. e.g.
     - `[TagType]`
     - `[{ type: TagType }]`
     - `[{ type: TagType, id: number | string }]`
- 
+
 #### Description
- 
+
 A function that can select query parameters to be invalidated.
- 
+
 The function accepts two arguments
-  - the root state and
-  - the cache tags to be invalidated.
- 
+
+- the root state and
+- the cache tags to be invalidated.
+
 It returns an array that contains
-  - the endpoint name,
-  - the original args and
-  - the queryCacheKey.
- 
+
+- the endpoint name,
+- the original args and
+- the queryCacheKey.
+
 #### Example
- 
+
 ```ts no-transpile
 dispatch(api.util.selectInvalidatedBy(state, ['Post']))
 dispatch(api.util.selectInvalidatedBy(state, [{ type: 'Post', id: 1 }]))