ts-jest 26.4.4-alpha.0 → 26.5.2

package/.ts-jest-digest

@@ -1 +1 @@
-336cc4e94740cf0fe1f2860194506c4f8866b4e4
+f05021154752d867f897fb08a2c5739108a4251c

package/CHANGELOG.md

@@ -1,3 +1,58 @@
+## [26.5.2](https://github.com/kulshekhar/ts-jest/compare/v26.5.1...v26.5.2) (2021-02-21)
+
+
+### Bug Fixes
+
+* **compiler:** exclude files in `outDir` from compiler source files ([#2376](https://github.com/kulshekhar/ts-jest/issues/2376)) ([9034677](https://github.com/kulshekhar/ts-jest/commit/9034677f9ce0968339d3d942a70e888996fac532)), closes [#2350](https://github.com/kulshekhar/ts-jest/issues/2350) [#2374](https://github.com/kulshekhar/ts-jest/issues/2374)
+* **config:** define `matchTestFilePath` before `setupTsJestCfg` ([#2373](https://github.com/kulshekhar/ts-jest/issues/2373)) ([c427fea](https://github.com/kulshekhar/ts-jest/commit/c427fea48a24b5ce6e8b9260d3c322583b062a77)), closes [#2371](https://github.com/kulshekhar/ts-jest/issues/2371)
+* **config:** improve emit skipped error message and ensure `outDir` always `TS_JEST_OUT_DIR` ([#2357](https://github.com/kulshekhar/ts-jest/issues/2357)) ([f2808bb](https://github.com/kulshekhar/ts-jest/commit/f2808bb0b15231c67ccb9a97ed606741213c03e6))
+* **typings:** set correct typing for `tsconfig`/`tsConfig` option ([#2377](https://github.com/kulshekhar/ts-jest/issues/2377)) ([d4f6aff](https://github.com/kulshekhar/ts-jest/commit/d4f6aff3f181761bf25c64ff1a97dd19a69196f9)), closes [#2368](https://github.com/kulshekhar/ts-jest/issues/2368)
+
+
+
+## [26.5.1](https://github.com/kulshekhar/ts-jest/compare/v26.5.0...v26.5.1) (2021-02-09)
+
+
+### Features
+
+* **config:** support typed config options for jest config typescript ([#2336](https://github.com/kulshekhar/ts-jest/issues/2336)) ([f4f5d32](https://github.com/kulshekhar/ts-jest/commit/f4f5d3205d1c80e545a32c02c6a66e7e91386f7f))
+* **presets:** add typing for `presets` entry point ([#2341](https://github.com/kulshekhar/ts-jest/issues/2341)) ([e12b004](https://github.com/kulshekhar/ts-jest/commit/e12b004dcc5848d5ae0638e885147c54e11cc72b)), closes [#2325](https://github.com/kulshekhar/ts-jest/issues/2325)
+
+
+
+# [26.5.0](https://github.com/kulshekhar/ts-jest/compare/v26.5.0...v26.4.4) (2021-01-29)
+
+
+### Bug Fixes
+
+* reduce size of `node_modules` when adding `ts-jest` ([#2309](https://github.com/kulshekhar/ts-jest/issues/2309)) ([6bf2e8a](https://github.com/kulshekhar/ts-jest/commit/b8d5d2090567f23947d9efd87f5f869b16bf2e8a))
+
+
+### Features
+
+* introduce `exclude` to exclude files from diagnostics ([#2308](https://github.com/kulshekhar/ts-jest/issues/2308)) ([cd82fd3](https://github.com/kulshekhar/ts-jest/commit/0c555c250774a7fd9e356cf20a3d8b693cd82fd3))
+
+
+### DEPRECATIONS
+
+* **config**: deprecate `pathRegex` in favor of `exclude` ([#2308](https://github.com/kulshekhar/ts-jest/issues/2308)) ([cd82fd3](https://github.com/kulshekhar/ts-jest/commit/0c555c250774a7fd9e356cf20a3d8b693cd82fd3))
+
+
+
+## [26.4.4](https://github.com/kulshekhar/ts-jest/compare/v26.4.3...v26.4.4) (2020-11-08)
+
+
+### Bug Fixes
+
+* revert usage of `@jest/create-cache-key-function` ([#2108](https://github.com/kulshekhar/ts-jest/issues/2108)) ([dee8231](https://github.com/kulshekhar/ts-jest/commit/dee823172ce1e8eb9e0b2dd3aeed1ab4033bd0d9)), closes [#2080](https://github.com/kulshekhar/ts-jest/issues/2080) [#2090](https://github.com/kulshekhar/ts-jest/issues/2090) [#2104](https://github.com/kulshekhar/ts-jest/issues/2104)
+
+
+### Features
+
+* **testing:** expose all types for util `mocked` ([#2096](https://github.com/kulshekhar/ts-jest/issues/2096)) ([b1d072b](https://github.com/kulshekhar/ts-jest/commit/b1d072b52b9a7665b3a6914b0895f84f6ee3f8c0)), closes [#2086](https://github.com/kulshekhar/ts-jest/issues/2086)
+
+
+
 ## [26.4.3](https://github.com/kulshekhar/ts-jest/compare/v26.4.2...v26.4.3) (2020-10-26)
 
 

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

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

package/dist/cli/config/init.js

@@ -0,0 +1,154 @@
+"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 };
+    }
+};
+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");
+var presets_1 = require("../helpers/presets");
+exports.run = function (args) { 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;
+    var _b, _c;
+    return __generator(this, function (_d) {
+        file = (_c = (_b = args._[0]) === null || _b === void 0 ? void 0 : _b.toString()) !== null && _c !== void 0 ? _c : 'jest.config.js';
+        filePath = path_1.join(process.cwd(), file);
+        name = path_1.basename(file);
+        isPackage = name === 'package.json';
+        exists = fs_1.existsSync(filePath);
+        pkgFile = isPackage ? filePath : path_1.join(process.cwd(), 'package.json');
+        hasPackage = isPackage || fs_1.existsSync(pkgFile);
+        _a = args.jestPreset, jestPreset = _a === void 0 ? true : _a, askedTsconfig = args.tsconfig, force = args.force, jsdom = args.jsdom;
+        tsconfig = askedTsconfig === 'tsconfig.json' ? undefined : askedTsconfig;
+        pkgJson = hasPackage ? JSON.parse(fs_1.readFileSync(pkgFile, 'utf8')) : {};
+        jsFilesProcessor = args.js, shouldPostProcessWithBabel = args.babel;
+        if (jsFilesProcessor == null) {
+            jsFilesProcessor = shouldPostProcessWithBabel ? 'babel' : undefined;
+        }
+        else if (shouldPostProcessWithBabel == null) {
+            shouldPostProcessWithBabel = jsFilesProcessor === 'babel';
+        }
+        if (jsFilesProcessor === 'babel') {
+            preset = presets_1.jsWIthBabel;
+        }
+        else if (jsFilesProcessor === 'ts') {
+            preset = presets_1.jsWithTs;
+        }
+        else {
+            preset = presets_1.defaults;
+        }
+        if (isPackage && !exists) {
+            throw new Error("File " + file + " does not exists.");
+        }
+        else if (!isPackage && exists && !force) {
+            throw new Error("Configuration file " + file + " already exists.");
+        }
+        if (!isPackage && !name.endsWith('.js')) {
+            throw new TypeError("Configuration file " + file + " must be a .js file or the package.json.");
+        }
+        if (hasPackage && pkgJson.jest) {
+            if (force && !isPackage) {
+                delete pkgJson.jest;
+                fs_1.writeFileSync(pkgFile, JSON.stringify(pkgJson, undefined, '  '));
+            }
+            else if (!force) {
+                throw new Error("A Jest configuration is already set in " + pkgFile + ".");
+            }
+        }
+        if (isPackage) {
+            base = jestPreset ? { preset: preset.name } : __assign({}, preset.value);
+            if (!jsdom)
+                base.testEnvironment = 'node';
+            if (tsconfig || shouldPostProcessWithBabel) {
+                tsJestConf = {};
+                base.globals = { 'ts-jest': tsJestConf };
+                if (tsconfig)
+                    tsJestConf.tsconfig = tsconfig;
+                if (shouldPostProcessWithBabel)
+                    tsJestConf.babelConfig = true;
+            }
+            body = JSON.stringify(__assign(__assign({}, pkgJson), { jest: base }), undefined, '  ');
+        }
+        else {
+            content = [];
+            if (!jestPreset) {
+                content.push(preset.jsImport('tsjPreset') + ";", '');
+            }
+            content.push('module.exports = {');
+            if (jestPreset) {
+                content.push("  preset: '" + preset.name + "',");
+            }
+            else {
+                content.push('  ...tsjPreset,');
+            }
+            if (!jsdom)
+                content.push("  testEnvironment: 'node',");
+            if (tsconfig || shouldPostProcessWithBabel) {
+                content.push('  globals: {');
+                content.push("    'ts-jest': {");
+                if (tsconfig)
+                    content.push("      tsconfig: " + json5_1.stringify(tsconfig) + ",");
+                if (shouldPostProcessWithBabel)
+                    content.push('      babelConfig: true,');
+                content.push('    },');
+                content.push('  },');
+            }
+            content.push('};');
+            body = content.join('\n');
+        }
+        fs_1.writeFileSync(filePath, body);
+        process.stderr.write("\nJest configuration written to \"" + filePath + "\".\n");
+        return [2];
+    });
+}); };
+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];
+    });
+}); };

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

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

package/dist/cli/config/migrate.js

@@ -0,0 +1,219 @@
+"use strict";
+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;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    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");
+var json5_1 = require("json5");
+var path_1 = require("path");
+var backports_1 = require("../../utils/backports");
+var presets_1 = require("../helpers/presets");
+exports.run = function (args) { 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;
+    var _a;
+    return __generator(this, function (_b) {
+        nullLogger = bs_logger_1.createLogger({ targets: [] });
+        file = (_a = args._[0]) === null || _a === void 0 ? void 0 : _a.toString();
+        filePath = path_1.resolve(process.cwd(), file);
+        footNotes = [];
+        if (!fs_1.existsSync(filePath)) {
+            throw new Error("Configuration file " + file + " does not exists.");
+        }
+        name = path_1.basename(file);
+        isPackage = name === 'package.json';
+        if (!/\.(js|json)$/.test(name)) {
+            throw new TypeError("Configuration file " + file + " must be a JavaScript or JSON file.");
+        }
+        actualConfig = require(filePath);
+        if (isPackage) {
+            actualConfig = actualConfig.jest;
+        }
+        if (!actualConfig)
+            actualConfig = {};
+        migratedConfig = backports_1.backportJestConfig(nullLogger, actualConfig);
+        if (!migratedConfig.preset && args.jestPreset) {
+            if (args.js) {
+                presetName = args.js === 'babel' ? "ts-jest/presets/js-with-babel" : "ts-jest/presets/js-with-ts";
+            }
+            else {
+                jsTransformers = Object.keys(migratedConfig.transform || {}).reduce(function (list, pattern) {
+                    if (RegExp(pattern.replace(/^<rootDir>\/?/, '/dummy-project/')).test('/dummy-project/src/foo.js')) {
+                        var transformer = migratedConfig.transform[pattern];
+                        if (/\bbabel-jest\b/.test(transformer))
+                            transformer = 'babel-jest';
+                        else if (/\ts-jest\b/.test(transformer))
+                            transformer = 'ts-jest';
+                        return __spread(list, [transformer]);
+                    }
+                    return list;
+                }, []);
+                jsWithTs = jsTransformers.includes('ts-jest');
+                jsWithBabel = jsTransformers.includes('babel-jest');
+                if (jsWithBabel && !jsWithTs) {
+                    presetName = "ts-jest/presets/js-with-babel";
+                }
+                else if (jsWithTs && !jsWithBabel) {
+                    presetName = "ts-jest/presets/js-with-ts";
+                }
+                else {
+                    presetName = "ts-jest/presets/default";
+                }
+            }
+            presetName = presetName || "ts-jest/presets/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");
+        }
+        else if (migratedConfig.preset && migratedConfig.preset.startsWith('ts-jest')) {
+            if (args.jestPreset === false) {
+                delete migratedConfig.preset;
+            }
+            else {
+                preset = presets_1.allPresets[migratedConfig.preset] || presets_1.defaults;
+            }
+        }
+        if (preset)
+            migratedConfig.preset = preset.name;
+        if (migratedConfig.moduleFileExtensions && migratedConfig.moduleFileExtensions.length && preset) {
+            presetValue = dedupSort(preset.value.moduleFileExtensions || []).join('::');
+            migratedValue = dedupSort(migratedConfig.moduleFileExtensions).join('::');
+            if (presetValue === migratedValue) {
+                delete migratedConfig.moduleFileExtensions;
+            }
+        }
+        if (migratedConfig.testRegex && preset) {
+            migratedConfig.testMatch = null;
+        }
+        else if (migratedConfig.testMatch && migratedConfig.testMatch.length && preset) {
+            presetValue = dedupSort(preset.value.testMatch || []).join('::');
+            migratedValue = dedupSort(migratedConfig.testMatch).join('::');
+            if (presetValue === migratedValue) {
+                delete migratedConfig.testMatch;
+            }
+        }
+        if (migratedConfig.transform) {
+            Object.keys(migratedConfig.transform).forEach(function (key) {
+                var val = migratedConfig.transform[key];
+                if (typeof val === 'string' && /\/?ts-jest(?:\/preprocessor\.js)?$/.test(val)) {
+                    ;
+                    migratedConfig.transform[key] = 'ts-jest';
+                }
+            });
+        }
+        if (preset &&
+            migratedConfig.transform &&
+            stableStringify(migratedConfig.transform) === stableStringify(preset.value.transform)) {
+            delete migratedConfig.transform;
+        }
+        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];
+        }
+        stringify = file.endsWith('.json') ? JSON.stringify : json5_1.stringify;
+        prefix = file.endsWith('.json') ? '"jest": ' : 'module.exports = ';
+        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");
+        }
+        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];
+    });
+}); };
+function cleanupConfig(config) {
+    if (config.globals) {
+        if (config.globals['ts-jest'] && Object.keys(config.globals['ts-jest']).length === 0) {
+            delete config.globals['ts-jest'];
+        }
+        if (Object.keys(config.globals).length === 0) {
+            delete config.globals;
+        }
+    }
+    if (config.transform && Object.keys(config.transform).length === 0) {
+        delete config.transform;
+    }
+    if (config.moduleFileExtensions) {
+        config.moduleFileExtensions = dedupSort(config.moduleFileExtensions);
+        if (config.moduleFileExtensions.length === 0)
+            delete config.moduleFileExtensions;
+    }
+    if (config.testMatch) {
+        config.testMatch = dedupSort(config.testMatch);
+        if (config.testMatch.length === 0)
+            delete config.testMatch;
+    }
+    if (config.preset === "ts-jest/presets/default")
+        config.preset = presets_1.defaults.name;
+}
+function dedupSort(arr) {
+    return 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); });
+}
+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];
+    });
+}); };

