ts-jest 26.4.1 → 26.4.2

package/dist/config/config-set.js

@@ -49,29 +49,26 @@ var __spread = (this && this.__spread) || function () {
 };
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigSet = exports.TS_JEST_OUT_DIR = exports.IGNORE_DIAGNOSTIC_CODES = void 0;
+exports.ConfigSet = exports.TS_JEST_OUT_DIR = exports.IGNORE_DIAGNOSTIC_CODES = exports.MY_DIGEST = void 0;
 var bs_logger_1 = require("bs-logger");
 var fs_1 = require("fs");
 var jest_util_1 = require("jest-util");
 var json5 = require("json5");
 var path_1 = require("path");
 var typescript_1 = require("typescript");
-var __1 = require("..");
 var instance_1 = require("../compiler/instance");
 var constants_1 = require("../constants");
-var transformers_1 = require("../transformers");
+var hoist_jest_1 = require("../transformers/hoist-jest");
 var backports_1 = require("../utils/backports");
-var get_package_version_1 = require("../utils/get-package-version");
 var importer_1 = require("../utils/importer");
 var json_1 = require("../utils/json");
-var jsonable_value_1 = require("../utils/jsonable-value");
 var logger_1 = require("../utils/logger");
 var memoize_1 = require("../utils/memoize");
 var messages_1 = require("../utils/messages");
 var normalize_slashes_1 = require("../utils/normalize-slashes");
 var sha1_1 = require("../utils/sha1");
 var ts_error_1 = require("../utils/ts-error");
