type-fest 4.7.0 → 4.8.0

package/package.json

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

package/source/basic.d.ts

@@ -4,7 +4,7 @@ Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe
 @category Class
 */
 export type Class<T, Arguments extends unknown[] = any[]> = {
-	prototype: T;
+	prototype: Pick<T, keyof T>;
 	new(...arguments_: Arguments): T;
 };
 
@@ -25,7 +25,7 @@ We cannot use a `type` here because TypeScript throws: 'abstract' modifier canno
 */
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
 export interface AbstractClass<T, Arguments extends unknown[] = any[]> extends AbstractConstructor<T, Arguments> {
-	prototype: T;
+	prototype: Pick<T, keyof T>;
 }
 
 /**

package/source/delimiter-cased-properties-deep.d.ts

@@ -1,4 +1,5 @@
 import type {DelimiterCase} from './delimiter-case';
+import type {UnknownArray} from './unknown-array';
 
 /**
 Convert object properties to delimiter case recursively.
@@ -49,12 +50,34 @@ export type DelimiterCasedPropertiesDeep<
 	Delimiter extends string,
 > = Value extends Function | Date | RegExp
 	? Value
-	: Value extends Array<infer U>
-		? Array<DelimiterCasedPropertiesDeep<U, Delimiter>>
-		: Value extends Set<infer U>
-			? Set<DelimiterCasedPropertiesDeep<U, Delimiter>> : {
-				[K in keyof Value as DelimiterCase<
-				K,
-				Delimiter
-				>]: DelimiterCasedPropertiesDeep<Value[K], Delimiter>;
-			};
+	: Value extends string
+		? DelimiterCase<Value, Delimiter>
+		: Value extends UnknownArray
+			? DelimiterCasedPropertiesArrayDeep<Value, Delimiter>
+			: Value extends Set<infer U>
+				? Set<DelimiterCasedPropertiesDeep<U, Delimiter>> : {
+					[K in keyof Value as DelimiterCase<
+					K,
+					Delimiter
+					>]: DelimiterCasedPropertiesDeep<Value[K], Delimiter>;
+				};
+
+type DelimiterCasedPropertiesArrayDeep<Value extends UnknownArray, Delimiter extends string> =
+	Value extends []
+		? []
+		// Tailing spread array
+		:	Value extends [infer U, ...infer V]
+			? [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>]
+			: Value extends readonly [infer U, ...infer V]
+				? readonly [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>]
+				// Leading spread array
+				: Value extends readonly [...infer U, infer V]
+					? [...DelimiterCasedPropertiesDeep<U, Delimiter>, DelimiterCasedPropertiesDeep<V, Delimiter>]
+					: Value extends readonly [...infer U, infer V]
+						? readonly [...DelimiterCasedPropertiesDeep<U, Delimiter>, DelimiterCasedPropertiesDeep<V, Delimiter>]
+						// Array
+						: Value extends Array<infer U>
+							? Array<DelimiterCasedPropertiesDeep<U, Delimiter>>
+							: Value extends ReadonlyArray<infer U>
+								? ReadonlyArray<DelimiterCasedPropertiesDeep<U, Delimiter>>
+								: never;

package/source/internal.d.ts

@@ -40,7 +40,7 @@ type B = BuildObject<'a', string, {readonly a?: any}>;
 //=> {readonly a?: string}
 ```
 */
-export type BuildObject<Key extends PropertyKey, Value, CopiedFrom extends UnknownRecord = {}> =
+export type BuildObject<Key extends PropertyKey, Value, CopiedFrom extends object = {}> =
 	Key extends keyof CopiedFrom
 		? Pick<{[_ in keyof CopiedFrom]: Value}, Key>
 		: Key extends `${infer NumberKey extends number}`
@@ -67,9 +67,14 @@ export type Subtract<A extends number, B extends number> = BuildTuple<A> extends
 	: never;
 
 /**
-Matches any primitive, `Date`, or `RegExp` value.
+Matches any primitive, `Date`, `RegExp`, `Element` value.
 */
