Add Mutable type

base.d.ts

@@ -32,6 +32,7 @@ export {Entry} from './source/entry';
 export {Entries} from './source/entries';
 export {SetReturnType} from './source/set-return-type';
 export {Asyncify} from './source/asyncify';
+export {SetMutable} from './source/set-mutable';
 
 // Miscellaneous
 export {PackageJson} from './source/package-json';

readme.md

@@ -87,6 +87,7 @@ Click the type names for complete docs.
 - [`Entries`](source/entries.d.ts) - Create a type that represents the type of the entries of a collection.
 - [`SetReturnType`](source/set-return-type.d.ts) - Create a function type with a return type of your choice and the same parameters as the given function type.
 - [`Asyncify`](source/asyncify.d.ts) - Create an async version of the given function type.
+- [`SetMutable`](source/set-mutable.d.ts) - Create a type that converts the given keys from `readonly` to mutable.
 
 ### Template literal types
 

source/set-mutable.d.ts

@@ -0,0 +1,35 @@
+import {Except} from './except';
+import {Mutable} from './mutable';
+
+/**
+Create a type that converts the given keys from `readonly` to mutable. The remaining keys are kept as is.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are mutable.
+
+@example
+```
+import {SetMutable} from 'type-fest';
+
+type Foo = {
+	readonly a: number;
+	b: string;
+	readonly c: boolean;
+}
+
+type SomeMutable = SetMutable<Foo, 'b' | 'c'>;
+// type SomeMutable = {
+// 	readonly a: number;
+// 	b: string; // Was already mutable and still is.
+// 	c: boolean; // Is now mutable.
+// }
+```
+*/
+export type SetMutable<BaseType, Keys extends keyof BaseType = keyof BaseType> =
+	// Pick just the keys that are not mutable from the base type.
+	Except<BaseType, Keys> &
+	// Pick the keys that should be mutable from the base type and make them mutable.
+	Mutable<Pick<BaseType, Keys>> extends
+	// If `InferredType` extends the previous, then for each key, use the inferred type key.
+	infer InferredType
+		? {[KeyType in keyof InferredType]: InferredType[KeyType]}
+		: never;

test-d/set-mutable.ts

@@ -0,0 +1,18 @@
+import {expectType, expectError} from 'tsd';
+import {SetMutable} from '..';
+
+// Update one required and one optional to required.
+declare const variation1: SetMutable<{readonly a: number; b: string; readonly c: boolean}, 'b' | 'c'>;
+expectType<{readonly a: number; b: string; c: boolean}>(variation1);
+
+// Update two optional to required.
+declare const variation2: SetMutable<{readonly a: number; readonly b: string; readonly c: boolean}, 'a' | 'b'>;
+expectType<{a: number; b: string; readonly c: boolean}>(variation2);
+
+// Three required remain required.
+declare const variation3: SetMutable<{a: number; b: string; c: boolean}, 'a' | 'b' | 'c'>;
+expectType<{a: number; b: string; c: boolean}>(variation3);
+
+// Fail if type changes even if optional is right.
+declare const variation4: SetMutable<{readonly a: number; b: string; readonly c: boolean}, 'b' | 'c'>;
+expectError<{readonly a: boolean; b: string; c: boolean}>(variation4);