ts-jest 26.3.0 → 26.4.2

package/dist/compiler/language-service.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __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) {
@@ -85,21 +74,16 @@ var path_1 = require("path");
 var memoize = require("lodash.memoize");
 var mkdirp = require("mkdirp");
 var constants_1 = require("../constants");
-var messages_1 = require("../util/messages");
-var json_1 = require("../util/json");
-var sha1_1 = require("../util/sha1");
+var messages_1 = require("../utils/messages");
+var json_1 = require("../utils/json");
+var sha1_1 = require("../utils/sha1");
 function doTypeChecking(configs, diagnosedFiles, fileName, service, logger) {
-    if (configs.shouldReportDiagnostic(fileName)) {
-        // Get the relevant diagnostics - this is 3x faster than `getPreEmitDiagnostics`.
+    if (configs.shouldReportDiagnostics(fileName)) {
         var diagnostics = service.getSemanticDiagnostics(fileName).concat(service.getSyntacticDiagnostics(fileName));
         diagnosedFiles.push(fileName);
-        // will raise or just warn diagnostics depending on config
         configs.raiseDiagnostics(diagnostics, fileName, logger);
     }
 }
-/**
- * @internal
- */
 exports.initializeLanguageServiceInstance = function (configs, logger) {
     var _a;
     logger.debug('initializeLanguageServiceInstance(): create typescript compiler');
@@ -120,28 +104,25 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
     };
     var tsResolvedModulesCachePath;
     if (cacheDir) {
-        // Make sure the cache directory exists before continuing.
         mkdirp.sync(cacheDir);
         tsResolvedModulesCachePath = path_1.join(cacheDir, sha1_1.sha1('ts-jest-resolved-modules', '\x00'));
         try {
-            /* istanbul ignore next (already covered with unit test) */
             var cachedTSResolvedModules = fs_1.readFileSync(tsResolvedModulesCachePath, 'utf-8');
             memoryCache.resolvedModules = new Map(json_1.parse(cachedTSResolvedModules));
         }
         catch (e) { }
     }
-    // Initialize memory cache for typescript compiler
-    configs.parsedTsConfig.fileNames.forEach(function (fileName) {
+    configs.parsedTsConfig.fileNames
+        .filter(function (fileName) { return fileName.endsWith('.d.ts'); })
+        .forEach(function (fileName) {
         memoryCache.files.set(fileName, {
             version: 0,
         });
     });
     function isFileInCache(fileName) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         return memoryCache.files.has(fileName) && memoryCache.files.get(fileName).version !== 0;
     }
     var cacheReadFile = logger.wrap(serviceHostTraceCtx, 'readFile', memoize(ts.sys.readFile));
-    /* istanbul ignore next */
     var moduleResolutionHost = {
         fileExists: memoize(ts.sys.fileExists),
         readFile: cacheReadFile,
@@ -169,8 +150,6 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
         });
     }
     var projectVersion = 1;
-    // Set the file contents into cache.
-    /* istanbul ignore next (cover by e2e) */
     var updateMemoryCache = function (contents, fileName) {
         logger.debug({ fileName: fileName }, 'updateMemoryCache(): update memory cache for language service');
         var shouldIncrementProjectVersion = false;
@@ -183,22 +162,15 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
             shouldIncrementProjectVersion = true;
         }
         else {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             var previousContents = memoryCache.files.get(fileName).text;
-            // Avoid incrementing cache when nothing has changed.
             if (previousContents !== contents) {
                 memoryCache.files.set(fileName, {
                     text: contents,
                     version: memoryCache.files.get(fileName).version + 1,
                 });
-                // Only bump project version when file is modified in cache, not when discovered for the first time
                 if (hit)
                     shouldIncrementProjectVersion = true;
             }
-            /**
-             * When a file is from node_modules or referenced to a referenced project and jest wants to transform it, we need
-             * to make sure that the Program is updated with this information
-             */
             if (!fileNames.includes(fileName)) {
                 shouldIncrementProjectVersion = true;
             }
@@ -213,11 +185,6 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
             var _a;
             var normalizedFileName = path_1.normalize(fileName);
             var version = (_a = memoryCache.files.get(normalizedFileName)) === null || _a === void 0 ? void 0 : _a.version;
-            // We need to return `undefined` and not a string here because TypeScript will use
-            // `getScriptVersion` and compare against their own version - which can be `undefined`.
-            // If we don't return `undefined` it results in `undefined === "undefined"` and run
-            // `createProgram` again (which is very slow). Using a `string` assertion here to avoid
-            // TypeScript errors from the function signature (expects `(x: string) => string`).
             return version === undefined ? undefined : String(version);
         },
         getScriptSnapshot: function (fileName) {
@@ -225,7 +192,6 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
             var normalizedFileName = path_1.normalize(fileName);
             var hit = isFileInCache(normalizedFileName);
             logger.trace({ normalizedFileName: normalizedFileName, cacheHit: hit }, 'getScriptSnapshot():', 'cache', hit ? 'hit' : 'miss');
-            // Read contents from TypeScript memory cache.
             if (!hit) {
                 memoryCache.files.set(normalizedFileName, {
                     text: cacheReadFile(normalizedFileName),
@@ -247,7 +213,7 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
         getCurrentDirectory: function () { return cwd; },
         getCompilationSettings: function () { return options; },
         getDefaultLibFileName: function () { return ts.getDefaultLibFilePath(options); },
-        getCustomTransformers: function () { return configs.tsCustomTransformers; },
+        getCustomTransformers: function () { return configs.customTransformers; },
         resolveModuleNames: resolveModuleNames,
     };
     logger.debug('initializeLanguageServiceInstance(): creating language service');
@@ -257,47 +223,33 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
             var e_1, _a;
             var _b;
             logger.debug({ fileName: fileName }, 'compileFn(): compiling using language service');
-            // Must set memory cache before attempting to compile
             updateMemoryCache(code, fileName);
             var output = service.getEmitOutput(fileName);
-            /* istanbul ignore next */
             if (tsResolvedModulesCachePath) {
-                // Cache resolved modules to disk so next run can reuse it
                 void (function () { return __awaiter(void 0, void 0, void 0, function () {
                     return __generator(this, function (_a) {
                         switch (_a.label) {
-                            case 0: 
-                            // eslint-disable-next-line @typescript-eslint/await-thenable
-                            return [4 /*yield*/, fs_1.writeFile(tsResolvedModulesCachePath, json_1.stringify(__spread(memoryCache.resolvedModules)), function () { })];
+                            case 0: return [4, fs_1.writeFile(tsResolvedModulesCachePath, json_1.stringify(__spread(memoryCache.resolvedModules)), function () { })];
                             case 1:
-                                // eslint-disable-next-line @typescript-eslint/await-thenable
                                 _a.sent();
-                                return [2 /*return*/];
+                                return [2];
                         }
                     });
                 }); })();
             }
-            /**
-             * There might be a chance that test files are type checked even before jest executes them, we don't need to do
-             * type check again
-             */
             if (!diagnosedFiles.includes(fileName)) {
                 logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics using language service');
                 doTypeChecking(configs, diagnosedFiles, fileName, service, logger);
             }
-            /* istanbul ignore next (already covered with unit tests) */
             if (!configs.isTestFile(fileName)) {
                 try {
                     for (var _c = __values(memoryCache.resolvedModules.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
                         var _e = __read(_d.value, 2), testFileName = _e[0], resolvedModules = _e[1];
-                        // Only do type checking for test files which haven't been type checked before as well as the file must exist
                         if (resolvedModules.includes(fileName) &&
                             !diagnosedFiles.includes(testFileName) &&
                             fs_1.existsSync(testFileName)) {
                             var testFileContent = (_b = memoryCache.files.get(testFileName)) === null || _b === void 0 ? void 0 : _b.text;
                             if (!testFileContent) {
-                                // Must set memory cache before attempting to get diagnostics
-                                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                                 updateMemoryCache(cacheReadFile(testFileName), testFileName);
                             }
                             logger.debug({ testFileName: testFileName }, 'compileFn(): computing diagnostics using language service for test file which uses the module');
@@ -313,17 +265,14 @@ exports.initializeLanguageServiceInstance = function (configs, logger) {
                     finally { if (e_1) throw e_1.error; }
                 }
             }
-            /* istanbul ignore next (this should never happen but is kept for security) */
             if (output.emitSkipped) {
                 throw new TypeError(path_1.relative(cwd, fileName) + ": Emit skipped for language service");
             }
-            // Throw an error when requiring `.d.ts` files.
             if (!output.outputFiles.length) {
-                throw new TypeError(messages_1.interpolate("Unable to require `.d.ts` file for file: {{file}}.\nThis is usually the result of a faulty configuration or import. Make sure there is a `.js`, `.json` or another executable extension available alongside `{{file}}`." /* UnableToRequireDefinitionFile */, {
+                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(fileName),
                 }));
             }
-            memoryCache.files.set(fileName, __assign(__assign({}, memoryCache.files.get(fileName)), { output: output.outputFiles[1].text }));
             return [output.outputFiles[1].text, output.outputFiles[0].text];
         },
         program: service.getProgram(),

package/dist/compiler/transpiler.js

@@ -1,29 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initializeTranspilerInstance = void 0;
-/**
- * @internal
- */
 exports.initializeTranspilerInstance = function (configs, logger) {
     logger.debug('initializeTranspilerInstance(): create typescript compiler');
-    var _a = configs.parsedTsConfig, options = _a.options, fileNames = _a.fileNames;
+    var options = configs.parsedTsConfig.options;
     var ts = configs.compilerModule;
-    var program = ts.createProgram(fileNames, options);
     return {
         compileFn: function (code, fileName) {
             logger.debug({ fileName: fileName }, 'compileFn(): compiling as isolated module');
             var result = ts.transpileModule(code, {
                 fileName: fileName,
-                transformers: configs.tsCustomTransformers,
+                transformers: configs.customTransformers,
                 compilerOptions: options,
-                reportDiagnostics: configs.shouldReportDiagnostic(fileName),
+                reportDiagnostics: configs.shouldReportDiagnostics(fileName),
             });
-            if (result.diagnostics && configs.shouldReportDiagnostic(fileName)) {
+            if (result.diagnostics && configs.shouldReportDiagnostics(fileName)) {
                 configs.raiseDiagnostics(result.diagnostics, fileName, logger);
             }
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             return [result.outputText, result.sourceMapText];
         },
-        program: program,
+        program: undefined,
     };
 };

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

@@ -1,31 +1,24 @@
-/**
- * This is the core of settings and so ts-jest.
- * Since configuration are used to create a good cache key, everything
- * depending on it is here. Fast jest relies on correct cache keys
- * depending on all settings that could affect the generated output.
- *
- * The big issue is that jest calls first `getCacheKey()` with stringified
- * version of the `jest.ProjectConfig`, and then later it calls `process()`
- * with the complete, object version of it.
- */
 import type { Config } from '@jest/types';
 import { Logger } from 'bs-logger';
-import type { TsCompiler, TsJestGlobalOptions, TTypeScript } from '../types';
+import { CustomTransformers, Diagnostic, ParsedCommandLine } from 'typescript';
+import type { TTypeScript } from '../types';
 export declare class ConfigSet {
-    readonly parentOptions?: TsJestGlobalOptions | undefined;
-    /**
-     * Use by e2e, don't mark as internal
-     */
-    get versions(): Record<string, string>;
-    /**
-     * This API can be used by custom transformers
-     */
-    get compilerModule(): TTypeScript;
-    get tsCompiler(): TsCompiler;
-    /**
-     * Use by e2e, don't mark as internal
-     */
-    get tsJestDigest(): string;
     readonly logger: Logger;
-    constructor(jestConfig: Config.ProjectConfig, parentOptions?: TsJestGlobalOptions | undefined, parentLogger?: Logger);
+    readonly compilerModule: TTypeScript;
+    readonly isolatedModules: boolean;
+    readonly cwd: string;
+    tsCacheDir: string | undefined;
+    parsedTsConfig: ParsedCommandLine;
+    customTransformers: CustomTransformers;
+    readonly rootDir: string;
+    constructor(jestConfig: Config.ProjectConfig, parentLogger?: Logger | undefined);
+    get tsJestDigest(): string;
+    get isTestFile(): (fileName: string) => boolean;
+    shouldStringifyContent(filePath: string): boolean;
+    raiseDiagnostics(diagnostics: Diagnostic[], filePath?: string, logger?: Logger): void;
+    shouldReportDiagnostics(filePath: string): boolean;
+    resolvePath(inputPath: string, { throwIfMissing, nodeResolve }?: {
+        throwIfMissing?: boolean;
+        nodeResolve?: boolean;
+    }): string;
 }