@depup/ts-jest 29.4.6-depup.0

package/dist/transpilers/typescript/transpile-module.d.ts

@@ -0,0 +1,8 @@
+import ts from 'typescript';
+type ExtendedTranspileOptions = Omit<ts.TranspileOptions, 'transformers'> & {
+    transformers?: (program: ts.Program) => ts.CustomTransformers;
+};
+type ExtendedTsTranspileModuleFn = (fileContent: string, transpileOptions: ExtendedTranspileOptions) => ts.TranspileOutput;
+export declare const isModernNodeModuleKind: (module: ts.ModuleKind | undefined) => boolean;
+export declare const tsTranspileModule: ExtendedTsTranspileModuleFn;
+export {};

package/dist/transpilers/typescript/transpile-module.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsTranspileModule = exports.isModernNodeModuleKind = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const utils_1 = require("../../utils");
+const barebonesLibContent = `/// <reference no-default-lib="true"/>
+interface Boolean {}
+interface Function {}
+interface CallableFunction {}
+interface NewableFunction {}
+interface IArguments {}
+interface Number {}
+interface Object {}
+interface RegExp {}
+interface String {}
+interface Array<T> { length: number; [n: number]: T; }
+interface SymbolConstructor {
+    (desc?: string | number): symbol;
+    for(name: string): symbol;
+    readonly toStringTag: symbol;
+}
+declare var Symbol: SymbolConstructor;
+interface Symbol {
+    readonly [Symbol.toStringTag]: string;
+}`;
+const barebonesLibName = 'lib.d.ts';
+let barebonesLibSourceFile;
+const carriageReturnLineFeed = '\r\n';
+const lineFeed = '\n';
+function getNewLineCharacter(options) {
+    switch (options.newLine) {
+        case typescript_1.default.NewLineKind.CarriageReturnLineFeed:
+            return carriageReturnLineFeed;
+        case typescript_1.default.NewLineKind.LineFeed:
+        default:
+            return lineFeed;
+    }
+}
+const isModernNodeModuleKind = (module) => {
+    return module
+        ? [typescript_1.default.ModuleKind.Node16, /* ModuleKind.Node18 */ 101, /* ModuleKind.Node20 */ 102, typescript_1.default.ModuleKind.NodeNext].includes(module)
+        : false;
+};
+exports.isModernNodeModuleKind = isModernNodeModuleKind;
+const shouldCheckProjectPkgJsonContent = (fileName, moduleKind) => {
+    return fileName.endsWith('package.json') && (0, exports.isModernNodeModuleKind)(moduleKind);
+};
+/**
+ * Copy source code of {@link ts.transpileModule} from {@link https://github.com/microsoft/TypeScript/blob/main/src/services/transpile.ts}
+ * with extra modifications:
+ * - Remove generation of declaration files
+ * - Allow using custom AST transformers with the internal created {@link Program}
+ */
+const transpileWorker = (input, transpileOptions) => {
+    if (!barebonesLibSourceFile) {
+        barebonesLibSourceFile = typescript_1.default.createSourceFile(barebonesLibName, barebonesLibContent, {
+            languageVersion: typescript_1.default.ScriptTarget.Latest,
+        });
+    }
+    const diagnostics = [];
+    const options = transpileOptions.compilerOptions
+        ? // @ts-expect-error internal TypeScript API
+            typescript_1.default.fixupCompilerOptions(transpileOptions.compilerOptions, diagnostics)
+        : {};
+    // mix in default options
+    const defaultOptions = typescript_1.default.getDefaultCompilerOptions();
+    for (const key in defaultOptions) {
+        if (Object.hasOwn(defaultOptions, key) && options[key] === undefined) {
+            options[key] = defaultOptions[key];
+        }
+    }
+    // @ts-expect-error internal TypeScript API
+    for (const option of typescript_1.default.transpileOptionValueCompilerOptions) {
+        // Do not set redundant config options if `verbatimModuleSyntax` was supplied.
+        if (options.verbatimModuleSyntax && new Set(['isolatedModules']).has(option.name)) {
+            continue;
+        }
+        options[option.name] = option.transpileOptionValue;
+    }
+    // transpileModule does not write anything to disk so there is no need to verify that there are no conflicts between input and output paths.
+    options.suppressOutputPathCheck = true;
+    // Filename can be non-ts file.
+    options.allowNonTsExtensions = true;
+    options.declaration = false;
+    options.declarationMap = false;
+    const newLine = getNewLineCharacter(options);
+    // if jsx is specified then treat file as .tsx
+    const inputFileName = transpileOptions.fileName ?? (transpileOptions.compilerOptions?.jsx ? 'module.tsx' : 'module.ts');
+    // Create a compilerHost object to allow the compiler to read and write files
+    const compilerHost = {
+        getSourceFile: (fileName) => {
+            // @ts-expect-error internal TypeScript API
+            if (fileName === typescript_1.default.normalizePath(inputFileName)) {
+                return sourceFile;
+            }
+            // @ts-expect-error internal TypeScript API
+            return fileName === typescript_1.default.normalizePath(barebonesLibName) ? barebonesLibSourceFile : undefined;
+        },
+        writeFile: (name, text) => {
+            if (node_path_1.default.extname(name) === '.map') {
+                sourceMapText = text;
+            }
+            else {
+                outputText = text;
+            }
+        },
+        getDefaultLibFileName: () => barebonesLibName,
+        useCaseSensitiveFileNames: () => false,
+        getCanonicalFileName: (fileName) => fileName,
+        getCurrentDirectory: () => '',
+        getNewLine: () => newLine,
+        fileExists: (fileName) => {
+            if (shouldCheckProjectPkgJsonContent(fileName, options.module)) {
+                return typescript_1.default.sys.fileExists(fileName);
+            }
+            return fileName === inputFileName;
+        },
+        readFile: (fileName) => {
+            if (shouldCheckProjectPkgJsonContent(fileName, options.module)) {
+                return typescript_1.default.sys.readFile(fileName);
+            }
+            return '';
+        },
+        directoryExists: () => true,
+        getDirectories: () => [],
+    };
+    const sourceFile = typescript_1.default.createSourceFile(inputFileName, input, {
+        languageVersion: options.target ?? typescript_1.default.ScriptTarget.ESNext,
+        impliedNodeFormat: typescript_1.default.getImpliedNodeFormatForFile(inputFileName, 
+        /*packageJsonInfoCache*/ undefined, compilerHost, options),
+        // @ts-expect-error internal TypeScript API
+        setExternalModuleIndicator: typescript_1.default.getSetExternalModuleIndicator(options),
+        jsDocParsingMode: transpileOptions.jsDocParsingMode ?? typescript_1.default.JSDocParsingMode.ParseAll,
+    });
+    if (transpileOptions.moduleName) {
+        sourceFile.moduleName = transpileOptions.moduleName;
+    }
+    if (transpileOptions.renamedDependencies) {
+        // @ts-expect-error internal TypeScript API
+        sourceFile.renamedDependencies = new Map(Object.entries(transpileOptions.renamedDependencies));
+    }
+    // Output
+    let outputText;
+    let sourceMapText;
+    const inputs = [inputFileName];
+    const program = typescript_1.default.createProgram(inputs, options, compilerHost);
+    if (transpileOptions.reportDiagnostics) {
+        diagnostics.push(...program.getSyntacticDiagnostics(sourceFile));
+    }
+    diagnostics.push(...program.getOptionsDiagnostics());
+    // Emit
+    const result = program.emit(
+    /*targetSourceFile*/ undefined, 
+    /*writeFile*/ undefined, 
+    /*cancellationToken*/ undefined, 
+    /*emitOnlyDtsFiles*/ undefined, transpileOptions.transformers?.(program));
+    diagnostics.push(...result.diagnostics);
+    if (outputText === undefined) {
+        diagnostics.push({
+            category: typescript_1.default.DiagnosticCategory.Error,
+            code: utils_1.TsJestDiagnosticCodes.Generic,
+            messageText: 'No output generated',
+            file: sourceFile,
+            start: 0,
+            length: 0,
+        });
+    }
+    return { outputText: outputText ?? '', diagnostics, sourceMapText };
+};
+exports.tsTranspileModule = transpileWorker;

