type-fest 3.0.0 → 3.2.0

package/index.d.ts

@@ -9,6 +9,7 @@ export type {EmptyObject, IsEmptyObject} from './source/empty-object';
 export type {Except} from './source/except';
 export type {Writable} from './source/writable';
 export type {Merge} from './source/merge';
+export type {MergeDeep, MergeDeepOptions} from './source/merge-deep';
 export type {MergeExclusive} from './source/merge-exclusive';
 export type {RequireAtLeastOne} from './source/require-at-least-one';
 export type {RequireExactlyOne} from './source/require-exactly-one';
@@ -49,6 +50,7 @@ export type {SetReturnType} from './source/set-return-type';
 export type {Asyncify} from './source/asyncify';
 export type {Simplify} from './source/simplify';
 export type {Jsonify} from './source/jsonify';
+export type {Jsonifiable} from './source/jsonifiable';
 export type {Schema} from './source/schema';
 export type {LiteralToPrimitive} from './source/literal-to-primitive';
 export type {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "3.0.0",
+	"version": "3.2.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -35,10 +35,10 @@
 	],
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "~0.7.0",
-		"expect-type": "^0.14.2",
+		"expect-type": "^0.15.0",
 		"tsd": "^0.24.1",
-		"typescript": "^4.8.3",
-		"xo": "^0.52.2"
+		"typescript": "^4.8.4",
+		"xo": "^0.52.4"
 	},
 	"xo": {
 		"rules": {

package/readme.md

@@ -144,6 +144,7 @@ Click the type names for complete docs.
 - [`Except`](source/except.d.ts) - Create a type from an object type without certain keys. This is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys).
 - [`Writable`](source/writable.d.ts) - Create a type that strips `readonly` from all or some of an object's keys. The inverse of `Readonly<T>`.
 - [`Merge`](source/merge.d.ts) - Merge two types into a new type. Keys of the second type overrides keys of the first type.
+- [`MergeDeep`](source/merge-deep.d.ts) - Merge two objects or two arrays/tuples recursively into a new type.
 - [`MergeExclusive`](source/merge-exclusive.d.ts) - Create a type that has mutually exclusive keys.
 - [`RequireAtLeastOne`](source/require-at-least-one.d.ts) - Create a type that requires at least one of the given keys.
 - [`RequireExactlyOne`](source/require-exactly-one.d.ts) - Create a type that requires exactly a single key of the given keys and disallows more.
@@ -186,6 +187,7 @@ Click the type names for complete docs.
 ### JSON
 
 - [`Jsonify`](source/jsonify.d.ts) - Transform a type to one that is assignable to the `JsonValue` type.
+- [`Jsonifiable`](source/jsonifiable.d.ts) - Matches a value that can be losslessly converted to JSON.
 - [`JsonPrimitive`](source/basic.d.ts) - Matches a JSON primitive.
 - [`JsonObject`](source/basic.d.ts) - Matches a JSON object.
 - [`JsonArray`](source/basic.d.ts) - Matches a JSON array.
@@ -212,7 +214,7 @@ Click the type names for complete docs.
 - [`MultidimensionalArray`](source/multidimensional-array.d.ts) - Create a type that represents a multidimensional array of the given type and dimensions.
 - [`MultidimensionalReadonlyArray`](source/multidimensional-readonly-array.d.ts) - Create a type that represents a multidimensional readonly array of the given type and dimensions.
 - [`ReadonlyTuple`](source/readonly-tuple.d.ts) - Create a type that represents a read-only tuple of the given type and length.
-- [`TupleToUnion`](source/tuple-to-union.d.ts) - Convert a tuple into a union type of its elements.
+- [`TupleToUnion`](source/tuple-to-union.d.ts) - Convert a tuple/array into a union type of its elements.
 
 ### Numeric
 

package/source/camel-case.d.ts

@@ -1,39 +1,42 @@
-import type {WordSeparators} from '../source/internal';
-import type {Split} from './split';
+import type {SplitWords} from './split-words';
 
 /**
-Step by step takes the first item in an array literal, formats it and adds it to a string literal, and then recursively appends the remainder.
+CamelCase options.
 
-Only to be used by `CamelCaseStringArray<>`.
-
-@see CamelCaseStringArray
+@see {@link CamelCase}
 */
-type InnerCamelCaseStringArray<Parts extends readonly any[], PreviousPart> =
-	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
-		? FirstPart extends undefined
-			? ''
-			: FirstPart extends ''
-				? InnerCamelCaseStringArray<RemainingParts, PreviousPart>
-				: `${PreviousPart extends '' ? FirstPart : Capitalize<FirstPart>}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}`
-		: '';
-
-/**
-Starts fusing the output of `Split<>`, an array literal of strings, into a camel-cased string literal.
+export type CamelCaseOptions = {
+	/**
+	Whether to preserved consecutive uppercase letter.
 
-It's separate from `InnerCamelCaseStringArray<>` to keep a clean API outwards to the rest of the code.
+	@default true
+	*/
+	preserveConsecutiveUppercase?: boolean;
+};
 
-@see Split
+/**
+Convert an array of words to camel-case.
 */
