Infer jest globals from @jest/globals

types/expect-puppeteer/expect-puppeteer-tests.ts

@@ -1,5 +1,6 @@
 import { ElementHandle, Page } from "puppeteer";
 import { getDefaultOptions, setDefaultOptions } from 'expect-puppeteer';
+import { expect } from 'expect';
 
 const testGlobal = async (instance: ElementHandle | Page) => {
     await expect(instance).toClick({ type: 'css', value: 'selector' });

types/expect-puppeteer/index.d.ts

@@ -5,8 +5,6 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // Minimum TypeScript Version: 4.3
 
-/// <reference types="jest" />
-
 import { ElementHandle, Page, Dialog } from "puppeteer";
 
 /**
@@ -90,20 +88,18 @@ interface ExpectPuppeteer {
     toUploadFile(selector: string | MatchSelector, filePath: string, options?: ExpectTimingActions): Promise<void>;
 }
 
-declare global {
-    namespace jest {
-        interface Matchers<R, T> {
-            // These must all match the ExpectPuppeteer interface above.
-            // We can't extend from it directly because some method names conflict in type-incompatible ways.
-            toClick(selector: string | MatchSelector, options?: ExpectToClickOptions): Promise<void>;
-            toDisplayDialog(block: () => Promise<void>): Promise<Dialog>;
-            toFill(selector: string | MatchSelector, value: string, options?: ExpectTimingActions): Promise<void>;
-            toFillForm(selector: string | MatchSelector, value: { [key: string]: any}, options?: ExpectTimingActions): Promise<void>;
-            toMatch(matcher: string | RegExp, options?: ExpectTimingActions): Promise<void>;
-            toMatchElement(selector: string | MatchSelector, options?: ExpectToClickOptions): Promise<ElementHandle>;
-            toSelect(selector: string | MatchSelector, valueOrText: string, options?: ExpectTimingActions): Promise<void>;
-            toUploadFile(selector: string | MatchSelector, filePath: string, options?: ExpectTimingActions): Promise<void>;
-        }
+declare module 'expect' {
+    interface Matchers<R> {
+        // These must all match the ExpectPuppeteer interface above.
+        // We can't extend from it directly because some method names conflict in type-incompatible ways.
+        toClick(selector: string | MatchSelector, options?: ExpectToClickOptions): Promise<void>;
+        toDisplayDialog(block: () => Promise<void>): Promise<Dialog>;
+        toFill(selector: string | MatchSelector, value: string, options?: ExpectTimingActions): Promise<void>;
+        toFillForm(selector: string | MatchSelector, value: { [key: string]: any}, options?: ExpectTimingActions): Promise<void>;
+        toMatch(matcher: string | RegExp, options?: ExpectTimingActions): Promise<void>;
+        toMatchElement(selector: string | MatchSelector, options?: ExpectToClickOptions): Promise<ElementHandle>;
+        toSelect(selector: string | MatchSelector, valueOrText: string, options?: ExpectTimingActions): Promise<void>;
+        toUploadFile(selector: string | MatchSelector, filePath: string, options?: ExpectTimingActions): Promise<void>;
     }
 }
 

types/expect-puppeteer/package.json

@@ -0,0 +1,6 @@
+{
+    "private": true,
+    "dependencies": {
+        "expect": "^29.0.0"
+    }
+}

types/heft-jest/index.d.ts

@@ -3,10 +3,42 @@
 // Definitions by: Pete Gonzalez <https://github.com/octogonz>
 //                 Ian Clanton-Thuon <https://github.com/iclanton>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.3
+// Minimum TypeScript Version: 4.5
 
-/// <reference types="jest" />
-/// <reference path="./mocked.d.ts" />
+type MockInstance<T> = import('jest-mock').MockInstance<T>;
+
+namespace mocked {
+    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<T> {
+        new (...args: ConstructorArgumentsOf<T>): T;
+        (...args: ArgumentsOf<T>): ReturnType<T>;
+    }
+
+    type MaybeMockedConstructor<T> = T extends new (...args: any[]) => infer R
+        ? MockInstance<(...args: ConstructorArgumentsOf<T>) => R>
+        : {};
+    type MockedFunction<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 ? MockedFunction<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
+        ? MockedObjectDeep<T>
+        : T;
+
+    type MaybeMocked<T> = T extends MockableFunction ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
+}
 
 /**
  * Tests can use the `mocked()` function to access additional properties that
@@ -32,5 +64,5 @@
  *
  * https://kulshekhar.github.io/ts-jest/user/test-helpers
  */
-declare function mocked<T>(item: T, deep?: false): mocked.MaybeMocked<T>;
-declare function mocked<T>(item: T, deep: true): mocked.MaybeMockedDeep<T>;
+function mocked<T>(item: T, deep?: false): mocked.MaybeMocked<T>;
+function mocked<T>(item: T, deep: true): mocked.MaybeMockedDeep<T>;

types/heft-jest/package.json

@@ -0,0 +1,6 @@
+{
+    "private": true,
+    "dependencies": {
+        "jest-mock": "^29.0.0"
+    }
+}

types/jest-axe/index.d.ts

@@ -4,8 +4,6 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // Minimum TypeScript Version: 4.3
 
-/// <reference types="jest" />
-
 import { AxeResults, Result, RunOptions, Spec } from 'axe-core';
 
 export interface JestAxeConfigureOptions extends RunOptions {
@@ -69,13 +67,13 @@ export const toHaveNoViolations: {
     toHaveNoViolations: IToHaveNoViolations;
 };
 
-declare global {
-    namespace jest {
-        interface Matchers<R, T> {
-            toHaveNoViolations(): R;
-        }
+declare module 'expect' {
+    interface Matchers<R> {
+        toHaveNoViolations(): R;
     }
+}
 
+declare global {
     // axe-core depends on a global Node
     interface Node {}
 }

types/jest-axe/package.json

@@ -1,6 +1,7 @@
 {
     "private": true,
     "dependencies": {
-        "axe-core": "^3.5.5"
+        "axe-core": "^3.5.5",
+        "expect": "^29.0.0"
     }
 }

types/jest-expect-message/index.d.ts

@@ -5,17 +5,18 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // Minimum TypeScript Version: 4.3
 
-/// <reference types="jest"/>
+import { Matchers } from 'expect';
 
-declare namespace jest {
-    interface Expect {
+// tslint:disable-next-line: no-single-declare-module
+declare module 'expect' {
+    interface BaseExpect {
         /**
          * The `expect` function is used every time you want to test a value.
          * You will rarely call `expect` by itself.
          *
          * @param actual The value to apply matchers against.
          * @param message Clarification message
          */
-        <T = any>(actual: T, message: string): JestMatchers<T>;
+        (actual: any, message: string): Matchers<void>;
     }
 }

types/jest-expect-message/jest-expect-message-tests.ts

@@ -1,6 +1,3 @@
-import 'jest';
-import 'jest-expect-message';
+import { expect } from 'expect';
 
-declare const expect: jest.Expect;
-
-expect(2, "Two is always two").toBe(2);
+expect(2, 'Two is always two').toBe(2);

types/jest-expect-message/package.json

@@ -0,0 +1,6 @@
+{
+    "private": true,
+    "dependencies": {
+        "expect": "^29.0.0"
+    }
+}

types/jest-image-snapshot/index.d.ts

@@ -6,8 +6,6 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // Minimum TypeScript Version: 4.3
 
-/// <reference types="jest" />
-
 import { PixelmatchOptions } from 'pixelmatch';
 import { Options as SSIMOptions } from 'ssim.js';
 
@@ -140,10 +138,8 @@ export function updateSnapshotState<TObject, TPartial>(
     partialSnapshotState: TPartial,
 ): TObject & TPartial;
 
-declare global {
-    namespace jest {
-        interface Matchers<R, T> {
-            toMatchImageSnapshot(options?: MatchImageSnapshotOptions): R;
-        }
+declare module 'expect' {
+    interface Matchers<R> {
+        toMatchImageSnapshot(options?: MatchImageSnapshotOptions): R;
     }
 }

types/jest-image-snapshot/jest-image-snapshot-tests.ts

@@ -1,10 +1,13 @@
+import { expect } from 'expect';
 import {
     configureToMatchImageSnapshot,
     MatchImageSnapshotOptions,
     toMatchImageSnapshot,
     updateSnapshotState,
 } from 'jest-image-snapshot';
 
+declare const it: any;
+
 it('should be able to use toMatchImageSnapshot in a test', () => {
     expect.extend({ toMatchImageSnapshot });
 

types/jest-image-snapshot/package.json

@@ -1,6 +1,7 @@
 {
     "private": true,
     "dependencies": {
+        "expect": "^29.0.0",
         "ssim.js": "^3.1.1"
     }
 }