PartialDeep: Make the recurseIntoArrays option false by default

Author: sindresorhus

source/partial-deep.d.ts

@@ -7,7 +7,7 @@ export type PartialDeepOptions = {
 	/**
 	Whether to affect the individual elements of arrays and tuples.
 
-	@default true
+	@default false
 	*/
 	readonly recurseIntoArrays?: boolean;
 };
@@ -40,7 +40,7 @@ const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
 settings = applySavedSettings({textEditor: {fontWeight: 500}});
 ```
 
-By default, this also affects array and tuple types:
+By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
 
 ```
 import type {PartialDeep} from 'type-fest';
@@ -49,13 +49,11 @@ interface Settings {
 	languages: string[];
 }
 
-const partialSettings: PartialDeep<Settings> = {
+const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
 	languages: [undefined]
 };
 ```
 
-If this is undesirable, you can pass `{recurseIntoArrays: false}` as the second type argument.
-
 @category Object
 @category Array
 @category Set
@@ -75,13 +73,13 @@ export type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends
 						? T | undefined
 						: T extends object
 							? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-								? Options['recurseIntoArrays'] extends false // If they opt out of array testing, just use the original type
-									? T
-									: ItemType[] extends T // Test for arrays (non-tuples) specifically
+								? Options['recurseIntoArrays'] extends true
+									? ItemType[] extends T // Test for arrays (non-tuples) specifically
 										? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
 											? ReadonlyArray<PartialDeep<ItemType | undefined, Options>>
 											: 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
 								: PartialObjectDeep<T, Options>
 							: unknown;
 

test-d/partial-deep.ts

@@ -25,10 +25,10 @@ const foo = {
 	},
 };
 
-let partialDeepFoo: PartialDeep<typeof foo> = foo;
+let partialDeepFoo: PartialDeep<typeof foo, {recurseIntoArrays: true}> = foo;
 
 expectError(expectType<Partial<typeof foo>>(partialDeepFoo));
-const partialDeepBar: PartialDeep<typeof foo.bar> = foo.bar;
+const partialDeepBar: PartialDeep<typeof foo.bar, {recurseIntoArrays: true}> = foo.bar;
 expectType<typeof partialDeepBar | undefined>(partialDeepFoo.bar);
 expectType<((_: string) => void) | undefined>(partialDeepFoo.bar!.function);
 expectAssignable<object | undefined>(partialDeepFoo.bar!.object);
@@ -54,20 +54,20 @@ partialDeepFoo = {bar: {string: 'waldo'}};
 partialDeepFoo = {bar: {date: new Date()}};
 // Check that recursive array evalution isn't infinite depth
 type Recurse =
-    | string
-    | number
-    | boolean
-    | null
-    | Record<string, Recurse[]>
-    | Recurse[];
+	| string
+	| number
+	| boolean
+	| null
+	| Record<string, Recurse[]>
+	| Recurse[];
 type RecurseObject = {value: Recurse};
 const recurseObject: RecurseObject = {value: null};
 expectAssignable<PartialDeep<RecurseObject>>(recurseObject);
 
-// Check that recurseIntoArrays: true is the default
+// Check that `{recurseIntoArrays: false}` is the default
+const partialDeepNoRecurseIntoArraysFoo: PartialDeep<typeof foo> = foo;
+// Check that `{recurseIntoArrays: true}` behaves as intended
 expectType<PartialDeep<typeof foo, {recurseIntoArrays: true}>>(partialDeepFoo);
-// Check that recurseIntoArrays: false behaves as expected
-const partialDeepNoRecurseIntoArraysFoo: PartialDeep<typeof foo, {recurseIntoArrays: false}> = foo;
 // These are mostly the same checks as before, but the array/tuple types are different.
 expectError(expectType<Partial<typeof foo>>(partialDeepNoRecurseIntoArraysFoo));
 const partialDeepNoRecurseIntoArraysBar: PartialDeep<typeof foo.bar, {recurseIntoArrays: false}> = foo.bar;