type-fest 3.12.0 → 3.13.1

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.1",
 	"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/internal.d.ts

@@ -235,8 +235,8 @@ Needed to handle the case of a single call signature with properties.
 Multiple call signatures cannot currently be supported due to a TypeScript limitation.
 @see https://github.com/microsoft/TypeScript/issues/29732
 */
-export type HasMultipleCallSignatures<T extends (...arguments: any[]) => unknown> =
-	T extends {(...arguments: infer A): unknown; (...arguments: any[]): unknown}
+export type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> =
+	T extends {(...arguments_: infer A): unknown; (...arguments_: any[]): unknown}
 		? unknown[] extends A
 			? false
 			: true

package/source/partial-deep.d.ts

@@ -69,7 +69,7 @@ export type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends
 				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
 				: T extends ReadonlySet<infer ItemType>
 					? PartialReadonlySetDeep<ItemType, Options>
-					: T extends ((...arguments: any[]) => unknown)
+					: T extends ((...arguments_: any[]) => unknown)
 						? T | undefined
 						: T extends object
 							? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156

package/source/partial-on-undefined-deep.d.ts

@@ -55,7 +55,7 @@ export type PartialOnUndefinedDeep<T, Options extends PartialOnUndefinedDeepOpti
 /**
 Utility type to get the value type by key and recursively call `PartialOnUndefinedDeep` to transform sub-objects.
 */
-type PartialOnUndefinedDeepValue<T, Options extends PartialOnUndefinedDeepOptions> = T extends BuiltIns | ((...arguments: any[]) => unknown)
+type PartialOnUndefinedDeepValue<T, Options extends PartialOnUndefinedDeepOptions> = T extends BuiltIns | ((...arguments_: any[]) => unknown)
 	? T
 	: T extends ReadonlyArray<infer U> // Test if type is array or tuple
 		? Options['recurseIntoArrays'] extends true // Check if option is activated

package/source/readonly-deep.d.ts

@@ -38,12 +38,12 @@ Note that types containing overloaded functions are not made deeply readonly due
 */
 export type ReadonlyDeep<T> = T extends BuiltIns
 	? T
-	: T extends (...arguments: any[]) => unknown
+	: T extends (...arguments_: any[]) => unknown
 		? {} extends ReadonlyObjectDeep<T>
 			? T
 			: HasMultipleCallSignatures<T> extends true
 				? T
-				: ((...arguments: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T>
+				: ((...arguments_: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T>
 		: T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>>
 			? ReadonlyMapDeep<KeyType, ValueType>
 			: T extends Readonly<ReadonlySet<infer ItemType>>

package/source/required-deep.d.ts

@@ -59,12 +59,12 @@ export type RequiredDeep<T, E extends ExcludeUndefined<T> = ExcludeUndefined<T>>
 							? WeakSet<RequiredDeep<ItemType>>
 							: E extends Promise<infer ValueType>
 								? Promise<RequiredDeep<ValueType>>
-								: E extends (...args: any[]) => unknown
+								: E extends (...arguments_: any[]) => unknown
 									? {} extends RequiredObjectDeep<E>
 										? E
 										: HasMultipleCallSignatures<E> extends true
 											? E
-											: ((...arguments: Parameters<E>) => ReturnType<E>) & RequiredObjectDeep<E>
+											: ((...arguments_: Parameters<E>) => ReturnType<E>) & RequiredObjectDeep<E>
 									: E extends object
 										? E extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
 											? ItemType[] extends E // Test for arrays (non-tuples) specifically

package/source/schema.d.ts

@@ -51,7 +51,7 @@ export type Schema<ObjectType, ValueType> = ObjectType extends string
 						? ValueType
 						: ObjectType extends unknown[]
 							? ValueType
-							: ObjectType extends (...arguments: unknown[]) => unknown
+							: ObjectType extends (...arguments_: unknown[]) => unknown
 								? ValueType
 								: ObjectType extends Date
 									? ValueType

package/source/writable-deep.d.ts

@@ -32,12 +32,12 @@ Note that types containing overloaded functions are not made deeply writable due
 */
 export type WritableDeep<T> = T extends BuiltIns
 	? T
-	: T extends (...arguments: any[]) => unknown
+	: T extends (...arguments_: any[]) => unknown
 		? {} extends WritableObjectDeep<T>
 			? T
 			: HasMultipleCallSignatures<T> extends true
 				? T
-				: ((...arguments: Parameters<T>) => ReturnType<T>) & WritableObjectDeep<T>
+				: ((...arguments_: Parameters<T>) => ReturnType<T>) & WritableObjectDeep<T>
 		: T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>>
 			? WritableMapDeep<KeyType, ValueType>
 			: T extends Readonly<ReadonlySet<infer ItemType>>