-var logger = logger_1.rootLogger.child({ namespace: 'config' });
+exports.MY_DIGEST = fs_1.readFileSync(path_1.resolve(__dirname, '..', '..', '.ts-jest-digest'), 'utf8');
 exports.IGNORE_DIAGNOSTIC_CODES = [
     6059,
     18002,
@@ -119,543 +116,201 @@ var toDiagnosticCodeList = function (items, into) {
     return into;
 };
 var ConfigSet = (function () {
-    function ConfigSet(jestConfig, parentOptions, parentLogger) {
+    function ConfigSet(jestConfig, parentLogger) {
         var _a;
-        this.parentOptions = parentOptions;
-        this._jestConfig = jestConfig;
-        this.logger = parentLogger ? parentLogger.child((_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'config', _a)) : logger;
+        var _b, _c, _d, _e;
+        this.jestConfig = jestConfig;
+        this.parentLogger = parentLogger;
+        this.customTransformers = Object.create(null);
+        this._overriddenCompilerOptions = {
+            sourceMap: true,
+            inlineSourceMap: false,
+            inlineSources: true,
+            declaration: false,
+            noEmit: false,
+            removeComments: false,
+            out: undefined,
+            outFile: undefined,
+            composite: undefined,
+            declarationDir: undefined,
+            declarationMap: undefined,
+            emitDeclarationOnly: undefined,
+            sourceRoot: undefined,
+            tsBuildInfoFile: undefined,
+        };
+        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);
+        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.logger.debug({ compilerModule: this.compilerModule }, 'normalized compiler module config via ts-jest option');
+        this._backportJestCfg();
+        this._setupTsJestCfg(options);
+        this._resolveTsCacheDir();
     }
-    Object.defineProperty(ConfigSet.prototype, "jest", {
-        get: function () {
-            var _a;
-            var config = backports_1.backportJestConfig(this.logger, this._jestConfig);
-            if (this.parentOptions) {
-                var globals = (_a = config.globals) !== null && _a !== void 0 ? _a : Object.create(null);
-                globals['ts-jest'] = __assign(__assign({}, this.parentOptions), globals['ts-jest']);
-            }
-            this.logger.debug({ jestConfig: config }, 'normalized jest config');
-            return config;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "isTestFile", {
-        get: function () {
-            var matchablePatterns = __spread(this.jest.testMatch, this.jest.testRegex).filter(function (pattern) {
-                return pattern instanceof RegExp || typeof pattern === 'string';
-            });
-            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
-    });
-    Object.defineProperty(ConfigSet.prototype, "tsJest", {
-        get: function () {
-            var _this = this;
-            var _a, _b, _c, _d, _e, _f;
-            var parsedConfig = this.jest;
-            var _g = parsedConfig.globals, globals = _g === void 0 ? {} : _g;
-            var options = __assign({}, globals['ts-jest']);
-            var tsConfig = this.getInlineOrFileConfigOpt((_b = (_a = options.tsConfig) !== null && _a !== void 0 ? _a : options.tsconfig) !== null && _b !== void 0 ? _b : true);
-            var packageJson = this.getInlineOrFileConfigOpt((_c = options.packageJson) !== null && _c !== void 0 ? _c : true);
-            var transformers = Object.create(null);
-            var astTransformers = options.astTransformers;
-            if (astTransformers) {
-                if (Array.isArray(astTransformers)) {
-                    this.logger.warn("The configuration for astTransformers as string[] is deprecated and will be removed in ts-jest 27. Please define your custom AST transformers in a form of an object. More information you can check online documentation https://kulshekhar.github.io/ts-jest/user/config/astTransformers");
-                    transformers = {
-                        before: astTransformers.map(function (transformerPath) { return ({
-                            path: _this.resolvePath(transformerPath, { nodeResolve: true }),
-                        }); }),
-                    };
+    ConfigSet.prototype._backportJestCfg = function () {
+        var config = backports_1.backportJestConfig(this.logger, this.jestConfig);
+        this.logger.debug({ jestConfig: config }, 'normalized jest config');
+        this._jestCfg = config;
+    };
+    ConfigSet.prototype._setupTsJestCfg = function (options) {
+        var _this = this;
+        var _a, _b, _c;
+        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`");
+        }
+        if (!options.babelConfig) {
+            this.logger.debug('babel is disabled');
+        }
+        else {
+            var baseBabelCfg = { cwd: this.cwd };
+            if (typeof options.babelConfig === 'string') {
+                if (path_1.extname(options.babelConfig) === '.js') {
+                    this._babelConfig = __assign(__assign({}, baseBabelCfg), require(this.resolvePath(options.babelConfig, { nodeResolve: true })));
                 }
                 else {
-                    if (astTransformers.before) {
-                        transformers = {
-                            before: astTransformers.before.map(function (transformer) {
-                                return typeof transformer === 'string'
-                                    ? {
-                                        path: _this.resolvePath(transformer, { nodeResolve: true }),
-                                    }
-                                    : __assign(__assign({}, transformer), { path: _this.resolvePath(transformer.path, { nodeResolve: true }) });
-                            }),
-                        };
-                    }
-                    if (astTransformers.after) {
-                        transformers = __assign(__assign({}, transformers), { after: astTransformers.after.map(function (transformer) {
-                                return typeof transformer === 'string'
-                                    ? {
-                                        path: _this.resolvePath(transformer, { nodeResolve: true }),
-                                    }
-                                    : __assign(__assign({}, transformer), { path: _this.resolvePath(transformer.path, { nodeResolve: true }) });
-                            }) });
-                    }
-                    if (astTransformers.afterDeclarations) {
-                        transformers = __assign(__assign({}, transformers), { afterDeclarations: astTransformers.afterDeclarations.map(function (transformer) {
-                                return typeof transformer === 'string'
-                                    ? {
-                                        path: _this.resolvePath(transformer, { nodeResolve: true }),
-                                    }
-                                    : __assign(__assign({}, transformer), { path: _this.resolvePath(transformer.path, { nodeResolve: true }) });
-                            }) });
-                    }
+                    this._babelConfig = __assign(__assign({}, baseBabelCfg), json5.parse(fs_1.readFileSync(options.babelConfig, 'utf-8')));
                 }
             }
-            var babelConfig = this.getInlineOrFileConfigOpt(options.babelConfig);
-            var diagnostics;
-            var diagnosticsOpt = (_d = options.diagnostics) !== null && _d !== void 0 ? _d : true;
-            var ignoreList = __spread(exports.IGNORE_DIAGNOSTIC_CODES);
-            if (typeof diagnosticsOpt === 'object') {
-                var ignoreCodes = diagnosticsOpt.ignoreCodes;
-                if (ignoreCodes) {
-                    Array.isArray(ignoreCodes) ? ignoreList.push.apply(ignoreList, __spread(ignoreCodes)) : ignoreList.push(ignoreCodes);
-                }
-                diagnostics = {
-                    pretty: (_e = diagnosticsOpt.pretty) !== null && _e !== void 0 ? _e : true,
-                    ignoreCodes: toDiagnosticCodeList(ignoreList),
-                    pathRegex: normalizeRegex(diagnosticsOpt.pathRegex),
-                    throws: !diagnosticsOpt.warnOnly,
-                };
+            else if (typeof options.babelConfig === 'object') {
+                this._babelConfig = __assign(__assign({}, baseBabelCfg), options.babelConfig);
             }
             else {
-                diagnostics = {
-                    ignoreCodes: diagnosticsOpt ? toDiagnosticCodeList(ignoreList) : [],
-                    pretty: true,
-                    throws: diagnosticsOpt,
-                };
+                this._babelConfig = baseBabelCfg;
             }
-            var stringifyContentPathRegex = normalizeRegex(options.stringifyContentPathRegex);
-            var res = {
-                tsConfig: tsConfig,
-                packageJson: packageJson,
-                babelConfig: babelConfig,
-                diagnostics: diagnostics,
-                isolatedModules: !!options.isolatedModules,
-                compiler: (_f = options.compiler) !== null && _f !== void 0 ? _f : 'typescript',
-                transformers: transformers,
-                stringifyContentPathRegex: stringifyContentPathRegex,
-            };
-            this.logger.debug({ tsJestConfig: res }, 'normalized ts-jest config');
-            return res;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "parsedTsConfig", {
-        get: function () {
-            return this._parsedTsConfig;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "versions", {
-        get: function () {
-            var modules = ['jest', this.tsJest.compiler];
-            if (this.tsJest.babelConfig) {
-                modules.push('@babel/core', 'babel-jest');
+            this.logger.debug({ babelConfig: this._babelConfig }, 'normalized babel config via ts-jest option');
+        }
+        if (!this._babelConfig) {
+            this._overriddenCompilerOptions.module = this.compilerModule.ModuleKind.CommonJS;
+        }
+        else {
+            this._babelJestTransformers = importer_1.importer
+                .babelJest("Using \"babel-jest\" requires this package to be installed.")
+                .createTransformer(this._babelConfig);
+            this.logger.debug('created babel-jest transformer');
+        }
+        var diagnosticsOpt = (_a = options.diagnostics) !== null && _a !== void 0 ? _a : true;
+        var ignoreList = __spread(exports.IGNORE_DIAGNOSTIC_CODES);
+        if (typeof diagnosticsOpt === 'object') {
+            var ignoreCodes = diagnosticsOpt.ignoreCodes;
+            if (ignoreCodes) {
+                Array.isArray(ignoreCodes) ? ignoreList.push.apply(ignoreList, __spread(ignoreCodes)) : ignoreList.push(ignoreCodes);
             }
-            return modules.reduce(function (map, name) {
-                var _a;
-                map[name] = (_a = get_package_version_1.getPackageVersion(name)) !== null && _a !== void 0 ? _a : '-';
-                return map;
-            }, { 'ts-jest': __1.version });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "_parsedTsConfig", {
-        get: function () {
-            var tsConfig = this.tsJest.tsConfig;
-            var configFilePath = (tsConfig === null || tsConfig === void 0 ? void 0 : tsConfig.kind) === 'file' ? tsConfig.value : undefined;
-            var result = this.readTsConfig((tsConfig === null || tsConfig === void 0 ? void 0 : tsConfig.kind) === 'inline' ? tsConfig.value : undefined, configFilePath, tsConfig == null);
-            this.raiseDiagnostics(result.errors, configFilePath);
-            this.logger.debug({ tsconfig: result }, 'normalized typescript config');
-            return result;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "raiseDiagnostics", {
-        get: function () {
-            var _this = this;
-            var _a = this, createTsError = _a.createTsError, filterDiagnostics = _a.filterDiagnostics, throws = _a.tsJest.diagnostics.throws, DiagnosticCategory = _a.compilerModule.DiagnosticCategory;
-            return function (diagnostics, filePath, logger) {
-                if (logger === void 0) { logger = _this.logger; }
-                var filteredDiagnostics = filterDiagnostics(diagnostics, filePath);
-                if (!filteredDiagnostics.length)
-                    return;
-                var error = createTsError(filteredDiagnostics);
-                var importantCategories = [DiagnosticCategory.Warning, DiagnosticCategory.Error];
-                if (throws && filteredDiagnostics.some(function (d) { return importantCategories.includes(d.category); })) {
-                    throw error;
-                }
-                logger.warn({ error: error }, error.message);
+            this._diagnostics = {
+                pretty: (_b = diagnosticsOpt.pretty) !== null && _b !== void 0 ? _b : true,
+                ignoreCodes: toDiagnosticCodeList(ignoreList),
+                pathRegex: normalizeRegex(diagnosticsOpt.pathRegex),
+                throws: !diagnosticsOpt.warnOnly,
             };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "babel", {
-        get: function () {
-            var babelConfig = this.tsJest.babelConfig;
-            if (babelConfig == null) {
-                this.logger.debug('babel is disabled');
-                return undefined;
-            }
-            var base = { cwd: this.cwd };
-            if (babelConfig.kind === 'file') {
-                if (babelConfig.value) {
-                    if (path_1.extname(babelConfig.value) === '.js') {
-                        base = __assign(__assign({}, base), require(babelConfig.value));
-                    }
-                    else {
-                        base = __assign(__assign({}, base), json5.parse(fs_1.readFileSync(babelConfig.value, 'utf8')));
-                    }
-                }
-            }
-            else if (babelConfig.kind === 'inline') {
-                base = __assign(__assign({}, base), babelConfig.value);
-            }
-            this.logger.debug({ babelConfig: base }, 'normalized babel config via ts-jest option');
-            return base;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "compilerModule", {
-        get: function () {
-            return importer_1.importer.typescript("Using \"ts-jest\" requires this package to be installed.", this.tsJest.compiler);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "babelJestTransformer", {
-        get: function () {
-            var babel = this.babel;
-            if (!babel)
-                return undefined;
-            this.logger.debug('creating babel-jest transformer');
-            return importer_1.importer.babelJest("Using \"babel-jest\" requires this package to be installed.").createTransformer(babel);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "tsCompiler", {
-        get: function () {
-            return instance_1.createCompilerInstance(this);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "astTransformers", {
-        get: function () {
-            var astTransformers = {
-                before: __spread(transformers_1.internals.map(function (transformer) { return ({
-                    transformModule: transformer,
-                }); })),
+        }
+        else {
+            this._diagnostics = {
+                ignoreCodes: diagnosticsOpt ? toDiagnosticCodeList(ignoreList) : [],
+                pretty: true,
+                throws: diagnosticsOpt,
             };
-            var transformers = this.tsJest.transformers;
-            if (transformers.before) {
-                astTransformers = {
-                    before: __spread(astTransformers.before, transformers.before.map(function (transformer) {
-                        return typeof transformer === 'string'
-                            ? {
-                                transformModule: require(transformer),
-                            }
-                            : {
-                                transformModule: require(transformer.path),
-                                options: transformer.options,
-                            };
+        }
+        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 configFilePath = typeof tsconfigOpt === 'string' ? this.resolvePath(tsconfigOpt) : undefined;
+        this.parsedTsConfig = this._readTsConfig(typeof tsconfigOpt === 'object' ? tsconfigOpt : undefined, configFilePath);
+        this.raiseDiagnostics(this.parsedTsConfig.errors, configFilePath);
+        this.logger.debug({ tsconfig: this.parsedTsConfig }, 'normalized typescript config via ts-jest option');
+        var astTransformers = options.astTransformers;
+        this.customTransformers = {
+            before: [hoist_jest_1.factory(this)],
+        };
+        if (astTransformers) {
+            if (Array.isArray(astTransformers)) {
+                this.logger.warn("The configuration for astTransformers as string[] is deprecated and will be removed in ts-jest 27. Please define your custom AST transformers in a form of an object. More information you can check online documentation https://kulshekhar.github.io/ts-jest/user/config/astTransformers");
+                this.customTransformers = {
+                    before: __spread(this.customTransformers.before, astTransformers.map(function (transformer) {
+                        var transformerPath = _this.resolvePath(transformer, { nodeResolve: true });
+                        return require(transformerPath).factory(_this);
                     })),
                 };
             }
-            if (transformers.after) {
-                astTransformers = __assign(__assign({}, astTransformers), { after: transformers.after.map(function (transformer) {
-                        return typeof transformer === 'string'
-                            ? {
-                                transformModule: require(transformer),
-                            }
-                            : {
-                                transformModule: require(transformer.path),
-                                options: transformer.options,
-                            };
-                    }) });
-            }
-            if (transformers.afterDeclarations) {
-                astTransformers = __assign(__assign({}, astTransformers), { afterDeclarations: transformers.afterDeclarations.map(function (transformer) {
-                        return typeof transformer === 'string'
-                            ? {
-                                transformModule: require(transformer),
-                            }
-                            : {
-                                transformModule: require(transformer.path),
-                                options: transformer.options,
-                            };
-                    }) });
-            }
-            return astTransformers;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "tsCustomTransformers", {
-        get: function () {
-            var _this = this;
-            var customTransformers = {
-                before: this.astTransformers.before.map(function (t) { return t.transformModule.factory(_this, t.options); }),
-            };
-            if (this.astTransformers.after) {
-                customTransformers = __assign(__assign({}, customTransformers), { after: this.astTransformers.after.map(function (t) { return t.transformModule.factory(_this, t.options); }) });
-            }
-            if (this.astTransformers.afterDeclarations) {
-                customTransformers = __assign(__assign({}, customTransformers), { afterDeclarations: this.astTransformers.afterDeclarations.map(function (t) {
-                        return t.transformModule.factory(_this, t.options);
-                    }) });
-            }
-            return customTransformers;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "hooks", {
-        get: function () {
-            var hooksFile = process.env.TS_JEST_HOOKS;
-            if (hooksFile) {
-                hooksFile = path_1.resolve(this.cwd, hooksFile);
-                return importer_1.importer.tryTheseOr(hooksFile, {});
-            }
-            return {};
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "filterDiagnostics", {
-        get: function () {
-            var _a = this, ignoreCodes = _a.tsJest.diagnostics.ignoreCodes, shouldReportDiagnostic = _a.shouldReportDiagnostic;
-            return function (diagnostics, filePath) {
-                if (filePath && !shouldReportDiagnostic(filePath))
-                    return [];
-                return diagnostics.filter(function (diagnostic) {
-                    var _a;
-                    if (((_a = diagnostic.file) === null || _a === void 0 ? void 0 : _a.fileName) && !shouldReportDiagnostic(diagnostic.file.fileName)) {
-                        return false;
-                    }
-                    return !ignoreCodes.includes(diagnostic.code);
-                });
-            };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "shouldReportDiagnostic", {
-        get: function () {
-            var pathRegex = this.tsJest.diagnostics.pathRegex;
-            if (pathRegex) {
-                var regex_1 = new RegExp(pathRegex);
-                return function (file) { return regex_1.test(file); };
-            }
-            else {
-                return function () { return true; };
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "shouldStringifyContent", {
-        get: function () {
-            var stringifyContentPathRegex = this.tsJest.stringifyContentPathRegex;
-            if (stringifyContentPathRegex) {
-                var regex_2 = new RegExp(stringifyContentPathRegex);
-                return function (file) { return regex_2.test(file); };
-            }
             else {
-                return function () { return false; };
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "createTsError", {
-        get: function () {
-            var _this = this;
-            var pretty = this.tsJest.diagnostics.pretty;
-            var formatDiagnostics = pretty
-                ? this.compilerModule.formatDiagnosticsWithColorAndContext
-                : this.compilerModule.formatDiagnostics;
-            var diagnosticHost = {
-                getNewLine: function () { return '\n'; },
-                getCurrentDirectory: function () { return _this.cwd; },
-                getCanonicalFileName: function (path) { return path; },
-            };
-            return function (diagnostics) {
-                var diagnosticText = formatDiagnostics(diagnostics, diagnosticHost);
-                var diagnosticCodes = diagnostics.map(function (x) { return x.code; });
-                return new ts_error_1.TSError(diagnosticText, diagnosticCodes);
-            };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "tsCacheDir", {
-        get: function () {
-            if (!this.jest.cache) {
-                logger.debug('file caching disabled');
-                return undefined;
-            }
-            var cacheSuffix = sha1_1.sha1(json_1.stringify({
-                version: this.compilerModule.version,
-                digest: this.tsJestDigest,
-                compiler: this.tsJest.compiler,
-                compilerOptions: this.parsedTsConfig.options,
-                isolatedModules: this.tsJest.isolatedModules,
-                diagnostics: this.tsJest.diagnostics,
-            }));
-            var res = path_1.join(this.jest.cacheDirectory, 'ts-jest', cacheSuffix.substr(0, 2), cacheSuffix.substr(2));
-            logger.debug({ cacheDirectory: res }, 'will use file caching');
-            return res;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "overriddenCompilerOptions", {
-        get: function () {
-            var options = {
-                sourceMap: true,
-                inlineSourceMap: false,
-                inlineSources: true,
-                declaration: false,
-                noEmit: false,
-                removeComments: false,
-                out: undefined,
-                outFile: undefined,
-                composite: undefined,
-                declarationDir: undefined,
-                declarationMap: undefined,
-                emitDeclarationOnly: undefined,
-                sourceRoot: undefined,
-                tsBuildInfoFile: undefined,
-            };
-            if (!this.tsJest.babelConfig) {
-                options.module = this.compilerModule.ModuleKind.CommonJS;
+                var resolveTransformers = function (transformers) {
+                    return transformers.map(function (transformer) {
+                        var transformerPath;
+                        if (typeof transformer === 'string') {
+                            transformerPath = _this.resolvePath(transformer, { nodeResolve: true });
+                            return require(transformerPath).factory(_this);
+                        }
+                        else {
+                            transformerPath = _this.resolvePath(transformer.path, { nodeResolve: true });
+                            return require(transformerPath).factory(_this, transformer.options);
+                        }
+                    });
+                };
+                if (astTransformers.before) {
+                    this.customTransformers = {
+                        before: __spread(this.customTransformers.before, resolveTransformers(astTransformers.before)),
+                    };
+                }
+                if (astTransformers.after) {
+                    this.customTransformers = __assign(__assign({}, this.customTransformers), { after: resolveTransformers(astTransformers.after) });
+                }
+                if (astTransformers.afterDeclarations) {
+                    this.customTransformers = __assign(__assign({}, this.customTransformers), { afterDeclarations: resolveTransformers(astTransformers.afterDeclarations) });
+                }
             }
-            return options;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "rootDir", {
-        get: function () {
-            return path_1.normalize(this.jest.rootDir || this.cwd);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "cwd", {
-        get: function () {
-            return path_1.normalize(this.jest.cwd || process.cwd());
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "tsJestDigest", {
-        get: function () {
-            return __1.digest;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "jsonValue", {
-        get: function () {
-            var jest = __assign({}, this.jest);
-            var globals = (jest.globals = __assign({}, jest.globals));
-            jest.name = undefined;
-            jest.cacheDirectory = undefined;
-            delete globals['ts-jest'];
-            return new jsonable_value_1.JsonableValue({
-                digest: this.tsJestDigest,
-                transformers: Object.values(this.astTransformers)
-                    .reduce(function (acc, val) { return acc.concat(val); }, [])
-                    .map(function (_a) {
-                    var transformModule = _a.transformModule;
-                    return transformModule.name + "@" + transformModule.version;
-                }),
-                jest: jest,
-                tsJest: this.tsJest,
-                babel: this.babel,
-                tsconfig: {
-                    options: this.parsedTsConfig.options,
-                    raw: this.parsedTsConfig.raw,
-                },
-            });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConfigSet.prototype, "cacheKey", {
-        get: function () {
-            return this.jsonValue.serialized;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ConfigSet.prototype.makeDiagnostic = function (code, messageText, options) {
-        if (options === void 0) { options = {}; }
-        var _a = options.category, category = _a === void 0 ? this.compilerModule.DiagnosticCategory.Warning : _a, file = options.file, start = options.start, length = options.length;
-        return {
-            code: code,
-            messageText: messageText,
-            category: category,
-            file: file,
-            start: start,
-            length: length,
-        };
-    };
-    ConfigSet.prototype.getInlineOrFileConfigOpt = function (configOpt) {
-        if (typeof configOpt === 'string' || configOpt === true) {
-            return {
-                kind: 'file',
-                value: typeof configOpt === 'string' ? this.resolvePath(configOpt) : undefined,
-            };
         }
-        else if (typeof configOpt === 'object') {
-            return {
-                kind: 'inline',
-                value: configOpt,
-            };
+        this.logger.debug({ customTransformers: this.customTransformers }, 'normalized custom AST transformers via ts-jest option');
+        if (options.stringifyContentPathRegex) {
+            this._stringifyContentRegExp =
+                typeof options.stringifyContentPathRegex === 'string'
+                    ? new RegExp(normalizeRegex(options.stringifyContentPathRegex))
+                    : options.stringifyContentPathRegex;
+            this.logger.debug({ stringifyContentPathRegex: this._stringifyContentRegExp }, 'normalized stringifyContentPathRegex config via ts-jest option');
+        }
+    };
+    ConfigSet.prototype._resolveTsCacheDir = function () {
+        if (!this._jestCfg.cache) {
+            this.logger.debug('file caching disabled');
+            return undefined;
         }
-        return;
+        var cacheSuffix = sha1_1.sha1(json_1.stringify({
+            version: this.compilerModule.version,
+            digest: this.tsJestDigest,
+            compilerModule: this.compilerModule,
+            compilerOptions: this.parsedTsConfig.options,
+            isolatedModules: this.isolatedModules,
+            diagnostics: this._diagnostics,
+        }));
+        var res = path_1.join(this._jestCfg.cacheDirectory, 'ts-jest', cacheSuffix.substr(0, 2), cacheSuffix.substr(2));
+        this.logger.debug({ cacheDirectory: res }, 'will use file caching');
+        this.tsCacheDir = res;
     };
-    ConfigSet.prototype.readTsConfig = function (compilerOptions, resolvedConfigFile, noProject) {
+    ConfigSet.prototype._readTsConfig = function (compilerOptions, resolvedConfigFile) {
         var e_2, _a;
         var _b;
         var config = { compilerOptions: Object.create(null) };
         var basePath = normalize_slashes_1.normalizeSlashes(this.rootDir);
-        var configFileName;
         var ts = this.compilerModule;
-        if (!noProject) {
-            configFileName = resolvedConfigFile
-                ? normalize_slashes_1.normalizeSlashes(resolvedConfigFile)
-                : ts.findConfigFile(normalize_slashes_1.normalizeSlashes(this.rootDir), ts.sys.fileExists);
-            if (configFileName) {
-                this.logger.debug({ tsConfigFileName: configFileName }, 'readTsConfig(): reading', configFileName);
-                var result_1 = ts.readConfigFile(configFileName, ts.sys.readFile);
-                if (result_1.error) {
-                    return { errors: [result_1.error], fileNames: [], options: {} };
-                }
-                config = result_1.config;
-                basePath = normalize_slashes_1.normalizeSlashes(path_1.dirname(configFileName));
+        var configFileName = resolvedConfigFile
+            ? normalize_slashes_1.normalizeSlashes(resolvedConfigFile)
+            : ts.findConfigFile(normalize_slashes_1.normalizeSlashes(this.rootDir), ts.sys.fileExists);
+        if (configFileName) {
+            this.logger.debug({ tsConfigFileName: configFileName }, 'readTsConfig(): reading', configFileName);
+            var result_1 = ts.readConfigFile(configFileName, ts.sys.readFile);
+            if (result_1.error) {
+                return { errors: [result_1.error], fileNames: [], options: {} };
             }
+            config = result_1.config;
+            basePath = normalize_slashes_1.normalizeSlashes(path_1.dirname(configFileName));
         }
         config.compilerOptions = __assign(__assign({}, config.compilerOptions), compilerOptions);
         var result = ts.parseJsonConfigFileContent(config, ts.sys, basePath, undefined, configFileName);
-        var forcedOptions = this.overriddenCompilerOptions;
+        var forcedOptions = this._overriddenCompilerOptions;
         var finalOptions = result.options;
         if (finalOptions.target === undefined) {
             finalOptions.target = ts.ScriptTarget.ES5;
@@ -668,9 +323,14 @@ var ConfigSet = (function () {
         if ('module' in forcedOptions &&
             moduleValue !== forcedOptions.module &&
             !(finalOptions.esModuleInterop || finalOptions.allowSyntheticDefaultImports)) {
-            result.errors.push(this.makeDiagnostic(151001, "If you have issues related to imports, you should consider setting `esModuleInterop` to `true` in your TypeScript configuration file (usually `tsconfig.json`). See https://blogs.msdn.microsoft.com/typescript/2018/01/31/announcing-typescript-2-7/#easier-ecmascript-module-interoperability for more information.", {
+            result.errors.push({
+                code: 151001,
+                messageText: "If you have issues related to imports, you should consider setting `esModuleInterop` to `true` in your TypeScript configuration file (usually `tsconfig.json`). See https://blogs.msdn.microsoft.com/typescript/2018/01/31/announcing-typescript-2-7/#easier-ecmascript-module-interoperability for more information.",
                 category: ts.DiagnosticCategory.Message,
-            }));
+                file: undefined,
+                start: undefined,
+                length: undefined,
+            });
             if (!('allowSyntheticDefaultImports' in config.compilerOptions)) {
                 finalOptions.allowSyntheticDefaultImports = true;
             }
@@ -699,17 +359,123 @@ var ConfigSet = (function () {
         }
         var nodeJsVer = process.version;
         var compilationTarget = result.options.target;
-        if (!this.tsJest.babelConfig &&
+        if (!this._babelConfig &&
             ((nodeJsVer.startsWith('v10') && compilationTarget > typescript_1.ScriptTarget.ES2018) ||
                 (nodeJsVer.startsWith('v12') && compilationTarget > typescript_1.ScriptTarget.ES2019))) {
             var message = messages_1.interpolate("There is a mismatch between your NodeJs version {{nodeJsVer}} and your TypeScript target {{compilationTarget}}. This might lead to some unexpected errors when running tests with `ts-jest`. To fix this, you can check https://github.com/microsoft/TypeScript/wiki/Node-Target-Mapping", {
                 nodeJsVer: process.version,
                 compilationTarget: (_b = config.compilerOptions.target) !== null && _b !== void 0 ? _b : TARGET_TO_VERSION_MAPPING[compilationTarget],
             });
-            logger.warn(message);
+            this.logger.warn(message);
         }
         return result;
     };
+    Object.defineProperty(ConfigSet.prototype, "tsCompiler", {
+        get: function () {
+            return instance_1.createCompilerInstance(this);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ConfigSet.prototype, "babelConfig", {
+        get: function () {
+            return this._babelConfig;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ConfigSet.prototype, "babelJestTransformer", {
+        get: function () {
+            return this._babelJestTransformers;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ConfigSet.prototype, "tsJestDigest", {
+        get: function () {
+            return exports.MY_DIGEST;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ConfigSet.prototype, "hooks", {
+        get: function () {
+            var hooksFile = process.env.TS_JEST_HOOKS;
+            if (hooksFile) {
+                hooksFile = path_1.resolve(this.cwd, hooksFile);
+                return importer_1.importer.tryTheseOr(hooksFile, {});
+            }
+            return {};
+        },
+        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.shouldStringifyContent = function (filePath) {
+        return this._stringifyContentRegExp ? this._stringifyContentRegExp.test(filePath) : false;
+    };
+    ConfigSet.prototype.raiseDiagnostics = function (diagnostics, filePath, logger) {
+        var _this = this;
+        var ignoreCodes = this._diagnostics.ignoreCodes;
+        var DiagnosticCategory = this.compilerModule.DiagnosticCategory;
+        var filteredDiagnostics = filePath && !this.shouldReportDiagnostics(filePath)
+            ? []
+            : diagnostics.filter(function (diagnostic) {
+                var _a;
+                if (((_a = diagnostic.file) === null || _a === void 0 ? void 0 : _a.fileName) && !_this.shouldReportDiagnostics(diagnostic.file.fileName)) {
+                    return false;
+                }
+                return !ignoreCodes.includes(diagnostic.code);
+            });
+        if (!filteredDiagnostics.length)
+            return;
+        var error = this._createTsError(filteredDiagnostics);
+        var importantCategories = [DiagnosticCategory.Warning, DiagnosticCategory.Error];
+        if (this._diagnostics.throws && filteredDiagnostics.some(function (d) { return importantCategories.includes(d.category); })) {
+            throw error;
+        }
+        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;
+        }
+    };
+    ConfigSet.prototype._createTsError = function (diagnostics) {
+        var _this = this;
+        var formatDiagnostics = this._diagnostics.pretty
+            ? this.compilerModule.formatDiagnosticsWithColorAndContext
+            : this.compilerModule.formatDiagnostics;
+        var diagnosticHost = {
+            getNewLine: function () { return '\n'; },
+            getCurrentDirectory: function () { return _this.cwd; },
+            getCanonicalFileName: function (path) { return path; },
+        };
+        var diagnosticText = formatDiagnostics(diagnostics, diagnosticHost);
+        var diagnosticCodes = diagnostics.map(function (x) { return x.code; });
+        return new ts_error_1.TSError(diagnosticText, diagnosticCodes);
+    };
     ConfigSet.prototype.resolvePath = function (inputPath, _a) {
         var _b = _a === void 0 ? {} : _a, _c = _b.throwIfMissing, throwIfMissing = _c === void 0 ? true : _c, _d = _b.nodeResolve, nodeResolve = _d === void 0 ? false : _d;
         var path = inputPath;
@@ -742,78 +508,18 @@ var ConfigSet = (function () {
         this.logger.debug({ fromPath: inputPath, toPath: path }, 'resolved path from', inputPath, 'to', path);
         return path;
     };
-    ConfigSet.prototype.toJSON = function () {
-        return this.jsonValue.value;
-    };
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "jest", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "isTestFile", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "tsJest", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "versions", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "_parsedTsConfig", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "raiseDiagnostics", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "babel", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "compilerModule", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "babelJestTransformer", null);
     __decorate([
         memoize_1.Memoize()
     ], ConfigSet.prototype, "tsCompiler", null);
     __decorate([
         memoize_1.Memoize()
-    ], ConfigSet.prototype, "astTransformers", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "tsCustomTransformers", null);
+    ], ConfigSet.prototype, "tsJestDigest", null);
     __decorate([
         memoize_1.Memoize()
     ], ConfigSet.prototype, "hooks", null);
     __decorate([
         memoize_1.Memoize()
-    ], ConfigSet.prototype, "filterDiagnostics", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "shouldReportDiagnostic", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "shouldStringifyContent", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "createTsError", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "tsCacheDir", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "overriddenCompilerOptions", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "rootDir", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "cwd", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "tsJestDigest", null);
-    __decorate([
-        memoize_1.Memoize()
-    ], ConfigSet.prototype, "jsonValue", null);
+    ], ConfigSet.prototype, "isTestFile", null);
     return ConfigSet;
 }());
 exports.ConfigSet = ConfigSet;