Simplify: Revert back to how it worked in v2.15.1 (#441)

Author: skarab42

index.d.ts

@@ -40,7 +40,7 @@ export {Entry} from './source/entry';
 export {Entries} from './source/entries';
 export {SetReturnType} from './source/set-return-type';
 export {Asyncify} from './source/asyncify';
-export {Simplify, SimplifyOptions} from './source/simplify';
+export {Simplify} from './source/simplify';
 export {Jsonify} from './source/jsonify';
 export {Schema} from './source/schema';
 export {LiteralToPrimitive} from './source/literal-to-primitive';

source/simplify.d.ts

@@ -1,23 +1,3 @@
-/**
-@see Simplify
-*/
-export interface SimplifyOptions {
-	/**
-	Do the simplification recursively.
-
-	@default false
-	*/
-	deep?: boolean;
-}
-
-// Flatten a type without worrying about the result.
-type Flatten<
-	AnyType,
-	Options extends SimplifyOptions = {},
-> = Options['deep'] extends true
-	? {[KeyType in keyof AnyType]: Simplify<AnyType[KeyType], Options>}
-	: {[KeyType in keyof AnyType]: AnyType[KeyType]};
-
 /**
 Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 
@@ -75,9 +55,4 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 
 @category Object
 */
-export type Simplify<
-	AnyType,
-	Options extends SimplifyOptions = {},
-> = Flatten<AnyType> extends AnyType
-	? Flatten<AnyType, Options>
-	: AnyType;
+export type Simplify<T> = {[KeyType in keyof T]: T[KeyType]};

test-d/simplify.ts

@@ -1,4 +1,4 @@
-import {expectAssignable, expectNotAssignable, expectType} from 'tsd';
+import {expectAssignable, expectError, expectNotAssignable, expectType} from 'tsd';
 import type {Simplify} from '../index';
 
 type PositionProps = {
@@ -43,44 +43,32 @@ expectAssignable<Record<string, unknown>>(valueAsLiteral);
 expectAssignable<Record<string, unknown>>(valueAsSimplifiedInterface);
 expectNotAssignable<Record<string, unknown>>(valueAsInterface); // Index signature is missing in interface
 
-// Should return the original type if it is not simplifiable, like a function.
+// The following tests should be fixed once we have determined the cause of the bug reported in https://github.com/sindresorhus/type-fest/issues/436
+
 type SomeFunction = (type: string) => string;
-expectType<Simplify<SomeFunction>>((type: string) => type);
+type SimplifiedFunction = Simplify<SomeFunction>; // Return '{}' expected 'SomeFunction'
 
-class SomeClass {
-	id: string;
+declare const someFunction: SimplifiedFunction;
 
-	private readonly code: number;
+expectError<SomeFunction>(someFunction);
 
-	constructor() {
-		this.id = 'some-class';
-		this.code = 42;
-	}
+// // Should return the original type if it is not simplifiable, like a function.
+// type SomeFunction = (type: string) => string;
+// expectType<Simplify<SomeFunction>>((type: string) => type);
 
-	someMethod() {
-		return this.code;
-	}
-}
+// class SomeClass {
+// 	id: string;
 
-expectType<Simplify<SomeClass>>(new SomeClass());
+// 	private readonly code: number;
 
-// Test deep option
-// This is mostly visual, move the mouse over "expectAssignable" to see the result.
-type PositionAndSize = PositionProps & SizeProps;
+// 	constructor() {
+// 		this.id = 'some-class';
+// 		this.code = 42;
+// 	}
 
-interface Node {
-	parent: PositionAndSize;
-	child: {
-		parent: PositionAndSize;
-	};
-}
-
-const node = {
-	parent: flattenProps,
-	child: {
-		parent: flattenProps,
-	},
-};
+// 	someMethod() {
+// 		return this.code;
+// 	}
+// }
 
-expectAssignable<Simplify<Node>>(node);
-expectAssignable<Simplify<Node, {deep: true}>>(node);
+// expectType<Simplify<SomeClass>>(new SomeClass());