Make createReducer() return Reducer<Immutable<S>, A>

This reflects the actual runtime behavior of immer (which freezes
produced values) and fixes a type error with immer >= 1.10.3.

Author: denisw

package-lock.json

@@ -47,7 +47,7 @@
     "index.d.ts"
   ],
   "dependencies": {
-    "immer": "^1.9.3",
+    "immer": "^1.10.3",
     "redux": "^4.0.0",
     "redux-devtools-extension": "^2.13.7",
     "redux-immutable-state-invariant": "^2.1.0",

package.json

@@ -1,4 +1,4 @@
-import createNextState from 'immer'
+import createNextState, { Draft, Immutable } from 'immer'
 import { AnyAction, Action, Reducer } from 'redux'
 
 /**
@@ -16,7 +16,7 @@ import { AnyAction, Action, Reducer } from 'redux'
  * translated to copy operations that result in a new state.
  */
 export type CaseReducer<S = any, A extends Action = AnyAction> = (
-  state: S,
+  state: Draft<S>,
   action: A
 ) => S | void
 
@@ -44,13 +44,16 @@ export interface CaseReducersMapObject<S = any, A extends Action = AnyAction> {
  *   case redeucers.
  */
 export function createReducer<S = any, A extends Action = AnyAction>(
-  initialState: S,
+  initialState: Immutable<S>,
   actionsMap: CaseReducersMapObject<S, A>
-): Reducer<S, A> {
-  return function(state = initialState, action): S {
-    return createNextState(state, (draft: S) => {
+): Reducer<Immutable<S>, A> {
+  return function(state = initialState, action): Immutable<S> {
+    // @ts-ignore createNextState() produces an Immutable<Draft<S>> rather
+    // than an Immutable<S>, and TypeScript cannot find out how to reconcile
+    // these two types.
+    return createNextState(state, (draft: Draft<S>) => {
       const caseReducer = actionsMap[action.type]
-      return caseReducer ? caseReducer(draft as S, action) : draft
+      return caseReducer ? caseReducer(draft, action) : undefined
     })
   }
 }

src/createReducer.ts

@@ -1,3 +1,4 @@
+import { Immutable } from 'immer'
 import { Action, AnyAction, ActionCreator, Reducer } from 'redux'
 import { createAction, PayloadAction } from './createAction'
 import { createReducer, CaseReducersMapObject } from './createReducer'
@@ -50,7 +51,7 @@ export interface CreateSliceOptions<
   /**
    * The initial state to be returned by the slice reducer.
    */
-  initialState: S
+  initialState: Immutable<S>
 
   /**
    * A mapping from action types to action-type-specific *case reducer*
@@ -78,7 +79,7 @@ export function createSlice<
   CR extends CaseReducersMapObject<S, A> = CaseReducersMapObject<S, A>
 >(
   options: CreateSliceOptions<S, A, CR>
-): Slice<S, A, Extract<keyof CR, string>> {
+): Slice<Immutable<S>, A, Extract<keyof CR, string>> {
   const { slice = '', initialState } = options
   const reducers = options.reducers || {}
   const actionKeys = Object.keys(reducers)

src/createSlice.ts

@@ -56,3 +56,27 @@ import { AnyAction, createReducer, Reducer } from 'redux-starter-kit'
     decrement: decrementHandler
   })
 }
+
+/*
+ * Test: createReducer() reducers are typed to return readonly states.
+ */
+{
+  const initialCounters = {
+    a: 0,
+    b: 0
+  }
+
+  const reducer = createReducer(initialCounters, {
+    incrementA: state => {
+      state.a += 1
+    },
+    incrementB: state => {
+      state.b += 1
+    }
+  })
+
+  const newCounters = reducer(initialCounters, { type: 'incrementA' })
+
+  // typings:expect-error
+  newCounters.a++
+}