ts-jest 29.0.1 → 29.0.3

package/dist/legacy/compiler/compiler-utils.d.ts

@@ -1,2 +1,8 @@
+/**
+ * Rely on TypeScript compiled output generation which contains this prefix to point to sourcemap location.
+ */
 export declare const SOURCE_MAPPING_PREFIX = "sourceMappingURL=";
+/**
+ * Update the output remapping the source map.
+ */
 export declare function updateOutput(outputText: string, normalizedFileName: string, sourceMap?: string): string;

package/dist/legacy/compiler/compiler-utils.js

@@ -2,17 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateOutput = exports.SOURCE_MAPPING_PREFIX = void 0;
 var utils_1 = require("../../utils");
+/**
+ * Rely on TypeScript compiled output generation which contains this prefix to point to sourcemap location.
+ */
 exports.SOURCE_MAPPING_PREFIX = 'sourceMappingURL=';
+/**
+ * Update the output remapping the source map.
+ */
 function updateOutput(outputText, normalizedFileName, sourceMap) {
     if (sourceMap) {
         var base64Map = Buffer.from(updateSourceMap(sourceMap, normalizedFileName), 'utf8').toString('base64');
         var sourceMapContent = "data:application/json;charset=utf-8;base64,".concat(base64Map);
+        // sourceMappingURL= prefix is always at the end of compiledOutput, using lastIndexOf should be the safest way to substring
         return (outputText.slice(0, outputText.lastIndexOf(exports.SOURCE_MAPPING_PREFIX) + exports.SOURCE_MAPPING_PREFIX.length) +
             sourceMapContent);
     }
     return outputText;
 }
 exports.updateOutput = updateOutput;