-type CamelCaseStringArray<Parts extends readonly string[]> =
-	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
-		? Uncapitalize<`${FirstPart}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}`>
-		: never;
+type CamelCaseFromArray<
+	Words extends string[],
+	Options extends CamelCaseOptions,
+	OutputString extends string = '',
+> = Words extends [
+	infer FirstWord extends string,
+	...infer RemainingWords extends string[],
+]
+	? Options['preserveConsecutiveUppercase'] extends true
+		? `${Capitalize<FirstWord>}${CamelCaseFromArray<RemainingWords, Options>}`
+		: `${Capitalize<Lowercase<FirstWord>>}${CamelCaseFromArray<RemainingWords, Options>}`
+	: OutputString;
 
 /**
 Convert a string literal to camel-case.
 
 This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.
 
+By default, consecutive uppercase letter are preserved. See {@link CamelCaseOptions.preserveConsecutiveUppercase preserveConsecutiveUppercase} option to change this behaviour.
+
 @example
 ```
 import type {CamelCase} from 'type-fest';
@@ -70,4 +73,6 @@ const dbResult: CamelCasedProperties<RawOptions> = {
 @category Change case
 @category Template literal
 */
-export type CamelCase<K> = K extends string ? CamelCaseStringArray<Split<K extends Uppercase<K> ? Lowercase<K> : K, WordSeparators>> : K;
+export type CamelCase<Type, Options extends CamelCaseOptions = {preserveConsecutiveUppercase: true}> = Type extends string
+	? Uncapitalize<CamelCaseFromArray<SplitWords<Type extends Uppercase<Type> ? Lowercase<Type> : Type>, Options>>
+	: Type;

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

@@ -1,4 +1,4 @@
-import type {CamelCase} from './camel-case';
+import type {CamelCase, CamelCaseOptions} from './camel-case';
 
 /**
 Convert object properties to camel case recursively.
@@ -44,11 +44,11 @@ const result: CamelCasedPropertiesDeep<UserWithFriends> = {
 @category Template literal
 @category Object
 */
-export type CamelCasedPropertiesDeep<Value> = Value extends Function
+export type CamelCasedPropertiesDeep<Value, Options extends CamelCaseOptions = {preserveConsecutiveUppercase: true}> = Value extends Function
 	? Value
 	: Value extends Array<infer U>
-		? Array<CamelCasedPropertiesDeep<U>>
+		? Array<CamelCasedPropertiesDeep<U, Options>>
 		: Value extends Set<infer U>
