ts-jest 27.1.4 → 28.0.0-next.2

package/.ts-jest-digest

@@ -1 +1 @@
-606cdd028ccae5bd2e9b9917b4e8ac7f4e76229a
+a33d3c3435f0ce0d59e132c0594636ecb76175d9

package/CHANGELOG.md

@@ -1,3 +1,75 @@
+# [28.0.0-next.2](https://github.com/kulshekhar/ts-jest/compare/v28.0.0-next.1...v28.0.0-next.2) (2022-04-27)
+
+
+### Bug Fixes
+
+* revert deprecation message for `TsJestTransformer` ([#3466](https://github.com/kulshekhar/ts-jest/issues/3466)) ([cefa0da](https://github.com/kulshekhar/ts-jest/commit/cefa0da660c4f99cf6595e253981af6855bcc80c))
+
+
+### Features
+
+* **presets:** add presets for legacy mode ([#3465](https://github.com/kulshekhar/ts-jest/issues/3465)) ([543b4ad](https://github.com/kulshekhar/ts-jest/commit/543b4ad729d20fbd46a2de5cd4660dc50b94ebe7))
+
+
+
+# [28.0.0-next.1](https://github.com/kulshekhar/ts-jest/compare/v28.0.0-next.0...v28.0.0-next.1) (2022-04-26)
+
+
+### Features
+
+* mark `ConfigSet` as legacy ([#3456](https://github.com/kulshekhar/ts-jest/issues/3456)) ([a986729](https://github.com/kulshekhar/ts-jest/commit/a98672977a679d1ed882605a3e71ed405432ffdc))
+* mark `TsCompiler` and `TsJestCompiler` as legacy ([#3457](https://github.com/kulshekhar/ts-jest/issues/3457)) ([0f2fe30](https://github.com/kulshekhar/ts-jest/commit/0f2fe306762d8549bd29737becd4aed14a650427))
+* remove `path-mapping` AST transformer ([#3455](https://github.com/kulshekhar/ts-jest/issues/3455)) ([f566869](https://github.com/kulshekhar/ts-jest/commit/f5668698f8fab78b3008d936aa5001f134f530e2))
+* set Jest peer dependencies to v28 ([#3454](https://github.com/kulshekhar/ts-jest/issues/3454)) ([1e880ff](https://github.com/kulshekhar/ts-jest/commit/1e880fffe82bca231d1d23f6508f4ab4bc31e03e))
+
+
+### BREAKING CHANGES
+
+* `path-mapping` AST transformer is no longer shipped in `ts-jest` v28. Please use an alternative one like https://github.com/LeDDGroup/typescript-transform-paths instead.
+* Any imports `ts-jest/dist/compiler/ts-compiler` should change to `ts-jest/dist/legacy/compiler/ts-compiler`
+* Any imports `ts-jest/dist/compiler/ts-jest-compiler` should change to `ts-jest/dist/legacy/compiler/ts-jest-compiler`
+* Any imports `ts-jest/dist/config/config-set` should change to `ts-jest/dist/legacy/config/config-set
+
+
+
+# [28.0.0-next.0](https://github.com/kulshekhar/ts-jest/compare/v27.1.3...v28.0.0-next.0) (2022-04-24)
+
+
+### Bug Fixes
+
+* **legacy** invoke Babel `processAsync` for `babel-jest` in ESM mode instead of `process` ([#3430](https://github.com/kulshekhar/ts-jest/issues/3430)) ([0d7356c](https://github.com/kulshekhar/ts-jest/commit/0d7356cd767a924e5b57e3a93679eef4ca8fae51))
+
+
+### Features
+
+* **core:** drop support for Node.js 10 ([#3332](https://github.com/kulshekhar/ts-jest/issues/3332)) ([7a9aa61](https://github.com/kulshekhar/ts-jest/commit/7a9aa615ea0be881105676a17d5bd655afdc27f5))
+* **core:** remove `mocked` testing util ([#3333](https://github.com/kulshekhar/ts-jest/issues/3333)) ([2d9017d](https://github.com/kulshekhar/ts-jest/commit/2d9017ddfea39f45aa991876b314d1dbe4a36aad))
+* **core:** remove `ts-jest/utils` sub path export ([#3334](https://github.com/kulshekhar/ts-jest/issues/3334)) ([9f253d3](https://github.com/kulshekhar/ts-jest/commit/9f253d31dfcefa35ae00049d0d2dc4a3fe1b2f34))
+* mark `TsJestTransformer` as legacy ([#3451](https://github.com/kulshekhar/ts-jest/issues/3451)) ([b090179](https://github.com/kulshekhar/ts-jest/commit/b0901799adc519959a954dba5e7b8fc8b97a9665))
+
+
+### BREAKING CHANGES
+
+* Minimum support TypeScript version is now **4.3** since Jest 28 requires it
+* Jest 28 is required
+* **core:** Any imports `ts-jest/utils` should be replaced with `ts-jest`.
+* **core:** Starting from Jest 27.4, `mocked` has been integrated into Jest repo.
+* **core:** Support for Node.js v10 has been removed as Jest drops support for it
+* All presets now will they are preserved for refactored codes. If you wish to use the old codes, please do the following
+* 
+```diff
+// jest.config.js
+module.exports = {
+  // [...]
+-    preset: 'ts-jest', // or 'js-with-babel'/'js-with-ts'
++    transform: {
+        '^.+\\.tsx?$': 'ts-jest/legacy' // or '^.+\\.[tj]sx?$': 'ts-jest' to use legacy codes
+     }
+}
+```
+
+
+
 ## [27.1.4](https://github.com/kulshekhar/ts-jest/compare/v27.1.3...v27.1.4) (2022-03-24)
 
 

package/dist/config/index.d.ts

@@ -1,2 +1 @@
-export * from './config-set';
 export * from './paths-to-module-name-mapper';

package/dist/config/index.js

@@ -14,5 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./config-set"), exports);
 __exportStar(require("./paths-to-module-name-mapper"), exports);

package/dist/index.d.ts

@@ -1,13 +1,14 @@
-import { TsJestTransformer } from './ts-jest-transformer';
-export * from './constants';
-export * from './compiler';
+import { TsJestTransformer } from './legacy/ts-jest-transformer';
 export * from './config';
+export * from './constants';
+export * from './legacy/compiler';
+export * from './legacy/ts-jest-transformer';
+export * from './legacy/config/config-set';
 export * from './presets/create-jest-preset';
-export * from './utils';
 export * from './raw-compiler-options';
-export * from './ts-jest-transformer';
+export * from './utils';
 export * from './types';
 declare const _default: {
-    createTransformer: () => TsJestTransformer;
+    createTransformer(): TsJestTransformer;
 };
 export default _default;

package/dist/index.js

@@ -14,15 +14,18 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var ts_jest_transformer_1 = require("./ts-jest-transformer");
-__exportStar(require("./constants"), exports);
-__exportStar(require("./compiler"), exports);
+var ts_jest_transformer_1 = require("./legacy/ts-jest-transformer");
 __exportStar(require("./config"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./legacy/compiler"), exports);
+__exportStar(require("./legacy/ts-jest-transformer"), exports);
+__exportStar(require("./legacy/config/config-set"), exports);
 __exportStar(require("./presets/create-jest-preset"), exports);
-__exportStar(require("./utils"), exports);
 __exportStar(require("./raw-compiler-options"), exports);
-__exportStar(require("./ts-jest-transformer"), exports);
+__exportStar(require("./utils"), exports);
 __exportStar(require("./types"), exports);
 exports.default = {
-    createTransformer: function () { return new ts_jest_transformer_1.TsJestTransformer(); },
+    createTransformer: function () {
+        return new ts_jest_transformer_1.TsJestTransformer();
+    },
 };

package/dist/{compiler → legacy/compiler}/index.d.ts

@@ -1,3 +1,2 @@
-export * from './compiler-utils';
 export * from './ts-compiler';
 export * from './ts-jest-compiler';

package/dist/{compiler → legacy/compiler}/index.js

@@ -14,6 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./compiler-utils"), exports);
 __exportStar(require("./ts-compiler"), exports);
 __exportStar(require("./ts-jest-compiler"), exports);

package/dist/{compiler → legacy/compiler}/ts-compiler.d.ts

@@ -1,7 +1,8 @@
+import type { TransformedSource } from '@jest/transform';
 import { Logger } from 'bs-logger';
-import type { TranspileOutput, CompilerOptions, Program, CustomTransformers } from 'typescript';
-import type { ConfigSet } from '../config';
-import type { StringMap, TsCompilerInstance, TsJestAstTransformer, TsJestCompileOptions, TTypeScript } from '../types';
+import type { CompilerOptions, CustomTransformers, Program, TranspileOutput } from 'typescript';
+import type { StringMap, TsCompilerInstance, TsJestAstTransformer, TsJestCompileOptions, TTypeScript } from '../../types';
+import type { ConfigSet } from '../config/config-set';
 export declare class TsCompiler implements TsCompilerInstance {
     readonly configSet: ConfigSet;
     readonly runtimeCacheFS: StringMap;
@@ -14,7 +15,7 @@ export declare class TsCompiler implements TsCompilerInstance {
     program: Program | undefined;
     constructor(configSet: ConfigSet, runtimeCacheFS: StringMap);
     getResolvedModules(fileContent: string, fileName: string, runtimeCacheFS: StringMap): string[];
-    getCompiledOutput(fileContent: string, fileName: string, options: TsJestCompileOptions): string;
+    getCompiledOutput(fileContent: string, fileName: string, options: TsJestCompileOptions): TransformedSource;
     protected _transpileOutput(fileContent: string, fileName: string): TranspileOutput;
     protected _makeTransformers(customTransformers: TsJestAstTransformer): CustomTransformers;
 }

package/dist/{compiler → legacy/compiler}/ts-compiler.js

@@ -54,10 +54,9 @@ exports.TsCompiler = void 0;
 var path_1 = require("path");
 var bs_logger_1 = require("bs-logger");
 var lodash_memoize_1 = __importDefault(require("lodash.memoize"));
-var constants_1 = require("../constants");
-var utils_1 = require("../utils");
-var messages_1 = require("../utils/messages");
-var compiler_utils_1 = require("./compiler-utils");
+var constants_1 = require("../../constants");
+var utils_1 = require("../../utils");
+var messages_1 = require("../../utils/messages");
 var TsCompiler = (function () {
     function TsCompiler(configSet, runtimeCacheFS) {
         var _a;
@@ -137,7 +136,9 @@ var TsCompiler = (function () {
                 }
                 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 }));
-                    return (0, compiler_utils_1.updateOutput)(fileContent, fileName, undefined);
+                    return {
+                        code: fileContent,
+                    };
                 }
             }
             if (!output.outputFiles.length) {
@@ -146,8 +147,13 @@ var TsCompiler = (function () {
                 }));
             }
             return this._compilerOptions.sourceMap
-                ? (0, compiler_utils_1.updateOutput)(output.outputFiles[1].text, fileName, output.outputFiles[0].text)
-                : (0, compiler_utils_1.updateOutput)(output.outputFiles[0].text, fileName, undefined);
+                ? {
+                    code: output.outputFiles[1].text,
+                    map: output.outputFiles[0].text,
+                }
+                : {
+                    code: output.outputFiles[0].text,
+                };
         }
         else {
             this._logger.debug({ fileName: fileName }, 'getCompiledOutput(): compiling as isolated module');
@@ -155,7 +161,10 @@ var TsCompiler = (function () {
             if (result.diagnostics && this.configSet.shouldReportDiagnostics(fileName)) {
                 this.configSet.raiseDiagnostics(result.diagnostics, fileName, this._logger);
             }
-            return (0, compiler_utils_1.updateOutput)(result.outputText, fileName, result.sourceMapText);
+            return {
+                code: result.outputText,
+                map: result.sourceMapText,
+            };
         }
     };
     TsCompiler.prototype._transpileOutput = function (fileContent, fileName) {

package/dist/{compiler → legacy/compiler}/ts-jest-compiler.d.ts

@@ -1,8 +1,9 @@
-import type { ConfigSet } from '../config';
-import type { CompilerInstance, StringMap, TsJestCompileOptions } from '../types';
+import type { TransformedSource } from '@jest/transform';
+import type { CompilerInstance, StringMap, TsJestCompileOptions } from '../../types';
+import type { ConfigSet } from '../config/config-set';
 export declare class TsJestCompiler implements CompilerInstance {
     private readonly _compilerInstance;
     constructor(configSet: ConfigSet, runtimeCacheFS: StringMap);
     getResolvedModules(fileContent: string, fileName: string, runtimeCacheFS: StringMap): string[];
-    getCompiledOutput(fileContent: string, fileName: string, options: TsJestCompileOptions): string;
+    getCompiledOutput(fileContent: string, fileName: string, options: TsJestCompileOptions): TransformedSource;
 }

package/dist/{config → legacy/config}/config-set.d.ts

@@ -1,7 +1,7 @@
 import { Logger } from 'bs-logger';
 import type * as ts from 'typescript';
-import type { RawCompilerOptions } from '../raw-compiler-options';
-import type { ProjectConfigTsJest, TsJestAstTransformer, TTypeScript } from '../types';
+import type { RawCompilerOptions } from '../../raw-compiler-options';
+import type { ProjectConfigTsJest, TsJestAstTransformer, TTypeScript } from '../../types';
 export declare class ConfigSet {
     readonly parentLogger?: Logger | undefined;
     readonly tsJestDigest: string;

package/dist/{config → legacy/config}/config-set.js

@@ -57,15 +57,15 @@ var path_1 = require("path");
 var bs_logger_1 = require("bs-logger");
 var jest_util_1 = require("jest-util");
 var json5_1 = __importDefault(require("json5"));
-var constants_1 = require("../constants");
-var utils_1 = require("../utils");
-var backports_1 = require("../utils/backports");
-var importer_1 = require("../utils/importer");
-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");
-exports.MY_DIGEST = (0, fs_1.readFileSync)((0, path_1.resolve)(__dirname, '..', '..', '.ts-jest-digest'), 'utf8');
+var constants_1 = require("../../constants");
+var utils_1 = require("../../utils");
+var backports_1 = require("../../utils/backports");
+var importer_1 = require("../../utils/importer");
+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");
+exports.MY_DIGEST = (0, fs_1.readFileSync)((0, path_1.resolve)(__dirname, '../../../.ts-jest-digest'), 'utf8');
 exports.IGNORE_DIAGNOSTIC_CODES = [
     6059,
     18002,
@@ -198,7 +198,7 @@ var ConfigSet = (function () {
             this.logger.debug({ babelConfig: this.babelConfig }, 'normalized babel config via ts-jest option');
             this.babelJestTransformer = importer_1.importer
                 .babelJest("Using \"babel-jest\" requires this package to be installed.")
-                .default.createTransformer(this.babelConfig);
+                .createTransformer(this.babelConfig);
             this.logger.debug('created babel-jest transformer');
         }
         var diagnosticsOpt = (_b = options.diagnostics) !== null && _b !== void 0 ? _b : true;
@@ -232,7 +232,7 @@ var ConfigSet = (function () {
         this.parsedTsConfig = this._getAndResolveTsConfig(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');
-        this.resolvedTransformers.before = [require('../transformers/hoist-jest')];
+        this.resolvedTransformers.before = [require('../../transformers/hoist-jest')];
         var astTransformers = options.astTransformers;
         if (astTransformers) {
             var resolveTransformerFunc_1 = function (transformerPath) {
@@ -372,8 +372,8 @@ var ConfigSet = (function () {
             _b);
         if (compilationTarget &&
             !this.babelConfig &&
-            ((nodeJsVer.startsWith('v10') && compilationTarget > this.compilerModule.ScriptTarget.ES2018) ||
-                (nodeJsVer.startsWith('v12') && compilationTarget > this.compilerModule.ScriptTarget.ES2019))) {
+            nodeJsVer.startsWith('v12') &&
+            compilationTarget > this.compilerModule.ScriptTarget.ES2019) {
             var message = (0, 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: TARGET_TO_VERSION_MAPPING[compilationTarget],

package/dist/legacy/index.d.ts

@@ -0,0 +1,5 @@
+import { TsJestTransformer } from './ts-jest-transformer';
+declare const _default: {
+    createTransformer: () => TsJestTransformer;
+};
+export default _default;

package/dist/legacy/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ts_jest_transformer_1 = require("./ts-jest-transformer");
+exports.default = {
+    createTransformer: function () { return new ts_jest_transformer_1.TsJestTransformer(); },
+};

package/dist/{ts-jest-transformer.d.ts → legacy/ts-jest-transformer.d.ts}

@@ -1,7 +1,6 @@
 import type { SyncTransformer, TransformedSource } from '@jest/transform';
-import type { Config } from '@jest/types';
-import { ConfigSet } from './config';
-import type { CompilerInstance, ProjectConfigTsJest, TransformOptionsTsJest } from './types';
+import type { CompilerInstance, ProjectConfigTsJest, TransformOptionsTsJest } from '../types';
+import { ConfigSet } from './config/config-set';
 export declare class TsJestTransformer implements SyncTransformer {
     private readonly _logger;
     protected _compiler: CompilerInstance;
@@ -13,8 +12,10 @@ export declare class TsJestTransformer implements SyncTransformer {
     private _configsFor;
     protected _createConfigSet(config: ProjectConfigTsJest | undefined): ConfigSet;
     protected _createCompiler(configSet: ConfigSet, cacheFS: Map<string, string>): void;
-    process(fileContent: string, filePath: Config.Path, transformOptions: TransformOptionsTsJest): TransformedSource | string;
-    processAsync(sourceText: string, sourcePath: Config.Path, transformOptions: TransformOptionsTsJest): Promise<TransformedSource | string>;
+    process(sourceText: string, sourcePath: string, transformOptions: TransformOptionsTsJest): TransformedSource;
+    processAsync(sourceText: string, sourcePath: string, transformOptions: TransformOptionsTsJest): Promise<TransformedSource>;
+    private processWithTs;
+    private runTsJestHook;
     getCacheKey(fileContent: string, filePath: string, transformOptions: TransformOptionsTsJest): string;
     getCacheKeyAsync(sourceText: string, sourcePath: string, transformOptions: TransformOptionsTsJest): Promise<string>;
     private _getFsCachedResolvedModules;

package/dist/{ts-jest-transformer.js → legacy/ts-jest-transformer.js}

@@ -78,14 +78,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TsJestTransformer = exports.CACHE_KEY_EL_SEPARATOR = void 0;
 var fs_1 = require("fs");
 var path_1 = __importDefault(require("path"));
+var constants_1 = require("../constants");
+var utils_1 = require("../utils");
+var importer_1 = require("../utils/importer");
+var messages_1 = require("../utils/messages");
+var sha1_1 = require("../utils/sha1");
+var version_checkers_1 = require("../utils/version-checkers");
 var compiler_1 = require("./compiler");
-var config_1 = require("./config");
-var constants_1 = require("./constants");
-var utils_1 = require("./utils");
-var importer_1 = require("./utils/importer");
-var messages_1 = require("./utils/messages");
-var sha1_1 = require("./utils/sha1");
-var version_checkers_1 = require("./utils/version-checkers");
+var config_set_1 = require("./config/config-set");
 exports.CACHE_KEY_EL_SEPARATOR = '\x00';
 var TsJestTransformer = (function () {
     function TsJestTransformer() {
@@ -128,7 +128,6 @@ var TsJestTransformer = (function () {
                 this._logger.info('no matching config-set found, creating a new one');
                 configSet = this._createConfigSet(config);
                 var jest_1 = __assign({}, config);
-                jest_1.name = undefined;
                 jest_1.cacheDirectory = undefined;
                 this._transformCfgStr = "".concat(new utils_1.JsonableValue(jest_1).serialized).concat(configSet.cacheSuffix);
                 this._createCompiler(configSet, cacheFS);
@@ -148,38 +147,80 @@ var TsJestTransformer = (function () {
         return configSet;
     };
     TsJestTransformer.prototype._createConfigSet = function (config) {
-        return new config_1.ConfigSet(config);
+        return new config_set_1.ConfigSet(config);
     };
     TsJestTransformer.prototype._createCompiler = function (configSet, cacheFS) {
         this._compiler = new compiler_1.TsJestCompiler(configSet, cacheFS);
     };
-    TsJestTransformer.prototype.process = function (fileContent, filePath, transformOptions) {
-        this._logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'processing', filePath);
-        var result;
+    TsJestTransformer.prototype.process = function (sourceText, sourcePath, transformOptions) {
+        this._logger.debug({ fileName: sourcePath, transformOptions: transformOptions }, 'processing', sourcePath);
         var configs = this._configsFor(transformOptions);
-        var shouldStringifyContent = configs.shouldStringifyContent(filePath);
+        var shouldStringifyContent = configs.shouldStringifyContent(sourcePath);
         var babelJest = shouldStringifyContent ? undefined : configs.babelJestTransformer;
-        var isDefinitionFile = filePath.endsWith(constants_1.DECLARATION_TYPE_EXT);
-        var isJsFile = constants_1.JS_JSX_REGEX.test(filePath);
-        var isTsFile = !isDefinitionFile && constants_1.TS_TSX_REGEX.test(filePath);
-        var hooksFile = process.env.TS_JEST_HOOKS;
-        var hooks;
-        if (hooksFile) {
-            hooksFile = path_1.default.resolve(configs.cwd, hooksFile);
-            hooks = importer_1.importer.tryTheseOr(hooksFile, {});
+        var result = this.processWithTs(sourceText, sourcePath, transformOptions);
+        if (babelJest) {
+            this._logger.debug({ fileName: sourcePath }, 'calling babel-jest processor');
+            result = babelJest.process(result.code, sourcePath, __assign(__assign({}, transformOptions), { instrument: false }));
         }
+        result = this.runTsJestHook(sourcePath, sourceText, transformOptions, result);
+        return result;
+    };
+    TsJestTransformer.prototype.processAsync = function (sourceText, sourcePath, transformOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                this._logger.debug({ fileName: sourcePath, transformOptions: transformOptions }, 'processing', sourcePath);
+                return [2, new Promise(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
+                        var configs, shouldStringifyContent, babelJest, result;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    configs = this._configsFor(transformOptions);
+                                    shouldStringifyContent = configs.shouldStringifyContent(sourcePath);
+                                    babelJest = shouldStringifyContent ? undefined : configs.babelJestTransformer;
+                                    result = this.processWithTs(sourceText, sourcePath, transformOptions);
+                                    if (!babelJest) return [3, 2];
+                                    this._logger.debug({ fileName: sourcePath }, 'calling babel-jest processor');
+                                    return [4, babelJest.processAsync(result.code, sourcePath, __assign(__assign({}, transformOptions), { instrument: false }))];
+                                case 1:
+                                    result = _a.sent();
+                                    _a.label = 2;
+                                case 2:
+                                    result = this.runTsJestHook(sourcePath, sourceText, transformOptions, result);
+                                    resolve(result);
+                                    return [2];
+                            }
+                        });
+                    }); })];
+            });
+        });
+    };
+    TsJestTransformer.prototype.processWithTs = function (sourceText, sourcePath, transformOptions) {
+        var result;
+        var configs = this._configsFor(transformOptions);
+        var shouldStringifyContent = configs.shouldStringifyContent(sourcePath);
+        var babelJest = shouldStringifyContent ? undefined : configs.babelJestTransformer;
+        var isDefinitionFile = sourcePath.endsWith(constants_1.DECLARATION_TYPE_EXT);
+        var isJsFile = constants_1.JS_JSX_REGEX.test(sourcePath);
+        var isTsFile = !isDefinitionFile && constants_1.TS_TSX_REGEX.test(sourcePath);
         if (shouldStringifyContent) {
-            result = "module.exports=".concat((0, utils_1.stringify)(fileContent));
+            result = {
+                code: "module.exports=".concat((0, utils_1.stringify)(sourceText)),
+            };
         }
         else if (isDefinitionFile) {
-            result = '';
+            result = {
+                code: '',
+            };
         }
         else if (!configs.parsedTsConfig.options.allowJs && isJsFile) {
-            this._logger.warn({ fileName: filePath }, (0, 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 = fileContent;
+            this._logger.warn({ fileName: sourcePath }, (0, 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: sourcePath }));
+            result = {
+                code: sourceText,
+            };
         }
         else if (isJsFile || isTsFile) {
-            result = this._compiler.getCompiledOutput(fileContent, filePath, {
+            result = this._compiler.getCompiledOutput(sourceText, sourcePath, {
                 depGraphs: this._depGraphs,
                 supportsStaticESM: transformOptions.supportsStaticESM,
                 watchMode: this._watchMode,
@@ -187,29 +228,28 @@ var TsJestTransformer = (function () {
         }
         else {
             var message = babelJest ? "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore. If you still want Babel to process it, add another entry to the `transform` option with value `babel-jest` which key matches this type of files." : "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore.";
-            this._logger.warn({ fileName: filePath }, (0, messages_1.interpolate)(message, { path: filePath }));
-            result = fileContent;
+            this._logger.warn({ fileName: sourcePath }, (0, messages_1.interpolate)(message, { path: sourcePath }));
+            result = {
+                code: sourceText,
+            };
         }
-        if (babelJest) {
-            this._logger.debug({ fileName: filePath }, 'calling babel-jest processor');
-            result = babelJest.process(result, filePath, __assign(__assign({}, transformOptions), { instrument: false }));
+        return result;
+    };
+    TsJestTransformer.prototype.runTsJestHook = function (sourcePath, sourceText, transformOptions, compiledOutput) {
+        var hooksFile = process.env.TS_JEST_HOOKS;
+        var hooks;
+        if (hooksFile) {
+            hooksFile = path_1.default.resolve(this._configsFor(transformOptions).cwd, hooksFile);
+            hooks = importer_1.importer.tryTheseOr(hooksFile, {});
         }
         if (hooks === null || hooks === void 0 ? void 0 : hooks.afterProcess) {
-            this._logger.debug({ fileName: filePath, hookName: 'afterProcess' }, 'calling afterProcess hook');
-            var newResult = hooks.afterProcess([fileContent, filePath, transformOptions.config, transformOptions], result);
+            this._logger.debug({ fileName: sourcePath, hookName: 'afterProcess' }, 'calling afterProcess hook');
+            var newResult = hooks.afterProcess([sourceText, sourcePath, transformOptions.config, transformOptions], compiledOutput);
             if (newResult) {
                 return newResult;
             }
         }
-        return result;
-    };
-    TsJestTransformer.prototype.processAsync = function (sourceText, sourcePath, transformOptions) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2, new Promise(function (resolve) { return resolve(_this.process(sourceText, sourcePath, transformOptions)); })];
-            });
-        });
+        return compiledOutput;
     };
     TsJestTransformer.prototype.getCacheKey = function (fileContent, filePath, transformOptions) {
         var _a;

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

@@ -1,3 +1,3 @@
 import type { Config } from '@jest/types';
 import type { TsJestPresets } from '../types';
-export declare function createJestPreset(allowJs?: boolean, extraOptions?: Config.InitialOptions): TsJestPresets;
+export declare function createJestPreset(legacy?: boolean, allowJs?: boolean, extraOptions?: Config.InitialOptions): TsJestPresets;

package/dist/presets/create-jest-preset.js

@@ -14,13 +14,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createJestPreset = void 0;
 var utils_1 = require("../utils");
 var logger = utils_1.rootLogger.child({ namespace: 'jest-preset' });
-function createJestPreset(allowJs, extraOptions) {
+function createJestPreset(legacy, allowJs, extraOptions) {
     var _a;
+    if (legacy === void 0) { legacy = false; }
     if (allowJs === void 0) { allowJs = false; }
     if (extraOptions === void 0) { extraOptions = {}; }
     logger.debug({ allowJs: allowJs }, 'creating jest presets', allowJs ? 'handling' : 'not handling', 'JavaScript files');
     var extensionsToTreatAsEsm = extraOptions.extensionsToTreatAsEsm, moduleFileExtensions = extraOptions.moduleFileExtensions, testMatch = extraOptions.testMatch;
     var supportESM = extensionsToTreatAsEsm === null || extensionsToTreatAsEsm === void 0 ? void 0 : extensionsToTreatAsEsm.length;
-    return __assign(__assign(__assign(__assign({}, (extensionsToTreatAsEsm ? { extensionsToTreatAsEsm: extensionsToTreatAsEsm } : undefined)), (moduleFileExtensions ? { moduleFileExtensions: moduleFileExtensions } : undefined)), (testMatch ? { testMatch: testMatch } : undefined)), { transform: __assign(__assign({}, extraOptions.transform), (_a = {}, _a[allowJs ? (supportESM ? '^.+\\.m?[tj]sx?$' : '^.+\\.[tj]sx?$') : '^.+\\.tsx?$'] = 'ts-jest', _a)) });
+    return __assign(__assign(__assign(__assign({}, (extensionsToTreatAsEsm ? { extensionsToTreatAsEsm: extensionsToTreatAsEsm } : undefined)), (moduleFileExtensions ? { moduleFileExtensions: moduleFileExtensions } : undefined)), (testMatch ? { testMatch: testMatch } : undefined)), { transform: __assign(__assign({}, extraOptions.transform), (_a = {}, _a[allowJs ? (supportESM ? '^.+\\.m?[tj]sx?$' : '^.+\\.[tj]sx?$') : '^.+\\.tsx?$'] = legacy
+            ? 'ts-jest/legacy'
+            : 'ts-jest', _a)) });
 }
 exports.createJestPreset = createJestPreset;

package/dist/transformers/hoist-jest.d.ts

@@ -1,5 +1,5 @@
 import type _ts from 'typescript';
 import type { TsCompilerInstance } from '../types';
-export declare const version = 3;
+export declare const version = 4;
 export declare const name = "hoist-jest";
 export declare function factory({ configSet }: TsCompilerInstance): (ctx: _ts.TransformationContext) => _ts.Transformer<_ts.SourceFile>;

package/dist/transformers/hoist-jest.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.factory = exports.name = exports.version = void 0;
 var bs_logger_1 = require("bs-logger");
-exports.version = 3;
+exports.version = 4;
 exports.name = 'hoist-jest';
 var HOIST_METHODS = ['mock', 'unmock', 'enableAutomock', 'disableAutomock', 'deepUnmock'];
 var JEST_GLOBALS_MODULE_NAME = '@jest/globals';
@@ -11,7 +11,6 @@ function factory(_a) {
     var configSet = _a.configSet;
     var logger = configSet.logger.child({ namespace: exports.name });
     var ts = configSet.compilerModule;
-    var tsFactory = ts.factory ? ts.factory : ts;
     var importNamesOfJestObj = [];
     var isJestGlobalImport = function (node) {
         return (ts.isImportDeclaration(node) &&
@@ -71,8 +70,8 @@ function factory(_a) {
         var visitor = function (node) {
             var resultNode = ts.visitEachChild(node, visitor, ctx);
             if (ts.isBlock(resultNode) && canHoistInBlockScope(resultNode)) {
-                var newNodeArrayStatements = tsFactory.createNodeArray(sortStatements(resultNode.statements));
-                return tsFactory.updateBlock(resultNode, newNodeArrayStatements);
+                var newNodeArrayStatements = ts.factory.createNodeArray(sortStatements(resultNode.statements));
+                return ts.factory.updateBlock(resultNode, newNodeArrayStatements);
             }
             else {
                 if (ts.isSourceFile(resultNode)) {
@@ -91,11 +90,9 @@ function factory(_a) {
                             }
                         }
                     });
-                    var newNodeArrayStatements = tsFactory.createNodeArray(sortStatements(resultNode.statements));
+                    var newNodeArrayStatements = ts.factory.createNodeArray(sortStatements(resultNode.statements));
                     importNamesOfJestObj.length = 0;
-                    return ts.factory
-                        ? ts.factory.updateSourceFile(resultNode, newNodeArrayStatements, resultNode.isDeclarationFile, resultNode.referencedFiles, resultNode.typeReferenceDirectives, resultNode.hasNoDefaultLib, resultNode.libReferenceDirectives)
-                        : ts.updateSourceFileNode(resultNode, newNodeArrayStatements, resultNode.isDeclarationFile, resultNode.referencedFiles, resultNode.typeReferenceDirectives, resultNode.hasNoDefaultLib, resultNode.libReferenceDirectives);
+                    return ts.factory.updateSourceFile(resultNode, newNodeArrayStatements, resultNode.isDeclarationFile, resultNode.referencedFiles, resultNode.typeReferenceDirectives, resultNode.hasNoDefaultLib, resultNode.libReferenceDirectives);
                 }
                 return resultNode;
             }

package/dist/types.d.ts

@@ -1,8 +1,9 @@
-import type { TransformOptions } from '@jest/transform';
+import type { TransformedSource, TransformOptions } from '@jest/transform';
 import type { Config } from '@jest/types';
+import type * as babelJest from 'babel-jest';
 import type * as _babel from 'babel__core';
 import type * as _ts from 'typescript';
-import type { ConfigSet } from './config';
+import type { ConfigSet } from './legacy/config/config-set';
 import type { RawCompilerOptions } from './raw-compiler-options';
 declare module '@jest/types' {
     namespace Config {
@@ -11,6 +12,7 @@ declare module '@jest/types' {
         }
     }
 }
+export declare type TBabelJest = typeof babelJest;
 export declare type TTypeScript = typeof _ts;
 export interface TEsBuild {
     transformSync(input: string, options?: {
@@ -41,7 +43,7 @@ export interface TsJestGlobalOptions {
     diagnostics?: boolean | {
         pretty?: boolean;
         ignoreCodes?: number | string | Array<number | string>;
-        exclude?: Config.Glob[];
+        exclude?: string[];
         warnOnly?: boolean;
     };
     babelConfig?: boolean | string | BabelConfig;
@@ -51,7 +53,7 @@ export interface TsJestGlobalOptions {
 export interface TsJestDiagnosticsCfg {
     pretty: boolean;
     ignoreCodes: number[];
-    exclude: Config.Glob[];
+    exclude: string[];
     throws: boolean;
     warnOnly?: boolean;
 }
@@ -79,7 +81,7 @@ export interface TsJestCompileOptions {
 }
 export interface CompilerInstance {
     getResolvedModules(fileContent: string, fileName: string, runtimeCacheFS: StringMap): string[];
-    getCompiledOutput(fileContent: string, fileName: string, options: TsJestCompileOptions): string;
+    getCompiledOutput(fileContent: string, fileName: string, options: TsJestCompileOptions): TransformedSource;
 }
 export interface TsCompilerInstance extends CompilerInstance {
     configSet: ConfigSet;

package/dist/utils/index.d.ts

@@ -1,4 +1,3 @@
 export * from './json';
 export * from './jsonable-value';
 export * from './logger';
-export type { MockedObject, MockedObjectDeep, MockedFunctionDeep, MockedFunction, MaybeMockedConstructor, MaybeMocked, MaybeMockedDeep, ConstructorArgumentsOf, MockableFunction, ArgumentsOf, MockWithArgs, PropertyKeysOf, MethodKeysOf, } from './testing';

package/dist/utils/version-checkers.js

@@ -7,9 +7,9 @@ var logger_1 = require("./logger");
 var messages_1 = require("./messages");
 var logger = logger_1.rootLogger.child({ namespace: 'versions' });
 exports.VersionCheckers = {
-    jest: createVersionChecker('jest', ">=27.0.0 <28"),
-    typescript: createVersionChecker('typescript', ">=3.8 <5"),
-    babelJest: createVersionChecker('babel-jest', ">=27.0.0 <28"),
+    jest: createVersionChecker('jest', ">=28.0.0 <29"),
+    typescript: createVersionChecker('typescript', ">=4.3 <5"),
+    babelJest: createVersionChecker('babel-jest', ">=28.0.0 <29"),
     babelCore: createVersionChecker('@babel/core', ">=7.0.0-beta.0 <8"),
 };
 function checkVersion(name, expectedRange, action) {

package/legacy.js

@@ -0,0 +1 @@
+module.exports = require('./dist/legacy')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-jest",
-  "version": "27.1.4",
+  "version": "28.0.0-next.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -53,19 +53,19 @@
   "dependencies": {
     "bs-logger": "0.x",
     "fast-json-stable-stringify": "2.x",
-    "jest-util": "^27.0.0",
+    "jest-util": "^28.0.0",
     "json5": "2.x",
     "lodash.memoize": "4.x",
     "make-error": "1.x",
     "semver": "7.x",
-    "yargs-parser": "20.x"
+    "yargs-parser": "^20.x"
   },
   "peerDependencies": {
     "@babel/core": ">=7.0.0-beta.0 <8",
     "@types/jest": "^27.0.0",
-    "babel-jest": ">=27.0.0 <28",
-    "jest": "^27.0.0",
-    "typescript": ">=3.8 <5.0"
+    "babel-jest": "^28.0.0",
+    "jest": "^28.0.0",
+    "typescript": ">=4.3"
   },
   "peerDependenciesMeta": {
     "@babel/core": {
@@ -91,8 +91,8 @@
   "devDependencies": {
     "@commitlint/cli": "16.x",
     "@commitlint/config-angular": "^16.0.0",
-    "@jest/transform": "^27.4.2",
-    "@jest/types": "^27.4.2",
+    "@jest/transform": "^28.0.0",
+    "@jest/types": "^28.0.0",
     "@types/babel__core": "7.x",
     "@types/cross-spawn": "latest",
     "@types/fs-extra": "latest",
@@ -102,9 +102,9 @@
     "@types/lodash.memoize": "4.x",
     "@types/lodash.set": "4.x",
     "@types/micromatch": "4.x",
-    "@types/node": "17.0.21",
+    "@types/node": "17.0.29",
     "@types/node-fetch": "^3.0.3",
-    "@types/react": "17.x",
+    "@types/react": "18.x",
     "@types/rimraf": "^3.0.2",
     "@types/semver": "latest",
     "@types/yargs": "latest",
@@ -123,10 +123,10 @@
     "eslint-plugin-prettier": "latest",
     "execa": "5.1.1",
     "fs-extra": "10.x",
-    "glob": "^7.1.7",
+    "glob": "^8.0.1",
     "glob-gitignore": "latest",
     "husky": "4.x",
-    "jest": "^27.4.3",
+    "jest": "^28.0.0",
     "jest-snapshot-serializer-raw": "^1.2.0",
     "js-yaml": "latest",
     "json-schema-to-typescript": "^10.1.4",
@@ -144,6 +144,6 @@
     ]
   },
   "engines": {
-    "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+    "node": "^12.13.0 || ^14.15.0 || ^16.13.0 || >=17.0.0"
   }
 }

package/presets/default-esm-legacy/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('..').defaultsESMLegacy

package/presets/default-legacy/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('..').defaultsLegacy

package/presets/index.d.ts

@@ -2,10 +2,16 @@ import type { TsJestPresets } from '../dist'
 
 declare const _default: {
     defaults: TsJestPresets;
+    defaultsLegacy: TsJestPresets;
     defaultsESM: TsJestPresets;
+    defaultsESMLegacy: TsJestPresets;
     jsWithTs: TsJestPresets;
+    jsWithTsLegacy: TsJestPresets;
     jsWithTsESM: TsJestPresets;
+    jsWithTsESMLegacy: TsJestPresets;
     jsWithBabel: TsJestPresets;
+    jsWithBabelLegacy: TsJestPresets;
     jsWithBabelESM: TsJestPresets;
+    jsWithBabelESMLegacy: TsJestPresets;
 };
 export = _default;

package/presets/index.js

@@ -5,24 +5,55 @@ module.exports = {
   get defaults() {
     return createJestPreset()
   },
+  get defaultsLegacy() {
+    return createJestPreset(true, false)
+  },
   get defaultsESM() {
-    return createJestPreset(false, { extensionsToTreatAsEsm: TS_EXT_TO_TREAT_AS_ESM })
+    return createJestPreset(false, false, { extensionsToTreatAsEsm: TS_EXT_TO_TREAT_AS_ESM })
+  },
+  get defaultsESMLegacy() {
+    return createJestPreset(true, false, { extensionsToTreatAsEsm: TS_EXT_TO_TREAT_AS_ESM })
   },
   get jsWithTs() {
-    return createJestPreset(true)
+    return createJestPreset(false, true)
+  },
+  get jsWithTsLegacy() {
+    return createJestPreset(true, true)
   },
   get jsWithTsESM() {
-    return createJestPreset(true, { extensionsToTreatAsEsm: [...JS_EXT_TO_TREAT_AS_ESM, ...TS_EXT_TO_TREAT_AS_ESM] })
+    return createJestPreset(false, true, {
+      extensionsToTreatAsEsm: [...JS_EXT_TO_TREAT_AS_ESM, ...TS_EXT_TO_TREAT_AS_ESM],
+    })
+  },
+  get jsWithTsESMLegacy() {
+    return createJestPreset(true, true, {
+      extensionsToTreatAsEsm: [...JS_EXT_TO_TREAT_AS_ESM, ...TS_EXT_TO_TREAT_AS_ESM],
+    })
   },
   get jsWithBabel() {
-    return createJestPreset(false, {
+    return createJestPreset(false, false, {
+      transform: {
+        '^.+\\.jsx?$': 'babel-jest',
+      },
+    })
+  },
+  get jsWithBabelLegacy() {
+    return createJestPreset(true, false, {
       transform: {
         '^.+\\.jsx?$': 'babel-jest',
       },
     })
   },
   get jsWithBabelESM() {
-    return createJestPreset(false, {
+    return createJestPreset(false, false, {
+      extensionsToTreatAsEsm: [...JS_EXT_TO_TREAT_AS_ESM, ...TS_EXT_TO_TREAT_AS_ESM],
+      transform: {
+        '^.+\\.m?[j]sx?$': 'babel-jest',
+      },
+    })
+  },
+  get jsWithBabelESMLegacy() {
+    return createJestPreset(true, false, {
       extensionsToTreatAsEsm: [...JS_EXT_TO_TREAT_AS_ESM, ...TS_EXT_TO_TREAT_AS_ESM],
       transform: {
         '^.+\\.m?[j]sx?$': 'babel-jest',

package/presets/js-with-babel-esm-legacy/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('..').jsWithBabelESMLegacy

package/presets/js-with-babel-legacy/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('..').jsWithBabelLegacy

package/presets/js-with-ts-esm-legacy/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('..').jsWithTsESMLegacy

package/presets/js-with-ts-legacy/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('..').jsWithTsLegacy

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

@@ -1,2 +0,0 @@
-export declare const SOURCE_MAPPING_PREFIX = "sourceMappingURL=";
-export declare function updateOutput(outputText: string, normalizedFileName: string, sourceMap: string | undefined): string;

package/dist/compiler/compiler-utils.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateOutput = exports.SOURCE_MAPPING_PREFIX = void 0;
-var utils_1 = require("../utils");
-exports.SOURCE_MAPPING_PREFIX = 'sourceMappingURL=';
-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);
-        return (outputText.slice(0, outputText.lastIndexOf(exports.SOURCE_MAPPING_PREFIX) + exports.SOURCE_MAPPING_PREFIX.length) +
-            sourceMapContent);
-    }
-    else {
-        return outputText;
-    }
-}
-exports.updateOutput = updateOutput;
-var updateSourceMap = function (sourceMapText, normalizedFileName) {
-    var sourceMap = JSON.parse(sourceMapText);
-    sourceMap.file = normalizedFileName;
-    sourceMap.sources = [normalizedFileName];
-    delete sourceMap.sourceRoot;
-    return (0, utils_1.stringify)(sourceMap);
-};

package/dist/transformers/path-mapping.d.ts

@@ -1,5 +0,0 @@
-import type * as _ts from 'typescript';
-import type { TsCompilerInstance } from '../types';
-export declare const version = 2;
-export declare const name = "path-mapping";
-export declare function factory({ configSet, }: TsCompilerInstance): (ctx: _ts.TransformationContext) => _ts.Transformer<_ts.SourceFile>;

package/dist/transformers/path-mapping.js

@@ -1,129 +0,0 @@
-"use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.factory = exports.name = exports.version = void 0;
-var path_1 = require("path");
-var bs_logger_1 = require("bs-logger");
-exports.version = 2;
-exports.name = 'path-mapping';
-var isBaseDir = function (base, dir) { var _a; return !((_a = (0, path_1.relative)(base, dir)) === null || _a === void 0 ? void 0 : _a.startsWith('.')); };
-function factory(_a) {
-    var _b;
-    var configSet = _a.configSet;
-    var logger = configSet.logger.child({ namespace: exports.name });
-    logger.warn('path-mapping AST transformer is deprecated and will be removed in `ts-jest` v28. Please use an alternative one, like https://github.com/LeDDGroup/typescript-transform-paths instead');
-    var ts = configSet.compilerModule;
-    var tsFactory = ts.factory ? ts.factory : ts;
-    var compilerOptions = configSet.parsedTsConfig.options;
-    var rootDirs = (_b = compilerOptions.rootDirs) === null || _b === void 0 ? void 0 : _b.filter(path_1.isAbsolute);
-    var isDynamicImport = function (node) {
-        return ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword;
-    };
-    var isRequire = function (node) {
-        return ts.isCallExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            node.expression.text === 'require' &&
-            ts.isStringLiteral(node.arguments[0]) &&
-            node.arguments.length === 1;
-    };
-    var createVisitor = function (ctx, sf) {
-        var fileName = sf.fileName;
-        var fileDir = (0, path_1.normalize)((0, path_1.dirname)(fileName));
-        var rewritePath = function (importPath) {
-            var e_1, _a;
-            var p = importPath;
-            var resolvedModule = ts.resolveModuleName(importPath, fileName, compilerOptions, ts.sys).resolvedModule;
-            if (resolvedModule) {
-                var resolvedFileName = resolvedModule.resolvedFileName;
-                var filePath = fileDir;
-                var modulePath = (0, path_1.dirname)(resolvedFileName);
-                if (rootDirs) {
-                    var fileRootDir = '';
-                    var moduleRootDir = '';
-                    try {
-                        for (var rootDirs_1 = __values(rootDirs), rootDirs_1_1 = rootDirs_1.next(); !rootDirs_1_1.done; rootDirs_1_1 = rootDirs_1.next()) {
-                            var rootDir = rootDirs_1_1.value;
-                            if (isBaseDir(rootDir, resolvedFileName) && rootDir.length > moduleRootDir.length)
-                                moduleRootDir = rootDir;
-                            if (isBaseDir(rootDir, fileName) && rootDir.length > fileRootDir.length)
-                                fileRootDir = rootDir;
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (rootDirs_1_1 && !rootDirs_1_1.done && (_a = rootDirs_1.return)) _a.call(rootDirs_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                    if (fileRootDir && moduleRootDir) {
-                        filePath = (0, path_1.relative)(fileRootDir, filePath);
-                        modulePath = (0, path_1.relative)(moduleRootDir, modulePath);
-                    }
-                }
-                p = (0, path_1.normalize)((0, path_1.join)((0, path_1.relative)(filePath, modulePath), (0, path_1.basename)(resolvedFileName)));
-                p = p.startsWith('.') ? p : "./".concat(p);
-            }
-            return p;
-        };
-        var visitor = function (node) {
-            var rewrittenPath;
-            var newNode = ts.getMutableClone(node);
-            if (isDynamicImport(node) || isRequire(node)) {
-                rewrittenPath = rewritePath(node.arguments[0].text);
-                var argumentArrays = tsFactory.createNodeArray([tsFactory.createStringLiteral(rewrittenPath)]);
-                return ts.factory
-                    ? ts.factory.updateCallExpression(node, node.expression, node.typeArguments, argumentArrays)
-                    : ts.updateCall(node, node.expression, node.typeArguments, argumentArrays);
-            }
-            if (ts.isExternalModuleReference(node) && ts.isStringLiteral(node.expression)) {
-                rewrittenPath = rewritePath(node.expression.text);
-                return tsFactory.updateExternalModuleReference(newNode, tsFactory.createStringLiteral(rewrittenPath));
-            }
-            if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
-                rewrittenPath = rewritePath(node.moduleSpecifier.text);
-                return +ts.versionMajorMinor >= 4.5
-                    ? tsFactory.updateImportDeclaration(node, node.decorators, node.modifiers, node.importClause, tsFactory.createStringLiteral(rewrittenPath), node.assertClause)
-                    :
-                        tsFactory.updateImportDeclaration(node, node.decorators, node.modifiers, node.importClause, tsFactory.createStringLiteral(rewrittenPath));
-            }
-            if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
-                rewrittenPath = rewritePath(node.moduleSpecifier.text);
-                var stringLiteralNode = tsFactory.createStringLiteral(rewrittenPath);
-                if (ts.factory) {
-                    return +ts.versionMajorMinor >= 4.5
-                        ? ts.factory.updateExportDeclaration(node, node.decorators, node.modifiers, node.isTypeOnly, node.exportClause, stringLiteralNode, node.assertClause)
-                        :
-                            ts.factory.updateExportDeclaration(node, node.decorators, node.modifiers, node.isTypeOnly, node.exportClause, stringLiteralNode);
-                }
-                else {
-                    return ts.updateExportDeclaration(node, node.decorators, node.modifiers, node.exportClause, stringLiteralNode, node.isTypeOnly);
-                }
-            }
-            if (ts.isImportTypeNode(node) &&
-                ts.isLiteralTypeNode(node.argument) &&
-                ts.isStringLiteral(node.argument.literal)) {
-                rewrittenPath = rewritePath(node.argument.literal.text);
-                var importArguments = tsFactory.createLiteralTypeNode(tsFactory.createStringLiteral(rewrittenPath));
-                return tsFactory.updateImportTypeNode(node, importArguments, node.qualifier, node.typeArguments, node.isTypeOf);
-            }
-            return ts.visitEachChild(node, visitor, ctx);
-        };
-        return visitor;
-    };
-    return function (ctx) {
-        var _a;
-        return logger.wrap((_a = {}, _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.debug, _a.call = null, _a), 'visitSourceFileNode(): path mapping', function (sf) { return ts.visitNode(sf, createVisitor(ctx, sf)); });
-    };
-}
-exports.factory = factory;

package/dist/utils/testing.d.ts

@@ -1,33 +0,0 @@
-/// <reference types="jest" />
-export declare type MockableFunction = (...args: any[]) => any;
-export declare type MethodKeysOf<T> = {
-    [K in keyof T]: T[K] extends MockableFunction ? K : never;
-}[keyof T];
-export declare type PropertyKeysOf<T> = {
-    [K in keyof T]: T[K] extends MockableFunction ? never : K;
-}[keyof T];
-export declare type ArgumentsOf<T> = T extends (...args: infer A) => any ? A : never;
-export declare type ConstructorArgumentsOf<T> = T extends new (...args: infer A) => any ? A : never;
-export interface MockWithArgs<T extends MockableFunction> extends jest.MockInstance<ReturnType<T>, ArgumentsOf<T>> {
-    new (...args: ConstructorArgumentsOf<T>): T;
-    (...args: ArgumentsOf<T>): ReturnType<T>;
-}
-export declare type MaybeMockedConstructor<T> = T extends new (...args: any[]) => infer R ? jest.MockInstance<R, ConstructorArgumentsOf<T>> : T;
-export declare type MockedFunction<T extends MockableFunction> = MockWithArgs<T> & {
-    [K in keyof T]: T[K];
-};
-export declare type MockedFunctionDeep<T extends MockableFunction> = MockWithArgs<T> & MockedObjectDeep<T>;
-export declare type MockedObject<T> = MaybeMockedConstructor<T> & {
-    [K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFunction<T[K]> : T[K];
-} & {
-    [K in PropertyKeysOf<T>]: T[K];
-};
-export declare type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
-    [K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFunctionDeep<T[K]> : T[K];
-} & {
-    [K in PropertyKeysOf<T>]: MaybeMockedDeep<T[K]>;
-};
-export declare type MaybeMockedDeep<T> = T extends MockableFunction ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
-export declare type MaybeMocked<T> = T extends MockableFunction ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
-export declare function mocked<T>(item: T, deep?: false): MaybeMocked<T>;
-export declare function mocked<T>(item: T, deep: true): MaybeMockedDeep<T>;

package/dist/utils/testing.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mocked = void 0;
-function mocked(item, _deep) {
-    if (_deep === void 0) { _deep = false; }
-    return item;
-}
-exports.mocked = mocked;

package/utils/index.d.ts

@@ -1,3 +0,0 @@
-export { pathsToModuleNameMapper } from '../dist/config/paths-to-module-name-mapper'
-export { createJestPreset } from '../dist/presets/create-jest-preset'
-export { mocked } from '../dist/utils/testing'

package/utils/index.js

@@ -1,28 +0,0 @@
-const { pathsToModuleNameMapper } = require('../dist/config/paths-to-module-name-mapper')
-const { createJestPreset } = require('../dist/presets/create-jest-preset')
-const { mocked } = require('../dist/utils/testing')
-
-module.exports = {
-  get mocked() {
-    if (!process.env.DISABLE_MOCKED_WARNING) {
-      console.warn(
-        '\n`mocked` util function is now deprecated and has been moved to Jest repository,' +
-          ' see https://github.com/facebook/jest/pull/12089. In `ts-jest` v28.0.0, `mocked` function will be completely removed.' +
-          ' Users are encouraged to use to Jest v27.4.0 or above to have `mocked` function available from `jest-mock`. ' +
-          'One can disable this warning by setting environment variable process.env.DISABLE_MOCKED_WARNING=true\n'
-      )
-    }
-
-    return mocked
-  },
-  get createJestPreset() {
-    console.warn('ts-jest[main] (WARN) Replace any occurrences of "ts-jest/utils" with just "ts-jest".')
-
-    return createJestPreset
-  },
-  get pathsToModuleNameMapper() {
-    console.warn('ts-jest[main] (WARN) Replace any occurrences of "ts-jest/utils" with just "ts-jest".')
-
-    return pathsToModuleNameMapper
-  },
-}