type-fest 3.11.1 → 3.13.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';
@@ -78,7 +79,9 @@ export type {HasOptionalKeys} from './source/has-optional-keys';
 export type {RequiredKeysOf} from './source/required-keys-of';
 export type {HasRequiredKeys} from './source/has-required-keys';
 export type {ReadonlyKeysOf} from './source/readonly-keys-of';
+export type {HasReadonlyKeys} from './source/has-readonly-keys';
 export type {WritableKeysOf} from './source/writable-keys-of';
+export type {HasWritableKeys} from './source/has-writable-keys';
 export type {Spread} from './source/spread';
 export type {TupleToUnion} from './source/tuple-to-union';
 export type {IsEqual} from './source/is-equal';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "3.11.1",
+	"version": "3.13.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.
@@ -143,8 +144,10 @@ Click the type names for complete docs.
 - [`HasOptionalKeys`](source/has-optional-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any optional fields.
 - [`RequiredKeysOf`](source/required-keys-of.d.ts) - Extract all required keys from the given type.
 - [`HasRequiredKeys`](source/has-required-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any required fields.
-- [`ReadonlyKeysOf`](source/readonly-keys-of.d.ts) - Extract all writable (non-readonly) keys from the given type.
-- [`WritableKeysOf`](source/writable-keys-of.d.ts) - Extract all readonly keys from the given type.
+- [`ReadonlyKeysOf`](source/readonly-keys-of.d.ts) - Extract all readonly keys from the given type.
+- [`HasReadonlyKeys`](source/has-readonly-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any readonly fields.
+- [`WritableKeysOf`](source/writable-keys-of.d.ts) - Extract all writable (non-readonly) keys from the given type.
+- [`HasWritableKeys`](source/has-writable-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any writable fields.
 - [`Spread`](source/spread.d.ts) - Mimic the type inferred by TypeScript when merging two objects or two arrays/tuples using the spread syntax.
 - [`IsEqual`](source/is-equal.d.ts) - Returns a boolean for whether the two given types are equal.
 - [`TaggedUnion`](source/tagged-union.d.ts) - Create a union of types that share a common discriminant property.

package/source/basic.d.ts

@@ -3,7 +3,10 @@ Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe
 
 @category Class
 */
-export type Class<T, Arguments extends unknown[] = any[]> = Constructor<T, Arguments> & {prototype: T};
+export type Class<T, Arguments extends unknown[] = any[]> = {
+	prototype: T;
+	new(...arguments_: Arguments): T;
+};
 
 /**
 Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
@@ -16,8 +19,14 @@ export type Constructor<T, Arguments extends unknown[] = any[]> = new(...argumen
 Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/classes.html#abstract-classes).
 
 @category Class
+
+@privateRemarks
+We cannot use a `type` here because TypeScript throws: 'abstract' modifier cannot appear on a type member. (1070)
 */
-export type AbstractClass<T, Arguments extends unknown[] = any[]> = AbstractConstructor<T, Arguments> & {prototype: T};
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+export interface AbstractClass<T, Arguments extends unknown[] = any[]> extends AbstractConstructor<T, Arguments> {
+	prototype: T;
+}
 
 /**
 Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html#abstract-construct-signatures) constructor.

package/source/has-readonly-keys.d.ts

@@ -0,0 +1,21 @@
+import type {ReadonlyKeysOf} from './readonly-keys-of';
+
+/**
+Creates a type that represents `true` or `false` depending on whether the given type has any readonly fields.
+
+This is useful when you want to create an API whose behavior depends on the presence or absence of readonly fields.
+
+@example
+```
+import type {HasReadonlyKeys, ReadonlyKeysOf} from 'type-fest';
+
+type UpdateService<Entity extends object> = {
+	removeField: HasReadonlyKeys<Entity> extends true
+		? (field: ReadonlyKeysOf<Entity>) => Promise<void>
+		: never
+}
+```
+
+@category Utilities
+*/
+export type HasReadonlyKeys<BaseType extends object> = ReadonlyKeysOf<BaseType> extends never ? false : true;

package/source/has-writable-keys.d.ts

@@ -0,0 +1,21 @@
+import type {WritableKeysOf} from './writable-keys-of';
+
+/**
+Creates a type that represents `true` or `false` depending on whether the given type has any writable fields.
+
+This is useful when you want to create an API whose behavior depends on the presence or absence of writable fields.
+
+@example
+```
+import type {HasWritableKeys, WritableKeysOf} from 'type-fest';
+
+type UpdateService<Entity extends object> = {
+	removeField: HasWritableKeys<Entity> extends true
+		? (field: WritableKeysOf<Entity>) => Promise<void>
+		: never
+}
+```
+
+@category Utilities
+*/
+export type HasWritableKeys<BaseType extends object> = WritableKeysOf<BaseType> extends never ? false : true;

package/source/jsonify.d.ts

@@ -1,16 +1,26 @@
 import type {JsonPrimitive, JsonValue} from './basic';
 import type {EmptyObject} from './empty-object';
 import type {UndefinedToOptional} from './internal';
+import type {IsAny} from './is-any';
+import type {IsNever} from './is-never';
 import type {NegativeInfinity, PositiveInfinity} from './numeric';
 import type {TypedArray} from './typed-array';
-import type {IsAny} from './is-any';
 
 // Note: The return value has to be `any` and not `unknown` so it can match `void`.
 type NotJsonable = ((...arguments_: any[]) => any) | undefined | symbol;
 
-type JsonifyTuple<T extends [unknown, ...unknown[]]> = {
-	[Key in keyof T]: T[Key] extends NotJsonable ? null : Jsonify<T[Key]>;
-};
+type FilterNonNever<T extends unknown[]> = T extends [infer F, ...infer R]
+	? IsNever<F> extends true
+		? FilterNonNever<R>
+		: [F, ...FilterNonNever<R>]
+	: IsNever<T[number]> extends true
+		? []
+		: T;
+
+// Handles tuples and arrays
+type JsonifyList<T extends unknown[]> = T extends [infer F, ...infer R]
+	? FilterNonNever<[Jsonify<F>, ...JsonifyList<R>]>
+	: Array<Jsonify<T[number]>>;
 
 type FilterJsonableKeys<T extends object> = {
 	[Key in keyof T]: T[Key] extends NotJsonable ? never : Key;
@@ -107,7 +117,7 @@ export type Jsonify<T> = IsAny<T> extends true
 										: T extends []
 											? []
 											: T extends [unknown, ...unknown[]]
-												? JsonifyTuple<T>
+												? JsonifyList<T>
 												: T extends ReadonlyArray<infer U>
 													? Array<U extends NotJsonable ? null : Jsonify<U>>
 													: T extends object

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;