package/dist/compiler/language-service.js

@@ -71,8 +71,9 @@ 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 memoize = require("lodash/memoize");
 var mkdirp = require("mkdirp");
+var config_set_1 = require("../config/config-set");
 var constants_1 = require("../constants");
 var messages_1 = require("../utils/messages");
 var json_1 = require("../utils/json");
@@ -113,7 +114,7 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
         catch (e) { }
     }
     configs.parsedTsConfig.fileNames
-        .filter(function (fileName) { return !configs.isTestFile(fileName); })
+        .filter(function (fileName) { var _a; return !configs.isTestFile(fileName) && !fileName.includes((_a = configs.parsedTsConfig.options.outDir) !== null && _a !== void 0 ? _a : config_set_1.TS_JEST_OUT_DIR); })
         .forEach(function (fileName) {
         memoryCache.files.set(fileName, {
             version: 0,
@@ -266,7 +267,7 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
                 }
             }
             if (output.emitSkipped) {
-                throw new TypeError(path_1.relative(cwd, fileName) + ": Emit skipped for language service");
+                throw new Error(messages_1.interpolate("Unable to process '{{file}}'. Please make sure that `outDir` in your tsconfig is neither `''` or `'.'`.", { file: fileName }));
             }
             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}}`.", {

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

@@ -2,7 +2,10 @@ import type { Config } from '@jest/types';
 import { Logger } from 'bs-logger';
 import { CompilerOptions, CustomTransformers, Diagnostic, ParsedCommandLine } from 'typescript';
 import type { TTypeScript } from '../types';
+import type { RawCompilerOptions } from '../tsconfig-raw';
 export declare class ConfigSet {
+    private readonly jestConfig;
+    private readonly parentLogger?;
     readonly logger: Logger;
     readonly compilerModule: TTypeScript;
     readonly isolatedModules: boolean;
@@ -13,9 +16,9 @@ export declare class ConfigSet {
     readonly rootDir: string;
     protected _overriddenCompilerOptions: Partial<CompilerOptions>;
     constructor(jestConfig: Config.ProjectConfig, parentLogger?: Logger | undefined);
-    protected _resolveTsConfig(compilerOptions?: CompilerOptions, resolvedConfigFile?: string): Record<string, any>;
+    protected _resolveTsConfig(compilerOptions?: RawCompilerOptions, resolvedConfigFile?: string): Record<string, any>;
     get tsJestDigest(): string;
-    get isTestFile(): (fileName: string) => boolean;
+    isTestFile(fileName: string): boolean;
     shouldStringifyContent(filePath: string): boolean;
     raiseDiagnostics(diagnostics: Diagnostic[], filePath?: string, logger?: Logger): void;
     shouldReportDiagnostics(filePath: string): boolean;

package/dist/config/config-set.js

@@ -117,8 +117,8 @@ var toDiagnosticCodeList = function (items, into) {
 };
 var ConfigSet = (function () {
     function ConfigSet(jestConfig, parentLogger) {
-        var _a;
-        var _b, _c, _d, _e;
+        var _a, _b;
+        var _c, _d, _e, _f;
         this.jestConfig = jestConfig;
         this.parentLogger = parentLogger;
         this.customTransformers = Object.create(null);
@@ -141,14 +141,21 @@ var ConfigSet = (function () {
         this.logger = this.parentLogger
             ? this.parentLogger.child((_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'config', _a))
             : logger_1.rootLogger.child({ namespace: 'config' });
-        this.cwd = path_1.normalize((_b = this.jestConfig.cwd) !== null && _b !== void 0 ? _b : process.cwd());
-        this.rootDir = path_1.normalize((_c = this.jestConfig.rootDir) !== null && _c !== void 0 ? _c : this.cwd);
+        this.cwd = path_1.normalize((_c = this.jestConfig.cwd) !== null && _c !== void 0 ? _c : process.cwd());
+        this.rootDir = path_1.normalize((_d = this.jestConfig.rootDir) !== null && _d !== void 0 ? _d : this.cwd);
         var tsJestCfg = this.jestConfig.globals && this.jestConfig.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.", (_d = options.compiler) !== null && _d !== void 0 ? _d : 'typescript');
-        this.isolatedModules = (_e = options.isolatedModules) !== null && _e !== void 0 ? _e : false;
+        this.compilerModule = importer_1.importer.typescript("Using \"ts-jest\" requires this package to be installed.", (_e = options.compiler) !== null && _e !== void 0 ? _e : 'typescript');
+        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._backportJestCfg();
+        this._matchablePatterns = __spread(this._jestCfg.testMatch, this._jestCfg.testRegex).filter(function (pattern) {
+            return pattern instanceof RegExp || typeof pattern === 'string';
+        });
+        if (!this._matchablePatterns.length) {
+            (_b = this._matchablePatterns).push.apply(_b, __spread(constants_1.DEFAULT_JEST_TEST_MATCH));
+        }
+        this._matchTestFilePath = jest_util_1.globsToMatcher(this._matchablePatterns.filter(function (pattern) { return typeof pattern === 'string'; }));
         this._setupTsJestCfg(options);
         this._resolveTsCacheDir();
     }
@@ -159,7 +166,7 @@ var ConfigSet = (function () {
     };
     ConfigSet.prototype._setupTsJestCfg = function (options) {
         var _this = this;
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         if (options.packageJson) {
             this.logger.warn("The option `packageJson` is deprecated and will be removed in ts-jest 27. This option is not used by internal `ts-jest`");
         }
@@ -203,23 +210,36 @@ var ConfigSet = (function () {
             }
             this._diagnostics = {
                 pretty: (_b = diagnosticsOpt.pretty) !== null && _b !== void 0 ? _b : true,
+                exclude: (_c = diagnosticsOpt.exclude) !== null && _c !== void 0 ? _c : [],
                 ignoreCodes: toDiagnosticCodeList(ignoreList),
-                pathRegex: normalizeRegex(diagnosticsOpt.pathRegex),
                 throws: !diagnosticsOpt.warnOnly,
             };
+            if (diagnosticsOpt.pathRegex) {
+                this.logger.warn("The option `pathRegex` is deprecated and will be removed in ts-jest 27, use `exclude` instead");
+                this._diagnostics = __assign(__assign({}, this._diagnostics), { pathRegex: normalizeRegex(diagnosticsOpt.pathRegex) });
+            }
         }
         else {
             this._diagnostics = {
                 ignoreCodes: diagnosticsOpt ? toDiagnosticCodeList(ignoreList) : [],
+                exclude: [],
                 pretty: true,
                 throws: diagnosticsOpt,
             };
         }
+        if (this._diagnostics.pathRegex && !this._diagnostics.exclude.length) {
+            this._shouldGetDiagnosticsForFile = new RegExp(this._diagnostics.pathRegex);
+        }
+        else {
+            this._shouldGetDiagnosticsForFile = this._diagnostics.exclude.length
+                ? jest_util_1.globsToMatcher(this._diagnostics.exclude)
+                : function () { return true; };
+        }
         this.logger.debug({ diagnostics: this._diagnostics }, 'normalized diagnostics config via ts-jest option');
         if (options.tsConfig) {
             this.logger.warn("The option `tsConfig` is deprecated and will be removed in ts-jest 27, use `tsconfig` instead");
         }
-        var tsconfigOpt = (_c = options.tsConfig) !== null && _c !== void 0 ? _c : options.tsconfig;
+        var tsconfigOpt = (_d = options.tsConfig) !== null && _d !== void 0 ? _d : options.tsconfig;
         var configFilePath = typeof tsconfigOpt === 'string' ? this.resolvePath(tsconfigOpt) : undefined;
         this.parsedTsConfig = this._resolveTsConfig(typeof tsconfigOpt === 'object' ? tsconfigOpt : undefined, configFilePath);
         this.raiseDiagnostics(this.parsedTsConfig.errors, configFilePath);
@@ -411,23 +431,12 @@ var ConfigSet = (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(ConfigSet.prototype, "isTestFile", {
-        get: function () {
-            var matchablePatterns = __spread(this._jestCfg.testMatch, this._jestCfg.testRegex).filter(function (pattern) {
-                return pattern instanceof RegExp || typeof pattern === 'string';
-            });
-            if (!matchablePatterns.length) {
-                matchablePatterns.push.apply(matchablePatterns, __spread(constants_1.DEFAULT_JEST_TEST_MATCH));
-            }
-            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
-    });
+    ConfigSet.prototype.isTestFile = function (fileName) {
+        var _this = this;
+        return this._matchablePatterns.some(function (pattern) {
+            return typeof pattern === 'string' ? _this._matchTestFilePath(fileName) : pattern.test(fileName);
+        });
+    };
     ConfigSet.prototype.shouldStringifyContent = function (filePath) {
         return this._stringifyContentRegExp ? this._stringifyContentRegExp.test(filePath) : false;
     };
@@ -454,14 +463,9 @@ var ConfigSet = (function () {
         logger ? logger.warn({ error: error }, error.message) : this.logger.warn({ error: error }, error.message);
     };
     ConfigSet.prototype.shouldReportDiagnostics = function (filePath) {
-        var pathRegex = this._diagnostics.pathRegex;
-        if (pathRegex) {
-            var regex = new RegExp(pathRegex);
-            return regex.test(filePath);
-        }
-        else {
-            return true;
-        }
+        return this._shouldGetDiagnosticsForFile instanceof RegExp
+            ? this._shouldGetDiagnosticsForFile.test(filePath)
+            : this._shouldGetDiagnosticsForFile(filePath);
     };
     ConfigSet.prototype._createTsError = function (diagnostics) {
         var _this = this;
@@ -518,9 +522,6 @@ var ConfigSet = (function () {
     __decorate([
         memoize_1.Memoize()
     ], ConfigSet.prototype, "hooks", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "isTestFile", null);
     return ConfigSet;
 }());
 exports.ConfigSet = ConfigSet;

package/dist/presets/create-jest-preset.d.ts

@@ -1,5 +1,5 @@
 import type { Config } from '@jest/types';
-export declare type TsJestPresets = Pick<Config.InitialOptions, 'moduleFileExtensions' | 'transform' | 'testMatch'>;
+import type { TsJestPresets } from '../types';
 interface CreateJestPresetOptions {
     allowJs?: boolean;
 }

package/dist/transformers/index.d.ts

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

package/dist/transformers/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.internals = void 0;
+var hoisting = __importStar(require("./hoist-jest"));
+exports.internals = [hoisting];

package/dist/transformers/path-mapping.d.ts

@@ -0,0 +1,3 @@
+import type * as _ts from 'typescript';
+import type { ConfigSet } from '../config/config-set';
+export declare function factory(cs: ConfigSet): (ctx: _ts.TransformationContext) => _ts.Transformer<_ts.SourceFile>;

package/dist/transformers/path-mapping.js

@@ -0,0 +1,121 @@
+"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 __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.factory = exports.version = exports.name = void 0;
+var bs_logger_1 = require("bs-logger");
+var path_1 = require("path");
+exports.name = 'path-mapping';
+exports.version = 1;
+var isBaseDir = function (base, dir) { var _a; return !((_a = path_1.relative(base, dir)) === null || _a === void 0 ? void 0 : _a.startsWith('.')); };
+function factory(cs) {
+    var _a;
+    var logger = cs.logger.child({ namespace: 'ts-path-mapping' });
+    var ts = cs.compilerModule;
+    var compilerOptions = cs.parsedTsConfig.options;
+    var rootDirs = (_a = compilerOptions.rootDirs) === null || _a === void 0 ? void 0 : _a.filter(path_1.isAbsolute);
+    var isDynamicImport = function (node) {
+        return ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword;
+    };
+    var isRequire = function (node) {
+        return ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === 'require' &&
+            ts.isStringLiteral(node.arguments[0]) &&
+            node.arguments.length === 1;
+    };
+    var createVisitor = function (ctx, sf) {
+        var fileName = sf.fileName;
+        var fileDir = path_1.normalize(path_1.dirname(fileName));
+        var rewritePath = function (importPath) {
+            var e_1, _a;
+            var p = importPath;
+            var resolvedModule = ts.resolveModuleName(importPath, fileName, compilerOptions, ts.sys).resolvedModule;
+            if (resolvedModule) {
+                var resolvedFileName = resolvedModule.resolvedFileName;
+                var filePath = fileDir;
+                var modulePath = path_1.dirname(resolvedFileName);
+                if (rootDirs) {
+                    var fileRootDir = '';
+                    var moduleRootDir = '';
+                    try {
+                        for (var rootDirs_1 = __values(rootDirs), rootDirs_1_1 = rootDirs_1.next(); !rootDirs_1_1.done; rootDirs_1_1 = rootDirs_1.next()) {
+                            var rootDir = rootDirs_1_1.value;
+                            if (isBaseDir(rootDir, resolvedFileName) && rootDir.length > moduleRootDir.length)
+                                moduleRootDir = rootDir;
+                            if (isBaseDir(rootDir, fileName) && rootDir.length > fileRootDir.length)
+                                fileRootDir = rootDir;
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (rootDirs_1_1 && !rootDirs_1_1.done && (_a = rootDirs_1.return)) _a.call(rootDirs_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    if (fileRootDir && moduleRootDir) {
+                        filePath = path_1.relative(fileRootDir, filePath);
+                        modulePath = path_1.relative(moduleRootDir, modulePath);
+                    }
+                }
+                p = path_1.normalize(path_1.join(path_1.relative(filePath, modulePath), path_1.basename(resolvedFileName)));
+                p = p.startsWith('.') ? p : "./" + p;
+            }
+            return p;
+        };
+        var visitor = function (node) {
+            var rewrittenPath;
+            var newNode = ts.getMutableClone(node);
+            if (isDynamicImport(node) || isRequire(node)) {
+                rewrittenPath = rewritePath(node.arguments[0].text);
+                return __assign(__assign({}, newNode), { arguments: ts.createNodeArray([ts.createStringLiteral(rewrittenPath)]) });
+            }
+            if (ts.isExternalModuleReference(node) && ts.isStringLiteral(node.expression)) {
+                rewrittenPath = rewritePath(node.expression.text);
+                return ts.updateExternalModuleReference(newNode, ts.createLiteral(rewrittenPath));
+            }
+            if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+                rewrittenPath = rewritePath(node.moduleSpecifier.text);
+                return __assign(__assign({}, newNode), { moduleSpecifier: ts.createLiteral(rewrittenPath) });
+            }
+            if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+                rewrittenPath = rewritePath(node.moduleSpecifier.text);
+                return __assign(__assign({}, newNode), { moduleSpecifier: ts.createLiteral(rewrittenPath) });
+            }
+            if (ts.isImportTypeNode(node) &&
+                ts.isLiteralTypeNode(node.argument) &&
+                ts.isStringLiteral(node.argument.literal)) {
+                rewrittenPath = rewritePath(node.argument.literal.text);
+                return __assign(__assign({}, newNode), { argument: ts.createLiteralTypeNode(ts.createStringLiteral(rewrittenPath)) });
+            }
+            return ts.visitEachChild(node, visitor, ctx);
+        };
+        return visitor;
+    };
+    return function (ctx) {
+        var _a;
+        return logger.wrap((_a = {}, _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.debug, _a.call = null, _a), 'visitSourceFileNode(): path mapping', function (sf) { return ts.visitNode(sf, createVisitor(ctx, sf)); });
+    };
+}
+exports.factory = factory;

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

@@ -5,9 +5,8 @@ import { ConfigSet } from './config/config-set';
 export declare class TsJestTransformer implements Transformer {
     protected readonly logger: Logger;
     protected _transformCfgStr: string;
-    protected _configSet: ConfigSet;
     constructor();
+    configsFor(jestConfig: Config.ProjectConfig): ConfigSet;
     process(input: string, filePath: Config.Path, jestConfig: Config.ProjectConfig, transformOptions?: TransformOptions): TransformedSource | string;
     getCacheKey(fileContent: string, filePath: string, _jestConfigStr: string, transformOptions: CacheKeyOptions): string;
-    protected createOrResolveTransformerCfg(jestConfig: Config.ProjectConfig): void;
 }

package/dist/ts-jest-transformer.js

@@ -24,13 +24,50 @@ var TsJestTransformer = (function () {
         this.logger = logger_1.rootLogger.child({ namespace: 'ts-jest-transformer' });
         this.logger.debug('created new transformer');
     }
+    TsJestTransformer.prototype.configsFor = function (jestConfig) {
+        var ccs = TsJestTransformer._cachedConfigSets.find(function (cs) { return cs.jestConfig.value === jestConfig; });
+        var configSet;
+        if (ccs) {
+            this._transformCfgStr = ccs.transformerCfgStr;
+            configSet = ccs.configSet;
+        }
+        else {
+            var serializedJestCfg_1 = json_1.stringify(jestConfig);
+            var serializedCcs = TsJestTransformer._cachedConfigSets.find(function (cs) { return cs.jestConfig.serialized === serializedJestCfg_1; });
+            if (serializedCcs) {
+                serializedCcs.jestConfig.value = jestConfig;
+                this._transformCfgStr = serializedCcs.transformerCfgStr;
+                configSet = serializedCcs.configSet;
+            }
+            else {
+                this.logger.info('no matching config-set found, creating a new one');
+                configSet = new config_set_1.ConfigSet(jestConfig);
+                var jest_1 = __assign({}, jestConfig);
+                var globals = (jest_1.globals = __assign({}, jest_1.globals));
+                jest_1.name = undefined;
+                jest_1.cacheDirectory = undefined;
+                delete globals['ts-jest'];
+                this._transformCfgStr = new jsonable_value_1.JsonableValue(__assign(__assign({ digest: configSet.tsJestDigest, babel: configSet.babelConfig }, jest_1), { tsconfig: {
+                        options: configSet.parsedTsConfig.options,
+                        raw: configSet.parsedTsConfig.raw,
+                    } })).serialized;
+                TsJestTransformer._cachedConfigSets.push({
+                    jestConfig: new jsonable_value_1.JsonableValue(jestConfig),
+                    configSet: configSet,
+                    transformerCfgStr: this._transformCfgStr,
+                });
+            }
+        }
+        return configSet;
+    };
     TsJestTransformer.prototype.process = function (input, filePath, jestConfig, transformOptions) {
         this.logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'processing', filePath);
         var result;
         var source = input;
-        var hooks = this._configSet.hooks;
-        var shouldStringifyContent = this._configSet.shouldStringifyContent(filePath);
-        var babelJest = shouldStringifyContent ? undefined : this._configSet.babelJestTransformer;
+        var configs = this.configsFor(jestConfig);
+        var hooks = configs.hooks;
+        var shouldStringifyContent = configs.shouldStringifyContent(filePath);
+        var babelJest = shouldStringifyContent ? undefined : configs.babelJestTransformer;
         var isDefinitionFile = filePath.endsWith(constants_1.DECLARATION_TYPE_EXT);
         var isJsFile = constants_1.JS_JSX_REGEX.test(filePath);
         var isTsFile = !isDefinitionFile && constants_1.TS_TSX_REGEX.test(filePath);
@@ -40,12 +77,12 @@ var TsJestTransformer = (function () {
         else if (isDefinitionFile) {
             result = '';
         }
-        else if (!this._configSet.parsedTsConfig.options.allowJs && isJsFile) {
+        else if (!configs.parsedTsConfig.options.allowJs && isJsFile) {
             this.logger.warn({ fileName: filePath }, messages_1.interpolate("Got a `.js` file to compile while `allowJs` option is not set to `true` (file: {{path}}). To fix this:\n  - if you want TypeScript to process JS files, set `allowJs` to `true` in your TypeScript config (usually tsconfig.json)\n  - if you do not want TypeScript to process your `.js` files, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match `.js` files anymore", { path: filePath }));
             result = source;
         }
         else if (isJsFile || isTsFile) {
-            result = this._configSet.tsCompiler.compile(source, filePath);
+            result = configs.tsCompiler.compile(source, filePath);
         }
         else {
             var message = babelJest ? "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore. If you still want Babel to process it, add another entry to the `transform` option with value `babel-jest` which key matches this type of files." : "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore.";
@@ -66,45 +103,11 @@ var TsJestTransformer = (function () {
         return result;
     };
     TsJestTransformer.prototype.getCacheKey = function (fileContent, filePath, _jestConfigStr, transformOptions) {
-        this.createOrResolveTransformerCfg(transformOptions.config);
+        var configs = this.configsFor(transformOptions.config);
         this.logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'computing cache key for', filePath);
-        var _a = transformOptions.instrument, instrument = _a === void 0 ? false : _a, _b = transformOptions.rootDir, rootDir = _b === void 0 ? this._configSet.rootDir : _b;
+        var _a = transformOptions.instrument, instrument = _a === void 0 ? false : _a, _b = transformOptions.rootDir, rootDir = _b === void 0 ? configs.rootDir : _b;
         return sha1_1.sha1(this._transformCfgStr, '\x00', rootDir, '\x00', "instrument:" + (instrument ? 'on' : 'off'), '\x00', fileContent, '\x00', filePath);
     };
-    TsJestTransformer.prototype.createOrResolveTransformerCfg = function (jestConfig) {
-        var ccs = TsJestTransformer._cachedConfigSets.find(function (cs) { return cs.jestConfig.value === jestConfig; });
-        if (ccs) {
-            this._transformCfgStr = ccs.transformerCfgStr;
-            this._configSet = ccs.configSet;
-        }
-        else {
-            var serializedJestCfg_1 = json_1.stringify(jestConfig);
-            var serializedCcs = TsJestTransformer._cachedConfigSets.find(function (cs) { return cs.jestConfig.serialized === serializedJestCfg_1; });
-            if (serializedCcs) {
-                serializedCcs.jestConfig.value = jestConfig;
-                this._transformCfgStr = serializedCcs.transformerCfgStr;
-                this._configSet = serializedCcs.configSet;
-            }
-            else {
-                this.logger.info('no matching config-set found, creating a new one');
-                this._configSet = new config_set_1.ConfigSet(jestConfig);
-                var jest_1 = __assign({}, jestConfig);
-                var globals = (jest_1.globals = __assign({}, jest_1.globals));
-                jest_1.name = undefined;
-                jest_1.cacheDirectory = undefined;
-                delete globals['ts-jest'];
-                this._transformCfgStr = new jsonable_value_1.JsonableValue(__assign(__assign({ digest: this._configSet.tsJestDigest }, jest_1), { babel: this._configSet.babelConfig, tsconfig: {
-                        options: this._configSet.parsedTsConfig.options,
-                        raw: this._configSet.parsedTsConfig.raw,
-                    } })).serialized;
-                TsJestTransformer._cachedConfigSets.push({
-                    jestConfig: new jsonable_value_1.JsonableValue(jestConfig),
-                    configSet: this._configSet,
-                    transformerCfgStr: this._transformCfgStr,
-                });
-            }
-        }
-    };
     TsJestTransformer._cachedConfigSets = [];
     return TsJestTransformer;
 }());

package/dist/tsconfig-raw.d.ts

@@ -0,0 +1,105 @@
+export interface RawCompilerOptions {
+    charset?: string;
+    composite?: boolean;
+    declaration?: boolean;
+    declarationDir?: string | null;
+    diagnostics?: boolean;
+    disableReferencedProjectLoad?: boolean;
+    emitBOM?: boolean;
+    emitDeclarationOnly?: boolean;
+    incremental?: boolean;
+    tsBuildInfoFile?: string;
+    inlineSourceMap?: boolean;
+    inlineSources?: boolean;
+    jsx?: 'preserve' | 'react' | 'react-jsx' | 'react-jsxdev' | 'react-native';
+    reactNamespace?: string;
+    jsxFactory?: string;
+    jsxFragmentFactory?: string;
+    jsxImportSource?: string;
+    listFiles?: boolean;
+    mapRoot?: string;
+    module?: 'CommonJS' | 'AMD' | 'System' | 'UMD' | 'ES6' | 'ES2015' | 'ES2020' | 'ESNext' | 'None' | string;
+    moduleResolution?: 'Classic' | 'Node';
+    newLine?: 'crlf' | 'lf';
+    noEmit?: boolean;
+    noEmitHelpers?: boolean;
+    noEmitOnError?: boolean;
+    noImplicitAny?: boolean;
+    noImplicitThis?: boolean;
+    noUnusedLocals?: boolean;
+    noUnusedParameters?: boolean;
+    noLib?: boolean;
+    noResolve?: boolean;
+    noStrictGenericChecks?: boolean;
+    skipDefaultLibCheck?: boolean;
+    skipLibCheck?: boolean;
+    outFile?: string;
+    outDir?: string;
+    preserveConstEnums?: boolean;
+    preserveSymlinks?: boolean;
+    preserveWatchOutput?: boolean;
+    pretty?: boolean;
+    removeComments?: boolean;
+    rootDir?: string;
+    isolatedModules?: boolean;
+    sourceMap?: boolean;
+    sourceRoot?: string;
+    suppressExcessPropertyErrors?: boolean;
+    suppressImplicitAnyIndexErrors?: boolean;
+    target?: 'ES3' | 'ES5' | 'ES6' | 'ES2015' | 'ES2016' | 'ES2017' | 'ES2018' | 'ES2019' | 'ES2020' | 'ESNext' | string;
+    watch?: boolean;
+    fallbackPolling?: 'fixedPollingInterval' | 'priorityPollingInterval' | 'dynamicPriorityPolling';
+    watchDirectory?: 'useFsEvents' | 'fixedPollingInterval' | 'dynamicPriorityPolling';
+    watchFile?: 'fixedPollingInterval' | 'priorityPollingInterval' | 'dynamicPriorityPolling' | 'useFsEvents' | 'useFsEventsOnParentDirectory';
+    experimentalDecorators?: boolean;
+    emitDecoratorMetadata?: boolean;
+    allowUnusedLabels?: boolean;
+    noImplicitReturns?: boolean;
+    noUncheckedIndexedAccess?: boolean;
+    noFallthroughCasesInSwitch?: boolean;
+    allowUnreachableCode?: boolean;
+    forceConsistentCasingInFileNames?: boolean;
+    generateCpuProfile?: string;
+    baseUrl?: string;
+    paths?: {
+        [k: string]: string[];
+    };
+    plugins?: {
+        name?: string;
+        [k: string]: unknown;
+    }[];
+    rootDirs?: string[];
+    typeRoots?: string[];
+    types?: string[];
+    traceResolution?: boolean;
+    allowJs?: boolean;
+    noErrorTruncation?: boolean;
+    allowSyntheticDefaultImports?: boolean;
+    noImplicitUseStrict?: boolean;
+    listEmittedFiles?: boolean;
+    disableSizeLimit?: boolean;
+    lib?: ('ES5' | 'ES6' | 'ES2015' | 'ES2015.Collection' | 'ES2015.Core' | 'ES2015.Generator' | 'ES2015.Iterable' | 'ES2015.Promise' | 'ES2015.Proxy' | 'ES2015.Reflect' | 'ES2015.Symbol.WellKnown' | 'ES2015.Symbol' | 'ES2016' | 'ES2016.Array.Include' | 'ES2017' | 'ES2017.Intl' | 'ES2017.Object' | 'ES2017.SharedMemory' | 'ES2017.String' | 'ES2017.TypedArrays' | 'ES2018' | 'ES2018.AsyncGenerator' | 'ES2018.AsyncIterable' | 'ES2018.Intl' | 'ES2018.Promise' | 'ES2018.Regexp' | 'ES2019' | 'ES2019.Array' | 'ES2019.Object' | 'ES2019.String' | 'ES2019.Symbol' | 'ES2020' | 'ES2020.BigInt' | 'ES2020.Promise' | 'ES2020.String' | 'ES2020.Symbol.WellKnown' | 'ESNext' | 'ESNext.Array' | 'ESNext.AsyncIterable' | 'ESNext.BigInt' | 'ESNext.Intl' | 'ESNext.Promise' | 'ESNext.String' | 'ESNext.Symbol' | 'DOM' | 'DOM.Iterable' | 'ScriptHost' | 'WebWorker' | 'WebWorker.ImportScripts')[];
+    strictNullChecks?: boolean;
+    maxNodeModuleJsDepth?: number;
+    importHelpers?: boolean;
+    importsNotUsedAsValues?: 'remove' | 'preserve' | 'error';
+    alwaysStrict?: boolean;
+    strict?: boolean;
+    strictBindCallApply?: boolean;
+    downlevelIteration?: boolean;
+    checkJs?: boolean;
+    strictFunctionTypes?: boolean;
+    strictPropertyInitialization?: boolean;
+    esModuleInterop?: boolean;
+    allowUmdGlobalAccess?: boolean;
+    keyofStringsOnly?: boolean;
+    useDefineForClassFields?: boolean;
+    declarationMap?: boolean;
+    resolveJsonModule?: boolean;
+    assumeChangesOnlyAffectDirectDependencies?: boolean;
+    extendedDiagnostics?: boolean;
+    listFilesOnly?: boolean;
+    disableSourceOfProjectReferenceRedirect?: boolean;
+    disableSolutionSearching?: boolean;
+    [k: string]: unknown;
+}

package/dist/tsconfig-raw.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.d.ts

@@ -1,5 +1,7 @@
+import type { Config } from '@jest/types';
 import type * as _babel from 'babel__core';
 import type * as _ts from 'typescript';
+import type { RawCompilerOptions } from './tsconfig-raw';
 export declare type TTypeScript = typeof _ts;
 export declare type BabelConfig = _babel.TransformOptions;
 export interface AstTransformer<T = Record<string, unknown>> {
@@ -12,8 +14,8 @@ export interface ConfigCustomTransformer {
     afterDeclarations?: (string | AstTransformer)[];
 }
 export interface TsJestGlobalOptions {
-    tsConfig?: boolean | string | _ts.CompilerOptions;
-    tsconfig?: boolean | string | _ts.CompilerOptions;
+    tsConfig?: boolean | string | RawCompilerOptions;
+    tsconfig?: boolean | string | RawCompilerOptions;
     packageJson?: boolean | string | Record<string, unknown>;
     isolatedModules?: boolean;
     compiler?: string;
@@ -22,15 +24,24 @@ export interface TsJestGlobalOptions {
         pretty?: boolean;
         ignoreCodes?: number | string | (number | string)[];
         pathRegex?: RegExp | string;
+        exclude?: Config.Glob[];
         warnOnly?: boolean;
     };
     babelConfig?: boolean | string | BabelConfig;
     stringifyContentPathRegex?: string | RegExp;
 }
+export interface GlobalConfigTsJest extends Config.ConfigGlobals {
+    'ts-jest': TsJestGlobalOptions;
+}
+export interface InitialOptionsTsJest extends Config.InitialOptions {
+    globals?: GlobalConfigTsJest;
+}
+export declare type TsJestPresets = Pick<Config.InitialOptions, 'moduleFileExtensions' | 'transform' | 'testMatch'>;
 export interface TsJestDiagnosticsCfg {
     pretty: boolean;
     ignoreCodes: number[];
     pathRegex?: string | undefined;
+    exclude: Config.Glob[];
     throws: boolean;
     warnOnly?: boolean;
 }

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "ts-jest",
-  "version": "26.4.4-alpha.0",
+  "version": "26.5.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "bin": "cli.js",
+  "bin": {
+    "ts-jest": "cli.js"
+  },
   "description": "A preprocessor with source maps support to help use TypeScript with Jest",
   "scripts": {
-    "prebuild": "node scripts/clean-dist.js",
+    "prebuild": "node scripts/pre-build.js",
     "build": "tsc -p tsconfig.build.json",
     "postbuild": "node scripts/post-build.js",
     "clean": "node scripts/clean.js",
@@ -30,7 +32,8 @@
     "prepublishOnly": "npm run test",
     "preversion": "npm run test",
     "update:e2e": "node scripts/update-e2e-templates.js",
-    "version": "npm run changelog && git add CHANGELOG.md"
+    "version": "npm run changelog && git add CHANGELOG.md",
+    "raw-tsconfig-types": "node scripts/tsconfig-raw-types.js"
   },
   "repository": {
     "type": "git",
@@ -61,7 +64,7 @@
     "fast-json-stable-stringify": "2.x",
     "jest-util": "^26.1.0",
     "json5": "2.x",
-    "lodash.memoize": "4.x",
+    "lodash": "4.x",
     "make-error": "1.x",
     "mkdirp": "1.x",
     "semver": "7.x",
@@ -89,9 +92,7 @@
     "@types/fs-extra": "latest",
     "@types/js-yaml": "latest",
     "@types/json5": "latest",
-    "@types/lodash.memoize": "4.x",
-    "@types/lodash.merge": "4.x",
-    "@types/lodash.set": "4.x",
+    "@types/lodash": "4.x",
     "@types/micromatch": "4.x",
     "@types/mkdirp": "latest",
     "@types/node": "14.x",
@@ -114,9 +115,9 @@
     "husky": "4.x",
     "jest": "26.x",
     "js-yaml": "latest",
+    "json-schema-to-typescript": "^10.1.3",
     "lint-staged": "latest",
-    "lodash.merge": "4.x",
-    "lodash.set": "4.x",
+    "node-fetch": "^2.6.1",
     "npm-run-all": "latest",
     "prettier": "2.x",
     "source-map": "latest",

package/presets/index.d.ts

@@ -0,0 +1,8 @@
+import type { TsJestPresets } from '../dist/types'
+
+declare const _default: {
+  defaults: TsJestPresets;
+  jsWithTs: TsJestPresets;
+  jsWithBabel: TsJestPresets;
+};
+export = _default;