ts-jest 26.1.1 → 26.1.4

package/.ts-jest-digest

@@ -1 +1 @@
-5e9f319e512fe352ff9b9947c24dd3a512e4be3f
+0737e8c053dff53d27ba181062809f8e72a79f50

package/CHANGELOG.md

@@ -1,3 +1,37 @@
+## [26.1.4](https://github.com/kulshekhar/ts-jest/compare/v26.1.3...v26.1.4) (2020-07-28)
+
+
+### Bug Fixes
+
+* **compiler:** check if test file exists before doing type check ([#1827](https://github.com/kulshekhar/ts-jest/issues/1827)) ([cc89d5b](https://github.com/kulshekhar/ts-jest/commit/cc89d5b1f912975cd29114c5b3b0bf18426816da)), closes [#1506](https://github.com/kulshekhar/ts-jest/issues/1506)
+
+
+
+## [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)
 

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;
@@ -28,11 +17,9 @@ var __read = (this && this.__read) || function (o, n) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCompilerInstance = void 0;
-var fs_1 = require("fs");
-var mkdirp = require("mkdirp");
-var compiler_utils_1 = require("./compiler-utils");
 var language_service_1 = require("./language-service");
 var transpiler_1 = require("./transpiler");
+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');
@@ -44,48 +31,24 @@ var updateSourceMap = function (sourceMapText, normalizedFileName) {
     sourceMap.file = normalizedFileName;
     sourceMap.sources = [normalizedFileName];
     delete sourceMap.sourceRoot;
-    return JSON.stringify(sourceMap);
+    return json_1.stringify(sourceMap);
 };
-var compileAndCacheResult = function (memoryCache, compileFn, 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);
-    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 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 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, 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,36 +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');
@@ -90,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,
                 });
             }