package/dist/types.d.ts

@@ -0,0 +1,282 @@
+import type { TransformedSource, TransformOptions } from '@jest/transform';
+import type { Config } from '@jest/types';
+import type * as _babel from 'babel__core';
+import type * as _ts from 'typescript';
+import type { TsConfigCompilerOptionsJson } from './config/types';
+import { ESM_JS_TRANSFORM_PATTERN, ESM_TS_JS_TRANSFORM_PATTERN, ESM_TS_TRANSFORM_PATTERN, JS_TRANSFORM_PATTERN, TS_JS_TRANSFORM_PATTERN, TS_TRANSFORM_PATTERN } from './constants';
+import type { ConfigSet } from './legacy/config/config-set';
+import type { RawCompilerOptions } from './raw-compiler-options';
+export type TTypeScript = typeof _ts;
+/**
+ * Don't mark as internal because it is used in TsJestGlobalOptions which is an exposed type
+ */
+export type BabelConfig = _babel.TransformOptions;
+export interface AstTransformer<T = Record<string, unknown>> {
+    path: string;
+    options?: T;
+}
+export interface ConfigCustomTransformer {
+    before?: Array<string | AstTransformer>;
+    after?: Array<string | AstTransformer>;
+    afterDeclarations?: Array<string | AstTransformer>;
+}
+/**
+ * @deprecated use {@link TsJestTransformerOptions} instead
+ */
+export type TsJestGlobalOptions = Config.TransformerConfig[1] & {
+    /**
+     * Compiler options. It can be:
+     * - `true` (or `undefined`, it's the default): use default tsconfig file
+     * - `false`: do NOT use default config file
+     * - `path/to/tsconfig.json`: path to a specific tsconfig file (<rootDir> can be used)
+     * - `{...}`: an object with inline compiler options
+     *
+     * @default `undefined` (the default config file will be used if it exists)
+     *
+     * @remarks
+     *
+     * {@link RawCompilerOptions} will be replaced with {@link TsConfigCompilerOptionsJson} in the next major release
+     */
+    tsconfig?: boolean | string | RawCompilerOptions | TsConfigCompilerOptionsJson;
+    /**
+     * @deprecated use {@link TsConfigCompilerOptionsJson.isolatedModules} instead
+     *
+     * Compiles files as isolated modules (disables some features)
+     *
+     * @default `undefined` (disables transpiling files with {@link _ts.transpileModule})
+     */
+    isolatedModules?: boolean;
+    /**
+     * Compiler to use
+     *
+     * @default `typescript`
+     */
+    compiler?: 'typescript' | 'ttypescript' | string;
+    /**
+     * Custom transformers (mostly used by jest presets)
+     */
+    astTransformers?: ConfigCustomTransformer;
+    /**
+     * TS diagnostics - less to be reported if `isolatedModules` is `true`. It can be:
+     * - `true` (or `undefined`, it's the default): show all diagnostics
+     * - `false`: hide diagnostics of all files (kind of useless)
+     * - `{...}`: an inline object with fine grained settings
+     *
+     * @default `undefined`
+     */
+    diagnostics?: boolean | {
+        /**
+         * Enables colorful and pretty output of errors
+         *
+         * @default `undefined` (enables formatting errors)
+         */
+        pretty?: boolean;
+        /**
+         * List of TypeScript diagnostic error codes to ignore
+         * [here](https://github.com/Microsoft/TypeScript/blob/master/src/compiler/diagnosticMessages.json).
+         *
+         * @see https://github.com/Microsoft/TypeScript/blob/master/src/compiler/diagnosticMessages.json
+         * @default `[6059,18002,18003]`
+         */
+        ignoreCodes?: number | string | Array<number | string>;
+        /**
+         * If specified, diagnostics of source files which path **matches** will be ignored
+         */
+        exclude?: string[];
+        /**
+         * Logs TypeScript errors to stderr instead of throwing exceptions
+         *
+         * @default `undefined` (TypeScript errors will be thrown as exceptions)
+         */
+        warnOnly?: boolean;
+    };
+    /**
+     * Babel config. It can be:
+     * - `false` (or `undefined`, it's the default): do NOT use babel
+     * - `true`: use babel using default babelrc file
+     * - `path/to/.babelrc`: path to a babelrc file (<rootDir> can be used)
+     * - `{...}`: an object with inline babel options
+     *
+     * @default `undefined` (not using `Babel`)
+     */
+    babelConfig?: boolean | string | BabelConfig;
+    /**
+     * Kept for backward compatibility to handle __TRANSFORM_HTML__
+     * Any file which will match this regex will be transpiled as a module
+     * exporting the content of the file as a string
+     */
+    stringifyContentPathRegex?: string | RegExp;
+    /**
+     * Tell `ts-jest` to transform codes to ESM format. This only works in combination with `jest-runtime` ESM option
+     * `supportsStaticESM` true which is passed into Jest transformer
+     */
+    useESM?: boolean;
+};
+/**
+ * For transformers which extends `ts-jest`
+ * @deprecated use `JestConfigWithTsJest` instead
+ */
+export interface ProjectConfigTsJest extends Config.ProjectConfig {
+    globals: GlobalConfigTsJest;
+}
+/**
+ * @deprecated use `JestConfigWithTsJest` instead
+ */
+export interface TransformOptionsTsJest<TransformerConfig = unknown> extends TransformOptions<TransformerConfig> {
+    config: Config.ProjectConfig;
+}
+/**
+ * For typings in `jest.config.ts`
+ * @deprecated use `JestConfigWithTsJest` instead
+ */
+export interface GlobalConfigTsJest extends Config.ConfigGlobals {
+    'ts-jest'?: TsJestGlobalOptions;
+}
+/**
+ * @deprecated use `JestConfigWithTsJest` instead
+ */
+export interface InitialOptionsTsJest extends Config.InitialOptions {
+    globals?: GlobalConfigTsJest;
+}
+export type TsJestTransformerOptions = TsJestGlobalOptions;
+export type TsJestTransformOptions = TransformOptions<TsJestTransformerOptions>;
+export interface JestConfigWithTsJest extends Omit<Config.InitialOptions, 'transform'> {
+    transform?: {
+        [regex: string]: 'ts-jest' | 'ts-jest/legacy' | ['ts-jest', TsJestTransformerOptions] | ['ts-jest/legacy', TsJestTransformerOptions];
+    } | Config.InitialOptions['transform'];
+}
+export type StringMap = Map<string, string>;
+export interface DepGraphInfo {
+    fileContent: string;
+    resolvedModuleNames: string[];
+}
+export interface TsJestCompileOptions {
+    depGraphs: Map<string, DepGraphInfo>;
+    watchMode: boolean;
+    supportsStaticESM: boolean;
+}
+export interface CompiledOutput extends TransformedSource {
+    diagnostics?: _ts.Diagnostic[];
+}
+export interface CompilerInstance {
+    getResolvedModules(fileContent: string, fileName: string, runtimeCacheFS: StringMap): string[];
+    getCompiledOutput(fileContent: string, fileName: string, options: TsJestCompileOptions): CompiledOutput;
+}
+export interface TsCompilerInstance extends CompilerInstance {
+    configSet: ConfigSet;
+    program: _ts.Program | undefined;
+}
+export interface AstTransformerDesc<T = Record<string, unknown>> {
+    name: string;
+    version: number;
+    factory(tsCompiler: TsCompilerInstance, opts?: T): _ts.TransformerFactory<_ts.SourceFile> | _ts.TransformerFactory<_ts.Bundle | _ts.SourceFile>;
+    options?: T;
+}
+export interface TsJestAstTransformer {
+    before: AstTransformerDesc[];
+    after: AstTransformerDesc[];
+    afterDeclarations: AstTransformerDesc[];
+}
+/**
+ * @deprecated use other preset types below instead
+ */
+export type TsJestPresets = Pick<JestConfigWithTsJest, 'extensionsToTreatAsEsm' | 'moduleFileExtensions' | 'transform' | 'testMatch'>;
+export type DefaultTransformOptions = Omit<TsJestTransformerOptions, 'useESM'>;
+export type DefaultPreset = {
+    transform: {
+        [TS_TRANSFORM_PATTERN]: ['ts-jest', DefaultTransformOptions];
+    };
+};
+export type DefaultLegacyPreset = {
+    transform: {
+        [TS_TRANSFORM_PATTERN]: ['ts-jest/legacy', DefaultTransformOptions];
+    };
+};
+export type DefaultEsmTransformOptions = Omit<TsJestTransformerOptions, 'useESM'>;
+export type DefaultEsmPreset = {
+    extensionsToTreatAsEsm: string[];
+    transform: {
+        [ESM_TS_TRANSFORM_PATTERN]: ['ts-jest', {
+            useESM: true;
+        } & DefaultEsmTransformOptions];
+    };
+};
+export type DefaultEsmLegacyPreset = {
+    extensionsToTreatAsEsm: string[];
+    transform: {
+        [ESM_TS_TRANSFORM_PATTERN]: ['ts-jest/legacy', {
+            useESM: true;
+        } & DefaultEsmTransformOptions];
+    };
+};
+export type JsWithTsTransformOptions = Omit<TsJestTransformerOptions, 'useESM'>;
+export type JsWithTsPreset = {
+    transform: {
+        [TS_JS_TRANSFORM_PATTERN]: ['ts-jest', JsWithTsTransformOptions];
+    };
+};
+export type JsWithTsLegacyPreset = {
+    transform: {
+        [TS_JS_TRANSFORM_PATTERN]: ['ts-jest/legacy', JsWithTsTransformOptions];
+    };
+};
+export type JsWithTsEsmTransformOptions = Omit<TsJestTransformerOptions, 'useESM'>;
+export type JsWithTsEsmPreset = {
+    extensionsToTreatAsEsm: string[];
+    transform: {
+        [ESM_TS_JS_TRANSFORM_PATTERN]: ['ts-jest', {
+            useESM: true;
+        } & JsWithTsEsmTransformOptions];
+    };
+};
+export type JsWithTsEsmLegacyPreset = {
+    extensionsToTreatAsEsm: string[];
+    transform: {
+        [ESM_TS_JS_TRANSFORM_PATTERN]: ['ts-jest/legacy', {
+            useESM: true;
+        } & JsWithTsEsmTransformOptions];
+    };
+};
+export type JsWithBabelTransformerOptions = Omit<TsJestTransformerOptions, 'useESM'>;
+export type JsWithBabelPreset = {
+    transform: {
+        [JS_TRANSFORM_PATTERN]: 'babel-jest';
+        [TS_TRANSFORM_PATTERN]: ['ts-jest', JsWithBabelTransformerOptions];
+    };
+};
+export type JsWithBabelLegacyPreset = {
+    transform: {
+        [JS_TRANSFORM_PATTERN]: 'babel-jest';
+        [TS_TRANSFORM_PATTERN]: ['ts-jest/legacy', JsWithBabelTransformerOptions];
+    };
+};
+export type JsWithBabelEsmTransformOptions = Omit<TsJestTransformerOptions, 'useESM'>;
+export type JsWithBabelEsmPreset = {
+    extensionsToTreatAsEsm: string[];
+    transform: {
+        [ESM_JS_TRANSFORM_PATTERN]: 'babel-jest';
+        [ESM_TS_TRANSFORM_PATTERN]: ['ts-jest', {
+            useESM: true;
+        } & JsWithBabelEsmTransformOptions];
+    };
+};
+export type JsWithBabelEsmLegacyPreset = {
+    extensionsToTreatAsEsm: string[];
+    transform: {
+        [ESM_JS_TRANSFORM_PATTERN]: 'babel-jest';
+        [ESM_TS_TRANSFORM_PATTERN]: ['ts-jest/legacy', {
+            useESM: true;
+        } & JsWithBabelEsmTransformOptions];
+    };
+};
+declare module '@jest/types' {
+    namespace Config {
+        interface ConfigGlobals {
+            /**
+             * strangely `@ts-expect-error` doesn't work in this case when running
+             * `npm run build` vs `npm run pretest`
+             */
+            'ts-jest'?: TsJestTransformerOptions;
+        }
+    }
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");

package/dist/utils/backports.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/backports.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backportTsJestDebugEnvVar = exports.backportJestConfig = void 0;
+const bs_logger_1 = require("bs-logger");
+const messages_1 = require("./messages");
+const context = { [bs_logger_1.LogContexts.namespace]: 'backports' };
+/**
+ * @internal
+ */
+const backportJestConfig = (logger, config) => {
+    logger.debug({ ...context, config }, 'backporting config');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const { globals = {} } = (config || {});
+    const { 'ts-jest': tsJest = {} } = globals;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const mergeTsJest = {};
+    let hadWarnings = false;
+    const warnConfig = (oldPath, newPath, note) => {
+        hadWarnings = true;
+        logger.warn(context, (0, messages_1.interpolate)(note ? "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.\n    \u21B3 {{note}}" /* Deprecations.ConfigOptionWithNote */ : "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead." /* Deprecations.ConfigOption */, {
+            oldPath,
+            newPath,
+            note,
+        }));
+    };
+    if ('__TS_CONFIG__' in globals) {
+        warnConfig('globals.__TS_CONFIG__', 'globals.ts-jest.tsconfig');
+        if (typeof globals.__TS_CONFIG__ === 'object') {
+            mergeTsJest.tsconfig = globals.__TS_CONFIG__;
+        }
+        delete globals.__TS_CONFIG__;
+    }
+    if ('__TRANSFORM_HTML__' in globals) {
+        warnConfig('globals.__TRANSFORM_HTML__', 'globals.ts-jest.stringifyContentPathRegex');
+        if (globals.__TRANSFORM_HTML__) {
+            mergeTsJest.stringifyContentPathRegex = '\\.html?$';
+        }
+        delete globals.__TRANSFORM_HTML__;
+    }
+    if ('typeCheck' in tsJest) {
+        warnConfig('globals.ts-jest.typeCheck', 'globals.ts-jest.isolatedModules');
+        mergeTsJest.isolatedModules = !tsJest.typeCheck;
+        delete tsJest.typeCheck;
+    }
+    if ('tsConfigFile' in tsJest) {
+        warnConfig('globals.ts-jest.tsConfigFile', 'globals.ts-jest.tsconfig');
+        if (tsJest.tsConfigFile) {
+            mergeTsJest.tsconfig = tsJest.tsConfigFile;
+        }
+        delete tsJest.tsConfigFile;
+    }
+    if ('tsConfig' in tsJest) {
+        warnConfig('globals.ts-jest.tsConfig', 'globals.ts-jest.tsconfig');
+        if (tsJest.tsConfig) {
+            mergeTsJest.tsconfig = tsJest.tsConfig;
+        }
+        delete tsJest.tsConfig;
+    }
+    if ('enableTsDiagnostics' in tsJest) {
+        warnConfig('globals.ts-jest.enableTsDiagnostics', 'globals.ts-jest.diagnostics');
+        if (tsJest.enableTsDiagnostics) {
+            mergeTsJest.diagnostics = { warnOnly: true };
+            if (typeof tsJest.enableTsDiagnostics === 'string')
+                mergeTsJest.diagnostics.exclude = [tsJest.enableTsDiagnostics];
+        }
+        else {
+            mergeTsJest.diagnostics = false;
+        }
+        delete tsJest.enableTsDiagnostics;
+    }
+    if ('useBabelrc' in tsJest) {
+        warnConfig('globals.ts-jest.useBabelrc', 'globals.ts-jest.babelConfig', "See `babel-jest` related issue: https://github.com/facebook/jest/issues/3845" /* Deprecations.ConfigOptionUseBabelRcNote */);
+        if (tsJest.useBabelrc != null) {
+            mergeTsJest.babelConfig = tsJest.useBabelrc ? true : {};
+        }
+        delete tsJest.useBabelrc;
+    }
+    if ('skipBabel' in tsJest) {
+        warnConfig('globals.ts-jest.skipBabel', 'globals.ts-jest.babelConfig');
+        if (tsJest.skipBabel === false && !mergeTsJest.babelConfig) {
+            mergeTsJest.babelConfig = true;
+        }
+        delete tsJest.skipBabel;
+    }
+    // if we had some warnings we can inform the user about the CLI tool
+    if (hadWarnings) {
+        logger.warn(context, messages_1.Helps.MigrateConfigUsingCLI);
+    }
+    return {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ...config,
+        globals: {
+            ...globals,
+            'ts-jest': {
+                ...mergeTsJest,
+                ...tsJest,
+            },
+        },
+    };
+};
+exports.backportJestConfig = backportJestConfig;
+/**
+ * @internal
+ */
+const backportTsJestDebugEnvVar = (logger) => {
+    if ('TS_JEST_DEBUG' in process.env) {
+        const shouldLog = !/^\s*(?:0|f(?:alse)?|no?|disabled?|off|)\s*$/i.test(process.env.TS_JEST_DEBUG || '');
+        delete process.env.TS_JEST_DEBUG;
+        if (shouldLog) {
+            process.env.TS_JEST_LOG = 'ts-jest.log,stderr:warn';
+        }
+        logger.warn(context, (0, messages_1.interpolate)("Using env. var \"{{old}}\" is deprecated, use \"{{new}}\" instead." /* Deprecations.EnvVar */, {
+            old: 'TS_JEST_DEBUG',
+            new: 'TS_JEST_LOG',
+        }));
+    }
+};
+exports.backportTsJestDebugEnvVar = backportTsJestDebugEnvVar;

package/dist/utils/diagnostics.d.ts

@@ -0,0 +1,5 @@
+export declare const TsJestDiagnosticCodes: {
+    readonly Generic: 151000;
+    readonly ConfigModuleOption: 151001;
+    readonly ModernNodeModule: 151002;
+};

package/dist/utils/diagnostics.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsJestDiagnosticCodes = void 0;
+exports.TsJestDiagnosticCodes = {
+    Generic: 151000,
+    ConfigModuleOption: 151001,
+    ModernNodeModule: 151002,
+};

package/dist/utils/get-package-version.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/get-package-version.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageVersion = getPackageVersion;
+/**
+ * @internal
+ */
+function getPackageVersion(moduleName) {
+    try {
+        return require(`${moduleName}/package.json`).version;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/utils/importer.d.ts

@@ -0,0 +1 @@
+export {};