+/**
+ * Update the source map contents for improved output.
+ */
 var updateSourceMap = function (sourceMapText, normalizedFileName) {
     var sourceMap = JSON.parse(sourceMapText);
     sourceMap.file = normalizedFileName;

package/dist/legacy/compiler/ts-compiler.d.ts

@@ -10,7 +10,13 @@ export declare class TsCompiler implements TsCompilerInstance {
     protected readonly _ts: TTypeScript;
     protected readonly _initialCompilerOptions: CompilerOptions;
     protected _compilerOptions: CompilerOptions;
+    /**
+     * @private
+     */
     private _runtimeCacheFS;
+    /**
+     * @private
+     */
     private _fileContentCache;
     program: Program | undefined;
     constructor(configSet: ConfigSet, runtimeCacheFS: StringMap);

package/dist/legacy/compiler/ts-compiler.js

@@ -58,12 +58,15 @@ var constants_1 = require("../../constants");
 var utils_1 = require("../../utils");
 var messages_1 = require("../../utils/messages");
 var compiler_utils_1 = require("./compiler-utils");
-var TsCompiler = (function () {
+var TsCompiler = /** @class */ (function () {
     function TsCompiler(configSet, runtimeCacheFS) {
         var _a;
         var _this = this;
         this.configSet = configSet;
         this.runtimeCacheFS = runtimeCacheFS;
+        /**
+         * @internal
+         */
         this._projectVersion = 1;
         this._ts = configSet.compilerModule;
         this._logger = utils_1.rootLogger.child({ namespace: 'ts-compiler' });
@@ -80,6 +83,7 @@ var TsCompiler = (function () {
                 },
                 _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.trace,
                 _a), 'readFile', (0, lodash_memoize_1.default)(this._ts.sys.readFile));
+            /* istanbul ignore next */
             this._moduleResolutionHost = {
                 fileExists: (0, lodash_memoize_1.default)(this._ts.sys.fileExists),
                 readFile: this._cachedReadFile,
@@ -95,6 +99,7 @@ var TsCompiler = (function () {
     }
     TsCompiler.prototype.getResolvedModules = function (fileContent, fileName, runtimeCacheFS) {
         var _this = this;
+        // In watch mode, it is possible that the initial cacheFS becomes empty
         if (!this.runtimeCacheFS.size) {
             this._runtimeCacheFS = runtimeCacheFS;
         }
@@ -122,6 +127,7 @@ var TsCompiler = (function () {
                         ![this._ts.ModuleKind.ES2015, this._ts.ModuleKind.ES2020, this._ts.ModuleKind.ESNext].includes(moduleKind))
                     ? this._ts.ModuleKind.ESNext
                     : moduleKind;
+            // Make sure `esModuleInterop` and `allowSyntheticDefaultImports` true to support import CJS into ESM
             esModuleInterop = true;
             allowSyntheticDefaultImports = true;
         }
@@ -131,6 +137,7 @@ var TsCompiler = (function () {
         this._compilerOptions = __assign(__assign({}, this._compilerOptions), { allowSyntheticDefaultImports: allowSyntheticDefaultImports, esModuleInterop: esModuleInterop, module: moduleKind });
         if (this._languageService) {
             this._logger.debug({ fileName: fileName }, 'getCompiledOutput(): compiling using language service');
+            // Must set memory cache before attempting to compile
             this._updateMemoryCache(fileContent, fileName, currentModuleKind === moduleKind);
             var output = this._languageService.getEmitOutput(fileName);
             var diagnostics = this.getDiagnostics(fileName);
@@ -147,6 +154,7 @@ var TsCompiler = (function () {
                                 this._logger.debug({ fileToReTypeCheck: fileToReTypeCheck }, '_doTypeChecking(): computing diagnostics using language service');
                                 this._updateMemoryCache(this._getFileContentFromCache(fileToReTypeCheck), fileToReTypeCheck);
                                 var importedModulesDiagnostics = __spreadArray(__spreadArray([], __read(this._languageService.getSemanticDiagnostics(fileToReTypeCheck)), false), __read(this._languageService.getSyntacticDiagnostics(fileToReTypeCheck)), false);
+                                // will raise or just warn diagnostics depending on config
                                 this.configSet.raiseDiagnostics(importedModulesDiagnostics, fileName, this._logger);
                             }
                         }
@@ -162,17 +170,18 @@ var TsCompiler = (function () {
             }
             if (output.emitSkipped) {
                 if (constants_1.TS_TSX_REGEX.test(fileName)) {
-                    throw new Error((0, messages_1.interpolate)("Unable to process '{{file}}', please make sure that `outDir` in your tsconfig is neither `''` or `'.'`. You can also configure Jest config option `transformIgnorePatterns` to inform `ts-jest` to transform {{file}}", { file: fileName }));
+                    throw new Error((0, messages_1.interpolate)("Unable to process '{{file}}', please make sure that `outDir` in your tsconfig is neither `''` or `'.'`. You can also configure Jest config option `transformIgnorePatterns` to inform `ts-jest` to transform {{file}}" /* Errors.CannotProcessFile */, { file: fileName }));
                 }
                 else {
-                    this._logger.warn((0, messages_1.interpolate)("Unable to process '{{file}}', falling back to original file content. You can also configure Jest config option `transformIgnorePatterns` to ignore {{file}} from transformation or make sure that `outDir` in your tsconfig is neither `''` or `'.'`", { file: fileName }));
+                    this._logger.warn((0, messages_1.interpolate)("Unable to process '{{file}}', falling back to original file content. You can also configure Jest config option `transformIgnorePatterns` to ignore {{file}} from transformation or make sure that `outDir` in your tsconfig is neither `''` or `'.'`" /* Errors.CannotProcessFileReturnOriginal */, { file: fileName }));
                     return {
                         code: fileContent,
                     };
                 }
             }
+            // Throw an error when requiring `.d.ts` files.
             if (!output.outputFiles.length) {
-                throw new TypeError((0, 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}}`.", {
+                throw new TypeError((0, 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}}`." /* Errors.UnableToRequireDefinitionFile */, {
                     file: (0, path_1.basename)(fileName),
                 }));
             }
@@ -220,19 +229,33 @@ var TsCompiler = (function () {
             }),
         };
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype._createLanguageService = function () {
         var _this = this;
         var _a;
+        // Initialize memory cache for typescript compiler
         this._parsedTsConfig.fileNames
             .filter(function (fileName) { return constants_1.TS_TSX_REGEX.test(fileName) && !_this.configSet.isTestFile(fileName); })
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             .forEach(function (fileName) { return _this._fileVersionCache.set(fileName, 0); });
+        /* istanbul ignore next */
         var serviceHost = {
             useCaseSensitiveFileNames: function () { return _this._ts.sys.useCaseSensitiveFileNames; },
             getProjectVersion: function () { return String(_this._projectVersion); },
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             getScriptFileNames: function () { return __spreadArray([], __read(_this._fileVersionCache.keys()), false); },
             getScriptVersion: function (fileName) {
                 var normalizedFileName = (0, path_1.normalize)(fileName);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 var version = _this._fileVersionCache.get(normalizedFileName);
+                // 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`).
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 return version === undefined ? undefined : String(version);
             },
             getScriptSnapshot: function (fileName) {
@@ -240,13 +263,19 @@ var TsCompiler = (function () {
                 var normalizedFileName = (0, path_1.normalize)(fileName);
                 var hit = _this._isFileInCache(normalizedFileName);
                 _this._logger.trace({ normalizedFileName: normalizedFileName, cacheHit: hit }, 'getScriptSnapshot():', 'cache', hit ? 'hit' : 'miss');
+                // Read file content from either memory cache or Jest runtime cache or fallback to file system read
                 if (!hit) {
-                    var fileContent = (_d = (_b = (_a = _this._fileContentCache.get(normalizedFileName)) !== null && _a !== void 0 ? _a : _this._runtimeCacheFS.get(normalizedFileName)) !== null && _b !== void 0 ? _b : (_c = _this._cachedReadFile) === null || _c === void 0 ? void 0 : _c.call(_this, normalizedFileName)) !== null && _d !== void 0 ? _d : undefined;
+                    var fileContent = 
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    (_d = (_b = (_a = _this._fileContentCache.get(normalizedFileName)) !== null && _a !== void 0 ? _a : _this._runtimeCacheFS.get(normalizedFileName)) !== null && _b !== void 0 ? _b : (_c = _this._cachedReadFile) === null || _c === void 0 ? void 0 : _c.call(_this, normalizedFileName)) !== null && _d !== void 0 ? _d : undefined;
                     if (fileContent !== undefined) {
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                         _this._fileContentCache.set(normalizedFileName, fileContent);
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                         _this._fileVersionCache.set(normalizedFileName, 1);
                     }
                 }
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 var contents = _this._fileContentCache.get(normalizedFileName);
                 if (contents === undefined)
                     return;
@@ -271,51 +300,87 @@ var TsCompiler = (function () {
         this._languageService = this._ts.createLanguageService(serviceHost, this._ts.createDocumentRegistry(this._ts.sys.useCaseSensitiveFileNames, this.configSet.cwd));
         this.program = this._languageService.getProgram();
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype._getFileContentFromCache = function (filePath) {
         var normalizedFilePath = (0, path_1.normalize)(filePath);
         var resolvedFileContent = this._runtimeCacheFS.get(normalizedFilePath);
         if (!resolvedFileContent) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             resolvedFileContent = this._moduleResolutionHost.readFile(normalizedFilePath);
             this._runtimeCacheFS.set(normalizedFilePath, resolvedFileContent);
         }
         return resolvedFileContent;
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype._getImportedModulePaths = function (resolvedFileContent, containingFile) {
         var _this = this;
         return this._ts
             .preProcessFile(resolvedFileContent, true, true)
             .importedFiles.map(function (importedFile) {
             var resolvedModule = _this._resolveModuleName(importedFile.fileName, containingFile).resolvedModule;
+            /* istanbul ignore next already covered  */
             var resolvedFileName = resolvedModule === null || resolvedModule === void 0 ? void 0 : resolvedModule.resolvedFileName;
+            /* istanbul ignore next already covered  */
             return resolvedFileName && !(resolvedModule === null || resolvedModule === void 0 ? void 0 : resolvedModule.isExternalLibraryImport) ? resolvedFileName : '';
         })
             .filter(function (resolveFileName) { return !!resolveFileName; });
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype._resolveModuleName = function (moduleNameToResolve, containingFile) {
-        return this._ts.resolveModuleName(moduleNameToResolve, containingFile, this._compilerOptions, this._moduleResolutionHost, this._moduleResolutionCache);
+        return this._ts.resolveModuleName(moduleNameToResolve, containingFile, this._compilerOptions, 
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this._moduleResolutionHost, 
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this._moduleResolutionCache);
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype._isFileInCache = function (fileName) {
-        return (this._fileContentCache.has(fileName) &&
+        return (
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this._fileContentCache.has(fileName) &&
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             this._fileVersionCache.has(fileName) &&
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             this._fileVersionCache.get(fileName) !== 0);
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype._updateMemoryCache = function (contents, fileName, isModuleKindTheSame) {
         if (isModuleKindTheSame === void 0) { isModuleKindTheSame = true; }
         this._logger.debug({ fileName: fileName }, 'updateMemoryCache: update memory cache for language service');
         var shouldIncrementProjectVersion = false;
         var hit = this._isFileInCache(fileName);
         if (!hit) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             this._fileVersionCache.set(fileName, 1);
             shouldIncrementProjectVersion = true;
         }
         else {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             var prevVersion = this._fileVersionCache.get(fileName);
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             var previousContents = this._fileContentCache.get(fileName);
+            // Avoid incrementing cache when nothing has changed.
             if (previousContents !== contents) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 this._fileVersionCache.set(fileName, prevVersion + 1);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 this._fileContentCache.set(fileName, contents);
                 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 (!this._parsedTsConfig.fileNames.includes(fileName) || !isModuleKindTheSame) {
                 shouldIncrementProjectVersion = true;
             }
@@ -323,10 +388,14 @@ var TsCompiler = (function () {
         if (shouldIncrementProjectVersion)
             this._projectVersion++;
     };
+    /**
+     * @internal
+     */
     TsCompiler.prototype.getDiagnostics = function (fileName) {
         var diagnostics = [];
         if (this.configSet.shouldReportDiagnostics(fileName)) {
             this._logger.debug({ fileName: fileName }, '_doTypeChecking(): computing diagnostics using language service');
+            // Get the relevant diagnostics - this is 3x faster than `getPreEmitDiagnostics`.
             diagnostics.push.apply(diagnostics, __spreadArray(__spreadArray([], __read(this._languageService.getSemanticDiagnostics(fileName)), false), __read(this._languageService.getSyntacticDiagnostics(fileName)), false));
         }
         return diagnostics;

package/dist/legacy/compiler/ts-jest-compiler.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TsJestCompiler = void 0;
 var ts_compiler_1 = require("./ts-compiler");
-var TsJestCompiler = (function () {
+var TsJestCompiler = /** @class */ (function () {
     function TsJestCompiler(configSet, runtimeCacheFS) {
+        // Later we can add swc/esbuild or other typescript compiler instance here
         this._compilerInstance = new ts_compiler_1.TsCompiler(configSet, runtimeCacheFS);
     }
     TsJestCompiler.prototype.getResolvedModules = function (fileContent, fileName, runtimeCacheFS) {

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

@@ -4,6 +4,9 @@ import type { RawCompilerOptions } from '../../raw-compiler-options';
 import type { ProjectConfigTsJest, TsJestAstTransformer, TTypeScript } from '../../types';
 export declare class ConfigSet {
     readonly parentLogger?: Logger | undefined;
+    /**
+     * Use by e2e, don't mark as internal
+     */
     readonly tsJestDigest: string;
     readonly logger: Logger;
     readonly compilerModule: TTypeScript;
@@ -16,6 +19,10 @@ export declare class ConfigSet {
     resolvedTransformers: TsJestAstTransformer;
     useESM: boolean;
     constructor(jestConfig: ProjectConfigTsJest | undefined, parentLogger?: Logger | undefined);
+    /**
+     * Load TypeScript configuration. Returns the parsed TypeScript config and any `tsconfig` options specified in ts-jest
+     * Subclasses which extend `ConfigSet` can override the default behavior
+     */
     protected _resolveTsConfig(compilerOptions?: RawCompilerOptions, resolvedConfigFile?: string): Record<string, any>;
     isTestFile(fileName: string): boolean;
     shouldStringifyContent(filePath: string): boolean;