ts-jest 29.1.5 → 29.2.0

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),
+    };
+}