type-fest 4.8.1 → 4.8.3

package/package.json

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

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

@@ -50,17 +50,15 @@ export type DelimiterCasedPropertiesDeep<
 	Delimiter extends string,
 > = Value extends Function | Date | RegExp
 	? Value
-	: 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>;
-				};
+	: 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 []

package/source/join.d.ts

@@ -51,7 +51,7 @@ const path: Join<['hello' | undefined, 'world' | null], '.'> = ['hello', 'world'
 export type Join<
 	Items extends readonly JoinableItem[],
 	Delimiter extends string,
-> = Items extends []
+> = Items extends readonly []
 	? ''
 	: Items extends readonly [JoinableItem?]
 		? `${NullishCoalesce<Items[0], ''>}`

package/source/jsonify.d.ts

@@ -6,7 +6,7 @@ import type {IsNever} from './is-never';
 import type {IsUnknown} from './is-unknown';
 import type {NegativeInfinity, PositiveInfinity} from './numeric';
 import type {TypedArray} from './typed-array';
-import type {WritableDeep} from './writable-deep';
+import type {UnknownArray} from './unknown-array';
 
 // Note: The return value has to be `any` and not `unknown` so it can match `void`.
 type NotJsonable = ((...arguments_: any[]) => any) | undefined | symbol;
@@ -14,9 +14,9 @@ type NotJsonable = ((...arguments_: any[]) => any) | undefined | symbol;
 type NeverToNull<T> = IsNever<T> extends true ? null : T;
 
 // Handles tuples and arrays
-type JsonifyList<T extends readonly unknown[]> = T extends []
+type JsonifyList<T extends UnknownArray> = T extends readonly []
 	? []
-	: T extends [infer F, ...infer R]
+	: T extends readonly [infer F, ...infer R]
 		? [NeverToNull<Jsonify<F>>, ...JsonifyList<R>]
 		: IsUnknown<T[number]> extends true
 			? []
@@ -114,12 +114,8 @@ export type Jsonify<T> = IsAny<T> extends true
 									? Record<string, number>
 									: T extends NotJsonable
 										? never // Non-JSONable type union was found not empty
-										: T extends []
-											? []
-											: T extends unknown[]
-												? JsonifyList<T>
-												: T extends readonly unknown[]
-													? JsonifyList<WritableDeep<T>>
-													: T extends object
-														? JsonifyObject<UndefinedToOptional<T>> // JsonifyObject recursive call for its children
-														: never; // Otherwise any other non-object is removed
+										: T extends UnknownArray
+											? JsonifyList<T>
+											: T extends object
+												? JsonifyObject<UndefinedToOptional<T>> // JsonifyObject recursive call for its children
+												: never; // Otherwise any other non-object is removed

package/source/merge-deep.d.ts

@@ -1,7 +1,6 @@
 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,
@@ -30,23 +29,28 @@ type MergeDeepRecordProperty<
 
 /**
 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.
+Rules:
+1. If the source does not contain the key, the value of the destination is returned.
+2. If the source contains the key and the destination does not contain the key, the value of the source is returned.
+3. 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;
-}>;
+> =
+// Case in rule 1: The destination contains the key but the source doesn't.
+{
+	[Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
+}
+// Case in rule 2: The source contains the key but the destination doesn't.
+& {
+	[Key in keyof Source as Key extends keyof Destination ? never : Key]: Source[Key];
+}
+// Case in rule 3: Both the source and the destination contain the key.
+& {
+	[Key in keyof Source as Key extends keyof Destination ? Key : never]: MergeDeepRecordProperty<Destination[Key], Source[Key], Options>;
+};
 
 /**
 Wrapper around {@link DoMergeDeepRecord} which preserves index signatures.

package/source/paths.d.ts

@@ -78,7 +78,7 @@ open('listB.1'); // TypeError. Because listB only has one element.
 @category Array
 */
 export type Paths<T> =
-	T extends NonRecursiveType
+	T extends NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
 		? never
 		: IsAny<T> extends true
 			? never

package/source/writable-deep.d.ts

@@ -1,5 +1,4 @@
 import type {BuiltIns, HasMultipleCallSignatures} from './internal';
-import type {Writable} from './writable.js';
 
 /**
 Create a deeply mutable version of an `object`/`ReadonlyMap`/`ReadonlySet`/`ReadonlyArray` type. The inverse of `ReadonlyDeep<T>`. Use `Writable<T>` if you only need one level deep.