fix: transpile js files from node_modules whenever Jest asks (#4791)

Also only show warning about `allowJs` for `isolatedModules: false`

Closes #4637

Author: ahnpnl

src/__helpers__/dedent-string.ts

@@ -0,0 +1,13 @@
+export const omitLeadingWhitespace = (text: string): string => {
+  return text.replace(/^\s+/gm, '')
+}
+
+export const dedent = (strings: TemplateStringsArray, ...values: unknown[]) => {
+  let joinedString = ''
+  for (let i = 0; i < values.length; i++) {
+    joinedString += `${strings[i]}${values[i]}`
+  }
+  joinedString += strings[strings.length - 1]
+
+  return omitLeadingWhitespace(joinedString)
+}

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

@@ -1,11 +1,13 @@
 import { readFileSync } from 'fs'
 import { basename, join, normalize } from 'path'
 
+import { LogLevels } from 'bs-logger'
 import type { TsConfigJson } from 'type-fest'
 import type { CompilerOptions, EmitOutput, transpileModule, TranspileOutput } from 'typescript'
 import ts from 'typescript'
 
 import { createConfigSet, makeCompiler } from '../../__helpers__/fakers'
+import { logTargetMock } from '../../__helpers__/mocks'
 import type { RawCompilerOptions } from '../../raw-compiler-options'
 import { tsTranspileModule } from '../../transpilers/typescript/transpile-module'
 import type { DepGraphInfo } from '../../types'
@@ -38,6 +40,8 @@ const mockFolder = join(process.cwd(), 'src', '__mocks__')
 
 const baseTsJestConfig = { tsconfig: join(process.cwd(), 'tsconfig.json') }
 
+const logTarget = logTargetMock()
+
 describe('TsCompiler', () => {
   describe('getResolvedModules', () => {
     const fileName = join(mockFolder, 'thing.ts')
@@ -248,6 +252,33 @@ describe('TsCompiler', () => {
       const jsOutput = 'var bar = 1'
       const sourceMap = '{}'
 
+      test('should return the original js content for js file with allowJs false and show warning log', () => {
+        const configSet = createConfigSet({
+          tsJestConfig: {
+            ...baseTsJestConfig,
+            tsconfig: {
+              allowJs: false,
+            },
+          },
+        })
+        const compiler = new TsCompiler(configSet, new Map())
+
+        expect(
+          compiler.getCompiledOutput('const foo = 1', 'foo.js', {
+            supportsStaticESM: false,
+            depGraphs: new Map(),
+            watchMode: false,
+          }),
+        ).toEqual({
+          code: 'const foo = 1',
+        })
+        expect(logTarget.filteredLines(LogLevels.warn)).toEqual(
+          expect.arrayContaining([
+            expect.stringContaining(interpolate(Errors.GotJsFileButAllowJsFalse, { path: 'foo.js' })),
+          ]),
+        )
+      })
+
       test.each([
         {
           useESM: true,

src/legacy/compiler/ts-compiler.ts

@@ -22,7 +22,7 @@ import ts, {
   TranspileOutput,
 } from 'typescript'
 
-import { LINE_FEED, TS_TSX_REGEX } from '../../constants'
+import { JS_JSX_REGEX, LINE_FEED, TS_TSX_REGEX } from '../../constants'
 import { isModernNodeModuleKind, tsTranspileModule } from '../../transpilers/typescript/transpile-module'
 import type {
   StringMap,
@@ -200,6 +200,14 @@ export class TsCompiler implements TsCompilerInstance {
     const moduleKind = this._initialCompilerOptions.module
     const currentModuleKind = this._compilerOptions.module
     if (this._languageService) {
+      if (JS_JSX_REGEX.test(fileName) && !this._compilerOptions.allowJs) {
+        this._logger.warn({ fileName: fileName }, interpolate(Errors.GotJsFileButAllowJsFalse, { path: fileName }))
+
+        return {
+          code: fileContent,
+        }
+      }
+
       this._logger.debug({ fileName }, 'getCompiledOutput(): compiling using language service')
 
       // Must set memory cache before attempting to compile

src/legacy/ts-jest-transformer.spec.ts

@@ -3,8 +3,11 @@ import path from 'path'
 
 import { LogLevels } from 'bs-logger'
 import { removeSync } from 'fs-extra'
+import ts from 'typescript'
 
+import { dedent, omitLeadingWhitespace } from '../__helpers__/dedent-string'
 import { logTargetMock } from '../__helpers__/mocks'
+import type { TsJestTransformOptions } from '../types'
 import { importer } from '../utils/importer'
 
 import { TsJestCompiler } from './compiler'
@@ -14,7 +17,7 @@ const SOURCE_MAPPING_PREFIX = 'sourceMappingURL='
 
 const logTarget = logTargetMock()
 const cacheDir = path.join(process.cwd(), 'tmp')
-const baseTransformOptions = {
+const baseTransformOptions: TsJestTransformOptions = {
   config: {
     testMatch: [],
     testRegex: [],
@@ -298,34 +301,6 @@ describe('TsJestTransformer', () => {
       })
     })
 
-    test('should process js file with allowJs false and show warning log', () => {
-      const fileContent = 'const foo = 1'
-      const filePath = 'foo.js'
-      const transformOptions = {
-        ...baseTransformOptions,
-        config: {
-          ...baseTransformOptions.config,
-          globals: {
-            'ts-jest': { tsconfig: { allowJs: false } },
-          },
-        },
-      }
-      tr.getCacheKey(fileContent, filePath, transformOptions)
-      logTarget.clear()
-
-      const result = tr.process(fileContent, filePath, transformOptions)
-
-      expect(result).toEqual({
-        code: fileContent,
-      })
-      expect(logTarget.lines[1].substring(0)).toMatchInlineSnapshot(`
-        "[level:40] Got a \`.js\` file to compile while \`allowJs\` option is not set to \`true\` (file: foo.js). To fix this:
-          - if you want TypeScript to process JS files, set \`allowJs\` to \`true\` in your TypeScript config (usually tsconfig.json)
-          - if you do not want TypeScript to process your \`.js\` files, in your Jest config change the \`transform\` key which value is \`ts-jest\` so that it does not match \`.js\` files anymore
-        "
-      `)
-    })
-
     test('should allow detection of ts-jest', () => {
       expect(process.env.TS_JEST).toBe('1')
     })
@@ -432,6 +407,81 @@ describe('TsJestTransformer', () => {
 
       delete process.env.TS_JEST_HOOKS
     })
+
+    it.each([
+      {
+        filePath: 'my-project/node_modules/foo.js',
+        fileContent: `
+          function foo() {
+            return 1
+          }
+
+          export default foo;
+        `,
+      },
+      {
+        filePath: 'my-project/node_modules/foo.mjs',
+        fileContent: `
+          function foo() {
+            return 1
+          }
+
+          export default foo;
+        `,
+      },
+    ])('should transpile js file from node_modules for CJS', ({ filePath, fileContent }) => {
+      const result = tr.process(fileContent, filePath, baseTransformOptions)
+
+      expect(omitLeadingWhitespace(result.code)).toContain(dedent`
+        exports.default = foo;
+      `)
+    })
+
+    it('should transpile js file from node_modules for ESM', () => {
+      const result = tr.process(
+        `
+          function foo() {
+            return 1
+          }
+
+          module.exports = foo;
+        `,
+        'my-project/node_modules/foo.js',
+        {
+          ...baseTransformOptions,
+          supportsStaticESM: true,
+          transformerConfig: {
+            useESM: true,
+            tsconfig: {
+              module: 'ESNext',
+              target: 'ESNext',
+            },
+          },
+        },
+      )
+
+      const transpileResult = ts.transpileModule(
+        `
+          function foo() {
+            return 1
+          }
+
+          module.exports = foo;
+        `,
+        {
+          compilerOptions: {
+            module: ts.ModuleKind.ESNext, // Transpile to ESM
+            target: ts.ScriptTarget.ESNext,
+          },
+        },
+      )
+
+      console.log(transpileResult.outputText)
+
+      expect(omitLeadingWhitespace(result.code)).toContain(dedent`
+        module.exports = foo;
+      `)
+    })
   })
 
   describe('processAsync', () => {

src/legacy/ts-jest-transformer.ts

@@ -3,6 +3,7 @@ import path from 'path'
 
 import type { SyncTransformer, TransformedSource } from '@jest/transform'
 import type { Logger } from 'bs-logger'
+import ts from 'typescript'
 
 import { DECLARATION_TYPE_EXT, JS_JSX_REGEX, TS_TSX_REGEX } from '../constants'
 import type {
@@ -18,6 +19,7 @@ import { Deprecations, Errors, interpolate } from '../utils/messages'
 import { sha1 } from '../utils/sha1'
 
 import { TsJestCompiler } from './compiler'
+import { updateOutput } from './compiler/compiler-utils'
 import { ConfigSet } from './config/config-set'
 
 interface CachedConfigSet {
@@ -34,6 +36,10 @@ interface TsJestHooksMap {
   afterProcess?(args: any[], result: TransformedSource): TransformedSource
 }
 
+const isNodeModule = (filePath: string) => {
+  return path.normalize(filePath).split(path.sep).includes('node_modules')
+}
+
 /**
  * @internal
  */
@@ -146,9 +152,6 @@ export class TsJestTransformer implements SyncTransformer<TsJestTransformerOptio
     this._compiler = new TsJestCompiler(configSet, cacheFS)
   }
 
-  /**
-   * @public
-   */
   process(sourceText: string, sourcePath: string, transformOptions: TsJestTransformOptions): TransformedSource {
     this._logger.debug({ fileName: sourcePath, transformOptions }, 'processing', sourcePath)
 
@@ -226,20 +229,29 @@ export class TsJestTransformer implements SyncTransformer<TsJestTransformerOptio
       result = {
         code: '',
       }
-    } else if (!configs.parsedTsConfig.options.allowJs && isJsFile) {
-      // we've got a '.js' but the compiler option `allowJs` is not set or set to false
-      this._logger.warn({ fileName: sourcePath }, interpolate(Errors.GotJsFileButAllowJsFalse, { path: sourcePath }))
-
-      result = {
-        code: sourceText,
-      }
     } else if (isJsFile || isTsFile) {
-      // transpile TS code (source maps are included)
-      result = this._compiler.getCompiledOutput(sourceText, sourcePath, {
-        depGraphs: this._depGraphs,
-        supportsStaticESM: transformOptions.supportsStaticESM,
-        watchMode: this._watchMode,
-      })
+      if (isJsFile && isNodeModule(sourcePath)) {
+        const transpiledResult = ts.transpileModule(sourceText, {
+          compilerOptions: {
+            ...configs.parsedTsConfig.options,
+            module:
+              transformOptions.supportsStaticESM && transformOptions.transformerConfig.useESM
+                ? ts.ModuleKind.ESNext
+                : ts.ModuleKind.CommonJS,
+          },
+          fileName: sourcePath,
+        })
+        result = {
+          code: updateOutput(transpiledResult.outputText, sourcePath, transpiledResult.sourceMapText),
+        }
+      } else {
+        // transpile TS code (source maps are included)
+        result = this._compiler.getCompiledOutput(sourceText, sourcePath, {
+          depGraphs: this._depGraphs,
+          supportsStaticESM: transformOptions.supportsStaticESM,
+          watchMode: this._watchMode,
+        })
+      }
     } else {
       // we should not get called for files with other extension than js[x], ts[x] and d.ts,
       // TypeScript will bail if we try to compile, and if it was to call babel, users can

src/transpilers/typescript/transpile-module.spec.ts

@@ -4,6 +4,7 @@ import { vol } from 'memfs'
 import type { PackageJson } from 'type-fest'
 import ts from 'typescript'
 
+import { dedent, omitLeadingWhitespace } from '../../__helpers__/dedent-string'
 import { workspaceRoot } from '../../__helpers__/workspace-root'
 
 import { tsTranspileModule } from './transpile-module'
@@ -37,20 +38,6 @@ jest.mock('node:fs', () => {
   }
 })
 
-function dedent(strings: TemplateStringsArray, ...values: unknown[]) {
-  let joinedString = ''
-  for (let i = 0; i < values.length; i++) {
-    joinedString += `${strings[i]}${values[i]}`
-  }
-  joinedString += strings[strings.length - 1]
-
-  return omitLeadingWhitespace(joinedString)
-}
-
-function omitLeadingWhitespace(text: string): string {
-  return text.replace(/^\s+/gm, '')
-}
-
 describe('transpileModules', () => {
   describe('with modern Node resolution', () => {
     const tsFilePathInEsmModernNode = path.join(workspaceRoot, 'esm-node-modern', 'foo.ts')
@@ -300,13 +287,13 @@ describe('transpileModules', () => {
       })
 
       expect(omitLeadingWhitespace(result.outputText)).toContain(dedent`
-          const foo_1 = require("foo");
-          console.log(foo_1.foo);
-          const loadFooAsync = async () => {
-            const fooDefault = await Promise.resolve().then(() => require('foo'));
-            console.log(fooDefault);
-          };
-          console.log(loadFooAsync());
+        const foo_1 = require("foo");
+        console.log(foo_1.foo);
+        const loadFooAsync = async () => {
+          const fooDefault = await Promise.resolve().then(() => require('foo'));
+          console.log(fooDefault);
+        };
+        console.log(loadFooAsync());
       `)
     })
 
@@ -320,13 +307,13 @@ describe('transpileModules', () => {
       })
 
       expect(omitLeadingWhitespace(result.outputText)).toContain(dedent`
-          import { foo } from 'foo';
-          console.log(foo);
-          const loadFooAsync = async () => {
-            const fooDefault = await import('foo');
-            console.log(fooDefault);
-          };
-          console.log(loadFooAsync());
+        import { foo } from 'foo';
+        console.log(foo);
+        const loadFooAsync = async () => {
+          const fooDefault = await import('foo');
+          console.log(fooDefault);
+        };
+        console.log(loadFooAsync());
       `)
     })
   })
@@ -338,10 +325,10 @@ describe('transpileModules', () => {
       vol.fromJSON(
         {
           './foo.ts': `
-        import { foo } from 'foo';
+          import { foo } from 'foo';
 
-        console.log(foo);
-      `,
+          console.log(foo);
+        `,
         },
         workspaceRoot,
       )