From 9418133a3a4771121be7b224c9aaf5ed76287788 Mon Sep 17 00:00:00 2001
From: Rajat <rd.rajat23@gmail.com>
Date: Fri, 31 Dec 2021 01:01:24 +0530
Subject: [PATCH] =?UTF-8?q?=F0=9F=A4=96=20Merge=20PR=20#57776=20[jest]=20a?=
 =?UTF-8?q?dding=20definitions=20for=20`mocked`=20function=20by=20@k-rajat?=
 =?UTF-8?q?19?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* mocked

* fixing jest-tests

* prettier

* removing prettier changes

* tslint

* making requested changes

* jest-tests

* removing comments
---
 types/jest/index.d.ts    | 49 +++++++++++++++++++++++++++++++++++++++-
 types/jest/jest-tests.ts |  5 ++++
 2 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/types/jest/index.d.ts b/types/jest/index.d.ts
index bf9f61899643d88..0970a208ac52beb 100644
--- a/types/jest/index.d.ts
+++ b/types/jest/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Jest 27.0
+// Type definitions for Jest 27.4
 // Project: https://jestjs.io/
 // Definitions by: Asana (https://asana.com)
 //                 Ivo Stratev <https://github.com/NoHomey>
@@ -178,6 +178,25 @@ declare namespace jest {
      * Mocks a module with an auto-mocked version when it is being required.
      */
     function mock(moduleName: string, factory?: () => unknown, options?: MockOptions): typeof jest;
+
+    /**
+     * The mocked test helper provides typings on your mocked modules and even
+     * their deep methods, based on the typing of its source. It makes use of
+     * the latest TypeScript feature, so you even have argument types
+     * completion in the IDE (as opposed to jest.MockInstance).
+     *
+     * Note: while it needs to be a function so that input type is changed, the helper itself does nothing else than returning the given input value.
+     */
+     function mocked<T>(item: T, deep?: false): MaybeMocked<T>;
+    /**
+     * The mocked test helper provides typings on your mocked modules and even
+     * their deep methods, based on the typing of its source. It makes use of
+     * the latest TypeScript feature, so you even have argument types
+     * completion in the IDE (as opposed to jest.MockInstance).
+     *
+     * Note: while it needs to be a function so that input type is changed, the helper itself does nothing else than returning the given input value.
+     */
+     function mocked<T>(item: T, deep: true): MaybeMockedDeep<T>;
     /**
      * Returns the actual module instead of a mock, bypassing all checks on
      * whether the module should receive a mock implementation or not.
@@ -312,6 +331,34 @@ declare namespace jest {
         virtual?: boolean | undefined;
     }
 
+    type MockableFunction = (...args: any[]) => any;
+    type MethodKeysOf<T> = { [K in keyof T]: T[K] extends MockableFunction ? K : never }[keyof T];
+    type PropertyKeysOf<T> = { [K in keyof T]: T[K] extends MockableFunction ? never : K }[keyof T];
+    type ArgumentsOf<T> = T extends (...args: infer A) => any ? A : never;
+    type ConstructorArgumentsOf<T> = T extends new (...args: infer A) => any ? A : never;
+
+    interface MockWithArgs<T extends MockableFunction> extends MockInstance<ReturnType<T>, ArgumentsOf<T>> {
+        new (...args: ConstructorArgumentsOf<T>): T;
+        (...args: ArgumentsOf<T>): ReturnType<T>;
+    }
+    type MaybeMockedConstructor<T> = T extends new (...args: any[]) => infer R
+        ? MockInstance<R, ConstructorArgumentsOf<T>>
+        : T;
+    type MockedFn<T extends MockableFunction> = MockWithArgs<T> & { [K in keyof T]: T[K] };
+    type MockedFunctionDeep<T extends MockableFunction> = MockWithArgs<T> & MockedObjectDeep<T>;
+    type MockedObject<T> = MaybeMockedConstructor<T> & {
+        [K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFn<T[K]> : T[K];
+    } & { [K in PropertyKeysOf<T>]: T[K] };
+    type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
+        [K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFunctionDeep<T[K]> : T[K];
+    } & { [K in PropertyKeysOf<T>]: MaybeMockedDeep<T[K]> };
+    type MaybeMockedDeep<T> = T extends MockableFunction
+        ? MockedFunctionDeep<T>
+        : T extends object // eslint-disable-line @typescript-eslint/ban-types
+        ? MockedObjectDeep<T>
+        : T;
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    type MaybeMocked<T> = T extends MockableFunction ? MockedFn<T> : T extends object ? MockedObject<T> : T;
     type EmptyFunction = () => void;
     type ArgsType<T> = T extends (...args: infer A) => any ? A : never;
     type ConstructorArgsType<T> = T extends new (...args: infer A) => any ? A : never;
diff --git a/types/jest/jest-tests.ts b/types/jest/jest-tests.ts
index 4169455e21c95c1..45bdea34269b12f 100644
--- a/types/jest/jest-tests.ts
+++ b/types/jest/jest-tests.ts
@@ -531,6 +531,11 @@ class SpyableClass {
 // $ExpectType SpyInstance<SpyableClass, [number, string]> || SpyInstance<SpyableClass, [a: number, b: string]>
 jest.spyOn({ SpyableClass }, "SpyableClass");
 
+// $ExpectType MockedObject<{}>
+jest.mocked({});
+// $ExpectError
+jest.mocked();
+
 interface Type1 {
     a: number;
 }