type-fest 3.11.1 → 3.12.0

package/index.d.ts

@@ -33,6 +33,7 @@ export type {Promisable} from './source/promisable';
 export type {Opaque, UnwrapOpaque} from './source/opaque';
 export type {InvariantOf} from './source/invariant-of';
 export type {SetOptional} from './source/set-optional';
+export type {SetReadonly} from './source/set-readonly';
 export type {SetRequired} from './source/set-required';
 export type {SetNonNullable} from './source/set-non-nullable';
 export type {ValueOf} from './source/value-of';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "3.11.1",
+	"version": "3.12.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",

package/readme.md

@@ -119,6 +119,7 @@ Click the type names for complete docs.
 - [`UnwrapOpaque`](source/opaque.d.ts) - Revert an [opaque type](https://codemix.com/opaque-types-in-javascript/) back to its original type.
 - [`InvariantOf`](source/invariant-of.d.ts) - Create an [invariant type](https://basarat.gitbook.io/typescript/type-system/type-compatibility#footnote-invariance), which is a type that does not accept supertypes and subtypes.
 - [`SetOptional`](source/set-optional.d.ts) - Create a type that makes the given keys optional.
+- [`SetReadonly`](source/set-readonly.d.ts) - Create a type that makes the given keys readonly.
 - [`SetRequired`](source/set-required.d.ts) - Create a type that makes the given keys required.
 - [`SetNonNullable`](source/set-non-nullable.d.ts) - Create a type that makes the given keys non-nullable.
 - [`ValueOf`](source/value-of.d.ts) - Create a union of the given object's values, and optionally specify which keys to get the values from.

package/source/set-readonly.d.ts

@@ -0,0 +1,38 @@
+import type {Except} from './except';
+import type {Simplify} from './simplify';
+
+/**
+Create a type that makes the given keys readonly. 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 readonly.
+
+@example
+```
+import type {SetReadonly} from 'type-fest';
+
+type Foo = {
+	a: number;
+	readonly b: string;
+	c: boolean;
+}
+
+type SomeReadonly = SetReadonly<Foo, 'b' | 'c'>;
+// type SomeReadonly = {
+// 	a: number;
+// 	readonly b: string; // Was already readonly and still is.
+// 	readonly c: boolean; // Is now readonly.
+// }
+```
+
+@category Object
+*/
+export type SetReadonly<BaseType, Keys extends keyof BaseType> =
+	// `extends unknown` is always going to be the case and is used to convert any
+	// union into a [distributive conditional
+	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+	BaseType extends unknown
+		? Simplify<
+		Except<BaseType, Keys> &
+		Readonly<Pick<BaseType, Keys>>
+		>
+		: never;