Merge branch 'v2.0-integration' into pr/configure-produce-implementation

packages/toolkit/src/entities/create_adapter.ts

@@ -18,10 +18,10 @@ export interface BuildCreateEntityAdapterConfiguration
  BuildStateOperatorConfiguration {}
 
 export type CreateEntityAdapter = {
- <T>(options?: {
- selectId?: IdSelector<T>
+ <T, Id extends EntityId>(options?: {
+ selectId?: IdSelector<T, Id>
  sortComparer?: false | Comparer<T>
- }): EntityAdapter<T>
+ }): EntityAdapter<T, Id>
 }
 
 export function buildCreateEntityAdapter(
@@ -30,20 +30,20 @@ export function buildCreateEntityAdapter(
  const createSelectorsFactory = buildCreateSelectorsFactory(config)
  const createUnsortedStateAdapter = buildCreateUnsortedStateAdapter(config)
  const createSortedStateAdapter = buildCreateSortedStateAdapter(config)
- return function createEntityAdapter<T>(
+ return function createEntityAdapter<T, Id extends EntityId>(
  options: {
- selectId?: IdSelector<T>
+ selectId?: IdSelector<T, Id>
  sortComparer?: false | Comparer<T>
  } = {}
- ): EntityAdapter<T> {
- const { selectId, sortComparer }: EntityDefinition<T> = {
+ ): EntityAdapter<T, Id> {
+ const { selectId, sortComparer }: EntityDefinition<T, Id> = {
  sortComparer: false,
  selectId: (instance: any) => instance.id,
  ...options,
  }
 
- const stateFactory = createInitialStateFactory<T>()
- const selectorsFactory = createSelectorsFactory<T>()
+ const stateFactory = createInitialStateFactory<T, Id>()
+ const selectorsFactory = createSelectorsFactory<T, Id>()
  const stateAdapter = sortComparer
  ? createSortedStateAdapter(selectId, sortComparer)
  : createUnsortedStateAdapter(selectId)

packages/toolkit/src/entities/sorted_state_adapter.ts

@@ -20,11 +20,11 @@ export function buildCreateSortedStateAdapter(
 ) {
  const createUnsortedStateAdapter = buildCreateUnsortedStateAdapter(config)
  const createStateOperator = buildCreateStateOperator(config)
- return function createSortedStateAdapter<T>(
- selectId: IdSelector<T>,
+ return function createSortedStateAdapter<T, Id extends EntityId>(
+ selectId: IdSelector<T, Id>,
  sort: Comparer<T>
- ): EntityStateAdapter<T> {
- type R = EntityState<T>
+ ): EntityStateAdapter<T, Id> {
+ type R = EntityState<T, Id>
 
  const { removeOne, removeMany, removeAll } =
  createUnsortedStateAdapter(selectId)
@@ -34,7 +34,7 @@ export function buildCreateSortedStateAdapter(
  }
 
  function addManyMutably(
- newEntities: readonly T[] | Record<EntityId, T>,
+ newEntities: readonly T[] | Record<Id, T>,
  state: R
  ): void {
  newEntities = ensureEntitiesArray(newEntities)
@@ -53,7 +53,7 @@ export function buildCreateSortedStateAdapter(
  }
 
  function setManyMutably(
- newEntities: readonly T[] | Record<EntityId, T>,
+ newEntities: readonly T[] | Record<Id, T>,
  state: R
  ): void {
  newEntities = ensureEntitiesArray(newEntities)
@@ -63,7 +63,7 @@ export function buildCreateSortedStateAdapter(
  }
 
  function setAllMutably(
- newEntities: readonly T[] | Record<EntityId, T>,
+ newEntities: readonly T[] | Record<Id, T>,
  state: R
  ): void {
  newEntities = ensureEntitiesArray(newEntities)
@@ -73,12 +73,12 @@ export function buildCreateSortedStateAdapter(
  addManyMutably(newEntities, state)
  }
 
- function updateOneMutably(update: Update<T>, state: R): void {
+ function updateOneMutably(update: Update<T, Id>, state: R): void {
  return updateManyMutably([update], state)
  }
 
  function updateManyMutably(
- updates: ReadonlyArray<Update<T>>,
+ updates: ReadonlyArray<Update<T, Id>>,
  state: R
  ): void {
  let appliedUpdates = false
@@ -109,10 +109,10 @@ export function buildCreateSortedStateAdapter(
  }
 
  function upsertManyMutably(
- newEntities: readonly T[] | Record<EntityId, T>,
+ newEntities: readonly T[] | Record<Id, T>,
  state: R
  ): void {
- const [added, updated] = splitAddedUpdatedEntities<T>(
+ const [added, updated] = splitAddedUpdatedEntities<T, Id>(
  newEntities,
  selectId,
  state

packages/toolkit/src/entities/state_adapter.ts

@@ -1,8 +1,7 @@
-import type { EntityState, PreventAny } from './models'
+import type { EntityId, EntityState, PreventAny } from './models'
 import type { PayloadAction } from '../createAction'
 import { isFSA } from '../createAction'
 import type { ImmutableHelpers } from '../tsHelpers'
-import { IsAny } from '../tsHelpers'
 
 export type BuildStateOperatorConfiguration = Pick<
  ImmutableHelpers,
@@ -13,15 +12,15 @@ export function buildCreateSingleArgumentStateOperator(
  config: BuildStateOperatorConfiguration
 ) {
  const createStateOperator = buildCreateStateOperator(config)
- return function createSingleArgumentStateOperator<V>(
- mutator: (state: EntityState<V>) => void
+ return function createSingleArgumentStateOperator<V, Id extends EntityId>(
+ mutator: (state: EntityState<V, Id>) => void
  ) {
  const operator = createStateOperator(
- (_: undefined, state: EntityState<V>) => mutator(state)
+ (_: undefined, state: EntityState<V, Id>) => mutator(state)
  )
 
- return function operation<S extends EntityState<V>>(
- state: PreventAny<S, V>
+ return function operation<S extends EntityState<V, Id>>(
+ state: PreventAny<S, V, Id>
  ): S {
  return operator(state as S, undefined)
  }
@@ -32,10 +31,10 @@ export function buildCreateStateOperator({
  isDraft,
  createNextState,
 }: BuildStateOperatorConfiguration) {
- return function createStateOperator<V, R>(
- mutator: (arg: R, state: EntityState<V>) => void
+ return function createStateOperator<V, Id extends EntityId, R>(
+ mutator: (arg: R, state: EntityState<V, Id>) => void
  ) {
- return function operation<S extends EntityState<V>>(
+ return function operation<S extends EntityState<V, Id>>(
  state: S,
  arg: R | PayloadAction<R>
  ): S {
@@ -45,7 +44,7 @@ export function buildCreateStateOperator({
  return isFSA(arg)
  }
 
- const runMutator = (draft: EntityState<V>) => {
+ const runMutator = (draft: EntityState<V, Id>) => {
  if (isPayloadActionArgument(arg)) {
  mutator(arg.payload, draft)
  } else {

packages/toolkit/src/entities/state_selectors.ts

@@ -13,28 +13,27 @@ export function buildCreateSelectorsFactory(
 ) {
  const createDraftSafeSelector = buildCreateDraftSafeSelector(config)
 
- return function createSelectorsFactory<T>() {
- function getSelectors(): EntitySelectors<T, EntityState<T>>
+ return function createSelectorsFactory<T, Id extends EntityId>() {
+ function getSelectors(): EntitySelectors<T, EntityState<T, Id>, Id>
  function getSelectors<V>(
- selectState: (state: V) => EntityState<T>
- ): EntitySelectors<T, V>
+ selectState: (state: V) => EntityState<T, Id>
+ ): EntitySelectors<T, V, Id>
  function getSelectors<V>(
- selectState?: (state: V) => EntityState<T>
- ): EntitySelectors<T, any> {
- const selectIds = (state: EntityState<T>) => state.ids
+ selectState?: (state: V) => EntityState<T, Id>
+ ): EntitySelectors<T, any, Id> {
+ const selectIds = (state: EntityState<T, Id>) => state.ids
 
- const selectEntities = (state: EntityState<T>) => state.entities
+ const selectEntities = (state: EntityState<T, Id>) => state.entities
 
  const selectAll = createDraftSafeSelector(
  selectIds,
  selectEntities,
  (ids, entities): T[] => ids.map((id) => entities[id]!)
  )
 
- const selectId = (_: unknown, id: EntityId) => id
-
- const selectById = (entities: Dictionary<T>, id: EntityId) => entities[id]
+ const selectId = (_: unknown, id: Id) => id
 
+ const selectById = (entities: Dictionary<T, Id>, id: Id) => entities[id]
  const selectTotal = createDraftSafeSelector(
  selectIds,
  (ids) => ids.length
@@ -55,7 +54,7 @@ export function buildCreateSelectorsFactory(
  }
 
  const selectGlobalizedEntities = createDraftSafeSelector(
- selectState as Selector<V, EntityState<T>>,
+ selectState as Selector<V, EntityState<T, Id>>,
  selectEntities
  )
 

packages/toolkit/src/entities/unsorted_state_adapter.ts

@@ -22,10 +22,10 @@ export function buildCreateUnsortedStateAdapter(
  const createSingleArgumentStateOperator =
  buildCreateSingleArgumentStateOperator(config)
  const createStateOperator = buildCreateStateOperator(config)
- return function createUnsortedStateAdapter<T>(
- selectId: IdSelector<T>
- ): EntityStateAdapter<T> {
- type R = EntityState<T>
+ return function createUnsortedStateAdapter<T, Id extends EntityId>(
+ selectId: IdSelector<T, Id>
+ ): EntityStateAdapter<T, Id> {
+ type R = EntityState<T, Id>
 
  function addOneMutably(entity: T, state: R): void {
  const key = selectIdValue(entity, selectId)
@@ -39,7 +39,7 @@ export function buildCreateUnsortedStateAdapter(
  }
 
  function addManyMutably(
- newEntities: readonly T[] | Record<EntityId, T>,
+ newEntities: readonly T[] | Record<Id, T>,
  state: R
  ): void {
  newEntities = ensureEntitiesArray(newEntities)
@@ -58,7 +58,7 @@ export function buildCreateUnsortedStateAdapter(
  }
 
  function setManyMutably(
- newEntities: readonly T[] | Record<EntityId, T>,
+ newEntities: readonly T[] | Record<Id, T>,
  state: R
  ): void {
  newEntities = ensureEntitiesArray(newEntities)
@@ -68,7 +68,7 @@ export function buildCreateUnsortedStateAdapter(
  }
 
  function setAllMutably(
- newEntities: readonly T[] | Record<EntityId, T>,
+ newEntities: readonly T[] | Record<Id, T>,
  state: R
  ): void {
  newEntities = ensureEntitiesArray(newEntities)
@@ -79,11 +79,11 @@ export function buildCreateUnsortedStateAdapter(
  addManyMutably(newEntities, state)
  }
 
- function removeOneMutably(key: EntityId, state: R): void {
+ function removeOneMutably(key: Id, state: R): void {
  return removeManyMutably([key], state)
  }
 
- function removeManyMutably(keys: readonly EntityId[], state: R): void {
+ function removeManyMutably(keys: readonly Id[], state: R): void {
  let didMutate = false
 
  keys.forEach((key) => {
@@ -106,11 +106,11 @@ export function buildCreateUnsortedStateAdapter(
  }
 
  function takeNewKey(
- keys: { [id: string]: EntityId },
- update: Update<T>,
+ keys: { [id: string]: Id },
+ update: Update<T, Id>,
  state: R
  ): boolean {
- const original = state.entities[update.id]
+ const original: T | undefined = state.entities[update.id]
  const updated: T = Object.assign({}, original, update.changes)
  const newKey = selectIdValue(updated, selectId)
  const hasNewKey = newKey !== update.id
@@ -125,17 +125,17 @@ export function buildCreateUnsortedStateAdapter(
  return hasNewKey
  }
 
- function updateOneMutably(update: Update<T>, state: R): void {
+ function updateOneMutably(update: Update<T, Id>, state: R): void {
  return updateManyMutably([update], state)
  }
 
  function updateManyMutably(
- updates: ReadonlyArray<Update<T>>,
+ updates: ReadonlyArray<Update<T, Id>>,
  state: R
  ): void {
- const newKeys: { [id: string]: EntityId } = {}
+ const newKeys: { [id: string]: Id } = {}
 
- const updatesPerEntity: { [id: string]: Update<T> } = {}
+ const updatesPerEntity: { [id: string]: Update<T, Id> } = {}
 
  updates.forEach((update) => {
  // Only apply updates to entities that currently exist
@@ -165,7 +165,9 @@ export function buildCreateUnsortedStateAdapter(
  .length > 0
 
  if (didMutateIds) {
- state.ids = Object.keys(state.entities)
+ state.ids = Object.values(state.entities).map((e) =>
+ selectIdValue(e as T, selectId)
+ )
  }
  }
  }
@@ -175,10 +177,10 @@ export function buildCreateUnsortedStateAdapter(
  }
 
  function upsertManyMutably(
- newEntities: readonly T[] | Record<EntityId, T>,
+ newEntities: readonly T[] | Record<Id, T>,
  state: R
  ): void {
- const [added, updated] = splitAddedUpdatedEntities<T>(
+ const [added, updated] = splitAddedUpdatedEntities<T, Id>(
  newEntities,
  selectId,
  state

packages/toolkit/src/tsHelpers.ts

@@ -1,6 +1,6 @@
 import type { Middleware, StoreEnhancer } from 'redux'
 import type { Draft, Patch, applyPatches } from 'immer'
-import type { EnhancerArray, MiddlewareArray } from './utils'
+import type { Tuple } from './utils'
 
 export function safeAssign<T extends object>(
  target: T,