ts-jest 29.0.1 → 29.0.2

package/dist/legacy/compiler/ts-compiler.js

@@ -58,12 +58,15 @@ var constants_1 = require("../../constants");
 var utils_1 = require("../../utils");
 var messages_1 = require("../../utils/messages");
 var compiler_utils_1 = require("./compiler-utils");
-var TsCompiler = (function () {
+var TsCompiler = /** @class */ (function () {
     function TsCompiler(configSet, runtimeCacheFS) {
         var _a;
         var _this = this;
         this.configSet = configSet;
         this.runtimeCacheFS = runtimeCacheFS;
+        /**
+         * @internal
+         */
         this._projectVersion = 1;
         this._ts = configSet.compilerModule;
         this._logger = utils_1.rootLogger.child({ namespace: 'ts-compiler' });
@@ -80,6 +83,7 @@ var TsCompiler = (function () {
                 },
                 _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.trace,
                 _a), 'readFile', (0, lodash_memoize_1.default)(this._ts.sys.readFile));
+            /* istanbul ignore next */
             this._moduleResolutionHost = {
                 fileExists: (0, lodash_memoize_1.default)(this._ts.sys.fileExists),
                 readFile: this._cachedReadFile,
@@ -95,6 +99,7 @@ var TsCompiler = (function () {
     }
     TsCompiler.prototype.getResolvedModules = function (fileContent, fileName, runtimeCacheFS) {
         var _this = this;
+        // In watch mode, it is possible that the initial cacheFS becomes empty
         if (!this.runtimeCacheFS.size) {
             this._runtimeCacheFS = runtimeCacheFS;
         }
@@ -122,6 +127,7 @@ var TsCompiler = (function () {
                         ![this._ts.ModuleKind.ES2015, this._ts.ModuleKind.ES2020, this._ts.ModuleKind.ESNext].includes(moduleKind))
                     ? this._ts.ModuleKind.ESNext
                     : moduleKind;
+            // Make sure `esModuleInterop` and `allowSyntheticDefaultImports` true to support import CJS into ESM
             esModuleInterop = true;
             allowSyntheticDefaultImports = true;
         }
@@ -131,6 +137,7 @@ var TsCompiler = (function () {
         this._compilerOptions = __assign(__assign({}, this._compilerOptions), { allowSyntheticDefaultImports: allowSyntheticDefaultImports, esModuleInterop: esModuleInterop, module: moduleKind });
         if (this._languageService) {
             this._logger.debug({ fileName: fileName }, 'getCompiledOutput(): compiling using language service');
+            // Must set memory cache before attempting to compile
             this._updateMemoryCache(fileContent, fileName, currentModuleKind === moduleKind);
             var output = this._languageService.getEmitOutput(fileName);
             var diagnostics = this.getDiagnostics(fileName);
@@ -147,6 +154,7 @@ var TsCompiler = (function () {
                                 this._logger.debug({ fileToReTypeCheck: fileToReTypeCheck }, '_doTypeChecking(): computing diagnostics using language service');
                                 this._updateMemoryCache(this._getFileContentFromCache(fileToReTypeCheck), fileToReTypeCheck);
                                 var importedModulesDiagnostics = __spreadArray(__spreadArray([], __read(this._languageService.getSemanticDiagnostics(fileToReTypeCheck)), false), __read(this._languageService.getSyntacticDiagnostics(fileToReTypeCheck)), false);
+                                // will raise or just warn diagnostics depending on config
                                 this.configSet.raiseDiagnostics(importedModulesDiagnostics, fileName, this._logger);
                             }
                         }
@@ -162,17 +170,18 @@ var TsCompiler = (function () {
             }
             if (output.emitSkipped) {
                 if (constants_1.TS_TSX_REGEX.test(fileName)) {
-                    throw new Error((0, messages_1.interpolate)("Unable to process '{{file}}', please make sure that `outDir` in your tsconfig is neither `''` or `'.'`. You can also configure Jest config option `transformIgnorePatterns` to inform `ts-jest` to transform {{file}}", { file: fileName }));
+                    throw new Error((0, messages_1.interpolate)("Unable to process '{{file}}', please make sure that `outDir` in your tsconfig is neither `''` or `'.'`. You can also configure Jest config option `transformIgnorePatterns` to inform `ts-jest` to transform {{file}}" /* Errors.CannotProcessFile */, { file: fileName }));
                 }
                 else {
-                    this._logger.warn((0, messages_1.interpolate)("Unable to process '{{file}}', falling back to original file content. You can also configure Jest config option `transformIgnorePatterns` to ignore {{file}} from transformation or make sure that `outDir` in your tsconfig is neither `''` or `'.'`", { file: fileName }));
+                    this._logger.warn((0, messages_1.interpolate)("Unable to process '{{file}}', falling back to original file content. You can also configure Jest config option `transformIgnorePatterns` to ignore {{file}} from transformation or make sure that `outDir` in your tsconfig is neither `''` or `'.'`" /* Errors.CannotProcessFileReturnOriginal */, { file: fileName }));
                     return {
                         code: fileContent,
                     };
                 }
             }
+            // Throw an error when requiring `.d.ts` files.
             if (!output.outputFiles.length) {
-                throw new TypeError((0, messages_1.interpolate)("Unable to require `.d.ts` file for file: {{file}}.\nThis is usually the result of a faulty configuration or import. Make sure there is a `.js`, `.json` or another executable extension available alongside `{{file}}`.", {
+                throw new TypeError((0, messages_1.interpolate)("Unable to require `.d.ts` file for file: {{file}}.\nThis is usually the result of a faulty configuration or import. Make sure there is a `.js`, `.json` or another executable extension available alongside `{{file}}`." /* Errors.UnableToRequireDefinitionFile */, {
                     file: (0, path_1.basename)(fileName),
                 }));
             }
@@ -220,19 +229,33 @@ var TsCompiler = (function () {
             }),
         };
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype._createLanguageService = function () {
         var _this = this;
         var _a;
+        // Initialize memory cache for typescript compiler
         this._parsedTsConfig.fileNames
             .filter(function (fileName) { return constants_1.TS_TSX_REGEX.test(fileName) && !_this.configSet.isTestFile(fileName); })
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             .forEach(function (fileName) { return _this._fileVersionCache.set(fileName, 0); });
+        /* istanbul ignore next */
         var serviceHost = {
             useCaseSensitiveFileNames: function () { return _this._ts.sys.useCaseSensitiveFileNames; },
             getProjectVersion: function () { return String(_this._projectVersion); },
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             getScriptFileNames: function () { return __spreadArray([], __read(_this._fileVersionCache.keys()), false); },
             getScriptVersion: function (fileName) {
                 var normalizedFileName = (0, path_1.normalize)(fileName);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 var version = _this._fileVersionCache.get(normalizedFileName);
+                // We need to return `undefined` and not a string here because TypeScript will use
+                // `getScriptVersion` and compare against their own version - which can be `undefined`.
+                // If we don't return `undefined` it results in `undefined === "undefined"` and run
+                // `createProgram` again (which is very slow). Using a `string` assertion here to avoid
+                // TypeScript errors from the function signature (expects `(x: string) => string`).
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 return version === undefined ? undefined : String(version);
             },
             getScriptSnapshot: function (fileName) {
@@ -240,13 +263,19 @@ var TsCompiler = (function () {
                 var normalizedFileName = (0, path_1.normalize)(fileName);
                 var hit = _this._isFileInCache(normalizedFileName);
                 _this._logger.trace({ normalizedFileName: normalizedFileName, cacheHit: hit }, 'getScriptSnapshot():', 'cache', hit ? 'hit' : 'miss');
+                // Read file content from either memory cache or Jest runtime cache or fallback to file system read
                 if (!hit) {
-                    var fileContent = (_d = (_b = (_a = _this._fileContentCache.get(normalizedFileName)) !== null && _a !== void 0 ? _a : _this._runtimeCacheFS.get(normalizedFileName)) !== null && _b !== void 0 ? _b : (_c = _this._cachedReadFile) === null || _c === void 0 ? void 0 : _c.call(_this, normalizedFileName)) !== null && _d !== void 0 ? _d : undefined;
+                    var fileContent = 
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    (_d = (_b = (_a = _this._fileContentCache.get(normalizedFileName)) !== null && _a !== void 0 ? _a : _this._runtimeCacheFS.get(normalizedFileName)) !== null && _b !== void 0 ? _b : (_c = _this._cachedReadFile) === null || _c === void 0 ? void 0 : _c.call(_this, normalizedFileName)) !== null && _d !== void 0 ? _d : undefined;
                     if (fileContent !== undefined) {
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                         _this._fileContentCache.set(normalizedFileName, fileContent);
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                         _this._fileVersionCache.set(normalizedFileName, 1);
                     }
                 }
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 var contents = _this._fileContentCache.get(normalizedFileName);
                 if (contents === undefined)
                     return;
@@ -271,51 +300,87 @@ var TsCompiler = (function () {
         this._languageService = this._ts.createLanguageService(serviceHost, this._ts.createDocumentRegistry(this._ts.sys.useCaseSensitiveFileNames, this.configSet.cwd));
         this.program = this._languageService.getProgram();
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype._getFileContentFromCache = function (filePath) {
         var normalizedFilePath = (0, path_1.normalize)(filePath);
         var resolvedFileContent = this._runtimeCacheFS.get(normalizedFilePath);
         if (!resolvedFileContent) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             resolvedFileContent = this._moduleResolutionHost.readFile(normalizedFilePath);
             this._runtimeCacheFS.set(normalizedFilePath, resolvedFileContent);
         }
         return resolvedFileContent;
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype._getImportedModulePaths = function (resolvedFileContent, containingFile) {
         var _this = this;
         return this._ts
             .preProcessFile(resolvedFileContent, true, true)
             .importedFiles.map(function (importedFile) {
             var resolvedModule = _this._resolveModuleName(importedFile.fileName, containingFile).resolvedModule;
+            /* istanbul ignore next already covered  */
             var resolvedFileName = resolvedModule === null || resolvedModule === void 0 ? void 0 : resolvedModule.resolvedFileName;
+            /* istanbul ignore next already covered  */
             return resolvedFileName && !(resolvedModule === null || resolvedModule === void 0 ? void 0 : resolvedModule.isExternalLibraryImport) ? resolvedFileName : '';
         })
             .filter(function (resolveFileName) { return !!resolveFileName; });
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype._resolveModuleName = function (moduleNameToResolve, containingFile) {
-        return this._ts.resolveModuleName(moduleNameToResolve, containingFile, this._compilerOptions, this._moduleResolutionHost, this._moduleResolutionCache);
+        return this._ts.resolveModuleName(moduleNameToResolve, containingFile, this._compilerOptions, 
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this._moduleResolutionHost, 
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this._moduleResolutionCache);
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype._isFileInCache = function (fileName) {
-        return (this._fileContentCache.has(fileName) &&
+        return (
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this._fileContentCache.has(fileName) &&
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             this._fileVersionCache.has(fileName) &&
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             this._fileVersionCache.get(fileName) !== 0);
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype._updateMemoryCache = function (contents, fileName, isModuleKindTheSame) {
         if (isModuleKindTheSame === void 0) { isModuleKindTheSame = true; }
         this._logger.debug({ fileName: fileName }, 'updateMemoryCache: update memory cache for language service');
         var shouldIncrementProjectVersion = false;
         var hit = this._isFileInCache(fileName);
         if (!hit) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             this._fileVersionCache.set(fileName, 1);
             shouldIncrementProjectVersion = true;
         }
         else {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             var prevVersion = this._fileVersionCache.get(fileName);
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             var previousContents = this._fileContentCache.get(fileName);
+            // Avoid incrementing cache when nothing has changed.
             if (previousContents !== contents) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 this._fileVersionCache.set(fileName, prevVersion + 1);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 this._fileContentCache.set(fileName, contents);
                 shouldIncrementProjectVersion = true;
             }
+            /**
+             * When a file is from node_modules or referenced to a referenced project and jest wants to transform it, we need
+             * to make sure that the Program is updated with this information
+             */
             if (!this._parsedTsConfig.fileNames.includes(fileName) || !isModuleKindTheSame) {
                 shouldIncrementProjectVersion = true;
             }
@@ -323,10 +388,14 @@ var TsCompiler = (function () {
         if (shouldIncrementProjectVersion)
             this._projectVersion++;
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype.getDiagnostics = function (fileName) {
         var diagnostics = [];
         if (this.configSet.shouldReportDiagnostics(fileName)) {
             this._logger.debug({ fileName: fileName }, '_doTypeChecking(): computing diagnostics using language service');
+            // Get the relevant diagnostics - this is 3x faster than `getPreEmitDiagnostics`.
             diagnostics.push.apply(diagnostics, __spreadArray(__spreadArray([], __read(this._languageService.getSemanticDiagnostics(fileName)), false), __read(this._languageService.getSyntacticDiagnostics(fileName)), false));
         }
         return diagnostics;

package/dist/legacy/compiler/ts-jest-compiler.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TsJestCompiler = void 0;
 var ts_compiler_1 = require("./ts-compiler");
-var TsJestCompiler = (function () {
+var TsJestCompiler = /** @class */ (function () {
     function TsJestCompiler(configSet, runtimeCacheFS) {
+        // Later we can add swc/esbuild or other typescript compiler instance here
         this._compilerInstance = new ts_compiler_1.TsCompiler(configSet, runtimeCacheFS);
     }
     TsJestCompiler.prototype.getResolvedModules = function (fileContent, fileName, runtimeCacheFS) {

package/dist/legacy/config/config-set.d.ts

@@ -4,6 +4,9 @@ import type { RawCompilerOptions } from '../../raw-compiler-options';
 import type { ProjectConfigTsJest, TsJestAstTransformer, TTypeScript } from '../../types';
 export declare class ConfigSet {
     readonly parentLogger?: Logger | undefined;
+    /**
+     * Use by e2e, don't mark as internal
+     */
     readonly tsJestDigest: string;
     readonly logger: Logger;
     readonly compilerModule: TTypeScript;
@@ -16,6 +19,10 @@ export declare class ConfigSet {
     resolvedTransformers: TsJestAstTransformer;
     useESM: boolean;
     constructor(jestConfig: ProjectConfigTsJest | undefined, parentLogger?: Logger | undefined);
+    /**
+     * Load TypeScript configuration. Returns the parsed TypeScript config and any `tsconfig` options specified in ts-jest
+     * Subclasses which extend `ConfigSet` can override the default behavior
+     */
     protected _resolveTsConfig(compilerOptions?: RawCompilerOptions, resolvedConfigFile?: string): Record<string, any>;
     isTestFile(fileName: string): boolean;
     shouldStringifyContent(filePath: string): boolean;

package/dist/legacy/config/config-set.js

@@ -74,6 +74,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigSet = exports.TS_JEST_OUT_DIR = exports.IGNORE_DIAGNOSTIC_CODES = exports.MY_DIGEST = void 0;
+/**
+ * This is the core of settings and so ts-jest.
+ * Since configuration are used to create a good cache key, everything
+ * depending on it is here. Fast jest relies on correct cache keys
+ * depending on all settings that could affect the generated output.
+ *
+ * The big issue is that jest calls first `getCacheKey()` with stringified
+ * version of the `jest.ProjectConfig`, and then later it calls `process()`
+ * with the complete, object version of it.
+ */
 var fs_1 = require("fs");
 var module_1 = __importDefault(require("module"));
 var path_1 = require("path");
@@ -89,12 +99,21 @@ var messages_1 = require("../../utils/messages");
 var normalize_slashes_1 = require("../../utils/normalize-slashes");
 var sha1_1 = require("../../utils/sha1");
 var ts_error_1 = require("../../utils/ts-error");
+/**
+ * @internal
+ */
 exports.MY_DIGEST = (0, fs_1.readFileSync)((0, path_1.resolve)(__dirname, '../../../.ts-jest-digest'), 'utf8');
+/**
+ * @internal
+ */
 exports.IGNORE_DIAGNOSTIC_CODES = [
     6059,
     18002,
-    18003,
+    18003, // "No inputs were found in config file."
 ];
+/**
+ * @internal
+ */
 exports.TS_JEST_OUT_DIR = '$$ts-jest$$';
 var normalizeRegex = function (pattern) {
     return pattern ? (typeof pattern === 'string' ? pattern : pattern.source) : undefined;
@@ -131,21 +150,26 @@ var toDiagnosticCodeList = function (items, into) {
     return into;
 };
 var requireFromString = function (code, fileName) {
+    // @ts-expect-error `_nodeModulePaths` is not exposed in typing
     var paths = module_1.default._nodeModulePaths((0, path_1.dirname)(fileName));
     var parent = module.parent;
     var m = new module_1.default(fileName, parent);
     m.filename = fileName;
     m.paths = [].concat(paths);
+    // @ts-expect-error `_compile` is not exposed in typing
     m._compile(code, fileName);
     var exports = m.exports;
     parent && parent.children && parent.children.splice(parent.children.indexOf(m), 1);
     return exports;
 };
-var ConfigSet = (function () {
+var ConfigSet = /** @class */ (function () {
     function ConfigSet(jestConfig, parentLogger) {
         var _a, _b;
         var _c, _d, _e, _f;
         this.parentLogger = parentLogger;
+        /**
+         * Use by e2e, don't mark as internal
+         */
         this.tsJestDigest = exports.MY_DIGEST;
         this.resolvedTransformers = {
             before: [],
@@ -153,11 +177,17 @@ var ConfigSet = (function () {
             afterDeclarations: [],
         };
         this.useESM = false;
+        /**
+         * @internal
+         */
         this._overriddenCompilerOptions = {
             inlineSourceMap: false,
+            // we don't want to create declaration files
             declaration: false,
             noEmit: false,
+            // else istanbul related will be dropped
             removeComments: false,
+            // to clear out else it's buggy
             out: undefined,
             outFile: undefined,
             composite: undefined,
@@ -175,12 +205,18 @@ var ConfigSet = (function () {
         this.rootDir = (0, path_1.normalize)((_d = this._jestCfg.rootDir) !== null && _d !== void 0 ? _d : this.cwd);
         var tsJestCfg = this._jestCfg.globals && this._jestCfg.globals['ts-jest'];
         var options = tsJestCfg !== null && tsJestCfg !== void 0 ? tsJestCfg : Object.create(null);
-        this.compilerModule = importer_1.importer.typescript("Using \"ts-jest\" requires this package to be installed.", (_e = options.compiler) !== null && _e !== void 0 ? _e : 'typescript');
+        // compiler module
+        this.compilerModule = importer_1.importer.typescript("Using \"ts-jest\" requires this package to be installed." /* ImportReasons.TsJest */, (_e = options.compiler) !== null && _e !== void 0 ? _e : 'typescript');
+        // isolatedModules
         this.isolatedModules = (_f = options.isolatedModules) !== null && _f !== void 0 ? _f : false;
         this.logger.debug({ compilerModule: this.compilerModule }, 'normalized compiler module config via ts-jest option');
         this._setupConfigSet(options);
         this._resolveTsCacheDir();
         this._matchablePatterns = __spreadArray(__spreadArray([], __read(this._jestCfg.testMatch), false), __read(this._jestCfg.testRegex), false).filter(function (pattern) {
+            /**
+             * jest config testRegex doesn't always deliver the correct RegExp object
+             * See https://github.com/facebook/jest/issues/9778
+             */
             return pattern instanceof RegExp || typeof pattern === 'string';
         });
         if (!this._matchablePatterns.length) {
@@ -188,16 +224,24 @@ var ConfigSet = (function () {
         }
         this._matchTestFilePath = (0, jest_util_1.globsToMatcher)(this._matchablePatterns.filter(function (pattern) { return typeof pattern === 'string'; }));
     }
+    /**
+     * @internal
+     */
     ConfigSet.prototype._backportJestCfg = function (jestCfg) {
         var _a, _b;
         var config = (0, backports_1.backportJestConfig)(this.logger, jestCfg);
         this.logger.debug({ jestConfig: config }, 'normalized jest config');
         this._jestCfg = __assign(__assign({}, config), { testMatch: (_a = config.testMatch) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_JEST_TEST_MATCH, testRegex: (_b = config.testRegex) !== null && _b !== void 0 ? _b : [] });
     };
+    /**
+     * @internal
+     */
     ConfigSet.prototype._setupConfigSet = function (options) {
         var _this = this;
         var _a, _b, _c, _d, _e;
+        // useESM
         this.useESM = (_a = options.useESM) !== null && _a !== void 0 ? _a : false;
+        // babel config (for babel-jest) default is undefined so we don't need to have fallback like tsConfig
         if (!options.babelConfig) {
             this.logger.debug('babel is disabled');
         }
@@ -221,10 +265,11 @@ var ConfigSet = (function () {
             }
             this.logger.debug({ babelConfig: this.babelConfig }, 'normalized babel config via ts-jest option');
             this.babelJestTransformer = importer_1.importer
-                .babelJest("Using \"babel-jest\" requires this package to be installed.")
+                .babelJest("Using \"babel-jest\" requires this package to be installed." /* ImportReasons.BabelJest */)
                 .createTransformer(this.babelConfig);
             this.logger.debug('created babel-jest transformer');
         }
+        // diagnostics
         var diagnosticsOpt = (_b = options.diagnostics) !== null && _b !== void 0 ? _b : true;
         var ignoreList = __spreadArray([], __read(exports.IGNORE_DIAGNOSTIC_CODES), false);
         if (typeof diagnosticsOpt === 'object') {
@@ -256,11 +301,14 @@ var ConfigSet = (function () {
             this._shouldIgnoreDiagnosticsForFile = function () { return true; };
         }
         this.logger.debug({ diagnostics: this._diagnostics }, 'normalized diagnostics config via ts-jest option');
+        // tsconfig
         var tsconfigOpt = options.tsconfig;
         var configFilePath = typeof tsconfigOpt === 'string' ? this.resolvePath(tsconfigOpt) : undefined;
         this.parsedTsConfig = this._getAndResolveTsConfig(typeof tsconfigOpt === 'object' ? tsconfigOpt : undefined, configFilePath);
+        // throw errors if any matching wanted diagnostics
         this.raiseDiagnostics(this.parsedTsConfig.errors, configFilePath);
         this.logger.debug({ tsconfig: this.parsedTsConfig }, 'normalized typescript config via ts-jest option');
+        // transformers
         this.resolvedTransformers.before = [
             {
                 factory: hoistJestTransformer.factory,
@@ -274,7 +322,7 @@ var ConfigSet = (function () {
                 var transformerFunc;
                 if ((0, path_1.extname)(transformerPath) === '.ts') {
                     var compiledTransformer = importer_1.importer
-                        .esBuild("Using \"esbuild\" requires this package to be installed.")
+                        .esBuild("Using \"esbuild\" requires this package to be installed." /* ImportReasons.EsBuild */)
                         .transformSync((0, fs_1.readFileSync)(transformerPath, 'utf-8'), {
                         loader: 'ts',
                         format: 'cjs',
@@ -286,10 +334,10 @@ var ConfigSet = (function () {
                     transformerFunc = require(transformerPath);
                 }
                 if (!transformerFunc.version) {
-                    _this.logger.warn("The AST transformer {{file}} must have an `export const version = <your_transformer_version>`", { file: transformerPath });
+                    _this.logger.warn("The AST transformer {{file}} must have an `export const version = <your_transformer_version>`" /* Errors.MissingTransformerVersion */, { file: transformerPath });
                 }
                 if (!transformerFunc.name) {
-                    _this.logger.warn("The AST transformer {{file}} must have an `export const name = <your_transformer_name>`", { file: transformerPath });
+                    _this.logger.warn("The AST transformer {{file}} must have an `export const name = <your_transformer_name>`" /* Errors.MissingTransformerName */, { file: transformerPath });
                 }
                 return transformerFunc;
             };
@@ -304,6 +352,7 @@ var ConfigSet = (function () {
                 });
             };
             if (astTransformers.before) {
+                /* istanbul ignore next (already covered in unit test) */
                 (_e = this.resolvedTransformers.before) === null || _e === void 0 ? void 0 : _e.push.apply(_e, __spreadArray([], __read(resolveTransformers(astTransformers.before)), false));
             }
             if (astTransformers.after) {
@@ -314,14 +363,18 @@ var ConfigSet = (function () {
             }
         }
         this.logger.debug({ customTransformers: this.resolvedTransformers }, 'normalized custom AST transformers via ts-jest option');
+        // stringifyContentPathRegex
         if (options.stringifyContentPathRegex) {
             this._stringifyContentRegExp =
                 typeof options.stringifyContentPathRegex === 'string'
-                    ? new RegExp(normalizeRegex(options.stringifyContentPathRegex))
+                    ? new RegExp(normalizeRegex(options.stringifyContentPathRegex)) // eslint-disable-line @typescript-eslint/no-non-null-assertion
                     : options.stringifyContentPathRegex;
             this.logger.debug({ stringifyContentPathRegex: this._stringifyContentRegExp }, 'normalized stringifyContentPathRegex config via ts-jest option');
         }
     };
+    /**
+     * @internal
+     */
     ConfigSet.prototype._resolveTsCacheDir = function () {
         this.cacheSuffix = (0, sha1_1.sha1)((0, utils_1.stringify)({
             version: this.compilerModule.version,
@@ -346,16 +399,22 @@ var ConfigSet = (function () {
             this.tsCacheDir = res;
         }
     };
+    /**
+     * @internal
+     */
     ConfigSet.prototype._getAndResolveTsConfig = function (compilerOptions, resolvedConfigFile) {
         var e_2, _a, _b;
         var _c, _d, _e;
         var result = this._resolveTsConfig(compilerOptions, resolvedConfigFile);
         var forcedOptions = this._overriddenCompilerOptions;
         var finalOptions = result.options;
+        // Target ES2015 output by default (instead of ES3).
         if (finalOptions.target === undefined) {
             finalOptions.target = this.compilerModule.ScriptTarget.ES2015;
         }
+        // check the module interoperability
         var target = finalOptions.target;
+        // compute the default if not set
         var defaultModule = [this.compilerModule.ScriptTarget.ES3, this.compilerModule.ScriptTarget.ES5].includes(target)
             ? this.compilerModule.ModuleKind.CommonJS
             : this.compilerModule.ModuleKind.ESNext;
@@ -364,21 +423,25 @@ var ConfigSet = (function () {
             moduleValue !== this.compilerModule.ModuleKind.CommonJS &&
             !(finalOptions.esModuleInterop || finalOptions.allowSyntheticDefaultImports)) {
             result.errors.push({
-                code: 151001,
-                messageText: "If you have issues related to imports, you should consider setting `esModuleInterop` to `true` in your TypeScript configuration file (usually `tsconfig.json`). See https://blogs.msdn.microsoft.com/typescript/2018/01/31/announcing-typescript-2-7/#easier-ecmascript-module-interoperability for more information.",
+                code: 151001 /* DiagnosticCodes.ConfigModuleOption */,
+                messageText: "If you have issues related to imports, you should consider setting `esModuleInterop` to `true` in your TypeScript configuration file (usually `tsconfig.json`). See https://blogs.msdn.microsoft.com/typescript/2018/01/31/announcing-typescript-2-7/#easier-ecmascript-module-interoperability for more information." /* Errors.ConfigNoModuleInterop */,
                 category: this.compilerModule.DiagnosticCategory.Message,
                 file: undefined,
                 start: undefined,
                 length: undefined,
             });
+            // at least enable synthetic default imports (except if it's set in the input config)
+            /* istanbul ignore next (already covered in unit test) */
             if (!('allowSyntheticDefaultImports' in finalOptions)) {
                 finalOptions.allowSyntheticDefaultImports = true;
             }
         }
+        // Make sure when allowJs is enabled, outDir is required to have when using allowJs: true
         if (finalOptions.allowJs && !finalOptions.outDir) {
             finalOptions.outDir = exports.TS_JEST_OUT_DIR;
         }
         try {
+            // ensure undefined are removed and other values are overridden
             for (var _f = __values(Object.keys(forcedOptions)), _g = _f.next(); !_g.done; _g = _f.next()) {
                 var key = _g.value;
                 var val = forcedOptions[key];
@@ -397,6 +460,10 @@ var ConfigSet = (function () {
             }
             finally { if (e_2) throw e_2.error; }
         }
+        /**
+         * See https://github.com/microsoft/TypeScript/wiki/Node-Target-Mapping
+         * Every time this page is updated, we also need to update here. Here we only show warning message for Node LTS versions
+         */
         var nodeJsVer = process.version;
         var compilationTarget = result.options.target;
         var TARGET_TO_VERSION_MAPPING = (_b = {},
@@ -405,11 +472,12 @@ var ConfigSet = (function () {
             _b[this.compilerModule.ScriptTarget.ES2020] = 'es2020',
             _b[this.compilerModule.ScriptTarget.ESNext] = 'ESNext',
             _b);
+        /* istanbul ignore next (cover by e2e) */
         if (compilationTarget &&
             !this.babelConfig &&
             nodeJsVer.startsWith('v12') &&
             compilationTarget > this.compilerModule.ScriptTarget.ES2019) {
-            var message = (0, messages_1.interpolate)("There is a mismatch between your NodeJs version {{nodeJsVer}} and your TypeScript target {{compilationTarget}}. This might lead to some unexpected errors when running tests with `ts-jest`. To fix this, you can check https://github.com/microsoft/TypeScript/wiki/Node-Target-Mapping", {
+            var message = (0, messages_1.interpolate)("There is a mismatch between your NodeJs version {{nodeJsVer}} and your TypeScript target {{compilationTarget}}. This might lead to some unexpected errors when running tests with `ts-jest`. To fix this, you can check https://github.com/microsoft/TypeScript/wiki/Node-Target-Mapping" /* Errors.MismatchNodeTargetMapping */, {
                 nodeJsVer: process.version,
                 compilationTarget: TARGET_TO_VERSION_MAPPING[compilationTarget],
             });
@@ -419,23 +487,28 @@ var ConfigSet = (function () {
         var sourceMap = (_d = resultOptions.sourceMap) !== null && _d !== void 0 ? _d : true;
         return __assign(__assign({}, result), { options: __assign(__assign({}, resultOptions), { sourceMap: sourceMap, inlineSources: sourceMap, module: (_e = resultOptions.module) !== null && _e !== void 0 ? _e : this.compilerModule.ModuleKind.CommonJS }) });
     };
+    // eslint-disable-next-line no-dupe-class-members
     ConfigSet.prototype._resolveTsConfig = function (compilerOptions, resolvedConfigFile) {
         var config = { compilerOptions: Object.create(null) };
         var basePath = (0, normalize_slashes_1.normalizeSlashes)(this.rootDir);
         var ts = this.compilerModule;
+        // Read project configuration when available.
         var configFileName = resolvedConfigFile
             ? (0, normalize_slashes_1.normalizeSlashes)(resolvedConfigFile)
             : ts.findConfigFile((0, normalize_slashes_1.normalizeSlashes)(this.rootDir), ts.sys.fileExists);
         if (configFileName) {
             this.logger.debug({ tsConfigFileName: configFileName }, 'readTsConfig(): reading', configFileName);
             var result = ts.readConfigFile(configFileName, ts.sys.readFile);
+            // Return diagnostics.
             if (result.error) {
                 return { errors: [result.error], fileNames: [], options: {} };
             }
             config = result.config;
             basePath = (0, normalize_slashes_1.normalizeSlashes)((0, path_1.dirname)(configFileName));
         }
+        // Override default configuration options `ts-jest` requires.
         config.compilerOptions = __assign(__assign({}, config.compilerOptions), compilerOptions);
+        // parse json, merge config extending others, ...
         return ts.parseJsonConfigFileContent(config, ts.sys, basePath, undefined, configFileName);
     };
     ConfigSet.prototype.isTestFile = function (fileName) {
@@ -463,10 +536,12 @@ var ConfigSet = (function () {
         if (!filteredDiagnostics.length)
             return;
         var error = this.createTsError(filteredDiagnostics);
+        // only throw if `warnOnly` and it is a warning or error
         var importantCategories = [DiagnosticCategory.Warning, DiagnosticCategory.Error];
         if (this._diagnostics.throws && filteredDiagnostics.some(function (d) { return importantCategories.includes(d.category); })) {
             throw error;
         }
+        /* istanbul ignore next (already covered) */
         logger ? logger.warn({ error: error }, error.message) : this.logger.warn({ error: error }, error.message);
     };
     ConfigSet.prototype.shouldReportDiagnostics = function (filePath) {
@@ -475,11 +550,15 @@ var ConfigSet = (function () {
             ? this.parsedTsConfig.options.checkJs && !this._shouldIgnoreDiagnosticsForFile(filePath)
             : !this._shouldIgnoreDiagnosticsForFile(filePath);
     };
+    /**
+     * @internal
+     */
     ConfigSet.prototype.createTsError = function (diagnostics) {
         var _this = this;
         var formatDiagnostics = this._diagnostics.pretty
             ? this.compilerModule.formatDiagnosticsWithColorAndContext
             : this.compilerModule.formatDiagnostics;
+        /* istanbul ignore next (not possible to cover) */
         var diagnosticHost = {
             getNewLine: function () { return '\n'; },
             getCurrentDirectory: function () { return _this.cwd; },
@@ -516,7 +595,7 @@ var ConfigSet = (function () {
             catch (_) { }
         }
         if (throwIfMissing && !(0, fs_1.existsSync)(path)) {
-            throw new Error((0, messages_1.interpolate)("File not found: {{inputPath}} (resolved as: {{resolvedPath}})", { inputPath: inputPath, resolvedPath: path }));
+            throw new Error((0, messages_1.interpolate)("File not found: {{inputPath}} (resolved as: {{resolvedPath}})" /* Errors.FileNotFound */, { inputPath: inputPath, resolvedPath: path }));
         }
         this.logger.debug({ fromPath: inputPath, toPath: path }, 'resolved path from', inputPath, 'to', path);
         return path;

package/dist/legacy/ts-jest-transformer.d.ts

@@ -13,11 +13,24 @@ export declare class TsJestTransformer implements SyncTransformer {
     private _configsFor;
     protected _createConfigSet(config: ProjectConfigTsJest | undefined): ConfigSet;
     protected _createCompiler(configSet: ConfigSet, cacheFS: Map<string, string>): void;
+    /**
+     * @public
+     */
     process(sourceText: string, sourcePath: string, transformOptions: TransformOptionsTsJest): TransformedSource;
     processAsync(sourceText: string, sourcePath: string, transformOptions: TransformOptionsTsJest): Promise<TransformedSource>;
     private processWithTs;
     private runTsJestHook;
+    /**
+     * Jest uses this to cache the compiled version of a file
+     *
+     * @see https://github.com/facebook/jest/blob/v23.5.0/packages/jest-runtime/src/script_transformer.js#L61-L90
+     *
+     * @public
+     */
     getCacheKey(fileContent: string, filePath: string, transformOptions: TransformOptionsTsJest): string;
     getCacheKeyAsync(sourceText: string, sourcePath: string, transformOptions: TransformOptionsTsJest): Promise<string>;
+    /**
+     * Subclasses extends `TsJestTransformer` can call this method to get resolved module disk cache
+     */
     private _getFsCachedResolvedModules;
 }