Merge pull request #1103 from reduxjs/chore/readonly-array-params

add `readonly` to array-type function parameters where mutation is not intended

Author: markerikson

.eslintrc.js

@@ -19,6 +19,25 @@ module.exports = {
     ],
   },
   overrides: [
+    // {
+    //   // only add after https://github.com/typescript-eslint/typescript-eslint/pull/3463 is merged
+    //   files: ['src/**/*.ts'],
+    //   excludedFiles: [
+    //     '**/tests/*.ts',
+    //     '**/tests/**/*.ts',
+    //     '**/tests/*.tsx',
+    //     '**/tests/**/*.tsx',
+    //   ],
+    //   parserOptions: {
+    //     project: './tsconfig.json',
+    //   },
+    //   rules: {
+    //     '@typescript-eslint/prefer-readonly-parameter-types': [
+    //       'warn',
+    //       { arraysAndTuplesOnly: true },
+    //     ],
+    //   },
+    // },
     {
       files: ['src/tests/*.ts', 'src/**/tests/*.ts', 'src/**/tests/*.tsx'],
       rules: {

src/configureStore.ts

@@ -30,7 +30,7 @@ const IS_PRODUCTION = process.env.NODE_ENV === 'production'
  * @public
  */
 export type ConfigureEnhancersCallback = (
-  defaultEnhancers: StoreEnhancer[]
+  defaultEnhancers: readonly StoreEnhancer[]
 ) => StoreEnhancer[]
 
 /**

src/createReducer.ts

@@ -24,6 +24,10 @@ export type ActionMatcherDescription<S, A extends AnyAction> = {
   reducer: CaseReducer<S, NoInfer<A>>
 }
 
+export type ReadonlyActionMatcherDescriptionCollection<S> = ReadonlyArray<
+  ActionMatcherDescription<S, any>
+>
+
 export type ActionMatcherDescriptionCollection<S> = Array<
   ActionMatcherDescription<S, any>
 >
@@ -190,7 +194,7 @@ export function createReducer<S>(
   mapOrBuilderCallback:
     | CaseReducers<S, any>
     | ((builder: ActionReducerMapBuilder<S>) => void),
-  actionMatchers: ActionMatcherDescriptionCollection<S> = [],
+  actionMatchers: ReadonlyActionMatcherDescriptionCollection<S> = [],
   defaultCaseReducer?: CaseReducer<S>
 ): Reducer<S> {
   // We deliberately enable Immer's ES5 support, on the grounds that

src/entities/models.ts

@@ -65,11 +65,11 @@ export interface EntityStateAdapter<T> {
 
   addMany<S extends EntityState<T>>(
     state: PreventAny<S, T>,
-    entities: T[] | Record<EntityId, T>
+    entities: readonly T[] | Record<EntityId, T>
   ): S
   addMany<S extends EntityState<T>>(
     state: PreventAny<S, T>,
-    entities: PayloadAction<T[] | Record<EntityId, T>>
+    entities: PayloadAction<readonly T[] | Record<EntityId, T>>
   ): S
 
   setOne<S extends EntityState<T>>(state: PreventAny<S, T>, entity: T): S
@@ -79,19 +79,19 @@ export interface EntityStateAdapter<T> {
   ): S
   setMany<S extends EntityState<T>>(
     state: PreventAny<S, T>,
-    entities: T[] | Record<EntityId, T>
+    entities: readonly T[] | Record<EntityId, T>
   ): S
   setMany<S extends EntityState<T>>(
     state: PreventAny<S, T>,
-    entities: PayloadAction<T[] | Record<EntityId, T>>
+    entities: PayloadAction<readonly T[] | Record<EntityId, T>>
   ): S
   setAll<S extends EntityState<T>>(
     state: PreventAny<S, T>,
-    entities: T[] | Record<EntityId, T>
+    entities: readonly T[] | Record<EntityId, T>
   ): S
   setAll<S extends EntityState<T>>(
     state: PreventAny<S, T>,
-    entities: PayloadAction<T[] | Record<EntityId, T>>
+    entities: PayloadAction<readonly T[] | Record<EntityId, T>>
   ): S
 
   removeOne<S extends EntityState<T>>(state: PreventAny<S, T>, key: EntityId): S
@@ -102,11 +102,11 @@ export interface EntityStateAdapter<T> {
 
   removeMany<S extends EntityState<T>>(
     state: PreventAny<S, T>,
-    keys: EntityId[]
+    keys: readonly EntityId[]
   ): S
   removeMany<S extends EntityState<T>>(
     state: PreventAny<S, T>,
-    keys: PayloadAction<EntityId[]>
+    keys: PayloadAction<readonly EntityId[]>
   ): S
 
   removeAll<S extends EntityState<T>>(state: PreventAny<S, T>): S
@@ -122,11 +122,11 @@ export interface EntityStateAdapter<T> {
 
   updateMany<S extends EntityState<T>>(
     state: PreventAny<S, T>,
-    updates: Update<T>[]
+    updates: ReadonlyArray<Update<T>>
   ): S
   updateMany<S extends EntityState<T>>(
     state: PreventAny<S, T>,
-    updates: PayloadAction<Update<T>[]>
+    updates: PayloadAction<ReadonlyArray<Update<T>>>
   ): S
 
   upsertOne<S extends EntityState<T>>(state: PreventAny<S, T>, entity: T): S
@@ -137,11 +137,11 @@ export interface EntityStateAdapter<T> {
 
   upsertMany<S extends EntityState<T>>(
     state: PreventAny<S, T>,
-    entities: T[] | Record<EntityId, T>
+    entities: readonly T[] | Record<EntityId, T>
   ): S
   upsertMany<S extends EntityState<T>>(
     state: PreventAny<S, T>,
-    entities: PayloadAction<T[] | Record<EntityId, T>>
+    entities: PayloadAction<readonly T[] | Record<EntityId, T>>
   ): S
 }
 

src/entities/sorted_state_adapter.ts

@@ -29,7 +29,7 @@ export function createSortedStateAdapter<T>(
   }
 
   function addManyMutably(
-    newEntities: T[] | Record<EntityId, T>,
+    newEntities: readonly T[] | Record<EntityId, T>,
     state: R
   ): void {
     newEntities = ensureEntitiesArray(newEntities)
@@ -48,7 +48,7 @@ export function createSortedStateAdapter<T>(
   }
 
   function setManyMutably(
-    newEntities: T[] | Record<EntityId, T>,
+    newEntities: readonly T[] | Record<EntityId, T>,
     state: R
   ): void {
     newEntities = ensureEntitiesArray(newEntities)
@@ -58,7 +58,7 @@ export function createSortedStateAdapter<T>(
   }
 
   function setAllMutably(
-    newEntities: T[] | Record<EntityId, T>,
+    newEntities: readonly T[] | Record<EntityId, T>,
     state: R
   ): void {
     newEntities = ensureEntitiesArray(newEntities)
@@ -72,6 +72,7 @@ export function createSortedStateAdapter<T>(
     return updateManyMutably([update], state)
   }
 
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   function takeUpdatedModel(models: T[], update: Update<T>, state: R): boolean {
     if (!(update.id in state.entities)) {
       return false
@@ -88,7 +89,10 @@ export function createSortedStateAdapter<T>(
     return newKey !== update.id
   }
 
-  function updateManyMutably(updates: Update<T>[], state: R): void {
+  function updateManyMutably(
+    updates: ReadonlyArray<Update<T>>,
+    state: R
+  ): void {
     const models: T[] = []
 
     updates.forEach((update) => takeUpdatedModel(models, update, state))
@@ -103,7 +107,7 @@ export function createSortedStateAdapter<T>(
   }
 
   function upsertManyMutably(
-    newEntities: T[] | Record<EntityId, T>,
+    newEntities: readonly T[] | Record<EntityId, T>,
     state: R
   ): void {
     const [added, updated] = splitAddedUpdatedEntities<T>(
@@ -116,7 +120,7 @@ export function createSortedStateAdapter<T>(
     addManyMutably(added, state)
   }
 
-  function areArraysEqual(a: unknown[], b: unknown[]) {
+  function areArraysEqual(a: readonly unknown[], b: readonly unknown[]) {
     if (a.length !== b.length) {
       return false
     }
@@ -130,7 +134,7 @@ export function createSortedStateAdapter<T>(
     return true
   }
 
-  function merge(models: T[], state: R): void {
+  function merge(models: readonly T[], state: R): void {
     // Insert/overwrite all new/updated
     models.forEach((model) => {
       state.entities[selectId(model)] = model

src/entities/state_selectors.ts

@@ -1,5 +1,10 @@
 import { createDraftSafeSelector } from '../createDraftSafeSelector'
-import type { EntityState, EntitySelectors, Dictionary, EntityId } from './models'
+import type {
+  EntityState,
+  EntitySelectors,
+  Dictionary,
+  EntityId,
+} from './models'
 
 export function createSelectorsFactory<T>() {
   function getSelectors(): EntitySelectors<T, EntityState<T>>
@@ -16,7 +21,7 @@ export function createSelectorsFactory<T>() {
     const selectAll = createDraftSafeSelector(
       selectIds,
       selectEntities,
-      (ids: T[], entities: Dictionary<T>): any =>
+      (ids: readonly T[], entities: Dictionary<T>): any =>
         ids.map((id: any) => (entities as any)[id])
     )
 

src/entities/unsorted_state_adapter.ts

@@ -32,7 +32,7 @@ export function createUnsortedStateAdapter<T>(
   }
 
   function addManyMutably(
-    newEntities: T[] | Record<EntityId, T>,
+    newEntities: readonly T[] | Record<EntityId, T>,
     state: R
   ): void {
     newEntities = ensureEntitiesArray(newEntities)
@@ -51,7 +51,7 @@ export function createUnsortedStateAdapter<T>(
   }
 
   function setManyMutably(
-    newEntities: T[] | Record<EntityId, T>,
+    newEntities: readonly T[] | Record<EntityId, T>,
     state: R
   ): void {
     newEntities = ensureEntitiesArray(newEntities)
@@ -61,7 +61,7 @@ export function createUnsortedStateAdapter<T>(
   }
 
   function setAllMutably(
-    newEntities: T[] | Record<EntityId, T>,
+    newEntities: readonly T[] | Record<EntityId, T>,
     state: R
   ): void {
     newEntities = ensureEntitiesArray(newEntities)
@@ -76,7 +76,7 @@ export function createUnsortedStateAdapter<T>(
     return removeManyMutably([key], state)
   }
 
-  function removeManyMutably(keys: EntityId[], state: R): void {
+  function removeManyMutably(keys: readonly EntityId[], state: R): void {
     let didMutate = false
 
     keys.forEach((key) => {
@@ -122,7 +122,10 @@ export function createUnsortedStateAdapter<T>(
     return updateManyMutably([update], state)
   }
 
-  function updateManyMutably(updates: Update<T>[], state: R): void {
+  function updateManyMutably(
+    updates: ReadonlyArray<Update<T>>,
+    state: R
+  ): void {
     const newKeys: { [id: string]: EntityId } = {}
 
     const updatesPerEntity: { [id: string]: Update<T> } = {}
@@ -165,7 +168,7 @@ export function createUnsortedStateAdapter<T>(
   }
 
   function upsertManyMutably(
-    newEntities: T[] | Record<EntityId, T>,
+    newEntities: readonly T[] | Record<EntityId, T>,
     state: R
   ): void {
     const [added, updated] = splitAddedUpdatedEntities<T>(

src/entities/utils.ts

@@ -18,8 +18,8 @@ export function selectIdValue<T>(entity: T, selectId: IdSelector<T>) {
 }
 
 export function ensureEntitiesArray<T>(
-  entities: T[] | Record<EntityId, T>
-): T[] {
+  entities: readonly T[] | Record<EntityId, T>
+): readonly T[] {
   if (!Array.isArray(entities)) {
     entities = Object.values(entities)
   }
@@ -28,7 +28,7 @@ export function ensureEntitiesArray<T>(
 }
 
 export function splitAddedUpdatedEntities<T>(
-  newEntities: T[] | Record<EntityId, T>,
+  newEntities: readonly T[] | Record<EntityId, T>,
   selectId: IdSelector<T>,
   state: EntityState<T>
 ): [T[], Update<T>[]] {

src/immutableStateInvariantMiddleware.ts

@@ -121,7 +121,7 @@ function trackProperties(
   return tracked as TrackedProperty
 }
 
-type IgnorePaths = string[]
+type IgnorePaths = readonly string[]
 
 function detectMutations(
   isImmutable: IsImmutableFunc,

src/matchers.ts

@@ -69,7 +69,10 @@ export function isAllOf<Matchers extends [Matcher<any>, ...Matcher<any>[]]>(
  *
  * @internal
  */
-export function hasExpectedRequestMetadata(action: any, validStatus: string[]) {
+export function hasExpectedRequestMetadata(
+  action: any,
+  validStatus: readonly string[]
+) {
   if (!action || !action.meta) return false
 
   const hasValidRequestId = typeof action.meta.requestId === 'string'