@@ -104,42 +213,65 @@ 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) &&
+                            fs_1.existsSync(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) {
@@ -150,6 +282,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,21 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initializeTranspilerInstance = void 0;
-exports.initializeTranspilerInstance = function (configs, memoryCache, logger) {
+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;

package/dist/config/config-set.js

@@ -52,6 +52,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigSet = exports.TS_JEST_OUT_DIR = exports.IGNORE_DIAGNOSTIC_CODES = exports.MATCH_NOTHING = void 0;
 var bs_logger_1 = require("bs-logger");
 var fs_1 = require("fs");
+var jest_util_1 = require("jest-util");
 var json5 = require("json5");
 var path_1 = require("path");
 var typescript_1 = require("typescript");
@@ -194,7 +195,7 @@ var ConfigSet = (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(ConfigSet.prototype, "testMatchPatterns", {
+    Object.defineProperty(ConfigSet.prototype, "isTestFile", {
         get: function () {
             var matchablePatterns = __spread(this.jest.testMatch, this.jest.testRegex).filter(function (pattern) {
                 return pattern instanceof RegExp || typeof pattern === 'string';
@@ -202,7 +203,11 @@ var ConfigSet = (function () {
             if (!matchablePatterns.length) {
                 matchablePatterns.push.apply(matchablePatterns, __spread(constants_1.DEFAULT_JEST_TEST_MATCH));
             }
-            return matchablePatterns;
+            var stringPatterns = matchablePatterns.filter(function (pattern) { return typeof pattern === 'string'; });
+            var isMatch = jest_util_1.globsToMatcher(stringPatterns);
+            return function (fileName) {
+                return matchablePatterns.some(function (pattern) { return (typeof pattern === 'string' ? isMatch(fileName) : pattern.test(fileName)); });
+            };
         },
         enumerable: false,
         configurable: true
@@ -584,7 +589,10 @@ var ConfigSet = (function () {
                 jest: jest,
                 tsJest: this.tsJest,
                 babel: this.babel,
-                tsconfig: this.parsedTsConfig.options,
+                tsconfig: {
+                    options: this.parsedTsConfig.options,
+                    raw: this.parsedTsConfig.raw,
+                },
             });
         },
         enumerable: false,
@@ -731,9 +739,6 @@ var ConfigSet = (function () {
     __decorate([
         memoize_1.Memoize()
     ], ConfigSet.prototype, "jest", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "testMatchPatterns", null);
     __decorate([
         memoize_1.Memoize()
     ], ConfigSet.prototype, "tsJest", null);

package/dist/index.d.ts

@@ -44,7 +44,7 @@ declare const jestPreset: Pick<Partial<{
     dependencyExtractor: string;
     detectLeaks: boolean;
     detectOpenHandles: boolean;
-    displayName: import("@jest/types/build/Config").DisplayName;
+    displayName: string | import("@jest/types/build/Config").DisplayName;
     expand: boolean;
     extraGlobals: string[];
     filter: string;

package/dist/ts-jest-transformer.js

@@ -67,13 +67,13 @@ var TsJestTransformer = (function () {
         var source = input;
         var configs = this.configsFor(jestConfig);
         var hooks = configs.hooks;
-        var stringify = configs.shouldStringifyContent(filePath);
-        var babelJest = stringify ? undefined : configs.babelJestTransformer;
+        var shouldStringifyContent = configs.shouldStringifyContent(filePath);
+        var babelJest = shouldStringifyContent ? undefined : configs.babelJestTransformer;
         var isDefinitionFile = filePath.endsWith('.d.ts');
         var isJsFile = constants_1.JS_JSX_REGEX.test(filePath);
         var isTsFile = !isDefinitionFile && constants_1.TS_TSX_REGEX.test(filePath);
-        if (stringify) {
-            result = "module.exports=" + JSON.stringify(source);
+        if (shouldStringifyContent) {
+            result = "module.exports=" + json_1.stringify(source);
         }
         else if (isDefinitionFile) {
             result = '';

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 import * as _babel from 'babel__core';
 import * as _ts from 'typescript';
+export declare type TTypeScript = typeof _ts;
 export declare type BabelConfig = _babel.TransformOptions;
 export interface TsJestGlobalOptions {
     tsConfig?: boolean | string | _ts.CompilerOptions;
@@ -65,14 +66,4 @@ export interface TsJestConfig {
 export interface TsCompiler {
     program: _ts.Program | undefined;
 }
-export declare type TSFiles = Map<string, TSFile>;
-export interface TSFile {
-    text?: string;
-    output?: string;
-    version: number;
-    projectReference?: {
-        project?: _ts.ResolvedProjectReference;
-        outputFileName?: string;
-    };
-}
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-jest",
-  "version": "26.1.1",
+  "version": "26.1.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": "cli.js",
@@ -60,10 +60,10 @@
     "bs-logger": "0.x",
     "buffer-from": "1.x",
     "fast-json-stable-stringify": "2.x",
+    "jest-util": "26.x",
     "json5": "2.x",
     "lodash.memoize": "4.x",
     "make-error": "1.x",
-    "micromatch": "4.x",
     "mkdirp": "1.x",
     "semver": "7.x",
     "yargs-parser": "18.x"
@@ -80,15 +80,15 @@
     }
   },
   "devDependencies": {
-    "@commitlint/cli": "8.x",
-    "@commitlint/config-conventional": "8.x",
+    "@commitlint/cli": "9.x",
+    "@commitlint/config-conventional": "9.x",
     "@jest/transform": "26.x",
     "@jest/types": "26.x",
     "@types/babel__core": "7.x",
     "@types/buffer-from": "latest",
     "@types/cross-spawn": "latest",
     "@types/fs-extra": "latest",
-    "@types/jest": "25.x",
+    "@types/jest": "26.x",
     "@types/js-yaml": "latest",
     "@types/json5": "latest",
     "@types/lodash.memoize": "4.x",
@@ -96,7 +96,7 @@
     "@types/lodash.set": "4.x",
     "@types/micromatch": "4.x",
     "@types/mkdirp": "latest",
-    "@types/node": "10.x",
+    "@types/node": "12.x",
     "@types/react": "16.x",
     "@types/semver": "latest",
     "@types/yargs": "latest",

package/dist/compiler/compiler-utils.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/compiler/compiler-utils.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTestFile = exports.cacheResolvedModules = exports.getResolvedModulesCache = void 0;
-var fs_1 = require("fs");
-var micromatch = require("micromatch");
-var path_1 = require("path");
-var sha1_1 = require("../util/sha1");
-function getResolvedModulesCache(cacheDir) {
-    return path_1.join(cacheDir, sha1_1.sha1('ts-jest-resolved-modules', '\x00'));
-}
-exports.getResolvedModulesCache = getResolvedModulesCache;
-function cacheResolvedModules(fileName, fileContent, memoryCache, program, cacheDir, logger) {
-    var importReferences = program.getSourceFile(fileName).imports;
-    if (importReferences.length) {
-        logger.debug({ fileName: fileName }, 'cacheResolvedModules(): get resolved modules');
-        memoryCache.resolvedModules[fileName] = Object.create(null);
-        memoryCache.resolvedModules[fileName].modulePaths = importReferences
-            .filter(function (importReference) { var _a; return (_a = importReference.parent.parent.resolvedModules) === null || _a === void 0 ? void 0 : _a.get(importReference.text); })
-            .map(function (importReference) {
-            return path_1.normalize(importReference.parent.parent.resolvedModules.get(importReference.text)
-                .resolvedFileName);
-        })
-            .reduce(function (a, b) { return a.concat(b); }, []);
-        memoryCache.resolvedModules[fileName].testFileContent = fileContent;
-        fs_1.writeFileSync(getResolvedModulesCache(cacheDir), JSON.stringify(memoryCache.resolvedModules));
-    }
-}
-exports.cacheResolvedModules = cacheResolvedModules;
-function isTestFile(testMatchPatterns, fileName) {
-    return testMatchPatterns.some(function (pattern) {
-        return typeof pattern === 'string' ? micromatch.isMatch(fileName, pattern) : pattern.test(fileName);
-    });
-}
-exports.isTestFile = isTestFile;