-			? Set<CamelCasedPropertiesDeep<U>> : {
-				[K in keyof Value as CamelCase<K>]: CamelCasedPropertiesDeep<Value[K]>;
+			? Set<CamelCasedPropertiesDeep<U, Options>> : {
+				[K in keyof Value as CamelCase<K, Options>]: CamelCasedPropertiesDeep<Value[K], Options>;
 			};

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

@@ -1,4 +1,4 @@
-import type {CamelCase} from './camel-case';
+import type {CamelCase, CamelCaseOptions} from './camel-case';
 
 /**
 Convert object properties to camel case but not recursively.
@@ -27,10 +27,10 @@ const result: CamelCasedProperties<User> = {
 @category Template literal
 @category Object
 */
-export type CamelCasedProperties<Value> = Value extends Function
+export type CamelCasedProperties<Value, Options extends CamelCaseOptions = {preserveConsecutiveUppercase: true}> = Value extends Function
 	? Value
 	: Value extends Array<infer U>
 		? Value
 		: {
-			[K in keyof Value as CamelCase<K>]: Value[K];
+			[K in keyof Value as CamelCase<K, Options>]: Value[K];
 		};

package/source/delimiter-case.d.ts

@@ -1,9 +1,9 @@
 import type {UpperCaseCharacters, WordSeparators} from '../source/internal';
 
-// Transforms a string that is fully uppercase into a fully lowercase version. Needed to add support for SCREMAING_SNAKE_CASE, see https://github.com/sindresorhus/type-fest/issues/385
+// Transforms a string that is fully uppercase into a fully lowercase version. Needed to add support for SCREAMING_SNAKE_CASE, see https://github.com/sindresorhus/type-fest/issues/385
 type UpperCaseToLowerCase<T extends string> = T extends Uppercase<T> ? Lowercase<T> : T;
 
-// This implemntation does not supports SCREMAING_SNAKE_CASE, it used internaly by `SplitIncludingDelimiters`.
+// This implementation does not support SCREAMING_SNAKE_CASE, it is used internally by `SplitIncludingDelimiters`.
 type SplitIncludingDelimiters_<Source extends string, Delimiter extends string> =
 	Source extends '' ? [] :
 		Source extends `${infer FirstPart}${Delimiter}${infer SecondPart}` ?

package/source/enforce-optional.d.ts

@@ -19,7 +19,7 @@ Enforce optional keys (by adding the `?` operator) for keys that have a union wi
 
 @example
 ```
-import type {Merge} from 'type-fest';
+import type {EnforceOptional} from 'type-fest';
 
 type Foo = {
 	a: string;

package/source/fixed-length-array.d.ts

@@ -6,7 +6,7 @@ type ArrayLengthMutationKeys = 'splice' | 'push' | 'pop' | 'shift' | 'unshift';
 /**
 Create a type that represents an array of the given type and length. The array's length and the `Array` prototype methods that manipulate its length are excluded in the resulting type.
 
-Please participate in [this issue](https://github.com/microsoft/TypeScript/issues/26223) if you want to have a similiar type built into TypeScript.
+Please participate in [this issue](https://github.com/microsoft/TypeScript/issues/26223) if you want to have a similar type built into TypeScript.
 
 Use-cases:
 - Declaring fixed-length tuples or arrays with a large number of items.

package/source/internal.d.ts

@@ -57,3 +57,54 @@ export type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H'
 export type WordSeparators = '-' | '_' | ' ';
 
 export type StringDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+
+/**
+Matches any unknown record.
+*/
+export type UnknownRecord = Record<PropertyKey, unknown>;
+
+/**
+Matches any unknown array or tuple.
+*/
+export type UnknownArrayOrTuple = readonly [...unknown[]];
+
+/**
+Matches any non empty tuple.
+*/
+export type NonEmptyTuple = readonly [unknown, ...unknown[]];
+
+/**
+Returns a boolean for whether the two given types extends the base type.
+*/
+export type IsBothExtends<BaseType, FirstType, SecondType> = FirstType extends BaseType
+	? SecondType extends BaseType
+		? true
+		: false
+	: false;
+
+/**
+Extracts the type of the first element of an array or tuple.
+*/
+export type FirstArrayElement<TArray extends UnknownArrayOrTuple> = TArray extends readonly [infer THead, ...unknown[]]
+	? THead
+	: never;
+
+/**
+Extracts the type of an array or tuple minus the first element.
+*/
+export type ArrayTail<TArray extends UnknownArrayOrTuple> = TArray extends readonly [unknown, ...infer TTail] ? TTail : [];
+
+/**
+Returns a boolean for whether the string is lowercased.
+*/
+export type IsLowerCase<T extends string> = T extends Lowercase<T> ? true : false;
+
+/**
+Returns a boolean for whether the string is uppercased.
+*/
+export type IsUpperCase<T extends string> = T extends Uppercase<T> ? true : false;
+
+/**
+Returns a boolean for whether the string is numeric.
+*/
+export type IsNumeric<T extends string> = T extends `${number}` ? true : false;

package/source/jsonifiable.d.ts

@@ -0,0 +1,37 @@
+import type {JsonPrimitive, JsonValue} from './basic';
+
+type JsonifiableObject = {[Key in string]?: Jsonifiable} | {toJSON: () => Jsonifiable};
+type JsonifiableArray = readonly Jsonifiable[];
+
+/**
+Matches a value that can be losslessly converted to JSON.
+
+Can be used to type values that you expect to pass to `JSON.stringify`.
+
+`undefined` is allowed in object fields (for example, `{a?: number}`) as a special case even though `JSON.stringify({a: undefined})` is `{}` because it makes this class more widely useful and checking for undefined-but-present values is likely an anti-pattern.
+
+@example
+```
+import type {Jsonifiable} from 'type-fest';
+
+// @ts-expect-error
+const error: Jsonifiable = {
+    map: new Map([['a', 1]]),
+};
+
+JSON.stringify(error);
+//=> {"map": {}}
+
+const good: Jsonifiable = {
+    number: 3,
+    date: new Date(),
+    missing: undefined,
+}
+
+JSON.stringify(good);
+//=> {"number": 3, "date": "2022-10-17T22:22:35.920Z"}
+```
+
+@category JSON
+*/
+export type Jsonifiable = JsonPrimitive | JsonifiableObject | JsonifiableArray;

package/source/jsonify.d.ts

@@ -1,4 +1,5 @@
 import type {JsonPrimitive, JsonValue} from './basic';
+import type {EmptyObject} from './empty-object';
 import type {Merge} from './merge';
 import type {NegativeInfinity, PositiveInfinity} from './numeric';
 import type {TypedArray} from './typed-array';
@@ -95,12 +96,12 @@ export type Jsonify<T> =
 				// Any object with toJSON is special case
 					? T extends {toJSON(): infer J} ? (() => J) extends (() => JsonValue) // Is J assignable to JsonValue?
 						? J // Then T is Jsonable and its Jsonable value is J
-						: never // Not Jsonable because its toJSON() method does not return JsonValue
+						: Jsonify<J> // Maybe if we look a level deeper we'll find a JsonValue
 					// Instanced primitives are objects
 						: T extends Number ? number
 							: T extends String ? string
 								: T extends Boolean ? boolean
-									: T extends Map<any, any> | Set<any> ? {}
+									: T extends Map<any, any> | Set<any> ? EmptyObject
 										: T extends TypedArray ? Record<string, number>
 											: T extends any[]
 												? {[I in keyof T]: T[I] extends NotJsonable ? null : Jsonify<T[I]>}

package/source/merge-deep.d.ts

@@ -0,0 +1,470 @@
+import type {ConditionalSimplifyDeep} from './conditional-simplify';
+import type {OmitIndexSignature} from './omit-index-signature';
+import type {PickIndexSignature} from './pick-index-signature';
+import type {EnforceOptional} from './enforce-optional';
+import type {Merge} from './merge';
+import type {
+	ArrayTail,
+	FirstArrayElement,
+	IsBothExtends,
+	NonEmptyTuple,
+	UnknownArrayOrTuple,
+	UnknownRecord,
+} from './internal';
+
+/**
+Deeply simplifies an object excluding iterables and functions. Used internally to improve the UX and accept both interfaces and type aliases as inputs.
+*/
+type SimplifyDeep<Type> = ConditionalSimplifyDeep<Type, Function | Iterable<unknown>, object>;
+
+/**
+Try to merge two record properties or return the source property value, preserving `undefined` properties values in both cases.
+*/
+type MergeDeepRecordProperty<
+	Destination,
+	Source,
+	Options extends MergeDeepInternalOptions,
+> = undefined extends Source
+	? MergeDeepOrReturn<Source, Exclude<Destination, undefined>, Exclude<Source, undefined>, Options> | undefined
+	: MergeDeepOrReturn<Source, Destination, Source, Options>;
+
+/**
+Walk through the union of the keys of the two objects and test in which object the properties are defined.
+- If the source does not contain the key, the value of the destination is returned.
+- If the source contains the key and the destination does not contain the key, the value of the source is returned.
+- If both contain the key, try to merge according to the chosen {@link MergeDeepOptions options} or return the source if unable to merge.
+*/
+type DoMergeDeepRecord<
+	Destination extends UnknownRecord,
+	Source extends UnknownRecord,
+	Options extends MergeDeepInternalOptions,
+> = EnforceOptional<{
+	[Key in keyof Destination | keyof Source]: Key extends keyof Source
+		? Key extends keyof Destination
+			? MergeDeepRecordProperty<Destination[Key], Source[Key], Options>
+			: Source[Key]
+		: Key extends keyof Destination
+			? Destination[Key]
+			: never;
+}>;
+
+/**
+Wrapper around {@link DoMergeDeepRecord} which preserves index signatures.
+*/
+type MergeDeepRecord<
+	Destination extends UnknownRecord,
+	Source extends UnknownRecord,
+	Options extends MergeDeepInternalOptions,
+> = DoMergeDeepRecord<OmitIndexSignature<Destination>, OmitIndexSignature<Source>, Options>
+& Merge<PickIndexSignature<Destination>, PickIndexSignature<Source>>;
+
+/**
+Pick the rest type.
+
+@example
+```
+type Rest1 = PickRestType<[]>; // => []
+type Rest2 = PickRestType<[string]>; // => []
+type Rest3 = PickRestType<[...number[]]>; // => number[]
+type Rest4 = PickRestType<[string, ...number[]]>; // => number[]
+type Rest5 = PickRestType<string[]>; // => string[]
+```
+*/
+type PickRestType<Type extends UnknownArrayOrTuple> = number extends Type['length']
+	? ArrayTail<Type> extends [] ? Type : PickRestType<ArrayTail<Type>>
+	: [];
+
+/**
+Omit the rest type.
+
+@example
+```
+type Tuple1 = OmitRestType<[]>; // => []
+type Tuple2 = OmitRestType<[string]>; // => [string]
+type Tuple3 = OmitRestType<[...number[]]>; // => []
+type Tuple4 = OmitRestType<[string, ...number[]]>; // => [string]
+type Tuple5 = OmitRestType<[string, boolean[], ...number[]]>; // => [string, boolean[]]
+type Tuple6 = OmitRestType<string[]>; // => []
+```
+*/
+type OmitRestType<Type extends UnknownArrayOrTuple, Result extends UnknownArrayOrTuple = []> = number extends Type['length']
+	? ArrayTail<Type> extends [] ? Result : OmitRestType<ArrayTail<Type>, [...Result, FirstArrayElement<Type>]>
+	: Type;
+
+// Utility to avoid picking two times the type.
+type TypeNumberOrType<Type extends UnknownArrayOrTuple> = Type[number] extends never ? Type : Type[number];
+
+// Pick the rest type (array) and try to get the intrinsic type or return the provided type.
+type PickRestTypeFlat<Type extends UnknownArrayOrTuple> = TypeNumberOrType<PickRestType<Type>>;
+
+/**
+Try to merge two array/tuple elements or return the source element if the end of the destination is reached or vis-versa.
+*/
+type MergeDeepArrayOrTupleElements<
+	Destination,
+	Source,
+	Options extends MergeDeepInternalOptions,
+> = Source extends []
+	? Destination
+	: Destination extends []
+		? Source
+		: MergeDeepOrReturn<Source, Destination, Source, Options>;
+
+/**
+Merge two tuples recursively.
+*/
+type DoMergeDeepTupleAndTupleRecursive<
+	Destination extends UnknownArrayOrTuple,
+	Source extends UnknownArrayOrTuple,
+	DestinationRestType,
+	SourceRestType,
+	Options extends MergeDeepInternalOptions,
+> = Destination extends []
+	? Source extends []
+		? []
+		: MergeArrayTypeAndTuple<DestinationRestType, Source, Options>
+	: Source extends []
+		? MergeTupleAndArrayType<Destination, SourceRestType, Options>
+		: [
+			MergeDeepArrayOrTupleElements<FirstArrayElement<Destination>, FirstArrayElement<Source>, Options>,
+			...DoMergeDeepTupleAndTupleRecursive<ArrayTail<Destination>, ArrayTail<Source>, DestinationRestType, SourceRestType, Options>,
+		];
+
+/**
+Merge two tuples recursively taking into account a possible rest element.
+*/
+type MergeDeepTupleAndTupleRecursive<
+	Destination extends UnknownArrayOrTuple,
+	Source extends UnknownArrayOrTuple,
+	Options extends MergeDeepInternalOptions,
+> = [
+	...DoMergeDeepTupleAndTupleRecursive<OmitRestType<Destination>, OmitRestType<Source>, PickRestTypeFlat<Destination>, PickRestTypeFlat<Source>, Options>,
+	...MergeDeepArrayOrTupleElements<PickRestType<Destination>, PickRestType<Source>, Options>,
+];
+
+/**
+Merge an array type with a tuple recursively.
+*/
+type MergeTupleAndArrayType<
+	Tuple extends UnknownArrayOrTuple,
+	ArrayType,
+	Options extends MergeDeepInternalOptions,
+> = Tuple extends []
+	? Tuple
+	: [
+		MergeDeepArrayOrTupleElements<FirstArrayElement<Tuple>, ArrayType, Options>,
+		...MergeTupleAndArrayType<ArrayTail<Tuple>, ArrayType, Options>,
+	];
+
+/**
+Merge an array into a tuple recursively taking into account a possible rest element.
+*/
+type MergeDeepTupleAndArrayRecursive<
+	Destination extends UnknownArrayOrTuple,
+	Source extends UnknownArrayOrTuple,
+	Options extends MergeDeepInternalOptions,
+> = [
+	...MergeTupleAndArrayType<OmitRestType<Destination>, Source[number], Options>,
+	...MergeDeepArrayOrTupleElements<PickRestType<Destination>, PickRestType<Source>, Options>,
+];
+
+/**
+Merge a tuple with an array type recursively.
+*/
+type MergeArrayTypeAndTuple<
+	ArrayType,
+	Tuple extends UnknownArrayOrTuple,
+	Options extends MergeDeepInternalOptions,
+> = Tuple extends []
+	? Tuple
+	: [
+		MergeDeepArrayOrTupleElements<ArrayType, FirstArrayElement<Tuple>, Options>,
+		...MergeArrayTypeAndTuple<ArrayType, ArrayTail<Tuple>, Options>,
+	];
+
+/**
+Merge a tuple into an array recursively taking into account a possible rest element.
+*/
+type MergeDeepArrayAndTupleRecursive<
+	Destination extends UnknownArrayOrTuple,
+	Source extends UnknownArrayOrTuple,
+	Options extends MergeDeepInternalOptions,
+> = [
+	...MergeArrayTypeAndTuple<Destination[number], OmitRestType<Source>, Options>,
+	...MergeDeepArrayOrTupleElements<PickRestType<Destination>, PickRestType<Source>, Options>,
+];
+
+/**
+Merge mode for array/tuple elements.
+*/
+type ArrayMergeMode = 'spread' | 'replace';
+
+/**
+Test if it should spread top-level arrays.
+*/
+type ShouldSpread<Options extends MergeDeepInternalOptions> = Options['spreadTopLevelArrays'] extends false
+	? Options['arrayMergeMode'] extends 'spread' ? true : false
+	: true;
+
+/**
+Merge two arrays/tuples according to the chosen {@link MergeDeepOptions.arrayMergeMode arrayMergeMode} option.
+*/
+type DoMergeArrayOrTuple<
+	Destination extends UnknownArrayOrTuple,
+	Source extends UnknownArrayOrTuple,
+	Options extends MergeDeepInternalOptions,
+> = ShouldSpread<Options> extends true
+	? Array<Exclude<Destination, undefined>[number] | Exclude<Source, undefined>[number]>
+	: Source; // 'replace'
+
+/**
+Merge two arrays recursively.
+
+If the two arrays are multi-level, we merge deeply, otherwise we merge the first level only.
+
+Note: The `[number]` accessor is used to test the type of the second level.
+*/
+type MergeDeepArrayRecursive<
+	Destination extends UnknownArrayOrTuple,
+	Source extends UnknownArrayOrTuple,
+	Options extends MergeDeepInternalOptions,
+> = Destination[number] extends UnknownArrayOrTuple
+	? Source[number] extends UnknownArrayOrTuple
+		? Array<MergeDeepArrayOrTupleRecursive<Destination[number], Source[number], Options>>
+		: DoMergeArrayOrTuple<Destination, Source, Options>
+	: Destination[number] extends UnknownRecord
+		? Source[number] extends UnknownRecord
+			? Array<SimplifyDeep<MergeDeepRecord<Destination[number], Source[number], Options>>>
+			: DoMergeArrayOrTuple<Destination, Source, Options>
+		: DoMergeArrayOrTuple<Destination, Source, Options>;
+
+/**
+Merge two array/tuple recursively by selecting one of the four strategies according to the type of inputs.
+
+- tuple/tuple
+- tuple/array
+- array/tuple
+- array/array
+*/
+type MergeDeepArrayOrTupleRecursive<
+	Destination extends UnknownArrayOrTuple,
+	Source extends UnknownArrayOrTuple,
+	Options extends MergeDeepInternalOptions,
+> = IsBothExtends<NonEmptyTuple, Destination, Source> extends true
+	? MergeDeepTupleAndTupleRecursive<Destination, Source, Options>
+	: Destination extends NonEmptyTuple
+		? MergeDeepTupleAndArrayRecursive<Destination, Source, Options>
+		: Source extends NonEmptyTuple
+			? MergeDeepArrayAndTupleRecursive<Destination, Source, Options>
+			: MergeDeepArrayRecursive<Destination, Source, Options>;
+
+/**
+Merge two array/tuple according to {@link MergeDeepOptions.recurseIntoArrays recurseIntoArrays} option.
+*/
+type MergeDeepArrayOrTuple<
+	Destination extends UnknownArrayOrTuple,
+	Source extends UnknownArrayOrTuple,
+	Options extends MergeDeepInternalOptions,
+> = Options['recurseIntoArrays'] extends true
+	? MergeDeepArrayOrTupleRecursive<Destination, Source, Options>
+	: DoMergeArrayOrTuple<Destination, Source, Options>;
+
+/**
+Try to merge two objects or two arrays/tuples recursively into a new type or return the default value.
+*/
+type MergeDeepOrReturn<
+	DefaultType,
+	Destination,
+	Source,
+	Options extends MergeDeepInternalOptions,
+> = SimplifyDeep<[undefined] extends [Destination | Source]
+	? DefaultType
+	: Destination extends UnknownRecord
+		? Source extends UnknownRecord
+			? MergeDeepRecord<Destination, Source, Options>
+			: DefaultType
+		: Destination extends UnknownArrayOrTuple
+			? Source extends UnknownArrayOrTuple
+				? MergeDeepArrayOrTuple<Destination, Source, Merge<Options, {spreadTopLevelArrays: false}>>
+				: DefaultType
+			: DefaultType>;
+
+/**
+MergeDeep options.
+
+@see {@link MergeDeep}
+*/
+export type MergeDeepOptions = {
+	/**
+	Merge mode for array and tuple.
+
+	When we walk through the properties of the objects and the same key is found and both are array or tuple, a merge mode must be chosen:
+	- `replace`: Replaces the destination value by the source value. This is the default mode.
+	- `spread`: Spreads the destination and the source values.
+
+	See {@link MergeDeep} for usages and examples.
+
+	Note: Top-level arrays and tuples are always spread.
+
+	@default 'spread'
+	*/
+	arrayMergeMode?: ArrayMergeMode;
+
+	/**
+	Whether to affect the individual elements of arrays and tuples.
+
+	If this option is set to `true` the following rules are applied:
+	- If the source does not contain the key, the value of the destination is returned.
+	- If the source contains the key and the destination does not contain the key, the value of the source is returned.
+	- If both contain the key, try to merge according to the chosen {@link MergeDeepOptions.arrayMergeMode arrayMergeMode} or return the source if unable to merge.
+
+	@default false
+	*/
+	recurseIntoArrays?: boolean;
+};
+
+/**
+Internal options.
+*/
+type MergeDeepInternalOptions = Merge<MergeDeepOptions, {spreadTopLevelArrays?: boolean}>;
+
+/**
+Merge default and internal options with user provided options.
+*/
+type DefaultMergeDeepOptions<Options extends MergeDeepOptions> = Merge<{
+	arrayMergeMode: 'replace';
+	recurseIntoArrays: false;
+	spreadTopLevelArrays: true;
+}, Options>;
+
+/**
+This utility selects the correct entry point with the corresponding default options. This avoids re-merging the options at each iteration.
+*/
+type MergeDeepWithDefaultOptions<Destination, Source, Options extends MergeDeepOptions> = SimplifyDeep<
+[undefined] extends [Destination | Source]
+	? never
+	: Destination extends UnknownRecord
+		? Source extends UnknownRecord
+			? MergeDeepRecord<Destination, Source, DefaultMergeDeepOptions<Options>>
+			: never
+		: Destination extends UnknownArrayOrTuple
+			? Source extends UnknownArrayOrTuple
+				? MergeDeepArrayOrTuple<Destination, Source, DefaultMergeDeepOptions<Options>>
+				: never
+			: never
+>;
+
+/**
+Merge two objects or two arrays/tuples recursively into a new type.
+
+- Properties that only exist in one object are copied into the new object.
+- Properties that exist in both objects are merged if possible or replaced by the one of the source if not.
+- Top-level arrays and tuples are always spread.
+- By default, inner arrays and tuples are replaced. See {@link MergeDeepOptions.arrayMergeMode arrayMergeMode} option to change this behaviour.
+- By default, individual array/tuple elements are not affected. See {@link MergeDeepOptions.recurseIntoArrays recurseIntoArrays} option to change this behaviour.
+
+@example
+```
+import type {MergeDeep} from 'type-fest';
+
+type Foo = {
+	life: number;
+	items: string[];
+	a: {b: string; c: boolean; d: number[]};
+};
+
+interface Bar {
+	name: string;
+	items: number[];
+	a: {b: number; d: boolean[]};
+}
+
+type FooBar = MergeDeep<Foo, Bar>;
+// {
+// 	life: number;
+// 	name: string;
+// 	items: number[];
+// 	a: {b: number; c: boolean; d: boolean[]};
+// }
+
+type FooBar = MergeDeep<Foo, Bar, {arrayMergeMode: 'spread'}>;
+// {
+// 	life: number;
+// 	name: string;
+// 	items: (string | number)[];
+// 	a: {b: number; c: boolean; d: (number | boolean)[]};
+// }
+```
+
+@example
+```
+import type {MergeDeep} from 'type-fest';
+
+// Merge two arrays
+type ArrayMerge = MergeDeep<string[], number[]>; // => (string | number)[]
+
+// Merge two tuples
+type TupleMerge = MergeDeep<[1, 2, 3], ['a', 'b']>; // => (1 | 2 | 3 | 'a' | 'b')[]
+
+// Merge an array into a tuple
+type TupleArrayMerge = MergeDeep<[1, 2, 3], string[]>; // => (string | 1 | 2 | 3)[]
+
+// Merge a tuple into an array
+type ArrayTupleMerge = MergeDeep<number[], ['a', 'b']>; // => (number | 'b' | 'a')[]
+```
+
+@example
+```
+import type {MergeDeep, MergeDeepOptions} from 'type-fest';
+
+type Foo = {foo: 'foo'; fooBar: string[]};
+type Bar = {bar: 'bar'; fooBar: number[]};
+
+type FooBar = MergeDeep<Foo, Bar>;
+// { foo: "foo"; bar: "bar"; fooBar: number[]}
+
+type FooBarSpread = MergeDeep<Foo, Bar, {arrayMergeMode: 'spread'}>;
+// { foo: "foo"; bar: "bar"; fooBar: (string | number)[]}
+
+type FooBarArray = MergeDeep<Foo[], Bar[]>;
+// (Foo | Bar)[]
+
+type FooBarArrayDeep = MergeDeep<Foo[], Bar[], {recurseIntoArrays: true}>;
+// FooBar[]
+
+type FooBarArraySpreadDeep = MergeDeep<Foo[], Bar[], {recurseIntoArrays: true; arrayMergeMode: 'spread'}>;
+// FooBarSpread[]
+
+type FooBarTupleDeep = MergeDeep<[Foo, true, 42], [Bar, 'life'], {recurseIntoArrays: true}>;
+// [FooBar, 'life', 42]
+
+type FooBarTupleWithArrayDeep = MergeDeep<[Foo[], true], [Bar[], 'life', 42], {recurseIntoArrays: true}>;
+// [FooBar[], 'life', 42]
+```
+
+@example
+```
+import type {MergeDeep, MergeDeepOptions} from 'type-fest';
+
+function mergeDeep<Destination, Source, Options extends MergeDeepOptions = {}>(
+	destination: Destination,
+	source: Source,
+	options?: Options,
+): MergeDeep<Destination, Source, Options> {
+	// Make your implementation ...
+}
+```
+
+@experimental This type is marked as experimental because it depends on {@link ConditionalSimplifyDeep} which itself is experimental.
+
+@see {@link MergeDeepOptions}
+
+@category Array
+@category Object
+@category Utilities
+*/
+export type MergeDeep<Destination, Source, Options extends MergeDeepOptions = {}> = MergeDeepWithDefaultOptions<
+SimplifyDeep<Destination>,
+SimplifyDeep<Source>,
+Options
+>;

package/source/observable-like.d.ts

@@ -8,7 +8,7 @@ declare global {
 /**
 @remarks
 The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
-As well, some guideance on making an `Observable` do not include `closed` propery.
+As well, some guidance on making an `Observable` to not include `closed` property.
 @see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
 @see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
 @see https://github.com/benlesh/symbol-observable#making-an-object-observable

package/source/package-json.d.ts

@@ -240,7 +240,7 @@ declare namespace PackageJson {
 	Import map entries of a module, optionally with conditions.
 	*/
 	export type Imports = { // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
-		[key: string]: string | {[key in ExportCondition]: Exports};
+		[key: `#${string}`]: string | {[key in ExportCondition]: Exports};
 	};
 
 	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions

package/source/require-at-least-one.d.ts

@@ -10,7 +10,6 @@ import type {RequireAtLeastOne} from 'type-fest';
 type Responder = {
 	text?: () => string;
 	json?: () => string;
-
 	secure?: boolean;
 };
 

package/source/schema.d.ts

@@ -29,7 +29,6 @@ const userMaskSettings: UserMask = {
 		firstname: 'show',
 		lastname: 'mask',
 	},
-	phoneNumbers: 'mask',
 	created: 'show',
 	active: 'show',
 	passwordHash: 'hide',

package/source/set-non-nullable.d.ts

@@ -2,23 +2,32 @@ import type {Except} from './except';
 import type {Simplify} from './simplify';
 
 /**
-Create a type that makes the given keys non-nullable. The remaining keys are kept as is.
+Create a type that makes the given keys non-nullable, where 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 non-nullable.
+If no keys are given, all keys will be made non-nullable.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some or all of the keys are non-nullable.
 
 @example
 ```
 import type {SetNonNullable} from 'type-fest';
 
 type Foo = {
-	a: number;
+	a: number | null;
 	b: string | undefined;
 	c?: boolean | null;
 }
 
 type SomeNonNullable = SetNonNullable<Foo, 'b' | 'c'>;
 // type SomeNonNullable = {
-// 	a: number;
+// 	a: number | null;
+// 	b: string; // Can no longer be undefined.
+// 	c?: boolean; // Can no longer be null, but is still optional.
+// }
+
+type AllNonNullable = SetNonNullable<Foo>;
+// type AllNonNullable = {
+// 	a: number; // Can no longer be null.
 // 	b: string; // Can no longer be undefined.
 // 	c?: boolean; // Can no longer be null, but is still optional.
 // }
@@ -26,7 +35,7 @@ type SomeNonNullable = SetNonNullable<Foo, 'b' | 'c'>;
 
 @category Object
 */