-export type BuiltIns = Primitive | Date | RegExp;
+export type BuiltIns = Primitive | Date | RegExp | Element;
+
+/**
+Matches non-recursive types.
+*/
+export type NonRecursiveType = BuiltIns | Function | (new (...args: any[]) => unknown);
 
 export type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
 
@@ -150,7 +155,16 @@ Extract the object field type if T is an object and K is a key of T, return `nev
 
 It creates a type-safe way to access the member type of `unknown` type.
 */
-export type ObjectValue<T, K> = K extends keyof T ? T[K] : never;
+export type ObjectValue<T, K> =
+	K extends keyof T
+		? T[K]
+		: ToString<K> extends keyof T
+			? T[ToString<K>]
+			: K extends `${infer NumberK extends number}`
+				? NumberK extends keyof T
+					? T[NumberK]
+					: never
+				: never;
 
 /**
 Returns a boolean for whether the string is lowercased.

package/source/jsonifiable.d.ts

@@ -1,4 +1,4 @@
-import type {JsonPrimitive, JsonValue} from './basic';
+import type {JsonPrimitive} from './basic';
 
 type JsonifiableObject = {[Key in string]?: Jsonifiable} | {toJSON: () => Jsonifiable};
 type JsonifiableArray = readonly Jsonifiable[];

package/source/partial-deep.d.ts

@@ -1,4 +1,4 @@
-import type {BuiltIns, UnknownRecord} from './internal';
+import type {BuiltIns} from './internal';
 
 /**
 @see PartialDeep
@@ -69,9 +69,8 @@ export type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends
 				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
 				: T extends ReadonlySet<infer ItemType>
 					? PartialReadonlySetDeep<ItemType, Options>
-					: T extends UnknownRecord
-						? PartialObjectDeep<T, Options>
-						: T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+					: T extends object
+						? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
 							? Options['recurseIntoArrays'] extends true
 								? ItemType[] extends T // Test for arrays (non-tuples) specifically
 									? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
@@ -79,7 +78,8 @@ export type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends
 										: Array<PartialDeep<ItemType | undefined, Options>>
 									: PartialObjectDeep<T, Options> // Tuples behave properly
 								: T // If they don't opt into array testing, just use the original type
-							: T;
+							: PartialObjectDeep<T, Options>
+						: unknown;
 
 /**
 Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.

package/source/pascal-case.d.ts

@@ -1,4 +1,4 @@
-import type {CamelCase} from './camel-case';
+import type {CamelCase, CamelCaseOptions} from './camel-case';
 
 /**
 Converts a string literal to pascal-case.
@@ -33,6 +33,6 @@ const dbResult: CamelCasedProperties<ModelProps> = {
 @category Change case
 @category Template literal
 */
-export type PascalCase<Value> = CamelCase<Value> extends string
-	? Capitalize<CamelCase<Value>>
-	: CamelCase<Value>;
+export type PascalCase<Value, Options extends CamelCaseOptions = {preserveConsecutiveUppercase: true}> = CamelCase<Value, Options> extends string
+	? Capitalize<CamelCase<Value, Options>>
+	: CamelCase<Value, Options>;

package/source/pascal-cased-properties-deep.d.ts

@@ -1,3 +1,4 @@
+import type {CamelCaseOptions} from './camel-case';
 import type {PascalCase} from './pascal-case';
 
 /**
@@ -44,11 +45,11 @@ const result: PascalCasedPropertiesDeep<UserWithFriends> = {
 @category Template literal
 @category Object
 */
-export type PascalCasedPropertiesDeep<Value> = Value extends Function | Date | RegExp
+export type PascalCasedPropertiesDeep<Value, Options extends CamelCaseOptions = {preserveConsecutiveUppercase: true}> = Value extends Function | Date | RegExp
 	? Value
 	: Value extends Array<infer U>
-		? Array<PascalCasedPropertiesDeep<U>>
+		? Array<PascalCasedPropertiesDeep<U, Options>>
 		: Value extends Set<infer U>
-			? Set<PascalCasedPropertiesDeep<U>> : {
-				[K in keyof Value as PascalCase<K>]: PascalCasedPropertiesDeep<Value[K]>;
+			? Set<PascalCasedPropertiesDeep<U, Options>> : {
+				[K in keyof Value as PascalCase<K, Options>]: PascalCasedPropertiesDeep<Value[K], Options>;
 			};

package/source/pascal-cased-properties.d.ts

@@ -1,3 +1,4 @@
+import type {CamelCaseOptions} from './camel-case';
 import type {PascalCase} from './pascal-case';
 
 /**
@@ -27,8 +28,8 @@ const result: PascalCasedProperties<User> = {
 @category Template literal
 @category Object
 */
-export type PascalCasedProperties<Value> = Value extends Function
+export type PascalCasedProperties<Value, Options extends CamelCaseOptions = {preserveConsecutiveUppercase: true}> = Value extends Function
 	? Value
 	: Value extends Array<infer U>
 		? Value
-		: {[K in keyof Value as PascalCase<K>]: Value[K]};
+		: {[K in keyof Value as PascalCase<K, Options>]: Value[K]};

package/source/paths.d.ts

@@ -1,9 +1,8 @@
-import type {ToString} from './internal';
+import type {NonRecursiveType, ToString} from './internal';
 import type {EmptyObject} from './empty-object';
 import type {IsAny} from './is-any';
 import type {IsNever} from './is-never';
 import type {UnknownArray} from './unknown-array';
-import type {UnknownRecord} from './unknown-record';
 
 /**
 Return the part of the given array with a fixed index.
@@ -78,30 +77,35 @@ open('listB.1'); // TypeError. Because listB only has one element.
 @category Object
 @category Array
 */
-export type Paths<T extends UnknownRecord | UnknownArray> =
-	IsAny<T> extends true
+export type Paths<T> =
+	T extends NonRecursiveType
 		? never
-		: T extends UnknownArray
-			? number extends T['length']
-				// We need to handle the fixed and non-fixed index part of the array separately.
-				? InternalPaths<FilterFixedIndexArray<T>>
-				| InternalPaths<Array<FilterNotFixedIndexArray<T>[number]>>
-				: InternalPaths<T>
-			: InternalPaths<T>;
+		: IsAny<T> extends true
+			? never
+			: T extends UnknownArray
+				? number extends T['length']
+					// We need to handle the fixed and non-fixed index part of the array separately.
+					? InternalPaths<FilterFixedIndexArray<T>>
+					| InternalPaths<Array<FilterNotFixedIndexArray<T>[number]>>
+					: InternalPaths<T>
+				: T extends object
+					? InternalPaths<T>
+					: never;
 
-export type InternalPaths<_T extends UnknownRecord | UnknownArray, T = Required<_T>> =
+export type InternalPaths<_T, T = Required<_T>> =
 	T extends EmptyObject | readonly []
 		? never
 		: {
 			[Key in keyof T]:
 			Key extends string | number // Limit `Key` to string or number.
-				? T[Key] extends UnknownRecord | UnknownArray
-					? (
-						IsNever<Paths<T[Key]>> extends false
-							// If `Key` is a number, return `Key | `${Key}``, because both `array[0]` and `array['0']` work.
-							? Key | ToString<Key> | `${Key}.${Paths<T[Key]>}`
-							: Key | ToString<Key>
-					)
-					: Key | ToString<Key>
+				// If `Key` is a number, return `Key | `${Key}``, because both `array[0]` and `array['0']` work.
+				?
+				| Key
+				| ToString<Key>
+				| (
+					IsNever<Paths<T[Key]>> extends false
+						? `${Key}.${Paths<T[Key]>}`
+						: never
+				)
 				: never
 		}[keyof T & (T extends UnknownArray ? number : unknown)];

package/source/pick-deep.d.ts

@@ -1,9 +1,9 @@
-import type {BuildObject, BuildTuple, ToString} from './internal';
+import type {BuildObject, BuildTuple, NonRecursiveType, ObjectValue} from './internal';
+import type {IsNever} from './is-never';
 import type {Paths} from './paths';
 import type {Simplify} from './simplify.d';
 import type {UnionToIntersection} from './union-to-intersection.d';
 import type {UnknownArray} from './unknown-array';
-import type {UnknownRecord} from './unknown-record.d';
 
 /**
 Pick properties from a deeply-nested object.
@@ -37,7 +37,8 @@ type Configuration = {
 type NameConfig = PickDeep<Configuration, 'userConfig.name'>;
 // type NameConfig = {
 // 	userConfig: {
-// 	name: string;
+// 		name: string;
+// 	}
 // };
 
 // Supports optional properties
@@ -50,7 +51,7 @@ type User = PickDeep<PartialDeep<Configuration>, 'userConfig.name' | 'userConfig
 // };
 
 // Supports array
-type AddressConfig = PickDeep<Configuration, `userConfig.address.0`>;
+type AddressConfig = PickDeep<Configuration, 'userConfig.address.0'>;
 // type AddressConfig = {
 // 	userConfig: {
 // 		address: [{
@@ -61,8 +62,8 @@ type AddressConfig = PickDeep<Configuration, `userConfig.address.0`>;
 // }
 
 // Supports recurse into array
-type Street = PickDeep<Configuration, `userConfig.address.1.street2`>;
-// type AddressConfig = {
+type Street = PickDeep<Configuration, 'userConfig.address.1.street2'>;
+// type Street = {
 // 	userConfig: {
 // 		address: [
 // 			unknown,
@@ -75,37 +76,44 @@ type Street = PickDeep<Configuration, `userConfig.address.1.street2`>;
 @category Object
 @category Array
 */
-export type PickDeep<T extends UnknownRecord | UnknownArray, PathUnion extends Paths<T>> =
-	T extends UnknownRecord
-		? Simplify<UnionToIntersection<{
-			[P in PathUnion]: InternalPickDeep<T, P>;
-		}[PathUnion]>>
+export type PickDeep<T, PathUnion extends Paths<T>> =
+	T extends NonRecursiveType
+		? never
 		: T extends UnknownArray
 			? UnionToIntersection<{
 				[P in PathUnion]: InternalPickDeep<T, P>;
 			}[PathUnion]
 			>
-			: never;
+			: T extends object
+				? Simplify<UnionToIntersection<{
+					[P in PathUnion]: InternalPickDeep<T, P>;
+				}[PathUnion]>>
+				: never;
 
 /**
 Pick an object/array from the given object/array by one path.
 */
-type InternalPickDeep<
-	T extends UnknownRecord | UnknownArray,
-	Path extends string | number, // Checked paths, extracted from unchecked paths
-> =
-	T extends UnknownArray ? PickDeepArray<T, Path>
-		: T extends UnknownRecord ? Simplify<PickDeepObject<T, Path>>
-			: never;
+type InternalPickDeep<T, Path extends string | number> =
+	T extends NonRecursiveType
+		? never
+		: T extends UnknownArray ? PickDeepArray<T, Path>
+			: T extends object ? Simplify<PickDeepObject<T, Path>>
+				: never;
 
 /**
 Pick an object from the given object by one path.
 */
-type PickDeepObject<RecordType extends UnknownRecord, P extends string | number> =
+type PickDeepObject<RecordType extends object, P extends string | number> =
 	P extends `${infer RecordKeyInPath}.${infer SubPath}`
-		? BuildObject<RecordKeyInPath, InternalPickDeep<NonNullable<RecordType[RecordKeyInPath]>, SubPath>, RecordType>
-		: P extends keyof RecordType | ToString<keyof RecordType> // Handle number keys
-			? BuildObject<P, RecordType[P], RecordType>
+		? ObjectValue<RecordType, RecordKeyInPath> extends infer ObjectV
+			? IsNever<ObjectV> extends false
+				? BuildObject<RecordKeyInPath, InternalPickDeep<NonNullable<ObjectV>, SubPath>, RecordType>
+				: never
+			: never
+		: ObjectValue<RecordType, P> extends infer ObjectV
+			? IsNever<ObjectV> extends false
+				? BuildObject<P, ObjectV, RecordType>
+				: never
 			: never;
 
 /**