ts-jest 25.0.0 → 25.3.0

package/dist/compiler/program.js

@@ -0,0 +1,123 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var bs_logger_1 = require("bs-logger");
+var memoize = require("lodash.memoize");
+var path_1 = require("path");
+var messages_1 = require("../util/messages");
+var hasOwn = Object.prototype.hasOwnProperty;
+exports.compileUsingProgram = function (configs, logger, memoryCache) {
+    var _a;
+    logger.debug('compileUsingProgram(): create typescript compiler');
+    var ts = configs.compilerModule, cwd = configs.cwd, _b = configs.typescript, options = _b.options, projectReferences = _b.projectReferences, errors = _b.errors, incremental = configs.tsJest.incremental;
+    var compilerHostTraceCtx = (_a = {
+            namespace: 'ts:compilerHost',
+            call: null
+        },
+        _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.trace,
+        _a), sys = __assign(__assign({}, ts.sys), { readFile: logger.wrap(compilerHostTraceCtx, 'readFile', memoize(ts.sys.readFile)), readDirectory: memoize(ts.sys.readDirectory), getDirectories: memoize(ts.sys.getDirectories), fileExists: memoize(ts.sys.fileExists), directoryExists: memoize(ts.sys.directoryExists), resolvePath: memoize(ts.sys.resolvePath), realpath: memoize(ts.sys.realpath), getCurrentDirectory: function () { return cwd; }, getNewLine: function () { return '\n'; }, getCanonicalFileName: function (fileName) {
+            return ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
+        } });
+    var builderProgram, program, host;
+    if (incremental) {
+        host = ts.createIncrementalCompilerHost(options, sys);
+        builderProgram = ts.createIncrementalProgram({
+            rootNames: Object.keys(memoryCache.versions),
+            options: options,
+            host: host,
+            configFileParsingDiagnostics: errors,
+            projectReferences: projectReferences,
+        });
+        program = builderProgram.getProgram();
+    }
+    else {
+        host = __assign(__assign({}, sys), { getSourceFile: function (fileName, languageVersion) {
+                var contents = ts.sys.readFile(fileName);
+                if (contents === undefined)
+                    return;
+                return ts.createSourceFile(fileName, contents, languageVersion);
+            }, getDefaultLibFileName: function () { return ts.getDefaultLibFilePath(options); }, useCaseSensitiveFileNames: function () { return sys.useCaseSensitiveFileNames; } });
+        program = ts.createProgram({
+            rootNames: Object.keys(memoryCache.versions),
+            options: options,
+            host: host,
+            configFileParsingDiagnostics: errors,
+            projectReferences: projectReferences,
+        });
+    }
+    var customTransformers = configs.tsCustomTransformers, updateMemoryCache = function (code, fileName) {
+        logger.debug({ fileName: fileName }, "updateMemoryCache(): update memory cache for " + (incremental ? 'incremental program' : 'program'));
+        var sourceFile = incremental ? builderProgram.getSourceFile(fileName) : program.getSourceFile(fileName);
+        if (!hasOwn.call(memoryCache.versions, fileName)) {
+            memoryCache.versions[fileName] = 1;
+        }
+        if (memoryCache.contents[fileName] !== code) {
+            memoryCache.contents[fileName] = code;
+            memoryCache.versions[fileName] = (memoryCache.versions[fileName] || 0) + 1;
+        }
+        if (sourceFile === undefined || sourceFile.text !== code || program.isSourceFileFromExternalLibrary(sourceFile)) {
+            var programOptions = {
+                rootNames: Object.keys(memoryCache.versions),
+                options: options,
+                host: host,
+                configFileParsingDiagnostics: errors,
+                projectReferences: projectReferences,
+            };
+            if (incremental) {
+                builderProgram = ts.createIncrementalProgram(programOptions);
+                program = builderProgram.getProgram();
+            }
+            else {
+                program = ts.createProgram(__assign(__assign({}, programOptions), { oldProgram: program }));
+            }
+        }
+    };
+    return {
+        compileFn: function (code, fileName) {
+            var normalizedFileName = path_1.normalize(fileName), output = ['', ''];
+            logger.debug({ normalizedFileName: normalizedFileName }, "compileFn(): compiling using " + (incremental ? 'incremental program' : 'program'));
+            updateMemoryCache(code, normalizedFileName);
+            var sourceFile = incremental
+                ? builderProgram.getSourceFile(normalizedFileName)
+                : program.getSourceFile(normalizedFileName);
+            if (!sourceFile)
+                throw new TypeError("Unable to read file: " + fileName);
+            var result = incremental
+                ? builderProgram.emit(sourceFile, function (path, file, _writeByteOrderMark) {
+                    output[path.endsWith('.map') ? 1 : 0] = file;
+                }, undefined, undefined, customTransformers)
+                : program.emit(sourceFile, function (path, file, _writeByteOrderMark) {
+                    output[path.endsWith('.map') ? 1 : 0] = file;
+                }, undefined, undefined, customTransformers);
+            if (result.emitSkipped) {
+                throw new TypeError(path_1.relative(cwd, fileName) + ": Emit skipped");
+            }
+            if (output[0] === '') {
+                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}}`.", {
+                    file: path_1.basename(normalizedFileName),
+                }));
+            }
+            return output;
+        },
+        diagnoseFn: function (code, filePath) {
+            var normalizedFileName = path_1.normalize(filePath);
+            updateMemoryCache(code, normalizedFileName);
+            if (configs.shouldReportDiagnostic(normalizedFileName)) {
+                logger.debug({ normalizedFileName: normalizedFileName }, "compileFn(): computing diagnostics for " + (incremental ? 'incremental program' : 'program'));
+                var sourceFile = program.getSourceFile(normalizedFileName), diagnostics = program.getSemanticDiagnostics(sourceFile).concat(program.getSyntacticDiagnostics(sourceFile));
+                configs.raiseDiagnostics(diagnostics, normalizedFileName, logger);
+            }
+        },
+        program: program,
+    };
+};

package/dist/compiler/transpile-module.d.ts

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

package/dist/compiler/transpile-module.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = require("path");
+exports.compileUsingTranspileModule = function (configs, logger) {
+    logger.debug('compileUsingTranspileModule(): create typescript compiler');
+    return {
+        compileFn: function (code, fileName) {
+            logger.debug({ fileName: fileName }, 'getOutput(): compiling as isolated module');
+            var normalizedFileName = path_1.normalize(fileName), result = configs.compilerModule.transpileModule(code, {
+                fileName: normalizedFileName,
+                transformers: configs.tsCustomTransformers,
+                compilerOptions: configs.typescript.options,
+                reportDiagnostics: configs.shouldReportDiagnostic(normalizedFileName),
+            });
+            if (result.diagnostics && configs.shouldReportDiagnostic(normalizedFileName)) {
+                configs.raiseDiagnostics(result.diagnostics, normalizedFileName, logger);
+            }
+            return [result.outputText, result.sourceMapText];
+        },
+    };
+};

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

@@ -1,4 +1,4 @@
-/// <reference types="jest" />
+import { Config } from '@jest/types';
 import { Logger } from 'bs-logger';
 import { CompilerOptions, CustomTransformers, ParsedCommandLine } from 'typescript';
 import { AstTransformerDesc, BabelConfig, BabelJestTransformer, TTypeScript, TsCompiler, TsJestConfig, TsJestGlobalOptions, TsJestHooksMap } from '../types';
@@ -6,12 +6,11 @@ export declare class ConfigSet {
     readonly parentOptions?: TsJestGlobalOptions | undefined;
     get projectPackageJson(): Record<string, any>;
     get projectDependencies(): Record<string, string>;
-    get jest(): jest.ProjectConfig;
+    get jest(): Config.ProjectConfig;
     get tsJest(): TsJestConfig;
     get typescript(): ParsedCommandLine;
     get tsconfig(): any;
     get versions(): Record<string, string>;
-    private static loadConfig;
     get babel(): BabelConfig | undefined;
     get compilerModule(): TTypeScript;
     get babelJestTransformer(): BabelJestTransformer | undefined;
@@ -28,7 +27,7 @@ export declare class ConfigSet {
     get tsJestDigest(): string;
     get cacheKey(): string;
     readonly logger: Logger;
-    constructor(jestConfig: jest.ProjectConfig, parentOptions?: TsJestGlobalOptions | undefined, parentLogger?: Logger);
+    constructor(jestConfig: Config.ProjectConfig, parentOptions?: TsJestGlobalOptions | undefined, parentLogger?: Logger);
     resolvePath(inputPath: string, { throwIfMissing, nodeResolve }?: {
         throwIfMissing?: boolean;
         nodeResolve?: boolean;

package/dist/config/config-set.js

@@ -52,9 +52,8 @@ var bs_logger_1 = require("bs-logger");
 var fs_1 = require("fs");
 var json5 = require("json5");
 var path_1 = require("path");
-var semver = require("semver");
 var __1 = require("..");
-var compiler_1 = require("../compiler");
+var instance_1 = require("../compiler/instance");
 var transformers_1 = require("../transformers");
 var backports_1 = require("../util/backports");
 var get_package_version_1 = require("../util/get-package-version");
@@ -74,11 +73,6 @@ exports.IGNORE_DIAGNOSTIC_CODES = [
     18002,
     18003,
 ];
-var DiagnosticCodes;
-(function (DiagnosticCodes) {
-    DiagnosticCodes[DiagnosticCodes["TsJest"] = 151000] = "TsJest";
-    DiagnosticCodes[DiagnosticCodes["ConfigModuleOption"] = 151001] = "ConfigModuleOption";
-})(DiagnosticCodes = exports.DiagnosticCodes || (exports.DiagnosticCodes = {}));
 var normalizeRegex = function (pattern) {
     return pattern ? (typeof pattern === 'string' ? pattern : pattern.source) : undefined;
 };
@@ -141,7 +135,7 @@ var ConfigSet = (function () {
                 if (fs_1.existsSync(path)) {
                     return require(path);
                 }
-                this.logger.warn(messages_1.Errors.UnableToFindProjectRoot);
+                this.logger.warn("Unable to find the root of the project where ts-jest has been installed.");
                 return {};
             }
             var tsJestRoot = path_1.resolve(__dirname, '..', '..');
@@ -155,7 +149,7 @@ var ConfigSet = (function () {
                     return require(pkgPath);
                 }
             }
-            this.logger.warn(messages_1.Errors.UnableToFindProjectRoot);
+            this.logger.warn("Unable to find the root of the project where ts-jest has been installed.");
             return {};
         },
         enumerable: true,
@@ -177,9 +171,10 @@ var ConfigSet = (function () {
     });
     Object.defineProperty(ConfigSet.prototype, "jest", {
         get: function () {
+            var _a;
             var config = backports_1.backportJestConfig(this.logger, this._jestConfig);
             if (this.parentOptions) {
-                var globals = config.globals || (config.globals = {});
+                var globals = (_a = config.globals) !== null && _a !== void 0 ? _a : {};
                 globals['ts-jest'] = __assign(__assign({}, this.parentOptions), globals['ts-jest']);
             }
             this.logger.debug({ jestConfig: config }, 'normalized jest config');
@@ -191,8 +186,9 @@ var ConfigSet = (function () {
     Object.defineProperty(ConfigSet.prototype, "tsJest", {
         get: function () {
             var _this = this;
+            var _a, _b, _c;
             var parsedConfig = this.jest;
-            var _a = parsedConfig.globals, globals = _a === void 0 ? {} : _a;
+            var _d = parsedConfig.globals, globals = _d === void 0 ? {} : _d;
             var options = __assign({}, globals['ts-jest']);
             var tsConfigOpt = options.tsConfig;
             var tsConfig;
@@ -238,7 +234,7 @@ var ConfigSet = (function () {
                 };
             }
             var diagnostics;
-            var _b = options.diagnostics, diagnosticsOpt = _b === void 0 ? true : _b;
+            var _e = options.diagnostics, diagnosticsOpt = _e === void 0 ? true : _e;
             var ignoreList = [exports.IGNORE_DIAGNOSTIC_CODES, process.env.TS_JEST_IGNORE_DIAGNOSTICS];
             if (diagnosticsOpt === true || diagnosticsOpt == null) {
                 diagnostics = { ignoreCodes: [], pretty: true, throws: true };
@@ -264,11 +260,13 @@ var ConfigSet = (function () {
             var stringifyContentPathRegex = normalizeRegex(options.stringifyContentPathRegex);
             var res = {
                 tsConfig: tsConfig,
+                compilerHost: (_a = options.compilerHost) !== null && _a !== void 0 ? _a : false,
+                incremental: (_b = options.incremental) !== null && _b !== void 0 ? _b : true,
                 packageJson: packageJson,
                 babelConfig: babelConfig,
                 diagnostics: diagnostics,
                 isolatedModules: !!options.isolatedModules,
-                compiler: options.compiler || 'typescript',
+                compiler: (_c = options.compiler) !== null && _c !== void 0 ? _c : 'typescript',
                 transformers: transformers,
                 stringifyContentPathRegex: stringifyContentPathRegex,
             };
@@ -299,7 +297,8 @@ var ConfigSet = (function () {
                 modules.push('@babel/core', 'babel-jest');
             }
             return modules.reduce(function (map, name) {
-                map[name] = get_package_version_1.getPackageVersion(name) || '-';
+                var _a;
+                map[name] = (_a = get_package_version_1.getPackageVersion(name)) !== null && _a !== void 0 ? _a : '-';
                 return map;
             }, { 'ts-jest': __1.version });
         },
@@ -325,7 +324,7 @@ var ConfigSet = (function () {
             return function (diagnostics, filePath, logger) {
                 if (logger === void 0) { logger = _this.logger; }
                 var filteredDiagnostics = filterDiagnostics(diagnostics, filePath);
-                if (filteredDiagnostics.length === 0)
+                if (!filteredDiagnostics.length)
                     return;
                 var error = createTsError(filteredDiagnostics);
                 var importantCategories = [DiagnosticCategory.Warning, DiagnosticCategory.Error];
@@ -338,19 +337,6 @@ var ConfigSet = (function () {
         enumerable: true,
         configurable: true
     });
-    ConfigSet.loadConfig = function (base) {
-        var _a = importer_1.importer.babelCore(messages_1.ImportReasons.BabelJest), OptionManager = _a.OptionManager, loadPartialConfig = _a.loadPartialConfig, version = _a.version;
-        if (version && semver.satisfies(version, '>=6 <7')) {
-            delete base.cwd;
-        }
-        if (typeof loadPartialConfig === 'function') {
-            var partialConfig = loadPartialConfig(base);
-            if (partialConfig) {
-                return partialConfig.options;
-            }
-        }
-        return new OptionManager().init(base);
-    };
     Object.defineProperty(ConfigSet.prototype, "babel", {
         get: function () {
             var babelConfig = this.tsJest.babelConfig;
@@ -372,16 +358,15 @@ var ConfigSet = (function () {
             else if (babelConfig.kind === 'inline') {
                 base = __assign(__assign({}, base), babelConfig.value);
             }
-            var config = ConfigSet.loadConfig(base);
-            this.logger.debug({ babelConfig: config }, 'normalized babel config');
-            return config;
+            this.logger.debug({ babelConfig: base }, 'normalized babel config via ts-jest option');
+            return base;
         },
         enumerable: true,
         configurable: true
     });
     Object.defineProperty(ConfigSet.prototype, "compilerModule", {
         get: function () {
-            return importer_1.importer.typescript(messages_1.ImportReasons.TsJest, this.tsJest.compiler);
+            return importer_1.importer.typescript("Using \"ts-jest\" requires this package to be installed.", this.tsJest.compiler);
         },
         enumerable: true,
         configurable: true
@@ -392,14 +377,14 @@ var ConfigSet = (function () {
             if (!babel)
                 return;
             this.logger.debug('creating babel-jest transformer');
-            return importer_1.importer.babelJest(messages_1.ImportReasons.BabelJest).createTransformer(babel);
+            return importer_1.importer.babelJest("Using \"babel-jest\" requires this package to be installed.").createTransformer(babel);
         },
         enumerable: true,
         configurable: true
     });
     Object.defineProperty(ConfigSet.prototype, "tsCompiler", {
         get: function () {
-            return compiler_1.createCompiler(this);
+            return instance_1.createCompiler(this);
         },
         enumerable: true,
         configurable: true
@@ -440,7 +425,8 @@ var ConfigSet = (function () {
                 if (filePath && !shouldReportDiagnostic(filePath))
                     return [];
                 return diagnostics.filter(function (diagnostic) {
-                    if (diagnostic.file && diagnostic.file.fileName && !shouldReportDiagnostic(diagnostic.file.fileName)) {
+                    var _a;
+                    if (((_a = diagnostic.file) === null || _a === void 0 ? void 0 : _a.fileName) && !shouldReportDiagnostic(diagnostic.file.fileName)) {
                         return false;
                     }
                     return ignoreCodes.indexOf(diagnostic.code) === -1;
@@ -529,7 +515,6 @@ var ConfigSet = (function () {
                 inlineSources: true,
                 declaration: false,
                 noEmit: false,
-                outDir: '$$ts-jest$$',
                 removeComments: false,
                 out: undefined,
                 outFile: undefined,
@@ -537,7 +522,6 @@ var ConfigSet = (function () {
                 declarationDir: undefined,
                 declarationMap: undefined,
                 emitDeclarationOnly: undefined,
-                incremental: undefined,
                 sourceRoot: undefined,
                 tsBuildInfoFile: undefined,
             };
@@ -563,13 +547,6 @@ var ConfigSet = (function () {
         enumerable: true,
         configurable: true
     });
-    Object.defineProperty(ConfigSet.prototype, "isDoctoring", {
-        get: function () {
-            return !!process.env.TS_JEST_DOCTOR;
-        },
-        enumerable: true,
-        configurable: true
-    });
     Object.defineProperty(ConfigSet.prototype, "tsJestDigest", {
         get: function () {
             return __1.digest;
@@ -659,7 +636,7 @@ var ConfigSet = (function () {
         if ('module' in forcedOptions &&
             moduleValue !== forcedOptions.module &&
             !(finalOptions.esModuleInterop || finalOptions.allowSyntheticDefaultImports)) {
-            result.errors.push(this.makeDiagnostic(DiagnosticCodes.ConfigModuleOption, messages_1.Errors.ConfigNoModuleInterop, {
+            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.", {
                 category: ts.DiagnosticCategory.Message,
             }));
             if (!('allowSyntheticDefaultImports' in config.compilerOptions)) {
@@ -714,7 +691,7 @@ var ConfigSet = (function () {
             catch (_) { }
         }
         if (throwIfMissing && !fs_1.existsSync(path)) {
-            throw new Error(messages_1.interpolate(messages_1.Errors.FileNotFound, { inputPath: inputPath, resolvedPath: path }));
+            throw new Error(messages_1.interpolate("File not found: {{inputPath}} (resolved as: {{resolvedPath}})", { inputPath: inputPath, resolvedPath: path }));
         }
         this.logger.debug({ fromPath: inputPath, toPath: path }, 'resolved path from', inputPath, 'to', path);
         return path;

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

@@ -1,10 +1,10 @@
-/// <reference types="jest" />
+import { Config } from '@jest/types';
 export interface TsJestPresets {
-    transform: Record<string, string>;
+    transform: Config.InitialOptions['transform'];
     testMatch?: string[];
     moduleFileExtensions?: string[];
 }
 export interface CreateJestPresetOptions {
     allowJs?: boolean;
 }
-export declare function createJestPreset({ allowJs }?: CreateJestPresetOptions, from?: jest.InitialOptions): TsJestPresets;
+export declare function createJestPreset({ allowJs }?: CreateJestPresetOptions, from?: Config.InitialOptions): TsJestPresets;

package/dist/config/paths-to-module-name-mapper.d.ts

@@ -1,5 +1,5 @@
 export declare const pathsToModuleNameMapper: (mapping: import("typescript").MapLike<string[]>, { prefix }?: {
     prefix?: string | undefined;
 }) => {
-    [key: string]: string;
+    [key: string]: string | string[];
 } | undefined;

package/dist/config/paths-to-module-name-mapper.js

@@ -27,11 +27,11 @@ exports.pathsToModuleNameMapper = function (mapping, _a) {
             var pattern = void 0;
             var toPaths = mapping[fromPath];
             if (toPaths.length === 0) {
-                logger.warn(messages_1.interpolate(messages_1.Errors.NotMappingPathWithEmptyMap, { path: fromPath }));
+                logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has no target.", { path: fromPath }));
                 continue;
             }
             else if (toPaths.length > 1) {
-                logger.warn(messages_1.interpolate(messages_1.Errors.MappingOnlyFirstTargetOfPath, {
+                logger.warn(messages_1.interpolate("Mapping only to first target of \"{{path}}\" because it has more than one ({{count}}).", {
                     path: fromPath,
                     count: toPaths.length,
                 }));
@@ -47,7 +47,7 @@ exports.pathsToModuleNameMapper = function (mapping, _a) {
                 jestMap[pattern] = "" + prefix + target.replace(/\*/g, '$1');
             }
             else {
-                logger.warn(messages_1.interpolate(messages_1.Errors.NotMappingMultiStarPath, { path: fromPath }));
+                logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has more than one star (`*`).", { path: fromPath }));
                 continue;
             }
         }

package/dist/index.d.ts

@@ -7,7 +7,7 @@ export declare const createJestPreset: typeof createJestPresetCore;
 export declare const pathsToModuleNameMapper: (mapping: import("typescript").MapLike<string[]>, { prefix }?: {
     prefix?: string | undefined;
 }) => {
-    [key: string]: string;
+    [key: string]: string | string[];
 } | undefined;
 export declare const version: string;
 export declare const digest: string;

package/dist/index.js

@@ -33,7 +33,7 @@ var testing_1 = require("./util/testing");
 var version_checkers_1 = require("./util/version-checkers");
 var warn = logger_1.rootLogger.child((_a = {}, _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.warn, _a));
 var helperMoved = function (name, helper) {
-    return warn.wrap(messages_1.interpolate(messages_1.Deprecateds.HelperMovedToUtils, { helper: name }), helper);
+    return warn.wrap(messages_1.interpolate("The `{{helper}}` helper has been moved to `ts-jest/utils`. Use `import { {{helper}} } from 'ts-jest/utils'` instead.", { helper: name }), helper);
 };
 exports.mocked = helperMoved('mocked', testing_1.mocked);
 exports.createJestPreset = helperMoved('createJestPreset', create_jest_preset_1.createJestPreset);

package/dist/transformers/hoist-jest.js

@@ -21,20 +21,21 @@ var __spread = (this && this.__spread) || function () {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var bs_logger_1 = require("bs-logger");
-var HOIST_METHODS = ['mock', 'unmock', 'enableAutomock', 'disableAutomock'];
+var HOIST_METHODS = ['mock', 'unmock', 'enableAutomock', 'disableAutomock', 'deepUnmock'];
 exports.name = 'hoisting-jest-mock';
 exports.version = 1;
 function factory(cs) {
     var logger = cs.logger.child({ namespace: 'ts-hoisting' });
     var ts = cs.compilerModule;
+    function shouldHoistExpression(expression) {
+        return (ts.isCallExpression(expression) &&
+            ts.isPropertyAccessExpression(expression.expression) &&
+            HOIST_METHODS.includes(expression.expression.name.text) &&
+            ((ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === 'jest') ||
+                shouldHoistExpression(expression.expression.expression)));
+    }
     function shouldHoistNode(node) {
-        return (ts.isExpressionStatement(node) &&
-            ts.isCallExpression(node.expression) &&
-            ts.isPropertyAccessExpression(node.expression.expression) &&
-            ts.isIdentifier(node.expression.expression.expression) &&
-            node.expression.expression.expression.text === 'jest' &&
-            ts.isIdentifier(node.expression.expression.name) &&
-            HOIST_METHODS.includes(node.expression.expression.name.text));
+        return ts.isExpressionStatement(node) && shouldHoistExpression(node.expression);
     }
     function createVisitor(ctx, _) {
         var level = 0;

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

@@ -1,15 +1,14 @@
-/// <reference types="jest" />
-import { Logger } from 'bs-logger';
+import { TransformOptions, TransformedSource, Transformer } from '@jest/transform/build/types';
+import { Config } from '@jest/types';
 import { ConfigSet } from './config/config-set';
 import { TsJestGlobalOptions } from './types';
-export declare class TsJestTransformer implements jest.Transformer {
-    static get lastTransformerId(): number;
-    readonly logger: Logger;
-    readonly id: number;
-    readonly options: TsJestGlobalOptions;
+export declare class TsJestTransformer implements Transformer {
+    private readonly logger;
+    private readonly id;
+    private readonly options;
     constructor(baseOptions?: TsJestGlobalOptions);
-    configsFor(jestConfig: jest.ProjectConfig | string): ConfigSet;
-    process(input: string, filePath: jest.Path, jestConfig: jest.ProjectConfig, transformOptions?: jest.TransformOptions): jest.TransformedSource | string;
+    configsFor(jestConfig: Config.ProjectConfig | string): ConfigSet;
+    process(input: string, filePath: Config.Path, jestConfig: Config.ProjectConfig, transformOptions?: TransformOptions): TransformedSource | string;
     getCacheKey(fileContent: string, filePath: string, jestConfigStr: string, transformOptions?: {
         instrument?: boolean;
         rootDir?: string;

package/dist/ts-jest-transformer.js

@@ -18,7 +18,16 @@ var jsonable_value_1 = require("./util/jsonable-value");
 var logger_1 = require("./util/logger");
 var messages_1 = require("./util/messages");
 var sha1_1 = require("./util/sha1");
-exports.INSPECT_CUSTOM = util_1.inspect.custom || 'inspect';
+var INSPECT_CUSTOM = util_1.inspect.custom || 'inspect';
+function checkDefinitionFile(filePath) {
+    return filePath.endsWith('.d.ts');
+}
+function checkJsFile(filePath) {
+    return !checkDefinitionFile(filePath) && /\.jsx?$/.test(filePath);
+}
+function checkTsFile(filePath) {
+    return !checkDefinitionFile(filePath) && /\.tsx?$/.test(filePath);
+}
 var TsJestTransformer = (function () {
     function TsJestTransformer(baseOptions) {
         if (baseOptions === void 0) { baseOptions = {}; }
@@ -30,13 +39,6 @@ var TsJestTransformer = (function () {
         });
         this.logger.debug({ baseOptions: baseOptions }, 'created new transformer');
     }
-    Object.defineProperty(TsJestTransformer, "lastTransformerId", {
-        get: function () {
-            return TsJestTransformer._lastTransformerId;
-        },
-        enumerable: true,
-        configurable: true
-    });
     Object.defineProperty(TsJestTransformer, "_nextTransformerId", {
         get: function () {
             return ++TsJestTransformer._lastTransformerId;
@@ -44,7 +46,7 @@ var TsJestTransformer = (function () {
         enumerable: true,
         configurable: true
     });
-    TsJestTransformer.prototype[exports.INSPECT_CUSTOM] = function () {
+    TsJestTransformer.prototype[INSPECT_CUSTOM] = function () {
         return "[object TsJestTransformer<#" + this.id + ">]";
     };
     TsJestTransformer.prototype.configsFor = function (jestConfig) {
@@ -79,14 +81,7 @@ var TsJestTransformer = (function () {
     TsJestTransformer.prototype.process = function (input, filePath, jestConfig, transformOptions) {
         this.logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'processing', filePath);
         var result;
-        var source = input;
-        var configs = this.configsFor(jestConfig);
-        var hooks = configs.hooks;
-        var stringify = configs.shouldStringifyContent(filePath);
-        var babelJest = stringify ? undefined : configs.babelJestTransformer;
-        var isDefinitionFile = filePath.endsWith('.d.ts');
-        var isJsFile = !isDefinitionFile && /\.jsx?$/.test(filePath);
-        var isTsFile = isDefinitionFile || /\.tsx?$/.test(filePath);
+        var source = input, configs = this.configsFor(jestConfig), hooks = configs.hooks, stringify = configs.shouldStringifyContent(filePath), babelJest = stringify ? undefined : configs.babelJestTransformer, isDefinitionFile = checkDefinitionFile(filePath), isJsFile = checkJsFile(filePath), isTsFile = checkTsFile(filePath);
         if (stringify) {
             result = "module.exports=" + JSON.stringify(source);
         }
@@ -94,14 +89,14 @@ var TsJestTransformer = (function () {
             result = '';
         }
         else if (!configs.typescript.options.allowJs && isJsFile) {
-            this.logger.warn({ fileName: filePath }, messages_1.interpolate(messages_1.Errors.GotJsFileButAllowJsFalse, { path: filePath }));
+            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 = configs.tsCompiler.compile(source, filePath);
         }
         else {
-            var message = babelJest ? messages_1.Errors.GotUnknownFileTypeWithBabel : messages_1.Errors.GotUnknownFileTypeWithoutBabel;
+            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.";
             this.logger.warn({ fileName: filePath }, messages_1.interpolate(message, { path: filePath }));
             result = source;
         }
@@ -123,6 +118,9 @@ var TsJestTransformer = (function () {
         this.logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'computing cache key for', filePath);
         var configs = this.configsFor(jestConfigStr);
         var _a = transformOptions.instrument, instrument = _a === void 0 ? false : _a, _b = transformOptions.rootDir, rootDir = _b === void 0 ? configs.rootDir : _b;
+        if (configs.tsCompiler.diagnose && (checkJsFile(filePath) || checkTsFile(filePath))) {
+            configs.tsCompiler.diagnose(fileContent, filePath);
+        }
         return sha1_1.sha1(configs.cacheKey, '\x00', rootDir, '\x00', "instrument:" + (instrument ? 'on' : 'off'), '\x00', fileContent, '\x00', filePath);
     };
     TsJestTransformer._configSetsIndex = [];