type-fest 2.18.0 → 2.18.1

package/package.json

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

package/readme.md

@@ -162,7 +162,7 @@ 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.
-- [`Spread`](source/spread.d.ts) - Mimic the type inferred by TypeScript when merging two objects using the spread operator.
+- [`Spread`](source/spread.d.ts) - Mimic the type inferred by TypeScript when merging two objects or two arrays/tuples using the spread syntax.
 
 ### JSON
 

package/source/jsonify.d.ts

@@ -67,25 +67,24 @@ type Jsonify<T> =
 	// Note: The use of tuples in this first condition side-steps distributive conditional types
 	// (see https://github.com/microsoft/TypeScript/issues/29368#issuecomment-453529532)
 	[Extract<T, NotJsonable | bigint>] extends [never]
-		? T extends PositiveInfinity | NegativeInfinity ? null
-		: T extends JsonPrimitive
-			? T // Primitive is acceptable
-			: T extends Number ? number
-			: T extends String ? string
-			: T extends Boolean ? boolean
-			: T extends Map<any, any> | Set<any> ? {}
-			: T extends TypedArray ? Record<string, number>
-			: T extends Array<infer U>
-				? Array<Jsonify<U extends NotJsonable ? null : U>> // It's an array: recursive call for its children
-				: T extends object
-					? 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
-						: {[P in keyof T as P extends symbol
-							? never
-							: T[P] extends NotJsonable
-							? never
-							: P]: Jsonify<Required<T>[P]>} // It's an object: recursive call for its children
-					: never // Otherwise any other non-object is removed
+		? T extends PositiveInfinity | NegativeInfinity	? null
+			: T extends JsonPrimitive ? T // Primitive is acceptable
+			: T extends object
+				// 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
+				// 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 TypedArray ? Record<string, number>
+				: T extends any[]
+					? {[I in keyof T]: T[I] extends NotJsonable ? null : Jsonify<T[I]>}
+				: {[P in keyof T as P extends symbol ? never
+					: T[P] extends NotJsonable ? never
+					: P
+				]: Jsonify<Required<T>[P]>} // Recursive call for its children
+			: never // Otherwise any other non-object is removed
 		: never; // Otherwise non-JSONable type union was found not empty

package/source/spread.d.ts

@@ -2,7 +2,7 @@ import type {Except} from './except';
 import type {RequiredKeysOf} from './required-keys-of';
 import type {Simplify} from './simplify';
 
-type Spread_<FirstType extends object, SecondType extends object> = {
+type SpreadObject<FirstType extends object, SecondType extends object> = {
 	[Key in keyof FirstType]: Key extends keyof SecondType
 		? FirstType[Key] | Required<SecondType>[Key]
 		: FirstType[Key];
@@ -11,8 +11,17 @@ type Spread_<FirstType extends object, SecondType extends object> = {
 	RequiredKeysOf<SecondType> | Exclude<keyof SecondType, keyof FirstType>
 >;
 
+type TupleOrArray = readonly [...unknown[]];
+
+type SpreadTupleOrArray<
+	FirstType extends TupleOrArray,
+	SecondType extends TupleOrArray,
+> = Array<FirstType[number] | SecondType[number]>;
+
+type Spreadable = object | TupleOrArray;
+
 /**
-Mimic the type inferred by TypeScript when merging two objects using the spread operator.
+Mimic the type inferred by TypeScript when merging two objects or two arrays/tuples using the spread syntax.
 
 @example
 ```
@@ -46,9 +55,31 @@ const baz = (argument: FooBar) => {
 baz(fooBar);
 ```
 
+@example
+```
+import type {Spread} from 'type-fest';
+
+const foo = [1, 2, 3];
+const bar = ['4', '5', '6'];
+
+const fooBar = [...foo, ...bar];
+type FooBar = Spread<typeof foo, typeof bar>;
+// FooBar = (string | number)[]
+
+const baz = (argument: FooBar) => {
+	// Do something
+};
+
+baz(fooBar);
+```
+
 @category Object
 */
 export type Spread<
-    FirstType extends object,
-    SecondType extends object,
-> = Simplify<Spread_<FirstType, SecondType>>;
+    FirstType extends Spreadable,
+    SecondType extends Spreadable,
+> = FirstType extends TupleOrArray
+	? SecondType extends TupleOrArray
+		? SpreadTupleOrArray<FirstType, SecondType>
+		: Simplify<SpreadObject<FirstType, SecondType>>
+	: Simplify<SpreadObject<FirstType, SecondType>>;