ts-jest 26.2.0 → 26.3.0

package/.ts-jest-digest

@@ -1 +1 @@
-3793ca0e5f06b7056a87f12d06ee54c5afb1dc2a
+c0f7b076fbdbbcb07384ff15394a4e997771ae49

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [26.3.0](https://github.com/kulshekhar/ts-jest/compare/v26.2.0...v26.3.0) (2020-08-25)
+
+
+### Bug Fixes
+
+* **config:** compute cache key without reading `package.json` ([#1893](https://github.com/kulshekhar/ts-jest/issues/1893)) ([4875a58](https://github.com/kulshekhar/ts-jest/commit/4875a58345666e0407f9f5b3f95049ae2c9d056d)), closes [#1892](https://github.com/kulshekhar/ts-jest/issues/1892)
+
+
+### Features
+
+* support TypeScript 4.0 ([#1889](https://github.com/kulshekhar/ts-jest/issues/1889)) ([f070e93](https://github.com/kulshekhar/ts-jest/commit/f070e9334a9cf31fa6f0d73b3f69d805be72601d))
+
+
+
 # [26.2.0](https://github.com/kulshekhar/ts-jest/compare/v26.1.4...v26.2.0) (2020-08-11)
 
 

package/dist/cli/config/init.d.ts

@@ -1 +1,6 @@
+/**
+ * This has been written quickly. While trying to improve I realised it'd be better to have it in Jest...
+ * ...and I saw a merged PR with `jest --init` tool!
+ * TODO: see what's the best path for this
+ */
 export {};

package/dist/cli/config/init.js

@@ -1,4 +1,9 @@
 "use strict";
+/**
+ * This has been written quickly. While trying to improve I realised it'd be better to have it in Jest...
+ * ...and I saw a merged PR with `jest --init` tool!
+ * TODO: see what's the best path for this
+ */
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -52,7 +57,10 @@ var fs_1 = require("fs");
 var json5_1 = require("json5");
 var path_1 = require("path");
 var presets_1 = require("../helpers/presets");
-exports.run = function (args) { return __awaiter(void 0, void 0, void 0, function () {
+/**
+ * @internal
+ */
+exports.run = function (args /* , logger: Logger */) { return __awaiter(void 0, void 0, void 0, function () {
     var file, filePath, name, isPackage, exists, pkgFile, hasPackage, _a, jestPreset, askedTsconfig, force, jsdom, tsconfig, pkgJson, jsFilesProcessor, shouldPostProcessWithBabel, preset, body, base, tsJestConf, content;
     return __generator(this, function (_b) {
         file = args._[0] || 'jest.config.js';
@@ -66,10 +74,13 @@ exports.run = function (args) { return __awaiter(void 0, void 0, void 0, functio
         tsconfig = askedTsconfig === 'tsconfig.json' ? undefined : askedTsconfig;
         pkgJson = hasPackage ? JSON.parse(fs_1.readFileSync(pkgFile, 'utf8')) : {};
         jsFilesProcessor = args.js, shouldPostProcessWithBabel = args.babel;
+        // set defaults for missing options
         if (jsFilesProcessor == null) {
+            // set default js files processor depending on whether the user wants to post-process with babel
             jsFilesProcessor = shouldPostProcessWithBabel ? 'babel' : undefined;
         }
         else if (shouldPostProcessWithBabel == null) {
+            // auto enables babel post-processing if the user wants babel to process js files
             shouldPostProcessWithBabel = jsFilesProcessor === 'babel';
         }
         if (jsFilesProcessor === 'babel') {
@@ -138,16 +149,20 @@ exports.run = function (args) { return __awaiter(void 0, void 0, void 0, functio
                 content.push('  },');
             }
             content.push('};');
+            // join all together
             body = content.join('\n');
         }
         fs_1.writeFileSync(filePath, body);
         process.stderr.write("\nJest configuration written to \"" + filePath + "\".\n");
-        return [2];
+        return [2 /*return*/];
     });
 }); };
+/**
+ * @internal
+ */
 exports.help = function () { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
         process.stdout.write("\nUsage:\n  ts-jest config:init [options] [<config-file>]\n\nArguments:\n  <config-file>         Can be a js or json Jest config file. If it is a\n                        package.json file, the configuration will be read from\n                        the \"jest\" property.\n                        Default: jest.config.js\n\nOptions:\n  --force               Discard any existing Jest config\n  --js ts|babel         Process .js files with ts-jest if 'ts' or with\n                        babel-jest if 'babel'\n  --no-jest-preset      Disable the use of Jest presets\n  --tsconfig <file>     Path to the tsconfig.json file\n  --babel               Pipe babel-jest after ts-jest\n  --jsdom               Use jsdom as test environment instead of node\n");
-        return [2];
+        return [2 /*return*/];
     });
 }); };

package/dist/cli/config/migrate.js

@@ -64,7 +64,10 @@ var json5_1 = require("json5");
 var path_1 = require("path");
 var backports_1 = require("../../util/backports");
 var presets_1 = require("../helpers/presets");
-exports.run = function (args) { return __awaiter(void 0, void 0, void 0, function () {
+/**
+ * @internal
+ */
+exports.run = function (args /* , logger: Logger*/) { return __awaiter(void 0, void 0, void 0, function () {
     var nullLogger, file, filePath, footNotes, name, isPackage, actualConfig, migratedConfig, presetName, preset, jsTransformers, jsWithTs, jsWithBabel, presetValue, migratedValue, presetValue, migratedValue, before, after, stringify, prefix;
     return __generator(this, function (_a) {
         nullLogger = bs_logger_1.createLogger({ targets: [] });
@@ -86,9 +89,11 @@ exports.run = function (args) { return __awaiter(void 0, void 0, void 0, functio
         if (!actualConfig)
             actualConfig = {};
         migratedConfig = backports_1.backportJestConfig(nullLogger, actualConfig);
+        // then we check if we can use `preset`
         if (!migratedConfig.preset && args.jestPreset) {
+            // find the best preset
             if (args.js) {
-                presetName = args.js === 'babel' ? "ts-jest/presets/js-with-babel" : "ts-jest/presets/js-with-ts";
+                presetName = args.js === 'babel' ? "ts-jest/presets/js-with-babel" /* jsWIthBabel */ : "ts-jest/presets/js-with-ts" /* jsWithTs */;
             }
             else {
                 jsTransformers = Object.keys(migratedConfig.transform || {}).reduce(function (list, pattern) {
@@ -105,16 +110,18 @@ exports.run = function (args) { return __awaiter(void 0, void 0, void 0, functio
                 jsWithTs = jsTransformers.includes('ts-jest');
                 jsWithBabel = jsTransformers.includes('babel-jest');
                 if (jsWithBabel && !jsWithTs) {
-                    presetName = "ts-jest/presets/js-with-babel";
+                    presetName = "ts-jest/presets/js-with-babel" /* jsWIthBabel */;
                 }
                 else if (jsWithTs && !jsWithBabel) {
-                    presetName = "ts-jest/presets/js-with-ts";
+                    presetName = "ts-jest/presets/js-with-ts" /* jsWithTs */;
                 }
                 else {
-                    presetName = "ts-jest/presets/default";
+                    // sounds like js files are NOT handled, or handled with a unknown transformer, so we do not need to handle it
+                    presetName = "ts-jest/presets/default" /* default */;
                 }
             }
-            presetName = presetName || "ts-jest/presets/default";
+            // ensure we are using a preset
+            presetName = presetName || "ts-jest/presets/default" /* default */;
             preset = presets_1.allPresets[presetName];
             footNotes.push("Detected preset '" + preset.label + "' as the best matching preset for your configuration.\nVisit https://kulshekhar.github.io/ts-jest/user/config/#jest-preset for more information about presets.\n");
         }
@@ -126,8 +133,10 @@ exports.run = function (args) { return __awaiter(void 0, void 0, void 0, functio
                 preset = presets_1.allPresets[migratedConfig.preset] || presets_1.defaults;
             }
         }
+        // enforce the correct name
         if (preset)
             migratedConfig.preset = preset.name;
+        // check the extensions
         if (migratedConfig.moduleFileExtensions && migratedConfig.moduleFileExtensions.length && preset) {
             presetValue = dedupSort(preset.value.moduleFileExtensions || []).join('::');
             migratedValue = dedupSort(migratedConfig.moduleFileExtensions).join('::');
@@ -135,9 +144,11 @@ exports.run = function (args) { return __awaiter(void 0, void 0, void 0, functio
                 delete migratedConfig.moduleFileExtensions;
             }
         }
+        // there is a testRegex, remove our testMatch
         if (migratedConfig.testRegex && preset) {
             migratedConfig.testMatch = null;
         }
+        // check the testMatch
         else if (migratedConfig.testMatch && migratedConfig.testMatch.length && preset) {
             presetValue = dedupSort(preset.value.testMatch || []).join('::');
             migratedValue = dedupSort(migratedConfig.testMatch).join('::');
@@ -145,6 +156,7 @@ exports.run = function (args) { return __awaiter(void 0, void 0, void 0, functio
                 delete migratedConfig.testMatch;
             }
         }
+        // migrate the transform
         if (migratedConfig.transform) {
             Object.keys(migratedConfig.transform).forEach(function (key) {
                 var val = migratedConfig.transform[key];
@@ -154,30 +166,45 @@ exports.run = function (args) { return __awaiter(void 0, void 0, void 0, functio
                 }
             });
         }
+        // check if it's the same as the preset's one
         if (preset &&
             migratedConfig.transform &&
             stableStringify(migratedConfig.transform) === stableStringify(preset.value.transform)) {
             delete migratedConfig.transform;
         }
+        // cleanup
         cleanupConfig(actualConfig);
         cleanupConfig(migratedConfig);
         before = stableStringify(actualConfig);
         after = stableStringify(migratedConfig);
         if (after === before) {
             process.stderr.write("\nNo migration needed for given Jest configuration\n    ");
-            return [2];
+            return [2 /*return*/];
         }
         stringify = file.endsWith('.json') ? JSON.stringify : json5_1.stringify;
         prefix = file.endsWith('.json') ? '"jest": ' : 'module.exports = ';
+        // if we are using preset, inform the user that he might be able to remove some section(s)
+        // we couldn't check for equality
+        //   if (usesPreset && migratedConfig.testMatch) {
+        //     footNotes.push(`
+        // I couldn't check if your "testMatch" value is the same as mine which is: ${stringify(
+        //       presets.testMatch,
+        //       undefined,
+        //       '  ',
+        //     )}
+        // If it is the case, you can safely remove the "testMatch" from what I've migrated.
+        // `)
+        //   }
         if (preset && migratedConfig.transform) {
             footNotes.push("\nI couldn't check if your \"transform\" value is the same as mine which is: " + stringify(preset.value.transform, undefined, '  ') + "\nIf it is the case, you can safely remove the \"transform\" from what I've migrated.\n");
         }
+        // output new config
         process.stderr.write("\nMigrated Jest configuration:\n");
         process.stdout.write("" + prefix + stringify(migratedConfig, undefined, '  ') + "\n");
         if (footNotes.length) {
             process.stderr.write("\n" + footNotes.join('\n') + "\n");
         }
-        return [2];
+        return [2 /*return*/];
     });
 }); };
 function cleanupConfig(config) {
@@ -202,7 +229,7 @@ function cleanupConfig(config) {
         if (config.testMatch.length === 0)
             delete config.testMatch;
     }
-    if (config.preset === "ts-jest/presets/default")
+    if (config.preset === "ts-jest/presets/default" /* default */)
         config.preset = presets_1.defaults.name;
 }
 function dedupSort(arr) {
@@ -210,9 +237,12 @@ function dedupSort(arr) {
         .filter(function (s, i, a) { return a.findIndex(function (e) { return s.toString() === e.toString(); }) === i; })
         .sort(function (a, b) { return (a.toString() > b.toString() ? 1 : a.toString() < b.toString() ? -1 : 0); });
 }
+/**
+ * @internal
+ */
 exports.help = function () { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
         process.stdout.write("\nUsage:\n  ts-jest config:migrate [options] <config-file>\n\nArguments:\n  <config-file>         Can be a js or json Jest config file. If it is a\n                        package.json file, the configuration will be read from\n                        the \"jest\" property.\n\nOptions:\n  --js ts|babel         Process .js files with ts-jest if 'ts' or with\n                        babel-jest if 'babel'\n  --no-jest-preset      Disable the use of Jest presets\n");
-        return [2];
+        return [2 /*return*/];
     });
 }); };

package/dist/cli/help.js

@@ -37,10 +37,16 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.help = exports.run = void 0;
+/**
+ * @internal
+ */
 exports.run = function (_) { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
         process.stdout.write("\nUsage:\n  ts-jest command [options] [...args]\n\nCommands:\n  config:init           Creates initial Jest configuration\n  config:migrate        Migrates a given Jest configuration\n  help [command]        Show this help, or help about a command\n\nExample:\n  ts-jest help config:migrate\n");
-        return [2];
+        return [2 /*return*/];
     });
 }); };
+/**
+ * @internal
+ */
 exports.help = exports.run;

package/dist/cli/helpers/presets.js

@@ -7,15 +7,17 @@ var definePreset = function (fullName) { return ({
         return this.isDefault ? 'ts-jest' : fullName;
     },
     get label() {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         return fullName.split('/').pop();
     },
     get jsVarName() {
         return this.isDefault
             ? 'defaults'
-            :
+            : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 fullName
                     .split('/')
                     .pop()
+                    // eslint-disable-next-line no-useless-escape
                     .replace(/\-([a-z])/g, function (_, l) { return l.toUpperCase(); });
     },
     get value() {
@@ -26,10 +28,14 @@ var definePreset = function (fullName) { return ({
         return "const { " + this.jsVarName + ": " + varName + " } = require('ts-jest/presets')";
     },
     get isDefault() {
-        return fullName === "ts-jest/presets/default";
+        return fullName === "ts-jest/presets/default" /* default */;
     },
 }); };
+/** @internal */
 exports.allPresets = {};
-exports.defaults = (exports.allPresets["ts-jest/presets/default"] = definePreset("ts-jest/presets/default"));
-exports.jsWithTs = (exports.allPresets["ts-jest/presets/js-with-ts"] = definePreset("ts-jest/presets/js-with-ts"));
-exports.jsWIthBabel = (exports.allPresets["ts-jest/presets/js-with-babel"] = definePreset("ts-jest/presets/js-with-babel"));
+/** @internal */
+exports.defaults = (exports.allPresets["ts-jest/presets/default" /* default */] = definePreset("ts-jest/presets/default" /* default */));
+/** @internal */
+exports.jsWithTs = (exports.allPresets["ts-jest/presets/js-with-ts" /* jsWithTs */] = definePreset("ts-jest/presets/js-with-ts" /* jsWithTs */));
+/** @internal */
+exports.jsWIthBabel = (exports.allPresets["ts-jest/presets/js-with-babel" /* jsWIthBabel */] = definePreset("ts-jest/presets/js-with-babel" /* jsWIthBabel */));

package/dist/cli/index.js

@@ -62,6 +62,7 @@ function cli(args) {
                     },
                 },
             });
+            // deprecated
             if (parsedArgv.allowJs != null) {
                 if (parsedArgv.js)
                     throw new Error("The 'allowJs' and 'js' options cannot be set together.");
@@ -75,10 +76,13 @@ function cli(args) {
                 command = 'help';
             _a = require("./" + command.replace(/:/g, '/')), run = _a.run, help = _a.help;
             cmd = isHelp && command !== 'help' ? help : run;
-            return [2, cmd(parsedArgv, logger)];
+            return [2 /*return*/, cmd(parsedArgv, logger)];
         });
     });
 }
+/**
+ * @internal
+ */
 function processArgv() {
     return __awaiter(this, void 0, void 0, function () {
         var err_1;
@@ -86,17 +90,17 @@ function processArgv() {
             switch (_a.label) {
                 case 0:
                     _a.trys.push([0, 2, , 3]);
-                    return [4, cli(process.argv.slice(2))];
+                    return [4 /*yield*/, cli(process.argv.slice(2))];
                 case 1:
                     _a.sent();
                     process.exit(0);
-                    return [3, 3];
+                    return [3 /*break*/, 3];
                 case 2:
                     err_1 = _a.sent();
                     logger.fatal(err_1.message);
                     process.exit(1);
-                    return [3, 3];
-                case 3: return [2];
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
             }
         });
     });

package/dist/compiler/instance.js

@@ -20,12 +20,22 @@ exports.createCompilerInstance = void 0;
 var language_service_1 = require("./language-service");
 var transpiler_1 = require("./transpiler");
 var json_1 = require("../util/json");
+/**
+ * Rely on TypeScript compiled output generation which contains this prefix to point to sourcemap location.
+ */
 var SOURCE_MAPPING_PREFIX = 'sourceMappingURL=';
+/**
+ * Update the output remapping the source map.
+ */
 function updateOutput(outputText, normalizedFileName, sourceMap) {
     var base64Map = Buffer.from(updateSourceMap(sourceMap, normalizedFileName), 'utf8').toString('base64');
     var sourceMapContent = "data:application/json;charset=utf-8;base64," + base64Map;
+    // sourceMappingURL= prefix is always at the end of compiledOutput, using lastIndexOf should be the safest way to substring
     return (outputText.slice(0, outputText.lastIndexOf(SOURCE_MAPPING_PREFIX) + SOURCE_MAPPING_PREFIX.length) + sourceMapContent);
 }
+/**
+ * Update the source map contents for improved output.
+ */
 var updateSourceMap = function (sourceMapText, normalizedFileName) {
     var sourceMap = JSON.parse(sourceMapText);
     sourceMap.file = normalizedFileName;
@@ -33,21 +43,31 @@ var updateSourceMap = function (sourceMapText, normalizedFileName) {
     delete sourceMap.sourceRoot;
     return json_1.stringify(sourceMap);
 };
+/**
+ * Compile files which are provided by jest via transform config and cache the result in file system if users run with
+ * cache mode
+ */
 var compileAndUpdateOutput = function (compileFn, logger) { return function (code, fileName, lineOffset) {
     logger.debug({ fileName: fileName }, 'compileAndUpdateOutput(): get compile output');
     var _a = __read(compileFn(code, fileName, lineOffset), 2), value = _a[0], sourceMap = _a[1];
     return updateOutput(value, fileName, sourceMap);
 }; };
+/**
+ * Register TypeScript compiler instance.
+ *
+ * @internal
+ */
 exports.createCompilerInstance = function (configs) {
     var logger = configs.logger.child({ namespace: 'ts-compiler' });
     var compilerOptions = configs.parsedTsConfig.options, tsJest = configs.tsJest;
     var extensions = ['.ts', '.tsx'];
+    // Enable `allowJs` when flag is set.
     if (compilerOptions.allowJs) {
         extensions.push('.js');
         extensions.push('.jsx');
     }
     var compilerInstance = !tsJest.isolatedModules
-        ? language_service_1.initializeLanguageServiceInstance(configs, logger)
+        ? language_service_1.initializeLanguageServiceInstance(configs, logger) // Use language services by default
         : transpiler_1.initializeTranspilerInstance(configs, logger);
     var compile = compileAndUpdateOutput(compilerInstance.compileFn, logger);
     return { cwd: configs.cwd, compile: compile, program: compilerInstance.program };

package/dist/compiler/language-service.js

@@ -90,11 +90,16 @@ var json_1 = require("../util/json");
 var sha1_1 = require("../util/sha1");
 function doTypeChecking(configs, diagnosedFiles, fileName, service, logger) {
     if (configs.shouldReportDiagnostic(fileName)) {
+        // Get the relevant diagnostics - this is 3x faster than `getPreEmitDiagnostics`.
         var diagnostics = service.getSemanticDiagnostics(fileName).concat(service.getSyntacticDiagnostics(fileName));
         diagnosedFiles.push(fileName);
+        // will raise or just warn diagnostics depending on config
         configs.raiseDiagnostics(diagnostics, fileName, logger);
     }
 }
+/**
+ * @internal
+ */
 exports.initializeLanguageServiceInstance = function (configs, logger) {
     var _a;
     logger.debug('initializeLanguageServiceInstance(): create typescript compiler');
@@ -115,23 +120,28 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
     };
     var tsResolvedModulesCachePath;
     if (cacheDir) {
+        // Make sure the cache directory exists before continuing.
         mkdirp.sync(cacheDir);
         tsResolvedModulesCachePath = path_1.join(cacheDir, sha1_1.sha1('ts-jest-resolved-modules', '\x00'));
         try {
+            /* istanbul ignore next (already covered with unit test) */
             var cachedTSResolvedModules = fs_1.readFileSync(tsResolvedModulesCachePath, 'utf-8');
             memoryCache.resolvedModules = new Map(json_1.parse(cachedTSResolvedModules));
         }
         catch (e) { }
     }
+    // Initialize memory cache for typescript compiler
     configs.parsedTsConfig.fileNames.forEach(function (fileName) {
         memoryCache.files.set(fileName, {
             version: 0,
         });
     });
     function isFileInCache(fileName) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         return memoryCache.files.has(fileName) && memoryCache.files.get(fileName).version !== 0;
     }
     var cacheReadFile = logger.wrap(serviceHostTraceCtx, 'readFile', memoize(ts.sys.readFile));
+    /* istanbul ignore next */
     var moduleResolutionHost = {
         fileExists: memoize(ts.sys.fileExists),
         readFile: cacheReadFile,
@@ -159,6 +169,8 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
         });
     }
     var projectVersion = 1;
+    // Set the file contents into cache.
+    /* istanbul ignore next (cover by e2e) */
     var updateMemoryCache = function (contents, fileName) {
         logger.debug({ fileName: fileName }, 'updateMemoryCache(): update memory cache for language service');
         var shouldIncrementProjectVersion = false;
@@ -171,15 +183,22 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
             shouldIncrementProjectVersion = true;
         }
         else {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             var previousContents = memoryCache.files.get(fileName).text;
+            // Avoid incrementing cache when nothing has changed.
             if (previousContents !== contents) {
                 memoryCache.files.set(fileName, {
                     text: contents,
                     version: memoryCache.files.get(fileName).version + 1,
                 });
+                // Only bump project version when file is modified in cache, not when discovered for the first time
                 if (hit)
                     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 (!fileNames.includes(fileName)) {
                 shouldIncrementProjectVersion = true;
             }
@@ -194,6 +213,11 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
             var _a;
             var normalizedFileName = path_1.normalize(fileName);
             var version = (_a = memoryCache.files.get(normalizedFileName)) === null || _a === void 0 ? void 0 : _a.version;
+            // 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`).
             return version === undefined ? undefined : String(version);
         },
         getScriptSnapshot: function (fileName) {
@@ -201,6 +225,7 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
             var normalizedFileName = path_1.normalize(fileName);
             var hit = isFileInCache(normalizedFileName);
             logger.trace({ normalizedFileName: normalizedFileName, cacheHit: hit }, 'getScriptSnapshot():', 'cache', hit ? 'hit' : 'miss');
+            // Read contents from TypeScript memory cache.
             if (!hit) {
                 memoryCache.files.set(normalizedFileName, {
                     text: cacheReadFile(normalizedFileName),
@@ -232,33 +257,47 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
             var e_1, _a;
             var _b;
             logger.debug({ fileName: fileName }, 'compileFn(): compiling using language service');
+            // Must set memory cache before attempting to compile
             updateMemoryCache(code, fileName);
             var output = service.getEmitOutput(fileName);
+            /* istanbul ignore next */
             if (tsResolvedModulesCachePath) {
+                // Cache resolved modules to disk so next run can reuse it
                 void (function () { return __awaiter(void 0, void 0, void 0, function () {
                     return __generator(this, function (_a) {
                         switch (_a.label) {
-                            case 0: return [4, fs_1.writeFile(tsResolvedModulesCachePath, json_1.stringify(__spread(memoryCache.resolvedModules)), function () { })];
+                            case 0: 
+                            // eslint-disable-next-line @typescript-eslint/await-thenable
+                            return [4 /*yield*/, fs_1.writeFile(tsResolvedModulesCachePath, json_1.stringify(__spread(memoryCache.resolvedModules)), function () { })];
                             case 1:
+                                // eslint-disable-next-line @typescript-eslint/await-thenable
                                 _a.sent();
-                                return [2];
+                                return [2 /*return*/];
                         }
                     });
                 }); })();
             }
+            /**
+             * There might be a chance that test files are type checked even before jest executes them, we don't need to do
+             * type check again
+             */
             if (!diagnosedFiles.includes(fileName)) {
                 logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics using language service');
                 doTypeChecking(configs, diagnosedFiles, fileName, service, logger);
             }
+            /* istanbul ignore next (already covered with unit tests) */
             if (!configs.isTestFile(fileName)) {
                 try {
                     for (var _c = __values(memoryCache.resolvedModules.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
                         var _e = __read(_d.value, 2), testFileName = _e[0], resolvedModules = _e[1];
+                        // Only do type checking for test files which haven't been type checked before as well as the file must exist
                         if (resolvedModules.includes(fileName) &&
                             !diagnosedFiles.includes(testFileName) &&
                             fs_1.existsSync(testFileName)) {
                             var testFileContent = (_b = memoryCache.files.get(testFileName)) === null || _b === void 0 ? void 0 : _b.text;
                             if (!testFileContent) {
+                                // Must set memory cache before attempting to get diagnostics
+                                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                                 updateMemoryCache(cacheReadFile(testFileName), testFileName);
                             }
                             logger.debug({ testFileName: testFileName }, 'compileFn(): computing diagnostics using language service for test file which uses the module');
@@ -274,11 +313,13 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
                     finally { if (e_1) throw e_1.error; }
                 }
             }
+            /* istanbul ignore next (this should never happen but is kept for security) */
             if (output.emitSkipped) {
                 throw new TypeError(path_1.relative(cwd, fileName) + ": Emit skipped for language service");
             }
+            // Throw an error when requiring `.d.ts` files.
             if (!output.outputFiles.length) {
-                throw new TypeError(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(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}}`." /* UnableToRequireDefinitionFile */, {
                     file: path_1.basename(fileName),
                 }));
             }

package/dist/compiler/transpiler.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initializeTranspilerInstance = void 0;
+/**
+ * @internal
+ */
 exports.initializeTranspilerInstance = function (configs, logger) {
     logger.debug('initializeTranspilerInstance(): create typescript compiler');
     var _a = configs.parsedTsConfig, options = _a.options, fileNames = _a.fileNames;
@@ -18,6 +21,7 @@ exports.initializeTranspilerInstance = function (configs, logger) {
             if (result.diagnostics && configs.shouldReportDiagnostic(fileName)) {
                 configs.raiseDiagnostics(result.diagnostics, fileName, logger);
             }
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             return [result.outputText, result.sourceMapText];
         },
         program: program,

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

@@ -1,11 +1,30 @@
+/**
+ * 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.
+ */
 import type { Config } from '@jest/types';
 import { Logger } from 'bs-logger';
 import type { TsCompiler, TsJestGlobalOptions, TTypeScript } from '../types';
 export declare class ConfigSet {
     readonly parentOptions?: TsJestGlobalOptions | undefined;
+    /**
+     * Use by e2e, don't mark as internal
+     */
     get versions(): Record<string, string>;
+    /**
+     * This API can be used by custom transformers
+     */
     get compilerModule(): TTypeScript;
     get tsCompiler(): TsCompiler;
+    /**
+     * Use by e2e, don't mark as internal
+     */
     get tsJestDigest(): string;
     readonly logger: Logger;
     constructor(jestConfig: Config.ProjectConfig, parentOptions?: TsJestGlobalOptions | undefined, parentLogger?: Logger);