type-fest 3.12.0 → 3.13.0

package/index.d.ts

@@ -79,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.12.0",
+	"version": "3.13.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",

package/readme.md

@@ -144,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