ts-jest 29.1.5 → 29.2.1

package/dist/constants.js

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_JEST_TEST_MATCH = exports.JS_EXT_TO_TREAT_AS_ESM = exports.TS_EXT_TO_TREAT_AS_ESM = exports.JS_JSX_REGEX = exports.TS_TSX_REGEX = exports.JS_JSX_EXTENSIONS = exports.DECLARATION_TYPE_EXT = exports.LINE_FEED = void 0;
+exports.JEST_CONFIG_EJS_TEMPLATE = exports.DEFAULT_JEST_TEST_MATCH = exports.JS_EXT_TO_TREAT_AS_ESM = exports.TS_EXT_TO_TREAT_AS_ESM = exports.ESM_JS_TRANSFORM_PATTERN = exports.JS_TRANSFORM_PATTERN = exports.ESM_TS_JS_TRANSFORM_PATTERN = exports.TS_JS_TRANSFORM_PATTERN = exports.ESM_TS_TRANSFORM_PATTERN = exports.TS_TRANSFORM_PATTERN = exports.JS_JSX_REGEX = exports.TS_TSX_REGEX = exports.JS_JSX_EXTENSIONS = exports.DECLARATION_TYPE_EXT = exports.LINE_FEED = void 0;
 exports.LINE_FEED = '\n';
 exports.DECLARATION_TYPE_EXT = '.d.ts';
 exports.JS_JSX_EXTENSIONS = ['.js', '.jsx'];
 exports.TS_TSX_REGEX = /\.[cm]?tsx?$/;
 exports.JS_JSX_REGEX = /\.[cm]?jsx?$/;
+exports.TS_TRANSFORM_PATTERN = '^.+.tsx?$';
+exports.ESM_TS_TRANSFORM_PATTERN = '^.+\\.m?tsx?$';
+exports.TS_JS_TRANSFORM_PATTERN = '^.+.[tj]sx?$';
+exports.ESM_TS_JS_TRANSFORM_PATTERN = '^.+\\.m?[tj]sx?$';
+exports.JS_TRANSFORM_PATTERN = '^.+.jsx?$';
+exports.ESM_JS_TRANSFORM_PATTERN = '^.+\\.m?jsx?$';
 // `extensionsToTreatAsEsm` will throw error with `.mjs`
 exports.TS_EXT_TO_TREAT_AS_ESM = ['.ts', '.tsx', '.mts'];
 exports.JS_EXT_TO_TREAT_AS_ESM = ['.jsx'];
@@ -14,3 +20,7 @@ exports.JS_EXT_TO_TREAT_AS_ESM = ['.jsx'];
  * See https://jestjs.io/docs/en/configuration#testmatch-arraystring
  */
 exports.DEFAULT_JEST_TEST_MATCH = ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[jt]s?(x)'];
+/**
+ * @internal
+ */
+exports.JEST_CONFIG_EJS_TEMPLATE = "/** @type {import('ts-jest').JestConfigWithTsJest} **/\n<%= exportKind %> {\n  testEnvironment: \"<%= testEnvironment %>\",\n  transform: {\n    \"<%= transformPattern %>\": <%- transformValue %>,\n  },\n};";

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { TsJestTransformer } from './legacy/ts-jest-transformer';
-import type { TsJestGlobalOptions } from './types';
+import type { TsJestTransformerOptions } from './types';
 export * from './config';
 export * from './constants';
 export * from './legacy/compiler';
@@ -10,6 +10,6 @@ export * from './raw-compiler-options';
 export * from './utils';
 export * from './types';
 declare const _default: {
-    createTransformer(tsJestConfig?: TsJestGlobalOptions): TsJestTransformer;
+    createTransformer(tsJestConfig?: TsJestTransformerOptions): TsJestTransformer;
 };
 export default _default;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateOutput = exports.SOURCE_MAPPING_PREFIX = void 0;
+exports.SOURCE_MAPPING_PREFIX = void 0;
+exports.updateOutput = updateOutput;
 var utils_1 = require("../../utils");
 /**
  * Rely on TypeScript compiled output generation which contains this prefix to point to sourcemap location.
@@ -19,7 +20,6 @@ function updateOutput(outputText, normalizedFileName, sourceMap) {
     }
     return outputText;
 }
-exports.updateOutput = updateOutput;
 /**
  * Update the source map contents for improved output.
  */

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

