fix: revert support implementation for Node16/NodeNext

- For CJS mode, `module` is always `CommonJS`
- For ESM mode, `module` with value `Node16/NodeNext` will use `ESNext`, otherwise use the value provided by test `tsconfig`
- `moduleResolution` is always `Node10`

Fixes #4468
Fixes #4473

e2e/__tests__/native-esm-ts.test.ts

@@ -1,11 +1,18 @@
+import path from 'path'
+
 import { json as runWithJson } from '../run-jest'
+import { runNpmInstall } from '../utils'
+
+beforeAll(() => {
+  runNpmInstall(path.join(__dirname, '..', 'native-esm-ts'))
+})
 
 test('runs TS test with native ESM', () => {
-  const { exitCode, json } = runWithJson('native-esm-ts', [], {
+  const { exitCode, json } = runWithJson('native-esm-ts', ['--no-cache'], {
     nodeOptions: '--experimental-vm-modules --no-warnings',
   })
 
   expect(exitCode).toBe(0)
-  expect(json.numTotalTests).toBe(4)
-  expect(json.numPassedTests).toBe(4)
+  expect(json.numTotalTests).toBe(6)
+  expect(json.numPassedTests).toBe(6)
 })

e2e/native-esm-ts/__tests__/third-party.spec.ts

@@ -0,0 +1,16 @@
+import path from 'node:path'
+
+import { it, describe, expect } from '@jest/globals'
+
+import { fileName } from '../third-parties/dirname-filename-esm.js'
+import { backend } from '../third-parties/i18next-fs-backend.js'
+
+describe('Third parties', () => {
+  it('should work with i18next-fs-backend', () => {
+    expect(backend).toBeDefined()
+  })
+
+  it('should work with dirname-filename-esm', () => {
+    expect(path.basename(fileName(import.meta))).toBe('third-party.spec.ts')
+  })
+})

e2e/native-esm-ts/package.json

@@ -1,6 +1,8 @@
 {
   "type": "module",
   "devDependencies": {
-    "@jest/globals": "^29.7.0"
+    "@jest/globals": "^29.7.0",
+    "dirname-filename-esm": "^1.1.2",
+    "i18next-fs-backend": "^2.3.2"
   }
 }

e2e/native-esm-ts/third-parties/dirname-filename-esm.ts

@@ -0,0 +1,3 @@
+import { filename } from 'dirname-filename-esm'
+
+export { filename as fileName }

e2e/native-esm-ts/third-parties/i18next-fs-backend.ts

@@ -0,0 +1,3 @@
+import { default as Backend } from 'i18next-fs-backend'
+
+export const backend = new Backend()

src/legacy/compiler/ts-compiler.spec.ts

@@ -200,7 +200,7 @@ describe('TsCompiler', () => {
           useESM: true,
           supportsStaticESM: true,
           moduleValue: 'NodeNext',
-          expectedModule: ts.ModuleKind.NodeNext,
+          expectedModule: ts.ModuleKind.ESNext,
           expectedEsModuleInterop: true,
         },
         {
@@ -252,6 +252,7 @@ describe('TsCompiler', () => {
 
           expect(usedCompilerOptions.module).toBe(expectedModule)
           expect(usedCompilerOptions.esModuleInterop).toBe(expectedEsModuleInterop)
+          expect(usedCompilerOptions.moduleResolution).toBe(ts.ModuleResolutionKind.Node10)
           expect(output).toEqual({
             code: updateOutput(jsOutput, fileName, sourceMap),
             diagnostics: [],

src/legacy/compiler/ts-compiler.ts

@@ -147,31 +147,27 @@ export class TsCompiler implements TsCompilerInstance {
   }
 
   private fixupCompilerOptionsForModuleKind(compilerOptions: CompilerOptions, isEsm: boolean): CompilerOptions {
+    const moduleResolution = this._ts.ModuleResolutionKind.Node10
     if (!isEsm) {
-      const moduleKind = compilerOptions.module ?? this._ts.ModuleKind.CommonJS
-      const moduleKindValue = [
-        this._ts.ModuleKind.CommonJS,
-        this._ts.ModuleKind.Node16,
-        this._ts.ModuleKind.NodeNext,
-      ].includes(moduleKind)
-        ? moduleKind
-        : this._ts.ModuleKind.CommonJS
-
       return {
         ...compilerOptions,
-        module: moduleKindValue,
+        module: this._ts.ModuleKind.CommonJS,
+        moduleResolution,
       }
     }
 
-    const moduleKind = compilerOptions.module ?? this._ts.ModuleKind.ESNext
-    const esModuleInterop = [this._ts.ModuleKind.Node16, this._ts.ModuleKind.NodeNext].includes(moduleKind)
-      ? true
-      : compilerOptions.esModuleInterop
+    let moduleKind = compilerOptions.module ?? this._ts.ModuleKind.ESNext
+    let esModuleInterop = compilerOptions.esModuleInterop
+    if ([this._ts.ModuleKind.Node16, this._ts.ModuleKind.NodeNext].includes(moduleKind)) {
+      esModuleInterop = true
+      moduleKind = this._ts.ModuleKind.ESNext
+    }
 
     return {
       ...compilerOptions,
       module: moduleKind,
-      esModuleInterop: esModuleInterop ?? false,
+      esModuleInterop,
+      moduleResolution,
     }
   }