ts-jest 26.0.0 → 26.1.3

package/.ts-jest-digest

@@ -1 +1 @@
-da6ae4997a1aa7d8530ada1d1bcd5472c3da9a71
+1b4f2f24dd078873082b82fa6c70d7029f0c60ab

package/CHANGELOG.md

@@ -1,3 +1,56 @@
+## [26.1.3](https://github.com/kulshekhar/ts-jest/compare/v26.1.2...v26.1.3) (2020-07-16)
+
+
+### Bug Fixes
+
+* revert [#1793](https://github.com/kulshekhar/ts-jest/issues/1793) ([#1804](https://github.com/kulshekhar/ts-jest/issues/1804)) ([5095525](https://github.com/kulshekhar/ts-jest/commit/5095525333c8579c9c5e7f3149294b31f28d6774))
+
+
+
+## [26.1.2](https://github.com/kulshekhar/ts-jest/compare/v26.1.1...v26.1.2) (2020-07-13)
+
+
+### Bug Fixes
+
+* **compiler:** use `resolveModuleNames` TypeScript API to get resolved modules for test files ([#1784](https://github.com/kulshekhar/ts-jest/issues/1784)) ([5f26054](https://github.com/kulshekhar/ts-jest/commit/5f2605457e94b548bd7b9b28fc968554f7eefa91)), closes [#1747](https://github.com/kulshekhar/ts-jest/issues/1747)
+* **config:** invalidate cache when other options in `tsconfig` change ([#1788](https://github.com/kulshekhar/ts-jest/issues/1788)) ([6948855](https://github.com/kulshekhar/ts-jest/commit/69488552eca2846f3fc6ba86ab49d7893caaf521))
+
+
+### Performance Improvements
+
+* **compiler:** cache module resolution for `isolatedModules: false` ([#1786](https://github.com/kulshekhar/ts-jest/issues/1786)) ([7f731ed](https://github.com/kulshekhar/ts-jest/commit/7f731ed8a02755aeb41ecb27df4eaf16db2ddd95))
+* **compiler:** use `globsToMatcher` from `jest-util` ([#1754](https://github.com/kulshekhar/ts-jest/issues/1754)) ([44f3913](https://github.com/kulshekhar/ts-jest/commit/44f3913c2a017734ed87346b1c5fbec639d02062))
+
+
+
+<a name="26.1.1"></a>
+## [26.1.1](https://github.com/kulshekhar/ts-jest/compare/v26.1.0...v26.1.1) (2020-06-21)
+
+
+### Bug Fixes
+
+* **compiler:** generate source map correctly when tsconfig `mapRoot` is set ([#1741](https://github.com/kulshekhar/ts-jest/issues/1741)) ([01ac417](https://github.com/kulshekhar/ts-jest/commit/01ac417)), closes [#1718](https://github.com/kulshekhar/ts-jest/issues/1718)
+* **config:** show version warning when using ts-jest without babel ([#1729](https://github.com/kulshekhar/ts-jest/issues/1729)) ([e512bc0](https://github.com/kulshekhar/ts-jest/commit/e512bc0)), fixes [#1678-issuecomment-641930332](https://github.com//github.com/kulshekhar/ts-jest/pull/1678/issues/issuecomment-641930332), [#1678-issuecomment-639528993](https://github.com//github.com/kulshekhar/ts-jest/pull/1678/issues/issuecomment-639528993)
+
+
+
+<a name="26.1.0"></a>
+# [26.1.0](https://github.com/kulshekhar/ts-jest/compare/v26.0.0...v26.1.0) (2020-05-30)
+
+
+### Bug Fixes
+
+* **typing:** don't mark `BabelConfig` as internal type ([#1667](https://github.com/kulshekhar/ts-jest/issues/1667)) ([558c307](https://github.com/kulshekhar/ts-jest/commit/558c307)), closes [#1666](https://github.com/kulshekhar/ts-jest/issues/1666)
+
+
+### Features
+
+* **config:** show a warning message when TypeScript `target` version doesn't match with recommended NodeJs version ([#1678](https://github.com/kulshekhar/ts-jest/issues/1678)) ([085bdf5](https://github.com/kulshekhar/ts-jest/commit/085bdf5))
+* **config:** support multiple paths for `pathsToModuleNameMapper` ([#1690](https://github.com/kulshekhar/ts-jest/issues/1690)) ([a727bd5](https://github.com/kulshekhar/ts-jest/commit/a727bd5))
+* support TypeScript 3.9 ([#1653](https://github.com/kulshekhar/ts-jest/issues/1653)) ([fc3d5ad](https://github.com/kulshekhar/ts-jest/commit/fc3d5ad))
+
+
+
 <a name="26.0.0"></a>
 # [26.0.0](https://github.com/kulshekhar/ts-jest/compare/v25.5.1...v26.0.0) (2020-05-15)
 

package/dist/cli/config/init.js

@@ -47,6 +47,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = exports.run = void 0;
 var fs_1 = require("fs");
 var json5_1 = require("json5");
 var path_1 = require("path");

package/dist/cli/config/migrate.js

@@ -56,6 +56,7 @@ var __spread = (this && this.__spread) || function () {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = exports.run = void 0;
 var bs_logger_1 = require("bs-logger");
 var stableStringify = require("fast-json-stable-stringify");
 var fs_1 = require("fs");

package/dist/cli/help.js

@@ -36,6 +36,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = exports.run = void 0;
 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");

package/dist/cli/helpers/presets.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsWIthBabel = exports.jsWithTs = exports.defaults = exports.allPresets = void 0;
 var definePreset = function (fullName) { return ({
     fullName: fullName,
     get name() {
@@ -11,10 +12,11 @@ var definePreset = function (fullName) { return ({
     get jsVarName() {
         return this.isDefault
             ? 'defaults'
-            : fullName
-                .split('/')
-                .pop()
-                .replace(/\-([a-z])/g, function (_, l) { return l.toUpperCase(); });
+            :
+                fullName
+                    .split('/')
+                    .pop()
+                    .replace(/\-([a-z])/g, function (_, l) { return l.toUpperCase(); });
     },
     get value() {
         return require("../../../" + fullName.replace(/^ts-jest\//, '') + "/jest-preset");

package/dist/cli/index.js

@@ -37,6 +37,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.processArgv = void 0;
 var bs_logger_1 = require("bs-logger");
 var yargsParser = require("yargs-parser");
 var logger_1 = require("../util/logger");

package/dist/compiler/instance.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -27,70 +16,39 @@ var __read = (this && this.__read) || function (o, n) {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var fs_1 = require("fs");
-var mkdirp = require("mkdirp");
-var path_1 = require("path");
-var compiler_utils_1 = require("./compiler-utils");
+exports.createCompilerInstance = void 0;
 var language_service_1 = require("./language-service");
 var transpiler_1 = require("./transpiler");
-function updateOutput(outputText, normalizedFileName, sourceMap, getExtension) {
-    var base = path_1.basename(normalizedFileName);
+var json_1 = require("../util/json");
+var SOURCE_MAPPING_PREFIX = 'sourceMappingURL=';
+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;
-    var sourceMapLength = (base + ".map").length + (getExtension(normalizedFileName).length - path_1.extname(normalizedFileName).length);
-    return outputText.slice(0, -sourceMapLength) + sourceMapContent;
+    return (outputText.slice(0, outputText.lastIndexOf(SOURCE_MAPPING_PREFIX) + SOURCE_MAPPING_PREFIX.length) + sourceMapContent);
 }
 var updateSourceMap = function (sourceMapText, normalizedFileName) {
     var sourceMap = JSON.parse(sourceMapText);
     sourceMap.file = normalizedFileName;
     sourceMap.sources = [normalizedFileName];
     delete sourceMap.sourceRoot;
-    return JSON.stringify(sourceMap);
+    return json_1.stringify(sourceMap);
 };
-var compileAndCacheResult = function (memoryCache, compileFn, getExtension, logger) { return function (code, fileName, lineOffset) {
-    logger.debug({ fileName: fileName }, 'compileAndCacheResult(): get compile output');
+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];
-    var output = updateOutput(value, fileName, sourceMap, getExtension);
-    memoryCache.files.set(fileName, __assign(__assign({}, memoryCache.files.get(fileName)), { output: output }));
-    return output;
+    return updateOutput(value, fileName, sourceMap);
 }; };
 exports.createCompilerInstance = function (configs) {
     var logger = configs.logger.child({ namespace: 'ts-compiler' });
     var compilerOptions = configs.parsedTsConfig.options, tsJest = configs.tsJest;
-    var cacheDir = configs.tsCacheDir;
-    var ts = configs.compilerModule;
     var extensions = ['.ts', '.tsx'];
-    var memoryCache = {
-        files: new Map(),
-        resolvedModules: Object.create(null),
-    };
     if (compilerOptions.allowJs) {
         extensions.push('.js');
         extensions.push('.jsx');
     }
-    if (cacheDir) {
-        mkdirp.sync(cacheDir);
-        try {
-            var fsMemoryCache = fs_1.readFileSync(compiler_utils_1.getResolvedModulesCache(cacheDir), 'utf-8');
-            memoryCache.resolvedModules = JSON.parse(fsMemoryCache);
-        }
-        catch (e) { }
-    }
-    configs.parsedTsConfig.fileNames.forEach(function (fileName) {
-        memoryCache.files.set(fileName, {
-            version: 0,
-        });
-    });
-    var getExtension = compilerOptions.jsx === ts.JsxEmit.Preserve
-        ? function (path) { return (/\.[tj]sx$/.test(path) ? '.jsx' : '.js'); }
-        : function (_) { return '.js'; };
-    var compilerInstance;
-    if (!tsJest.isolatedModules) {
-        compilerInstance = language_service_1.initializeLanguageServiceInstance(configs, memoryCache, logger);
-    }
-    else {
-        compilerInstance = transpiler_1.initializeTranspilerInstance(configs, memoryCache, logger);
-    }
-    var compile = compileAndCacheResult(memoryCache, compilerInstance.compileFn, getExtension, logger);
+    var compilerInstance = !tsJest.isolatedModules
+        ? language_service_1.initializeLanguageServiceInstance(configs, logger)
+        : 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

@@ -1,4 +1,51 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -19,35 +66,98 @@ var __spread = (this && this.__spread) || function () {
     for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
     return ar;
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeLanguageServiceInstance = void 0;
 var bs_logger_1 = require("bs-logger");
+var fs_1 = require("fs");
 var path_1 = require("path");
+var memoize = require("lodash.memoize");
+var mkdirp = require("mkdirp");
 var constants_1 = require("../constants");
 var messages_1 = require("../util/messages");
-var compiler_utils_1 = require("./compiler-utils");
-var memoize = require("lodash.memoize");
-function doTypeChecking(configs, fileName, service, logger) {
+var json_1 = require("../util/json");
+var sha1_1 = require("../util/sha1");
+function doTypeChecking(configs, diagnosedFiles, fileName, service, logger) {
     if (configs.shouldReportDiagnostic(fileName)) {
         var diagnostics = service.getSemanticDiagnostics(fileName).concat(service.getSyntacticDiagnostics(fileName));
+        diagnosedFiles.push(fileName);
         configs.raiseDiagnostics(diagnostics, fileName, logger);
     }
 }
-exports.initializeLanguageServiceInstance = function (configs, memoryCache, logger) {
+exports.initializeLanguageServiceInstance = function (configs, logger) {
     var _a;
     logger.debug('initializeLanguageServiceInstance(): create typescript compiler');
     var ts = configs.compilerModule;
     var cwd = configs.cwd;
     var cacheDir = configs.tsCacheDir;
     var _b = configs.parsedTsConfig, options = _b.options, fileNames = _b.fileNames;
+    var diagnosedFiles = [];
     var serviceHostTraceCtx = (_a = {
             namespace: 'ts:serviceHost',
             call: null
         },
         _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.trace,
         _a);
+    var memoryCache = {
+        files: new Map(),
+        resolvedModules: new Map(),
+    };
+    var tsResolvedModulesCachePath;
+    if (cacheDir) {
+        mkdirp.sync(cacheDir);
+        tsResolvedModulesCachePath = path_1.join(cacheDir, sha1_1.sha1('ts-jest-resolved-modules', '\x00'));
+        try {
+            var cachedTSResolvedModules = fs_1.readFileSync(tsResolvedModulesCachePath, 'utf-8');
+            memoryCache.resolvedModules = new Map(json_1.parse(cachedTSResolvedModules));
+        }
+        catch (e) { }
+    }
+    configs.parsedTsConfig.fileNames.forEach(function (fileName) {
+        memoryCache.files.set(fileName, {
+            version: 0,
+        });
+    });
     function isFileInCache(fileName) {
         return memoryCache.files.has(fileName) && memoryCache.files.get(fileName).version !== 0;
     }
+    var cacheReadFile = logger.wrap(serviceHostTraceCtx, 'readFile', memoize(ts.sys.readFile));
+    var moduleResolutionHost = {
+        fileExists: memoize(ts.sys.fileExists),
+        readFile: cacheReadFile,
+        directoryExists: memoize(ts.sys.directoryExists),
+        getCurrentDirectory: function () { return cwd; },
+        realpath: ts.sys.realpath && memoize(ts.sys.realpath),
+        getDirectories: memoize(ts.sys.getDirectories),
+    };
+    var moduleResolutionCache = ts.createModuleResolutionCache(cwd, function (x) { return x; }, options);
+    function resolveModuleNames(moduleNames, containingFile) {
+        var _a;
+        var normalizedContainingFile = path_1.normalize(containingFile);
+        var currentResolvedModules = (_a = memoryCache.resolvedModules.get(normalizedContainingFile)) !== null && _a !== void 0 ? _a : [];
+        return moduleNames.map(function (moduleName) {
+            var resolveModuleName = ts.resolveModuleName(moduleName, containingFile, options, moduleResolutionHost, moduleResolutionCache);
+            var resolvedModule = resolveModuleName.resolvedModule;
+            if (configs.isTestFile(normalizedContainingFile) && resolvedModule) {
+                var normalizedResolvedFileName = path_1.normalize(resolvedModule.resolvedFileName);
+                if (!currentResolvedModules.includes(normalizedResolvedFileName)) {
+                    currentResolvedModules.push(normalizedResolvedFileName);
+                    memoryCache.resolvedModules.set(normalizedContainingFile, currentResolvedModules);
+                }
+            }
+            return resolvedModule;
+        });
+    }
     var projectVersion = 1;
     var updateMemoryCache = function (contents, fileName) {
         logger.debug({ fileName: fileName }, 'updateMemoryCache(): update memory cache for language service');
@@ -89,11 +199,11 @@ exports.initializeLanguageServiceInstance = function (configs, memoryCache, logg
         getScriptSnapshot: function (fileName) {
             var _a;
             var normalizedFileName = path_1.normalize(fileName);
-            var hit = memoryCache.files.has(normalizedFileName) && memoryCache.files.get(normalizedFileName).version !== 0;
+            var hit = isFileInCache(normalizedFileName);
             logger.trace({ normalizedFileName: normalizedFileName, cacheHit: hit }, 'getScriptSnapshot():', 'cache', hit ? 'hit' : 'miss');
             if (!hit) {
                 memoryCache.files.set(normalizedFileName, {
-                    text: ts.sys.readFile(normalizedFileName),
+                    text: cacheReadFile(normalizedFileName),
                     version: 1,
                 });
             }
@@ -103,42 +213,63 @@ exports.initializeLanguageServiceInstance = function (configs, memoryCache, logg
             return ts.ScriptSnapshot.fromString(contents);
         },
         fileExists: memoize(ts.sys.fileExists),
-        readFile: logger.wrap(serviceHostTraceCtx, 'readFile', memoize(ts.sys.readFile)),
+        readFile: cacheReadFile,
         readDirectory: memoize(ts.sys.readDirectory),
         getDirectories: memoize(ts.sys.getDirectories),
         directoryExists: memoize(ts.sys.directoryExists),
-        realpath: memoize(ts.sys.realpath),
+        realpath: ts.sys.realpath && memoize(ts.sys.realpath),
         getNewLine: function () { return constants_1.LINE_FEED; },
         getCurrentDirectory: function () { return cwd; },
         getCompilationSettings: function () { return options; },
         getDefaultLibFileName: function () { return ts.getDefaultLibFilePath(options); },
         getCustomTransformers: function () { return configs.tsCustomTransformers; },
+        resolveModuleNames: resolveModuleNames,
     };
     logger.debug('initializeLanguageServiceInstance(): creating language service');
     var service = ts.createLanguageService(serviceHost, ts.createDocumentRegistry());
     return {
         compileFn: function (code, fileName) {
+            var e_1, _a;
+            var _b;
             logger.debug({ fileName: fileName }, 'compileFn(): compiling using language service');
             updateMemoryCache(code, fileName);
             var output = service.getEmitOutput(fileName);
-            logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics using language service');
-            doTypeChecking(configs, fileName, service, logger);
-            if (cacheDir) {
-                if (compiler_utils_1.isTestFile(configs.testMatchPatterns, fileName)) {
-                    compiler_utils_1.cacheResolvedModules(fileName, code, memoryCache, service.getProgram(), cacheDir, logger);
-                }
-                else {
-                    Object.entries(memoryCache.resolvedModules)
-                        .filter(function (entry) {
-                        return entry[1].modulePaths.find(function (modulePath) { return modulePath === fileName; }) && !memoryCache.files.has(entry[0]);
-                    })
-                        .forEach(function (entry) {
-                        var testFileName = entry[0];
-                        var testFileContent = entry[1].testFileContent;
-                        logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics for test file that imports this module using language service');
-                        updateMemoryCache(testFileContent, testFileName);
-                        doTypeChecking(configs, testFileName, service, logger);
+            if (tsResolvedModulesCachePath) {
+                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 1:
+                                _a.sent();
+                                return [2];
+                        }
                     });
+                }); })();
+            }
+            if (!diagnosedFiles.includes(fileName)) {
+                logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics using language service');
+                doTypeChecking(configs, diagnosedFiles, fileName, service, logger);
+            }
+            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];
+                        if (resolvedModules.includes(fileName) && !diagnosedFiles.includes(testFileName)) {
+                            var testFileContent = (_b = memoryCache.files.get(testFileName)) === null || _b === void 0 ? void 0 : _b.text;
+                            if (!testFileContent) {
+                                updateMemoryCache(cacheReadFile(testFileName), testFileName);
+                            }
+                            logger.debug({ testFileName: testFileName }, 'compileFn(): computing diagnostics using language service for test file which uses the module');
+                            doTypeChecking(configs, diagnosedFiles, testFileName, service, logger);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    }
+                    finally { if (e_1) throw e_1.error; }
                 }
             }
             if (output.emitSkipped) {
@@ -149,6 +280,7 @@ exports.initializeLanguageServiceInstance = function (configs, memoryCache, logg
                     file: path_1.basename(fileName),
                 }));
             }
+            memoryCache.files.set(fileName, __assign(__assign({}, memoryCache.files.get(fileName)), { output: output.outputFiles[1].text }));
             return [output.outputFiles[1].text, output.outputFiles[0].text];
         },
         program: service.getProgram(),

package/dist/compiler/transpiler.js

@@ -1,20 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeTranspilerInstance = function (configs, memoryCache, logger) {
+exports.initializeTranspilerInstance = void 0;
+exports.initializeTranspilerInstance = function (configs, logger) {
     logger.debug('initializeTranspilerInstance(): create typescript compiler');
     var _a = configs.parsedTsConfig, options = _a.options, fileNames = _a.fileNames;
     var ts = configs.compilerModule;
     var program = ts.createProgram(fileNames, options);
-    var updateFileInCache = function (contents, filePath) {
-        var file = memoryCache.files.get(filePath);
-        if (file && file.text !== contents) {
-            file.version++;
-            file.text = contents;
-        }
-    };
     return {
         compileFn: function (code, fileName) {
-            updateFileInCache(code, fileName);
             logger.debug({ fileName: fileName }, 'compileFn(): compiling as isolated module');
             var result = ts.transpileModule(code, {
                 fileName: fileName,

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

@@ -1,9 +1,10 @@
 import { Config } from '@jest/types';
 import { Logger } from 'bs-logger';
-import { TsCompiler, TsJestGlobalOptions } from '../types';
+import { TsCompiler, TsJestGlobalOptions, TTypeScript } from '../types';
 export declare class ConfigSet {
     readonly parentOptions?: TsJestGlobalOptions | undefined;
     get versions(): Record<string, string>;
+    get compilerModule(): TTypeScript;
     get tsCompiler(): TsCompiler;
     get tsJestDigest(): string;
     readonly logger: Logger;