-export type SetNonNullable<BaseType, Keys extends keyof BaseType> =
+export type SetNonNullable<BaseType, Keys extends keyof BaseType = keyof BaseType> =
 	Simplify<
 	// Pick just the keys that are readonly from the base type.
 	Except<BaseType, Keys> &

package/source/split-words.d.ts

@@ -0,0 +1,57 @@
+import type {IsLowerCase, IsNumeric, IsUpperCase, WordSeparators} from './internal';
+
+type SkipEmptyWord<Word extends string> = Word extends '' ? [] : [Word];
+
+type RemoveLastCharacter<Sentence extends string, Character extends string> = Sentence extends `${infer LeftSide}${Character}`
+	? SkipEmptyWord<LeftSide>
+	: never;
+
+/**
+Split a string (almost) like Lodash's `_.words()` function.
+
+- Split on each word that begins with a capital letter.
+- Split on each {@link WordSeparators}.
+- Split on numeric sequence.
+
+@example
+```
+type Words0 = SplitWords<'helloWorld'>; // ['hello', 'World']
+type Words1 = SplitWords<'helloWORLD'>; // ['hello', 'WORLD']
+type Words2 = SplitWords<'hello-world'>; // ['hello', 'world']
+type Words3 = SplitWords<'--hello the_world'>; // ['hello', 'the', 'world']
+type Words4 = SplitWords<'lifeIs42'>; // ['life', 'Is', '42']
+```
+
+@internal
+@category Change case
+@category Template literal
+*/
+export type SplitWords<
+	Sentence extends string,
+	LastCharacter extends string = '',
+	CurrentWord extends string = '',
+> = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}`
+	? FirstCharacter extends WordSeparators
+		// Skip word separator
+		? [...SkipEmptyWord<CurrentWord>, ...SplitWords<RemainingCharacters, LastCharacter>]
+		: LastCharacter extends ''
+			// Fist char of word
+			? SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>
+			// Case change: non-numeric to numeric, push word
+			: [false, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
+				? [...SkipEmptyWord<CurrentWord>, ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>]
+				// Case change: numeric to non-numeric, push word
+				: [true, false] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
+					? [...SkipEmptyWord<CurrentWord>, ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>]
+					// No case change: concat word
+					: [true, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
+						? SplitWords<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
+					// Case change: lower to upper, push word
+						: [true, true] extends [IsLowerCase<LastCharacter>, IsUpperCase<FirstCharacter>]
+							? [...SkipEmptyWord<CurrentWord>, ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>]
+						// Case change: upper to lower, brings back the last character, push word
+							: [true, true] extends [IsUpperCase<LastCharacter>, IsLowerCase<FirstCharacter>]
+								? [...RemoveLastCharacter<CurrentWord, LastCharacter>, ...SplitWords<RemainingCharacters, FirstCharacter, `${LastCharacter}${FirstCharacter}`>]
+							// No case change: concat word
+								: SplitWords<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
+	: [...SkipEmptyWord<CurrentWord>];

package/source/stringified.d.ts

@@ -7,7 +7,7 @@ Use-case: Changing interface values to strings in order to use them in a form mo
 ```
 import type {Stringified} from 'type-fest';
 
-type Car {
+type Car = {
 	model: string;
 	speed: number;
 }

package/source/tuple-to-union.d.ts

@@ -1,5 +1,5 @@
 /**
-Convert a tuple into a union type of its elements.
+Convert a tuple/array into a union type of its elements.
 
 This can be useful when you have a fixed set of allowed values and want a type defining only the allowed values, but do not want to repeat yourself.
 
@@ -48,4 +48,4 @@ type NumberBool = typeof numberBool[number];
 
 @category Array
 */
-export type TupleToUnion<ArrayType> = ArrayType extends readonly [infer Head, ...(infer Rest)] ? Head | TupleToUnion<Rest> : never;
+export type TupleToUnion<ArrayType> = ArrayType extends readonly unknown[] ? ArrayType[number] : never;