ConditionalPickDeep / SimplifyDeep: Prevent mapping over built-ins (#1293)

Author: ryangoree

source/internal/object.d.ts

@@ -1,5 +1,4 @@
 import type {Simplify} from '../simplify.d.ts';
-import type {UnknownArray} from '../unknown-array.d.ts';
 import type {IsEqual} from '../is-equal.d.ts';
 import type {KeysOfUnion} from '../keys-of-union.d.ts';
 import type {RequiredKeysOf} from '../required-keys-of.d.ts';
@@ -9,7 +8,7 @@ import type {IsAny} from '../is-any.d.ts';
 import type {If} from '../if.d.ts';
 import type {IsNever} from '../is-never.d.ts';
 import type {FilterDefinedKeys, FilterOptionalKeys} from './keys.d.ts';
-import type {NonRecursiveType} from './type.d.ts';
+import type {MapsSetsOrArrays, NonRecursiveType} from './type.d.ts';
 import type {ToString} from './string.d.ts';
 
 /**
@@ -40,11 +39,13 @@ export type BuildObject<Key extends PropertyKey, Value, CopiedFrom extends objec
 Returns a boolean for whether the given type is a plain key-value object.
 */
 export type IsPlainObject<T> =
-	T extends NonRecursiveType | UnknownArray | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
+	IsNever<T> extends true
 		? false
-		: T extends object
-			? true
-			: false;
+		: T extends NonRecursiveType | MapsSetsOrArrays
+			? false
+			: T extends object
+				? true
+				: false;
 
 /**
 Extract the object field type if T is an object and K is a key of T, return `never` otherwise.

source/internal/type.d.ts

@@ -12,7 +12,7 @@ export type BuiltIns = Primitive | void | Date | RegExp;
 /**
 Matches non-recursive types.
 */
-export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
+export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown) | Promise<unknown>;
 
 /**
 Matches maps, sets, or arrays.

source/simplify-deep.d.ts

@@ -1,5 +1,5 @@
 import type {ConditionalSimplifyDeep} from './conditional-simplify-deep.d.ts';
-import type {NonRecursiveType} from './internal/index.d.ts';
+import type {MapsSetsOrArrays, NonRecursiveType} from './internal/index.d.ts';
 
 /**
 Deeply simplifies an object type.
@@ -110,7 +110,7 @@ type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2, ComplexTyp
 export type SimplifyDeep<Type, ExcludeType = never> =
 	ConditionalSimplifyDeep<
 		Type,
-	ExcludeType | NonRecursiveType | Set<unknown> | Map<unknown, unknown>,
+	ExcludeType | NonRecursiveType | MapsSetsOrArrays,
 	object
 	>;
 

test-d/conditional-pick-deep.ts

@@ -16,16 +16,23 @@ type Example = {
 	literal: 'foo';
 	string: string;
 	map: Map<string, string>;
+	readonlyMap: ReadonlyMap<string, string>;
+	weakMap: WeakMap<WeakKey, string>;
 	set: Set<string>;
+	readonlySet: ReadonlySet<string>;
+	weakSet: WeakSet<WeakKey>;
 	date: Date;
 	number: 1;
 	array: string[];
+	readonlyArray: readonly string[];
 	tuples: ['foo', 'bar'];
 	interface: InterfaceA;
 	instanceA: ClassA;
 	ClassA: typeof ClassA;
 	function: (...arguments_: string[]) => string;
+	promise: Promise<string>;
 	stringOrBoolean: string | boolean;
+	never: never;
 	object: {
 		string: string;
 		subObject: {
@@ -42,6 +49,7 @@ expectType<{
 	instanceA: {
 		a: string;
 	};
+	never: never;
 	object: {
 		string: string;
 		subObject: {
@@ -71,6 +79,7 @@ expectType<{
 	instanceA: {
 		a: string;
 	};
+	never: never;
 	object: {
 		string: string;
 		subObject: {
@@ -84,13 +93,16 @@ declare const stringPickOptionalOnly: ConditionalPickDeep<Example, string | unde
 expectType<{object: {subObject: {optional?: string}}}>(stringPickOptionalOnly);
 
 declare const booleanPick: ConditionalPickDeep<Example, boolean | undefined>;
-expectType<{optional?: boolean; optionalWithUndefined?: boolean | undefined}>(booleanPick);
+expectType<{optional?: boolean; optionalWithUndefined?: boolean | undefined; never: never}>(booleanPick);
 
 declare const numberPick: ConditionalPickDeep<Example, number>;
-expectType<{number: 1; interface: {a: number}}>(numberPick);
+expectType<{number: 1; interface: {a: number}; never: never}>(numberPick);
 
 declare const emptyPick: ConditionalPickDeep<Example, 'abcdefg'>;
-expectType<{}>(emptyPick);
+expectType<{never: never}>(emptyPick);
+
+declare const emptyEqualityPick: ConditionalPickDeep<Example, 'abcdefg', {condition: 'equality'}>;
+expectType<{}>(emptyEqualityPick);
 
 declare const stringOrBooleanPick: ConditionalPickDeep<Example, string | boolean>;
 expectType<{
@@ -100,6 +112,7 @@ expectType<{
 	instanceA: {
 		a: string;
 	};
+	never: never;
 	object: {
 		string: string;
 		subObject: {
@@ -112,28 +125,28 @@ declare const stringOrBooleanPickOnly: ConditionalPickDeep<Example, string | boo
 expectType<{stringOrBoolean: string | boolean}>(stringOrBooleanPickOnly);
 
 declare const arrayPick: ConditionalPickDeep<Example, string[]>;
-expectType<{array: string[]; tuples: ['foo', 'bar']}>(arrayPick);
+expectType<{array: string[]; tuples: ['foo', 'bar']; never: never}>(arrayPick);
 
 declare const arrayEqualityPick: ConditionalPickDeep<Example, string[], {condition: 'equality'}>;
 expectType<{array: string[]}>(arrayEqualityPick);
 
 declare const tuplePick: ConditionalPickDeep<Example, ['foo', 'bar']>;
-expectType<{tuples: ['foo', 'bar']}>(tuplePick);
+expectType<{tuples: ['foo', 'bar']; never: never}>(tuplePick);
 
 declare const instancePick: ConditionalPickDeep<Example, ClassA>;
-expectType<{instanceA: ClassA}>(instancePick);
+expectType<{instanceA: ClassA; never: never}>(instancePick);
 
 declare const classPick: ConditionalPickDeep<Example, typeof ClassA>;
-expectType<{ClassA: typeof ClassA}>(classPick);
+expectType<{ClassA: typeof ClassA; never: never}>(classPick);
 
 declare const functionPick: ConditionalPickDeep<Example, (...arguments_: string[]) => string>;
-expectType<{function: (...arguments_: string[]) => string}>(functionPick);
+expectType<{function: (...arguments_: string[]) => string; never: never}>(functionPick);
 
 declare const mapPick: ConditionalPickDeep<Example, Map<string, string>>;
-expectType<{map: Map<string, string>}>(mapPick);
+expectType<{map: Map<string, string>; never: never}>(mapPick);
 
 declare const setPick: ConditionalPickDeep<Example, Set<string>>;
-expectType<{set: Set<string>}>(setPick);
+expectType<{set: Set<string>; never: never}>(setPick);
 
 declare const interfaceTest: ConditionalPickDeep<Example, InterfaceA>;
-expectType<{interface: InterfaceA}>(interfaceTest);
+expectType<{interface: InterfaceA; never: never}>(interfaceTest);