Allow jest.config.cts

CHANGELOG.md

@@ -12,6 +12,7 @@
 - `[jest-mock]` Tweak typings to allow `jest.replaceProperty()` replace methods ([#14008](https://github.com/facebook/jest/pull/14008))
 - `[jest-snapshot]` Fix a potential bug when not using prettier and improve performance ([#14036](https://github.com/facebook/jest/pull/14036))
 - `[@jest/transform]` Do not instrument `.json` modules ([#14048](https://github.com/facebook/jest/pull/14048))
+- `[jest-config]` Allow loading `jest.config.cts` files ([#14070](https://github.com/facebook/jest/pull/14070))
 
 ### Chore & Maintenance
 

docs/Configuration.md

@@ -5,7 +5,7 @@ title: Configuring Jest
 
 The Jest philosophy is to work great by default, but sometimes you just need more configuration power.
 
-It is recommended to define the configuration in a dedicated JavaScript, TypeScript or JSON file. The file will be discovered automatically, if it is named `jest.config.js|ts|mjs|cjs|json`. You can use [`--config`](CLI.md#--configpath) flag to pass an explicit path to the file.
+It is recommended to define the configuration in a dedicated JavaScript, TypeScript or JSON file. The file will be discovered automatically, if it is named `jest.config.js|ts|mjs|cjs|cts|json`. You can use [`--config`](CLI.md#--configpath) flag to pass an explicit path to the file.
 
 :::note
 

e2e/__tests__/tsIntegration.test.ts

@@ -54,6 +54,45 @@ describe('when `Config` type is imported from "@jest/types"', () => {
     expect(globalConfig.verbose).toBe(true);
   });
 
+  test('with object config exported from CTS file', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(123).toBe(123));",
+      'jest.config.cts': `
+      import type {Config} from '@jest/types';
+      const config: Config.InitialOptions = {displayName: 'ts-object-config', verbose: true};
+      export default config;
+      `,
+      'package.json': '{}',
+    });
+
+    const {configs, globalConfig} = getConfig(path.join(DIR));
+
+    expect(configs).toHaveLength(1);
+    expect(configs[0].displayName?.name).toBe('ts-object-config');
+    expect(globalConfig.verbose).toBe(true);
+  });
+
+  test('with function config exported from CTS file', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(123).toBe(123));",
+      'jest.config.cts': `
+        import type {Config} from '@jest/types';
+        async function getVerbose() {return true;}
+        export default async (): Promise<Config.InitialOptions> => {
+          const verbose: Config.InitialOptions['verbose'] = await getVerbose();
+          return {displayName: 'ts-async-function-config', verbose};
+        };
+        `,
+      'package.json': '{}',
+    });
+
+    const {configs, globalConfig} = getConfig(path.join(DIR));
+
+    expect(configs).toHaveLength(1);
+    expect(configs[0].displayName?.name).toBe('ts-async-function-config');
+    expect(globalConfig.verbose).toBe(true);
+  });
+
   test('throws if type errors are encountered', () => {
     writeFiles(DIR, {
       '__tests__/dummy.test.js': "test('dummy', () => expect(123).toBe(123));",
@@ -92,6 +131,44 @@ describe('when `Config` type is imported from "@jest/types"', () => {
     expect(exitCode).toBe(1);
   });
 
+  test('throws if type errors are encountered with CTS config', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(123).toBe(123));",
+      'jest.config.cts': `
+        import type {Config} from '@jest/types';
+        const config: Config.InitialOptions = {testTimeout: '10000'};
+        export default config;
+        `,
+      'package.json': '{}',
+    });
+
+    const {stderr, exitCode} = runJest(DIR);
+
+    expect(stderr).toMatch(
+      "jest.config.cts(2,40): error TS2322: Type 'string' is not assignable to type 'number'.",
+    );
+    expect(exitCode).toBe(1);
+  });
+
+  test('throws if syntax errors are encountered with CTS config', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(123).toBe(123));",
+      'jest.config.cts': `
+        import type {Config} from '@jest/types';
+        const config: Config.InitialOptions = {verbose: true};
+        export default get config;
+        `,
+      'package.json': '{}',
+    });
+
+    const {stderr, exitCode} = runJest(DIR);
+
+    expect(stderr).toMatch(
+      "jest.config.cts(3,16): error TS2304: Cannot find name 'get'.",
+    );
+    expect(exitCode).toBe(1);
+  });
+
   test('works with object config exported from TS file when package.json#type=module', () => {
     writeFiles(DIR, {
       '__tests__/dummy.test.js': "test('dummy', () => expect(12).toBe(12));",
@@ -114,6 +191,45 @@ describe('when `Config` type is imported from "@jest/types"', () => {
     writeFiles(DIR, {
       '__tests__/dummy.test.js': "test('dummy', () => expect(12).toBe(12));",
       'jest.config.ts': `
+      import type {Config} from '@jest/types';
+      async function getVerbose() {return true;}
+      export default async (): Promise<Config.InitialOptions> => {
+        const verbose: Config.InitialOptions['verbose'] = await getVerbose();
+        return {displayName: 'ts-esm-async-function-config', verbose};
+      };
+      `,
+      'package.json': '{"type": "module"}',
+    });
+
+    const {configs, globalConfig} = getConfig(path.join(DIR));
+
+    expect(configs).toHaveLength(1);
+    expect(configs[0].displayName?.name).toBe('ts-esm-async-function-config');
+    expect(globalConfig.verbose).toBe(true);
+  });
+
+  test('works with object config exported from CTS file when package.json#type=module', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(12).toBe(12));",
+      'jest.config.cts': `
+          import type {Config} from '@jest/types';
+          const config: Config.InitialOptions = {displayName: 'ts-esm-object-config', verbose: true};
+          export default config;
+          `,
+      'package.json': '{"type": "module"}',
+    });
+
+    const {configs, globalConfig} = getConfig(path.join(DIR));
+
+    expect(configs).toHaveLength(1);
+    expect(configs[0].displayName?.name).toBe('ts-esm-object-config');
+    expect(globalConfig.verbose).toBe(true);
+  });
+
+  test('works with function config exported from CTS file when package.json#type=module', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(12).toBe(12));",
+      'jest.config.cts': `
           import type {Config} from '@jest/types';
           async function getVerbose() {return true;}
           export default async (): Promise<Config.InitialOptions> => {
@@ -168,6 +284,44 @@ describe('when `Config` type is imported from "@jest/types"', () => {
     );
     expect(exitCode).toBe(1);
   });
+
+  test('throws if type errors are encountered when package.json#type=module with CTS config', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(12).toBe(12));",
+      'jest.config.cts': `
+          import type {Config} from '@jest/types';
+          const config: Config.InitialOptions = {testTimeout: '10000'};
+          export default config;
+          `,
+      'package.json': '{"type": "module"}',
+    });
+
+    const {stderr, exitCode} = runJest(DIR);
+
+    expect(stderr).toMatch(
+      "jest.config.cts(2,40): error TS2322: Type 'string' is not assignable to type 'number'.",
+    );
+    expect(exitCode).toBe(1);
+  });
+
+  test('throws if syntax errors are encountered when package.json#type=module with CTS config', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(123).toBe(123));",
+      'jest.config.cts': `
+          import type {Config} from '@jest/types';
+          const config: Config.InitialOptions = {verbose: true};
+          export default get config;
+          `,
+      'package.json': '{"type": "module"}',
+    });
+
+    const {stderr, exitCode} = runJest(DIR);
+
+    expect(stderr).toMatch(
+      "jest.config.cts(3,16): error TS2304: Cannot find name 'get'.",
+    );
+    expect(exitCode).toBe(1);
+  });
 });
 
 describe('when `Config` type is imported from "jest"', () => {
@@ -210,6 +364,45 @@ describe('when `Config` type is imported from "jest"', () => {
     expect(globalConfig.verbose).toBe(true);
   });
 
+  test('with object config exported from CTS file', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(123).toBe(123));",
+      'jest.config.cts': `
+        import type {Config} from 'jest';
+        const config: Config = {displayName: 'ts-object-config', verbose: true};
+        export default config;
+        `,
+      'package.json': '{}',
+    });
+
+    const {configs, globalConfig} = getConfig(path.join(DIR));
+
+    expect(configs).toHaveLength(1);
+    expect(configs[0].displayName?.name).toBe('ts-object-config');
+    expect(globalConfig.verbose).toBe(true);
+  });
+
+  test('with function config exported from CTS file', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(123).toBe(123));",
+      'jest.config.cts': `
+        import type {Config} from 'jest';
+        async function getVerbose() {return true;}
+        export default async (): Promise<Config> => {
+          const verbose: Config['verbose'] = await getVerbose();
+          return {displayName: 'ts-async-function-config', verbose};
+        };
+        `,
+      'package.json': '{}',
+    });
+
+    const {configs, globalConfig} = getConfig(path.join(DIR));
+
+    expect(configs).toHaveLength(1);
+    expect(configs[0].displayName?.name).toBe('ts-async-function-config');
+    expect(globalConfig.verbose).toBe(true);
+  });
+
   test('throws if type errors are encountered', () => {
     writeFiles(DIR, {
       '__tests__/dummy.test.js': "test('dummy', () => expect(123).toBe(123));",
@@ -248,6 +441,44 @@ describe('when `Config` type is imported from "jest"', () => {
     expect(exitCode).toBe(1);
   });
 
+  test('throws if type errors are encountered with CTS config', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(123).toBe(123));",
+      'jest.config.cts': `
+        import type {Config} from 'jest';
+        const config: Config = {testTimeout: '10000'};
+        export default config;
+        `,
+      'package.json': '{}',
+    });
+
+    const {stderr, exitCode} = runJest(DIR);
+
+    expect(stderr).toMatch(
+      "jest.config.cts(2,25): error TS2322: Type 'string' is not assignable to type 'number'.",
+    );
+    expect(exitCode).toBe(1);
+  });
+
+  test('throws if syntax errors are encountered with CTS config', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(123).toBe(123));",
+      'jest.config.cts': `
+        import type {Config} from 'jest';
+        const config: Config = {verbose: true};
+        export default get config;
+        `,
+      'package.json': '{}',
+    });
+
+    const {stderr, exitCode} = runJest(DIR);
+
+    expect(stderr).toMatch(
+      "jest.config.cts(3,16): error TS2304: Cannot find name 'get'.",
+    );
+    expect(exitCode).toBe(1);
+  });
+
   test('works with object config exported from TS file when package.json#type=module', () => {
     writeFiles(DIR, {
       '__tests__/dummy.test.js': "test('dummy', () => expect(12).toBe(12));",
@@ -287,6 +518,45 @@ describe('when `Config` type is imported from "jest"', () => {
     expect(globalConfig.verbose).toBe(true);
   });
 
+  test('works with object config exported from CTS file when package.json#type=module', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(12).toBe(12));",
+      'jest.config.cts': `
+          import type {Config} from 'jest';
+          const config: Config = {displayName: 'ts-esm-object-config', verbose: true};
+          export default config;
+          `,
+      'package.json': '{"type": "module"}',
+    });
+
+    const {configs, globalConfig} = getConfig(path.join(DIR));
+
+    expect(configs).toHaveLength(1);
+    expect(configs[0].displayName?.name).toBe('ts-esm-object-config');
+    expect(globalConfig.verbose).toBe(true);
+  });
+
+  test('works with function config exported from CTS file when package.json#type=module', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(12).toBe(12));",
+      'jest.config.cts': `
+          import type {Config} from 'jest';
+          async function getVerbose() {return true;}
+          export default async (): Promise<Config> => {
+            const verbose: Config['verbose'] = await getVerbose();
+            return {displayName: 'ts-esm-async-function-config', verbose};
+          };
+          `,
+      'package.json': '{"type": "module"}',
+    });
+
+    const {configs, globalConfig} = getConfig(path.join(DIR));
+
+    expect(configs).toHaveLength(1);
+    expect(configs[0].displayName?.name).toBe('ts-esm-async-function-config');
+    expect(globalConfig.verbose).toBe(true);
+  });
+
   test('throws if type errors are encountered when package.json#type=module', () => {
     writeFiles(DIR, {
       '__tests__/dummy.test.js': "test('dummy', () => expect(12).toBe(12));",
@@ -324,4 +594,42 @@ describe('when `Config` type is imported from "jest"', () => {
     );
     expect(exitCode).toBe(1);
   });
+
+  test('throws if type errors are encountered when package.json#type=module with CTS config', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(12).toBe(12));",
+      'jest.config.cts': `
+          import type {Config} from 'jest';
+          const config: Config = {testTimeout: '10000'};
+          export default config;
+          `,
+      'package.json': '{"type": "module"}',
+    });
+
+    const {stderr, exitCode} = runJest(DIR);
+
+    expect(stderr).toMatch(
+      "jest.config.cts(2,25): error TS2322: Type 'string' is not assignable to type 'number'.",
+    );
+    expect(exitCode).toBe(1);
+  });
+
+  test('throws if syntax errors are encountered when package.json#type=module with CTS config', () => {
+    writeFiles(DIR, {
+      '__tests__/dummy.test.js': "test('dummy', () => expect(123).toBe(123));",
+      'jest.config.cts': `
+          import type {Config} from 'jest';
+          const config: Config = {verbose: true};
+          export default get config;
+          `,
+      'package.json': '{"type": "module"}',
+    });
+
+    const {stderr, exitCode} = runJest(DIR);
+
+    expect(stderr).toMatch(
+      "jest.config.cts(3,16): error TS2304: Cannot find name 'get'.",
+    );
+    expect(exitCode).toBe(1);
+  });
 });

packages/jest-cli/src/__tests__/args.test.ts

@@ -89,13 +89,13 @@ describe('check', () => {
 
   it('raises an exception if config is not a valid JSON string', () => {
     expect(() => check(argv({config: 'x:1'}))).toThrow(
-      'The --config option requires a JSON string literal, or a file path with one of these extensions: .js, .ts, .mjs, .cjs, .json',
+      'The --config option requires a JSON string literal, or a file path with one of these extensions: .js, .ts, .mjs, .cjs, .cts, .json',
     );
   });
 
   it('raises an exception if config is not a supported file type', () => {
     const message =
-      'The --config option requires a JSON string literal, or a file path with one of these extensions: .js, .ts, .mjs, .cjs, .json';
+      'The --config option requires a JSON string literal, or a file path with one of these extensions: .js, .ts, .mjs, .cjs, .cts, .json';
 
     expect(() => check(argv({config: 'jest.configjs'}))).toThrow(message);
     expect(() => check(argv({config: 'jest.config.exe'}))).toThrow(message);