ts-jest 26.4.4-alpha.0 → 26.4.4

package/.ts-jest-digest

@@ -1 +1 @@
-336cc4e94740cf0fe1f2860194506c4f8866b4e4
+a9a5dc2939780dca25d373663e916519b0ac2dfb

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [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,153 @@
+"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;
+    return __generator(this, function (_b) {
+        file = args._[0] || '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,218 @@
+"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;
+    return __generator(this, function (_a) {
+        nullLogger = bs_logger_1.createLogger({ targets: [] });
+        file = args._[0];
+        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/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/package.json

@@ -1,9 +1,11 @@
 {
   "name": "ts-jest",
-  "version": "26.4.4-alpha.0",
+  "version": "26.4.4",
   "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",