Merge branch 'v2.0-integration' into customise-create-selector

Author: EskiMojo14

docs/api/createEntityAdapter.mdx

@@ -46,9 +46,9 @@ import {
 
 type Book = { bookId: string; title: string }
 
-const booksAdapter = createEntityAdapter<Book>({
+const booksAdapter = createEntityAdapter({
   // Assume IDs are stored in a field other than `book.id`
-  selectId: (book) => book.bookId,
+  selectId: (book: Book) => book.bookId,
   // Keep the "all IDs" array sorted based on book titles
   sortComparer: (a, b) => a.title.localeCompare(b.title),
 })
@@ -118,19 +118,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> {
@@ -183,7 +175,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

packages/toolkit/src/configureStore.ts

@@ -82,7 +82,7 @@ export interface ConfigureStoreOptions<
    * and should return a Tuple of enhancers (such as `getDefaultEnhancers().concat(offline)`).
    * If you only need to add middleware, you can use the `middleware` parameter instead.
    */
-  enhancers?: ((getDefaultEnhancers: GetDefaultEnhancers<M>) => E) | E
+  enhancers?: (getDefaultEnhancers: GetDefaultEnhancers<M>) => E
 }
 
 export type Middlewares<S> = ReadonlyArray<Middleware<{}, S>>
@@ -172,13 +172,18 @@ export function configureStore<
   const middlewareEnhancer = applyMiddleware(...finalMiddleware)
 
   const getDefaultEnhancers = buildGetDefaultEnhancers<M>(middlewareEnhancer)
+
+  if (!IS_PRODUCTION && enhancers && typeof enhancers !== 'function') {
+    throw new Error('"enhancers" field must be a callback')
+  }
+
   let storeEnhancers =
-    (typeof enhancers === 'function'
+    typeof enhancers === 'function'
       ? enhancers(getDefaultEnhancers)
-      : enhancers) ?? getDefaultEnhancers()
+      : getDefaultEnhancers()
 
   if (!IS_PRODUCTION && !Array.isArray(storeEnhancers)) {
-    throw new Error('enhancers must be an array')
+    throw new Error('"enhancers" callback must return an array')
   }
   if (
     !IS_PRODUCTION &&
@@ -194,7 +199,7 @@ export function configureStore<
     !storeEnhancers.includes(middlewareEnhancer)
   ) {
     console.error(
-      'middlewares were provided, but middleware enhancer was not included in final enhancers'
+      'middlewares were provided, but middleware enhancer was not included in final enhancers - make sure to call `getDefaultEnhancers`'
     )
   }
 

packages/toolkit/src/entities/entity_state.ts

@@ -6,7 +6,7 @@ export function getInitialEntityState<T, Id extends EntityId>(): EntityState<
 > {
   return {
     ids: [],
-    entities: {},
+    entities: {} as Record<Id, T>,
   }
 }
 

packages/toolkit/src/entities/index.ts

@@ -1,6 +1,5 @@
 export { createEntityAdapter } from './create_adapter'
 export type {
-  Dictionary,
   EntityState,
   EntityAdapter,
   Update,

packages/toolkit/src/entities/models.ts

@@ -1,6 +1,7 @@
+import type { UncheckedIndexedAccess } from '../uncheckedindexed'
 import type { PayloadAction } from '../createAction'
-import type { IsAny } from '../tsHelpers'
 import type { GetSelectorsOptions } from './state_selectors'
+import type { CastAny, Id as Compute } from '../tsHelpers'
 
 /**
  * @public
@@ -17,11 +18,6 @@ export type Comparer<T> = (a: T, b: T) => number
  */
 export type IdSelector<T, Id extends EntityId> = (model: T) => Id
 
-/**
- * @public
- */
-export type Dictionary<T, Id extends EntityId> = Partial<Record<Id, T>>
-
 /**
  * @public
  */
@@ -32,7 +28,7 @@ export type Update<T, Id extends EntityId> = { id: Id; changes: Partial<T> }
  */
 export interface EntityState<T, Id extends EntityId> {
   ids: Id[]
-  entities: Dictionary<T, Id>
+  entities: Record<Id, T>
 }
 
 /**
@@ -43,10 +39,9 @@ export interface EntityDefinition<T, Id extends EntityId> {
   sortComparer: false | Comparer<T>
 }
 
-export type PreventAny<S, T, Id extends EntityId> = IsAny<
+export type PreventAny<S, T, Id extends EntityId> = CastAny<
   S,
-  EntityState<T, Id>,
-  S
+  EntityState<T, Id>
 >
 
 /**
@@ -158,10 +153,10 @@ export interface EntityStateAdapter<T, Id extends EntityId> {
  */
 export interface EntitySelectors<T, V, Id extends EntityId> {
   selectIds: (state: V) => Id[]
-  selectEntities: (state: V) => Dictionary<T, Id>
+  selectEntities: (state: V) => Record<Id, T>
   selectAll: (state: V) => T[]
   selectTotal: (state: V) => number
-  selectById: (state: V, id: Id) => T | undefined
+  selectById: (state: V, id: Id) => Compute<UncheckedIndexedAccess<T>>
 }
 
 /**

packages/toolkit/src/entities/sorted_state_adapter.ts

@@ -61,7 +61,7 @@ export function createSortedStateAdapter<T, Id extends EntityId>(
     state: R
   ): void {
     newEntities = ensureEntitiesArray(newEntities)
-    state.entities = {}
+    state.entities = {} as Record<Id, T>
     state.ids = []
 
     addManyMutably(newEntities, state)

packages/toolkit/src/entities/state_selectors.ts

@@ -1,11 +1,6 @@
 import type { CreateSelectorFunction, Selector } from 'reselect'
 import { createDraftSafeSelector } from '../createDraftSafeSelector'
-import type {
-  EntityState,
-  EntitySelectors,
-  Dictionary,
-  EntityId,
-} from './models'
+import type { EntityState, EntitySelectors, EntityId } from './models'
 
 export type AnyCreateSelectorFunction = CreateSelectorFunction<
   (...args: unknown[]) => unknown,
@@ -42,7 +37,7 @@ export function createSelectorsFactory<T, Id extends EntityId>() {
 
     const selectId = (_: unknown, id: Id) => id
 
-    const selectById = (entities: Dictionary<T, Id>, id: Id) => entities[id]
+    const selectById = (entities: Record<Id, T>, id: Id) => entities[id]
 
     const selectTotal = createSelector(selectIds, (ids) => ids.length)
 

packages/toolkit/src/entities/unsorted_state_adapter.ts

@@ -67,7 +67,7 @@ export function createUnsortedStateAdapter<T, Id extends EntityId>(
     newEntities = ensureEntitiesArray(newEntities)
 
     state.ids = []
-    state.entities = {}
+    state.entities = {} as Record<Id, T>
 
     addManyMutably(newEntities, state)
   }

packages/toolkit/src/index.ts

@@ -108,7 +108,6 @@ export { Tuple } from './utils'
 
 export { createEntityAdapter } from './entities/create_adapter'
 export type {
-  Dictionary,
   EntityState,
   EntityAdapter,
   EntitySelectors,

packages/toolkit/src/tests/configureStore.test.ts

@@ -283,16 +283,28 @@ describe('configureStore', async () => {
         undefined,
         expect.any(Function)
       )
+
+      expect(dummyEnhancerCalled).toBe(true)
     })
 
-    it('accepts a callback for customizing enhancers', () => {
-      const store = configureStore({
-        reducer,
-        enhancers: (getDefaultEnhancers) =>
-          getDefaultEnhancers().concat(dummyEnhancer),
+    describe('invalid arguments', () => {
+      test('enhancers is not a callback', () => {
+        expect(() => configureStore({ reducer, enhancers: [] as any })).toThrow(
+          '"enhancers" field must be a callback'
+        )
       })
 
-      expect(dummyEnhancerCalled).toBe(true)
+      test('callback fails to return array', () => {
+        expect(() =>
+          configureStore({ reducer, enhancers: (() => {}) as any })
+        ).toThrow('"enhancers" callback must return an array')
+      })
+
+      test('array contains non-function', () => {
+        expect(() =>
+          configureStore({ reducer, enhancers: (() => ['']) as any })
+        ).toThrow('each enhancer provided to configureStore must be a function')
+      })
     })
 
     const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
@@ -306,20 +318,20 @@ describe('configureStore', async () => {
     it('warns if middleware enhancer is excluded from final array when middlewares are provided', () => {
       const store = configureStore({
         reducer,
-        enhancers: new Tuple(dummyEnhancer),
+        enhancers: () => new Tuple(dummyEnhancer),
       })
 
       expect(dummyEnhancerCalled).toBe(true)
 
       expect(consoleSpy).toHaveBeenCalledWith(
-        'middlewares were provided, but middleware enhancer was not included in final enhancers'
+        'middlewares were provided, but middleware enhancer was not included in final enhancers - make sure to call `getDefaultEnhancers`'
       )
     })
     it("doesn't warn when middleware enhancer is excluded if no middlewares provided", () => {
       const store = configureStore({
         reducer,
         middleware: new Tuple(),
-        enhancers: new Tuple(dummyEnhancer),
+        enhancers: () => new Tuple(dummyEnhancer),
       })
 
       expect(dummyEnhancerCalled).toBe(true)