@@ -21,6 +21,7 @@ export declare class TsCompiler implements TsCompilerInstance {
     program: Program | undefined;
     constructor(configSet: ConfigSet, runtimeCacheFS: StringMap);
     getResolvedModules(fileContent: string, fileName: string, runtimeCacheFS: StringMap): string[];
+    private fixupCompilerOptionsForModuleKind;
     getCompiledOutput(fileContent: string, fileName: string, options: TsJestCompileOptions): CompiledOutput;
     protected _transpileOutput(fileContent: string, fileName: string): TranspileOutput;
     protected _makeTransformers(customTransformers: TsJestAstTransformer): CustomTransformers;

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

@@ -112,29 +112,31 @@ var TsCompiler = /** @class */ (function () {
         });
         return importedModulePaths;
     };
+    TsCompiler.prototype.fixupCompilerOptionsForModuleKind = function (compilerOptions, isEsm) {
+        var _a, _b;
+        if (!isEsm) {
+            var moduleKind_1 = (_a = compilerOptions.module) !== null && _a !== void 0 ? _a : this._ts.ModuleKind.CommonJS;
+            var moduleKindValue = [
+                this._ts.ModuleKind.CommonJS,
+                this._ts.ModuleKind.Node16,
+                this._ts.ModuleKind.NodeNext,
+            ].includes(moduleKind_1)
+                ? moduleKind_1
+                : this._ts.ModuleKind.CommonJS;
+            return __assign(__assign({}, compilerOptions), { module: moduleKindValue });
+        }
+        var moduleKind = (_b = compilerOptions.module) !== null && _b !== void 0 ? _b : this._ts.ModuleKind.ESNext;
+        var esModuleInterop = [this._ts.ModuleKind.Node16, this._ts.ModuleKind.NodeNext].includes(moduleKind)
+            ? true
+            : compilerOptions.esModuleInterop;
+        return __assign(__assign({}, compilerOptions), { module: moduleKind, esModuleInterop: esModuleInterop !== null && esModuleInterop !== void 0 ? esModuleInterop : false });
+    };
     TsCompiler.prototype.getCompiledOutput = function (fileContent, fileName, options) {
         var e_1, _a;
         var moduleKind = this._initialCompilerOptions.module;
-        var esModuleInterop = this._initialCompilerOptions.esModuleInterop;
-        var allowSyntheticDefaultImports = this._initialCompilerOptions.allowSyntheticDefaultImports;
         var currentModuleKind = this._compilerOptions.module;
         var isEsmMode = this.configSet.useESM && options.supportsStaticESM;
-        if ((this.configSet.babelJestTransformer || (!this.configSet.babelJestTransformer && options.supportsStaticESM)) &&
-            this.configSet.useESM) {
-            moduleKind =
-                !moduleKind ||
-                    (moduleKind &&
-                        ![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;
-        }
-        else {
-            moduleKind = this._ts.ModuleKind.CommonJS;
-        }
-        this._compilerOptions = __assign(__assign({}, this._compilerOptions), { allowSyntheticDefaultImports: allowSyntheticDefaultImports, esModuleInterop: esModuleInterop, module: moduleKind });
+        this._compilerOptions = this.fixupCompilerOptionsForModuleKind(this._initialCompilerOptions, isEsmMode);
         if (this._languageService) {
             this._logger.debug({ fileName: fileName }, 'getCompiledOutput(): compiling using language service');
             // Must set memory cache before attempting to compile

package/dist/legacy/config/config-set.js

@@ -107,8 +107,8 @@ exports.MY_DIGEST = (0, fs_1.readFileSync)((0, path_1.resolve)(__dirname, '../..
  * @internal
  */
 exports.IGNORE_DIAGNOSTIC_CODES = [
-    6059,
-    18002,
+    6059, // "'rootDir' is expected to contain all source files."
+    18002, // "The 'files' list in config file is empty."
     18003, // "No inputs were found in config file."
 ];
 /**
@@ -184,13 +184,13 @@ var ConfigSet = /** @class */ (function () {
             inlineSourceMap: false,
             // we don't want to create declaration files
             declaration: false,
-            noEmit: false,
+            noEmit: false, // set to true will make compiler API not emit any compiled results.
             // else istanbul related will be dropped
             removeComments: false,
             // to clear out else it's buggy
             out: undefined,
             outFile: undefined,
-            composite: undefined,
+            composite: undefined, // see https://github.com/TypeStrong/ts-node/pull/657/files
             declarationDir: undefined,
             declarationMap: undefined,
             emitDeclarationOnly: undefined,
@@ -419,8 +419,13 @@ var ConfigSet = /** @class */ (function () {
             ? this.compilerModule.ModuleKind.CommonJS
             : this.compilerModule.ModuleKind.ESNext;
         var moduleValue = (_c = finalOptions.module) !== null && _c !== void 0 ? _c : defaultModule;
+        var warningModulesForEsmInterop = [
+            this.compilerModule.ModuleKind.CommonJS,
+            this.compilerModule.ModuleKind.Node16,
+            this.compilerModule.ModuleKind.NodeNext,
+        ];
         if (!this.babelConfig &&
-            moduleValue !== this.compilerModule.ModuleKind.CommonJS &&
+            !warningModulesForEsmInterop.includes(moduleValue) &&
             !(finalOptions.esModuleInterop || finalOptions.allowSyntheticDefaultImports)) {
             result.errors.push({
                 code: 151001 /* DiagnosticCodes.ConfigModuleOption */,
@@ -430,11 +435,6 @@ var ConfigSet = /** @class */ (function () {
                 start: undefined,
                 length: undefined,
             });
-            // at least enable synthetic default imports (except if it's set in the input config)
-            /* istanbul ignore next (already covered in unit test) */
-            if (!('allowSyntheticDefaultImports' in finalOptions)) {
-                finalOptions.allowSyntheticDefaultImports = true;
-            }
         }
         // Make sure when allowJs is enabled, outDir is required to have when using allowJs: true
         if (finalOptions.allowJs && !finalOptions.outDir) {

package/dist/legacy/index.d.ts

@@ -1,6 +1,6 @@
-import type { TsJestGlobalOptions } from '../types';
+import type { TsJestTransformerOptions } from '../types';
 import { TsJestTransformer } from './ts-jest-transformer';
 declare const _default: {
-    createTransformer: (tsJestConfig?: TsJestGlobalOptions) => TsJestTransformer;
+    createTransformer: (tsJestConfig?: TsJestTransformerOptions) => TsJestTransformer;
 };
 export default _default;

package/dist/legacy/index.js

@@ -2,5 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var ts_jest_transformer_1 = require("./ts-jest-transformer");
 exports.default = {
-    createTransformer: function (tsJestConfig) { return new ts_jest_transformer_1.TsJestTransformer(tsJestConfig); },
+    createTransformer: function (tsJestConfig) {
+        return new ts_jest_transformer_1.TsJestTransformer(tsJestConfig);
+    },
 };

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

@@ -2,13 +2,13 @@ import type { SyncTransformer, TransformedSource } from '@jest/transform';
 import type { CompilerInstance, TsJestTransformerOptions, TsJestTransformOptions } from '../types';
 import { ConfigSet } from './config/config-set';
 export declare class TsJestTransformer implements SyncTransformer<TsJestTransformerOptions> {
-    private readonly tsJestConfig?;
+    private readonly transformerOptions?;
     private readonly _logger;
     protected _compiler: CompilerInstance;
     private _transformCfgStr;
     private _depGraphs;
     private _watchMode;
-    constructor(tsJestConfig?: import("../types").TsJestGlobalOptions | undefined);
+    constructor(transformerOptions?: TsJestTransformerOptions | undefined);
     private _configsFor;
     protected _createConfigSet(config: TsJestTransformOptions['config'] | undefined): ConfigSet;
     protected _createCompiler(configSet: ConfigSet, cacheFS: Map<string, string>): void;

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

@@ -90,9 +90,9 @@ var config_set_1 = require("./config/config-set");
  * @internal
  */
 exports.CACHE_KEY_EL_SEPARATOR = '\x00';
-var TsJestTransformer = exports.TsJestTransformer = /** @class */ (function () {
-    function TsJestTransformer(tsJestConfig) {
-        this.tsJestConfig = tsJestConfig;
+var TsJestTransformer = /** @class */ (function () {
+    function TsJestTransformer(transformerOptions) {
+        this.transformerOptions = transformerOptions;
         this._depGraphs = new Map();
         this._watchMode = false;
         this._logger = utils_1.rootLogger.child({ namespace: 'ts-jest-transformer' });
@@ -139,12 +139,12 @@ var TsJestTransformer = exports.TsJestTransformer = /** @class */ (function () {
                 // create the new record in the index
                 this._logger.info('no matching config-set found, creating a new one');
                 if ((_a = config.globals) === null || _a === void 0 ? void 0 : _a['ts-jest']) {
-                    this._logger.warn("Define `ts-jest` config under `globals` is deprecated. Please do\ntransform: {\n    <transform_regex>: ['ts-jest', { /* ts-jest config goes here in Jest */ }],\n}," /* Deprecations.GlobalsTsJestConfigOption */);
+                    this._logger.warn("Define `ts-jest` config under `globals` is deprecated. Please do\ntransform: {\n    <transform_regex>: ['ts-jest', { /* ts-jest config goes here in Jest */ }],\n},\nSee more at https://kulshekhar.github.io/ts-jest/docs/getting-started/presets#advanced" /* Deprecations.GlobalsTsJestConfigOption */);
                 }
                 var jestGlobalsConfig = (_b = config.globals) !== null && _b !== void 0 ? _b : {};
                 var tsJestGlobalsConfig = (_c = jestGlobalsConfig['ts-jest']) !== null && _c !== void 0 ? _c : {};
-                var migratedConfig = this.tsJestConfig
-                    ? __assign(__assign({}, config), { globals: __assign(__assign({}, jestGlobalsConfig), { 'ts-jest': __assign(__assign({}, tsJestGlobalsConfig), this.tsJestConfig) }) }) : config;
+                var migratedConfig = this.transformerOptions
+                    ? __assign(__assign({}, config), { globals: __assign(__assign({}, jestGlobalsConfig), { 'ts-jest': __assign(__assign({}, tsJestGlobalsConfig), this.transformerOptions) }) }) : config;
                 configSet = this._createConfigSet(migratedConfig);
                 var jest_1 = __assign({}, migratedConfig);
                 // we need to remove some stuff from jest config
@@ -192,9 +192,9 @@ var TsJestTransformer = exports.TsJestTransformer = /** @class */ (function () {
         return result;
     };
     TsJestTransformer.prototype.processAsync = function (sourceText, sourcePath, transformOptions) {
-        var _a;
         return __awaiter(this, void 0, void 0, function () {
             var configs, shouldStringifyContent, babelJest, result, processWithTsResult;
+            var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -297,11 +297,10 @@ var TsJestTransformer = exports.TsJestTransformer = /** @class */ (function () {
      */
     TsJestTransformer.prototype.getCacheKey = function (fileContent, filePath, transformOptions) {
         var _a;
-        var _b;
         var configs = this._configsFor(transformOptions);
         this._logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'computing cache key for', filePath);
         // we do not instrument, ensure it is false all the time
-        var supportsStaticESM = transformOptions.supportsStaticESM, instrument = (_a = transformOptions.instrument, _a === void 0 ? false : _a);
+        var supportsStaticESM = transformOptions.supportsStaticESM, _b = transformOptions.instrument, instrument = _b === void 0 ? false : _b;
         var constructingCacheKeyElements = [
             this._transformCfgStr,
             exports.CACHE_KEY_EL_SEPARATOR,
@@ -317,7 +316,7 @@ var TsJestTransformer = exports.TsJestTransformer = /** @class */ (function () {
         ];
         if (!configs.isolatedModules && configs.tsCacheDir) {
             var resolvedModuleNames = void 0;
-            if (((_b = this._depGraphs.get(filePath)) === null || _b === void 0 ? void 0 : _b.fileContent) === fileContent) {
+            if (((_a = this._depGraphs.get(filePath)) === null || _a === void 0 ? void 0 : _a.fileContent) === fileContent) {
                 this._logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'getting resolved modules from disk caching or memory caching for', filePath);
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 resolvedModuleNames = this._depGraphs
@@ -353,3 +352,4 @@ var TsJestTransformer = exports.TsJestTransformer = /** @class */ (function () {
     TsJestTransformer._cachedConfigSets = [];
     return TsJestTransformer;
 }());
+exports.TsJestTransformer = TsJestTransformer;

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

@@ -1,3 +1,18 @@
 import type { Config } from '@jest/types';
-import type { TsJestPresets } from '../types';
+import { DefaultEsmLegacyPreset, DefaultEsmPreset, DefaultEsmTransformOptions, DefaultLegacyPreset, DefaultPreset, DefaultTransformOptions, JsWithBabelEsmLegacyPreset, JsWithBabelEsmPreset, JsWithBabelEsmTransformOptions, JsWithBabelLegacyPreset, JsWithBabelPreset, JsWithBabelTransformerOptions, JsWithTsEsmLegacyPreset, JsWithTsEsmPreset, JsWithTsEsmTransformOptions, JsWithTsLegacyPreset, JsWithTsPreset, JsWithTsTransformOptions, TsJestPresets } from '../types';
+/**
+ * @deprecated use other functions below instead
+ */
 export declare function createJestPreset(legacy?: boolean, allowJs?: boolean, extraOptions?: Config.InitialOptions): TsJestPresets;
+export declare function createDefaultPreset(tsJestTransformOptions?: DefaultTransformOptions): DefaultPreset;
+export declare function createDefaultLegacyPreset(tsJestTransformOptions?: DefaultTransformOptions): DefaultLegacyPreset;
+export declare function createJsWithTsPreset(tsJestTransformOptions?: JsWithTsTransformOptions): JsWithTsPreset;
+export declare function createJsWithTsLegacyPreset(tsJestTransformOptions?: JsWithTsTransformOptions): JsWithTsLegacyPreset;
+export declare function createJsWithBabelPreset(tsJestTransformOptions?: JsWithBabelTransformerOptions): JsWithBabelPreset;
+export declare function createJsWithBabelLegacyPreset(tsJestTransformOptions?: JsWithBabelTransformerOptions): JsWithBabelLegacyPreset;
+export declare function createDefaultEsmPreset(tsJestTransformOptions?: DefaultEsmTransformOptions): DefaultEsmPreset;
+export declare function createDefaultEsmLegacyPreset(tsJestTransformOptions?: DefaultEsmTransformOptions): DefaultEsmLegacyPreset;
+export declare function createJsWithTsEsmPreset(tsJestTransformOptions?: JsWithTsEsmTransformOptions): JsWithTsEsmPreset;
+export declare function createJsWithTsEsmLegacyPreset(tsJestTransformOptions?: JsWithTsEsmTransformOptions): JsWithTsEsmLegacyPreset;
+export declare function createJsWithBabelEsmPreset(tsJestTransformOptions?: JsWithBabelEsmTransformOptions): JsWithBabelEsmPreset;
+export declare function createJsWithBabelEsmLegacyPreset(tsJestTransformOptions?: JsWithBabelEsmTransformOptions): JsWithBabelEsmLegacyPreset;

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

@@ -10,10 +10,51 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createJestPreset = void 0;
+exports.createJestPreset = createJestPreset;
+exports.createDefaultPreset = createDefaultPreset;
+exports.createDefaultLegacyPreset = createDefaultLegacyPreset;
+exports.createJsWithTsPreset = createJsWithTsPreset;
+exports.createJsWithTsLegacyPreset = createJsWithTsLegacyPreset;
+exports.createJsWithBabelPreset = createJsWithBabelPreset;
+exports.createJsWithBabelLegacyPreset = createJsWithBabelLegacyPreset;
+exports.createDefaultEsmPreset = createDefaultEsmPreset;
+exports.createDefaultEsmLegacyPreset = createDefaultEsmLegacyPreset;
+exports.createJsWithTsEsmPreset = createJsWithTsEsmPreset;
+exports.createJsWithTsEsmLegacyPreset = createJsWithTsEsmLegacyPreset;
+exports.createJsWithBabelEsmPreset = createJsWithBabelEsmPreset;
+exports.createJsWithBabelEsmLegacyPreset = createJsWithBabelEsmLegacyPreset;
+var constants_1 = require("../constants");
 var utils_1 = require("../utils");
 var logger = utils_1.rootLogger.child({ namespace: 'jest-preset' });
+/**
+ * @deprecated use other functions below instead
+ */
 function createJestPreset(legacy, allowJs, extraOptions) {
     var _a;
     if (legacy === void 0) { legacy = false; }
@@ -27,4 +68,151 @@ function createJestPreset(legacy, allowJs, extraOptions) {
             ? ['ts-jest/legacy', tsJestTransformOptions]
             : ['ts-jest', tsJestTransformOptions], _a)) });
 }
-exports.createJestPreset = createJestPreset;
+function createDefaultPreset(tsJestTransformOptions) {
+    var _a;
+    if (tsJestTransformOptions === void 0) { tsJestTransformOptions = {}; }
+    logger.debug('creating default CJS Jest preset');
+    return {
+        transform: (_a = {},
+            _a[constants_1.TS_TRANSFORM_PATTERN] = ['ts-jest', tsJestTransformOptions],
+            _a),
+    };
+}
+function createDefaultLegacyPreset(tsJestTransformOptions) {
+    var _a;
+    if (tsJestTransformOptions === void 0) { tsJestTransformOptions = {}; }
+    logger.debug('creating default CJS Jest preset');
+    return {
+        transform: (_a = {},
+            _a[constants_1.TS_TRANSFORM_PATTERN] = ['ts-jest/legacy', tsJestTransformOptions],
+            _a),
+    };
+}
+function createJsWithTsPreset(tsJestTransformOptions) {
+    var _a;
+    if (tsJestTransformOptions === void 0) { tsJestTransformOptions = {}; }
+    logger.debug('creating Js with Ts CJS Jest preset');
+    return {
+        transform: (_a = {},
+            _a[constants_1.TS_JS_TRANSFORM_PATTERN] = ['ts-jest', tsJestTransformOptions],
+            _a),
+    };
+}
+function createJsWithTsLegacyPreset(tsJestTransformOptions) {
+    var _a;
+    if (tsJestTransformOptions === void 0) { tsJestTransformOptions = {}; }
+    logger.debug('creating Js with Ts CJS Jest preset');
+    return {
+        transform: (_a = {},
+            _a[constants_1.TS_JS_TRANSFORM_PATTERN] = ['ts-jest/legacy', tsJestTransformOptions],
+            _a),
+    };
+}
+function createJsWithBabelPreset(tsJestTransformOptions) {
+    var _a;
+    if (tsJestTransformOptions === void 0) { tsJestTransformOptions = {}; }
+    logger.debug('creating JS with Babel CJS Jest preset');
+    return {
+        transform: (_a = {},
+            _a[constants_1.JS_TRANSFORM_PATTERN] = 'babel-jest',
+            _a[constants_1.TS_TRANSFORM_PATTERN] = ['ts-jest', tsJestTransformOptions],
+            _a),
+    };
+}
+function createJsWithBabelLegacyPreset(tsJestTransformOptions) {
+    var _a;
+    if (tsJestTransformOptions === void 0) { tsJestTransformOptions = {}; }
+    logger.debug('creating JS with Babel CJS Jest preset');
+    return {
+        transform: (_a = {},
+            _a[constants_1.JS_TRANSFORM_PATTERN] = 'babel-jest',
+            _a[constants_1.TS_TRANSFORM_PATTERN] = ['ts-jest/legacy', tsJestTransformOptions],
+            _a),
+    };
+}
+function createDefaultEsmPreset(tsJestTransformOptions) {
+    var _a;
+    if (tsJestTransformOptions === void 0) { tsJestTransformOptions = {}; }
+    logger.debug('creating default ESM Jest preset');
+    return {
+        extensionsToTreatAsEsm: __spreadArray(__spreadArray([], __read(constants_1.JS_EXT_TO_TREAT_AS_ESM), false), __read(constants_1.TS_EXT_TO_TREAT_AS_ESM), false),
+        transform: (_a = {},
+            _a[constants_1.ESM_TS_TRANSFORM_PATTERN] = [
+                'ts-jest',
+                __assign(__assign({}, tsJestTransformOptions), { useESM: true }),
+            ],
+            _a),
+    };
+}
+function createDefaultEsmLegacyPreset(tsJestTransformOptions) {
+    var _a;
+    if (tsJestTransformOptions === void 0) { tsJestTransformOptions = {}; }
+    logger.debug('creating default ESM Jest preset');
+    return {
+        extensionsToTreatAsEsm: __spreadArray(__spreadArray([], __read(constants_1.JS_EXT_TO_TREAT_AS_ESM), false), __read(constants_1.TS_EXT_TO_TREAT_AS_ESM), false),
+        transform: (_a = {},
+            _a[constants_1.ESM_TS_TRANSFORM_PATTERN] = [
+                'ts-jest/legacy',
+                __assign(__assign({}, tsJestTransformOptions), { useESM: true }),
+            ],
+            _a),
+    };
+}
+function createJsWithTsEsmPreset(tsJestTransformOptions) {
+    var _a;
+    if (tsJestTransformOptions === void 0) { tsJestTransformOptions = {}; }
+    logger.debug('creating Js with Ts ESM Jest preset');
+    return {
+        extensionsToTreatAsEsm: __spreadArray(__spreadArray([], __read(constants_1.JS_EXT_TO_TREAT_AS_ESM), false), __read(constants_1.TS_EXT_TO_TREAT_AS_ESM), false),
+        transform: (_a = {},
+            _a[constants_1.ESM_TS_JS_TRANSFORM_PATTERN] = [
+                'ts-jest',
+                __assign(__assign({}, tsJestTransformOptions), { useESM: true }),
+            ],
+            _a),
+    };
+}
+function createJsWithTsEsmLegacyPreset(tsJestTransformOptions) {
+    var _a;
+    if (tsJestTransformOptions === void 0) { tsJestTransformOptions = {}; }
+    logger.debug('creating Js with Ts ESM Jest preset');
+    return {
+        extensionsToTreatAsEsm: __spreadArray(__spreadArray([], __read(constants_1.JS_EXT_TO_TREAT_AS_ESM), false), __read(constants_1.TS_EXT_TO_TREAT_AS_ESM), false),
+        transform: (_a = {},
+            _a[constants_1.ESM_TS_JS_TRANSFORM_PATTERN] = [
+                'ts-jest/legacy',
+                __assign(__assign({}, tsJestTransformOptions), { useESM: true }),
+            ],
+            _a),
+    };
+}
+function createJsWithBabelEsmPreset(tsJestTransformOptions) {
+    var _a;
+    if (tsJestTransformOptions === void 0) { tsJestTransformOptions = {}; }
+    logger.debug('creating JS with Babel ESM Jest preset');
+    return {
+        extensionsToTreatAsEsm: __spreadArray(__spreadArray([], __read(constants_1.JS_EXT_TO_TREAT_AS_ESM), false), __read(constants_1.TS_EXT_TO_TREAT_AS_ESM), false),
+        transform: (_a = {},
+            _a[constants_1.ESM_JS_TRANSFORM_PATTERN] = 'babel-jest',
+            _a[constants_1.ESM_TS_TRANSFORM_PATTERN] = [
+                'ts-jest',
+                __assign(__assign({}, tsJestTransformOptions), { useESM: true }),
+            ],
+            _a),
+    };
+}
+function createJsWithBabelEsmLegacyPreset(tsJestTransformOptions) {
+    var _a;
+    if (tsJestTransformOptions === void 0) { tsJestTransformOptions = {}; }
+    logger.debug('creating JS with Babel ESM Jest preset');
+    return {
+        extensionsToTreatAsEsm: __spreadArray(__spreadArray([], __read(constants_1.JS_EXT_TO_TREAT_AS_ESM), false), __read(constants_1.TS_EXT_TO_TREAT_AS_ESM), false),
+        transform: (_a = {},
+            _a[constants_1.ESM_JS_TRANSFORM_PATTERN] = 'babel-jest',
+            _a[constants_1.ESM_TS_TRANSFORM_PATTERN] = [
+                'ts-jest/legacy',
+                __assign(__assign({}, tsJestTransformOptions), { useESM: true }),
+            ],
+            _a),
+    };
+}