fix(ts): ensure produce returns an immutable type

Author: aleclarson

__tests__/immutable.ts

@@ -0,0 +1,66 @@
+import {Immutable} from "../dist/immer.js"
+
+// prettier-ignore
+type Exact<A, B> = (<T>() => T extends A ? 1 : 0) extends (<T>() => T extends B ? 1 : 0)
+    ? (A extends B ? (B extends A ? unknown : never) : never)
+    : never
+
+/** Fails when `actual` and `expected` have different types. */
+declare const exactType: <Actual, Expected>(
+    actual: Actual & Exact<Actual, Expected>,
+    expected: Expected & Exact<Actual, Expected>
+) => Expected
+
+// array in tuple
+{
+    let val = {} as Immutable<[string[], 1]>
+    exactType(val, {} as [ReadonlyArray<string>, 1])
+}
+
+// tuple in array
+{
+    let val = {} as Immutable<[string, 1][]>
+    exactType(val, {} as ReadonlyArray<[string, 1]>)
+}
+
+// tuple in tuple
+{
+    let val = {} as Immutable<[[string, 1], 1]>
+    exactType(val, {} as [[string, 1], 1])
+}
+
+// array in array
+{
+    let val = {} as Immutable<string[][]>
+    exactType(val, {} as ReadonlyArray<ReadonlyArray<string>>)
+}
+
+// tuple in object
+{
+    let val = {} as Immutable<{a: [string, 1]}>
+    exactType(val, {} as {readonly a: [string, 1]})
+}
+
+// object in tuple
+{
+    let val = {} as Immutable<[{a: string}, 1]>
+    exactType(val, {} as [{readonly a: string}, 1])
+}
+
+// array in object
+{
+    let val = {} as Immutable<{a: string[]}>
+    exactType(val, {} as {readonly a: ReadonlyArray<string>})
+}
+
+// object in array
+{
+    let val = {} as Immutable<Array<{a: string}>>
+    exactType(val, {} as ReadonlyArray<{readonly a: string}>)
+}
+
+// object in object
+{
+    let val = {} as Immutable<{a: {b: string}}>
+    exactType(val, {} as {readonly a: {readonly b: string}})
+}

__tests__/produce.ts

@@ -3,7 +3,8 @@ import produce, {
     applyPatches,
     Patch,
     nothing,
-    Draft
+    Draft,
+    Immutable
 } from "../dist/immer.js"
 
 // prettier-ignore
@@ -72,7 +73,7 @@ it("can update readonly state via standard api", () => {
 it("can infer state type from default state", () => {
     type Producer = <T>(
         base: (Draft<T> extends number ? T : number) | undefined
-    ) => number
+    ) => Immutable<T>
     let foo = produce(_ => {}, 1)
     exactType(foo, {} as Producer)
     exactType(foo(2), 0 as number)
@@ -83,11 +84,12 @@ it("can infer state type from recipe function", () => {
     type Producer = <T>(
         base: (Draft<T> extends Base ? T : Base) | undefined,
         _2: number
-    ) => Base
+    ) => Immutable<T>
 
     let foo = produce((_: string | number, _2: number) => {}, 1)
     exactType(foo, {} as Producer)
-    exactType(foo("", 0), {} as string | number)
+    exactType(foo("", 0), {} as string)
+    exactType(foo(0, 0), {} as number)
 })
 
 it("cannot infer state type when the function type and default state are missing", () => {
@@ -146,7 +148,7 @@ it("can provide rest parameters to a curried producer", () => {
         base: Draft<T> extends {} ? T : object,
         _2: number,
         _3: number
-    ) => object
+    ) => Immutable<T>
     let foo = produce((_1: object, _2: number, _3: number) => {})
     exactType(foo, {} as Foo)
     foo({}, 1, 2)
@@ -156,7 +158,7 @@ it("can provide rest parameters to a curried producer", () => {
         base: (Draft<T> extends {} ? T : object) | undefined,
         _2: number,
         _3: number
-    ) => object
+    ) => Immutable<T>
     let bar = produce((_1: object, _2: number, _3: number) => {}, {})
     exactType(bar, {} as Bar)
     bar(undefined, 1, 2)

src/immer.d.ts

@@ -58,10 +58,25 @@ type FromNothing<T> = Nothing extends T ? Exclude<T, Nothing> | undefined : T
 /** The inferred return type of `produce` */
 type Produced<Base, Return> = 1 extends HasVoidLike<Return>
     ? 1 extends IsVoidLike<Return>
-        ? Base
-        : Base | FromNothing<Exclude<Return, void>>
+        ? Immutable<Base>
+        : Immutable<Base> | FromNothing<Exclude<Return, void>>
     : FromNothing<Return>
 
+type ImmutableTuple<T extends ReadonlyArray<any>> = {
+    readonly [P in keyof T]: Immutable<T[P]>
+}
+
+/** Convert a mutable type into a readonly type */
+export type Immutable<T> = T extends object
+    ? T extends AtomicObject
+        ? T
+        : T extends ReadonlyArray<any>
+        ? Array<T[number]> extends T
+            ? {[P in keyof T]: ReadonlyArray<Immutable<T[number]>>}[keyof T]
+            : ImmutableTuple<T>
+        : {readonly [P in keyof T]: Immutable<T[P]>}
+    : T
+
 export interface IProduce {
     /**
      * The `produce` function takes a value and a "recipe function" (whose