fix: improve higher order type inference for WritableDraft

Author: unional

__tests__/produce.ts

@@ -200,8 +200,10 @@ describe("curried producer", () => {
 		// With initial state:
 		{
 			type Recipe = (state?: State | undefined, ...rest: number[]) => State
-			let bar = produce((state: Draft<State>, ...args: number[]) => {},
-			_ as State)
+			let bar = produce(
+				(state: Draft<State>, ...args: number[]) => {},
+				_ as State
+			)
 			assert(bar, _ as Recipe)
 			bar(_ as State, 1, 2)
 			bar(_ as State)
@@ -532,7 +534,7 @@ it("infers draft, #720 - 2", () => {
 	function useState<S>(
 		initialState: S | (() => S)
 	): [S, Dispatch<SetStateAction<S>>] {
-		return [initialState, function() {}] as any
+		return [initialState, function () {}] as any
 	}
 	type Dispatch<A> = (value: A) => void
 	type SetStateAction<S> = S | ((prevState: S) => S)
@@ -569,7 +571,7 @@ it("infers draft, #720 - 3", () => {
 	function useState<S>(
 		initialState: S | (() => S)
 	): [S, Dispatch<SetStateAction<S>>] {
-		return [initialState, function() {}] as any
+		return [initialState, function () {}] as any
 	}
 	type Dispatch<A> = (value: A) => void
 	type SetStateAction<S> = S | ((prevState: S) => S)
@@ -758,3 +760,15 @@ it("allows for mixed property value types", () => {
 		}
 	})
 })
+
+it("allows higher order type inference", () => {
+	function _test<A>() {
+		type S = {prop: A | undefined}
+		produce(
+			draft => {
+				draft.prop = undefined
+			},
+			{prop: undefined} as S
+		)
+	}
+})

src/types/types-external.ts

@@ -16,13 +16,11 @@ type AtomicObject = Function | Promise<any> | Date | RegExp
  */
 export type IfAvailable<T, Fallback = void> =
 	// fallback if any
-	true | false extends (T extends never
-	? true
-	: false)
+	true | false extends (T extends never ? true : false)
 		? Fallback // fallback if empty type
 		: keyof T extends never
-		? Fallback // original type
-		: T
+			? Fallback // original type
+			: T
 
 /**
  * These should also never be mapped but must be tested after regular Map and
@@ -37,7 +35,7 @@ export type WritableDraft<T> = T extends any[]
 	: WritableNonArrayDraft<T>
 
 type WritableNonArrayDraft<T> = {
-	-readonly [K in keyof T]: T[K] extends infer V
+	-readonly [K in keyof T]: {_: T[K]} extends {_: infer V}
 		? V extends object
 			? Draft<V>
 			: V
@@ -48,31 +46,31 @@ type WritableNonArrayDraft<T> = {
 export type Draft<T> = T extends PrimitiveType
 	? T
 	: T extends AtomicObject
-	? T
-	: T extends ReadonlyMap<infer K, infer V> // Map extends ReadonlyMap
-	? Map<Draft<K>, Draft<V>>
-	: T extends ReadonlySet<infer V> // Set extends ReadonlySet
-	? Set<Draft<V>>
-	: T extends WeakReferences
-	? T
-	: T extends object
-	? WritableDraft<T>
-	: T
+		? T
+		: T extends ReadonlyMap<infer K, infer V> // Map extends ReadonlyMap
+			? Map<Draft<K>, Draft<V>>
+			: T extends ReadonlySet<infer V> // Set extends ReadonlySet
+				? Set<Draft<V>>
+				: T extends WeakReferences
+					? T
+					: T extends object
+						? WritableDraft<T>
+						: T
 
 /** Convert a mutable type into a readonly type */
 export type Immutable<T> = T extends PrimitiveType
 	? T
 	: T extends AtomicObject
-	? T
-	: T extends ReadonlyMap<infer K, infer V> // Map extends ReadonlyMap
-	? ReadonlyMap<Immutable<K>, Immutable<V>>
-	: T extends ReadonlySet<infer V> // Set extends ReadonlySet
-	? ReadonlySet<Immutable<V>>
-	: T extends WeakReferences
-	? T
-	: T extends object
-	? {readonly [K in keyof T]: Immutable<T[K]>}
-	: T
+		? T
+		: T extends ReadonlyMap<infer K, infer V> // Map extends ReadonlyMap
+			? ReadonlyMap<Immutable<K>, Immutable<V>>
+			: T extends ReadonlySet<infer V> // Set extends ReadonlySet
+				? ReadonlySet<Immutable<V>>
+				: T extends WeakReferences
+					? T
+					: T extends object
+						? {readonly [K in keyof T]: Immutable<T[K]>}
+						: T
 
 export interface Patch {
 	op: "replace" | "remove" | "add"
@@ -117,7 +115,7 @@ type InferRecipeFromCurried<Curried> = Curried extends (
 		? (
 				draft: Draft<State>,
 				...rest: Args
-		  ) => ValidRecipeReturnType<Draft<State>>
+			) => ValidRecipeReturnType<Draft<State>>
 		: never
 	: never
 
@@ -136,7 +134,7 @@ type InferCurriedFromRecipe<
 		? (
 				base: Immutable<DraftState>,
 				...args: RestArgs
-		  ) => ReturnTypeWithPatchesIfNeeded<DraftState, UsePatches> // N.b. we return mutable draftstate, in case the recipe's first arg isn't read only, and that isn't expected as output either
+			) => ReturnTypeWithPatchesIfNeeded<DraftState, UsePatches> // N.b. we return mutable draftstate, in case the recipe's first arg isn't read only, and that isn't expected as output either
 		: never // incorrect return type
 	: never // not a function
 
@@ -151,7 +149,7 @@ type InferCurriedFromInitialStateAndRecipe<
 	? (
 			base?: State | undefined,
 			...args: RestArgs
-	  ) => ReturnTypeWithPatchesIfNeeded<State, UsePatches>
+		) => ReturnTypeWithPatchesIfNeeded<State, UsePatches>
 	: never // recipe doesn't match initial state
 
 /**
@@ -181,10 +179,9 @@ export interface IProduce {
 	): Curried
 
 	/** Curried producer that infers curried from the recipe  */
-	<Recipe extends AnyFunc>(recipe: Recipe): InferCurriedFromRecipe<
-		Recipe,
-		false
-	>
+	<Recipe extends AnyFunc>(
+		recipe: Recipe
+	): InferCurriedFromRecipe<Recipe, false>
 
 	/** Curried producer that infers curried from the State generic, which is explicitly passed in.  */
 	<State>(
@@ -200,9 +197,9 @@ export interface IProduce {
 		) => ValidRecipeReturnType<State>,
 		initialState: State
 	): (state?: State, ...args: Args) => State
-	<State>(recipe: (state: Draft<State>) => ValidRecipeReturnType<State>): (
-		state: State
-	) => State
+	<State>(
+		recipe: (state: Draft<State>) => ValidRecipeReturnType<State>
+	): (state: State) => State
 	<State, Args extends any[]>(
 		recipe: (state: Draft<State>, ...args: Args) => ValidRecipeReturnType<State>
 	): (state: State, ...args: Args) => State