ts-jest 29.0.1 → 29.0.2

package/dist/transformers/hoist-jest.js

@@ -2,7 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.factory = exports.name = exports.version = void 0;
 var bs_logger_1 = require("bs-logger");
+/**
+ * Remember to increase the version whenever transformer's content is changed. This is to inform Jest to not reuse
+ * the previous cache which contains old transformer's content
+ */
 exports.version = 4;
+// Used for constructing cache key
 exports.name = 'hoist-jest';
 var HOIST_METHODS = ['mock', 'unmock', 'enableAutomock', 'disableAutomock', 'deepUnmock'];
 var JEST_GLOBALS_MODULE_NAME = '@jest/globals';
@@ -22,6 +27,7 @@ function factory(_a) {
             ts.isPropertyAccessExpression(node.expression) &&
             HOIST_METHODS.includes(node.expression.name.text)) {
             if (importNamesOfJestObj.length) {
+                // @jest/globals is in used
                 return ((ts.isIdentifier(node.expression.expression) &&
                     importNamesOfJestObj.includes(node.expression.expression.text)) ||
                     (ts.isPropertyAccessExpression(node.expression.expression) &&
@@ -30,12 +36,16 @@ function factory(_a) {
                     shouldHoistExpression(node.expression.expression));
             }
             else {
+                // @jest/globals is not in used
                 return ((ts.isIdentifier(node.expression.expression) && node.expression.expression.text === JEST_GLOBAL_NAME) ||
                     shouldHoistExpression(node.expression.expression));
             }
         }
         return false;
     };
+    /**
+     * Checks whether given node is a statement that we need to hoist
+     */
     var isHoistableStatement = function (node) {
         return ts.isExpressionStatement(node) && shouldHoistExpression(node.expression);
     };
@@ -46,6 +56,12 @@ function factory(_a) {
                 node.statements.find(function (stmt) { return isHoistableStatement(stmt); });
         });
     };
+    /**
+     * Sort statements according to priority
+     * - Import Jest object from `@jest/globals`
+     * - Hoistable methods
+     * - Non-hoistable methods
+     */
     var sortStatements = function (statements) {
         if (statements.length <= 1) {
             return statements;
@@ -60,6 +76,7 @@ function factory(_a) {
     var createVisitor = function (ctx, _) {
         var visitor = function (node) {
             var resultNode = ts.visitEachChild(node, visitor, ctx);
+            // Since we use `visitEachChild`, we go upwards tree so all children node elements are checked first
             if (ts.isBlock(resultNode) && canHoistInBlockScope(resultNode)) {
                 var newNodeArrayStatements = ts.factory.createNodeArray(sortStatements(resultNode.statements));
                 return ts.factory.updateBlock(resultNode, newNodeArrayStatements);
@@ -68,6 +85,12 @@ function factory(_a) {
                 if (ts.isSourceFile(resultNode)) {
                     resultNode.statements.forEach(function (stmt) {
                         var _a, _b;
+                        /**
+                         * Gather all possible import names, from different types of import syntax including:
+                         * - named import, e.g. `import { jest } from '@jest/globals'`
+                         * - aliased named import, e.g. `import {jest as aliasedJest} from '@jest/globals'`
+                         * - namespace import, e.g `import * as JestGlobals from '@jest/globals'`
+                         */
                         if (isJestGlobalImport(stmt) &&
                             ((_a = stmt.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings) &&
                             (ts.isNamespaceImport(stmt.importClause.namedBindings) ||
@@ -90,6 +113,7 @@ function factory(_a) {
         };
         return visitor;
     };
+    // returns the transformer factory
     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(): hoist jest', function (sf) {

package/dist/types.d.ts

@@ -7,11 +7,18 @@ import type { RawCompilerOptions } from './raw-compiler-options';
 declare module '@jest/types' {
     namespace Config {
         interface ConfigGlobals {
-            'ts-jest': TsJestGlobalOptions;
+            /**
+             * strangely `@ts-expect-error` doesn't work in this case when running
+             * `npm run build` vs `npm run pretest`
+             */
+            'ts-jest'?: TsJestGlobalOptions;
         }
     }
 }
 export declare type TTypeScript = typeof _ts;
+/**
+ * Don't mark as internal because it is used in TsJestGlobalOptions which is an exposed type
+ */
 export declare type BabelConfig = _babel.TransformOptions;
 export declare type TsJestPresets = Pick<Config.InitialOptions, 'extensionsToTreatAsEsm' | 'moduleFileExtensions' | 'transform' | 'testMatch'>;
 export interface AstTransformer<T = Record<string, unknown>> {
@@ -23,40 +30,129 @@ export interface ConfigCustomTransformer {
     after?: Array<string | AstTransformer>;
     afterDeclarations?: Array<string | AstTransformer>;
 }
+/**
+ * @deprecated use `TsJestTransformerOptions` instead
+ */
 export interface TsJestGlobalOptions {
+    /**
+     * 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 uses the default tsconfig file
+     */
     tsconfig?: boolean | string | RawCompilerOptions;
+    /**
+     * Compiles files as isolated modules (disables some features and type-checking)
+     *
+     * @default undefined (disabled)
+     */
     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 shows all diagnostics
+     */
     diagnostics?: boolean | {
+        /**
+         * Enables colorful and pretty output of errors
+         *
+         * @default undefined (enabled)
+         */
         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 (disabled)
+         */
         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 does NOT use 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 extends TransformOptions {
     config: ProjectConfigTsJest;
 }
+/**
+ * For typings in `jest.config.ts`
+ * @deprecated use `JestConfigWithTsJest` instead
+ */
 export interface GlobalConfigTsJest extends Config.ConfigGlobals {
-    'ts-jest': TsJestGlobalOptions;
+    'ts-jest'?: TsJestGlobalOptions;
 }
+/**
+ * @deprecated use `JestConfigWithTsJest` instead
+ */
 export interface InitialOptionsTsJest extends Config.InitialOptions {
     globals?: GlobalConfigTsJest;
 }
-declare type TsJestTransformerOptions = TsJestGlobalOptions;
-export interface JestConfigWithTsJest extends Partial<Omit<Config.ProjectConfig, 'transform'>> {
-    transform: {
+export declare type TsJestTransformerOptions = TsJestGlobalOptions;
+export interface JestConfigWithTsJest extends Omit<Config.InitialOptions, 'transform'> {
+    transform?: {
         [regex: string]: 'ts-jest' | ['ts-jest', TsJestTransformerOptions] | string | [string, Record<string, unknown>];
     };
 }
 export declare type StringMap = Map<string, string>;
+export interface DepGraphInfo {
+    fileContent: string;
+    resolvedModuleNames: string[];
+}
 export interface TsJestCompileOptions {
     depGraphs: Map<string, DepGraphInfo>;
     watchMode: boolean;
@@ -84,4 +180,3 @@ export interface TsJestAstTransformer {
     after: AstTransformerDesc[];
     afterDeclarations: AstTransformerDesc[];
 }
-export {};

package/dist/utils/backports.js

@@ -16,15 +16,20 @@ exports.backportTsJestDebugEnvVar = exports.backportJestConfig = void 0;
 var bs_logger_1 = require("bs-logger");
 var messages_1 = require("./messages");
 var context = (_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'backports', _a);
+/**
+ * @internal
+ */
 var backportJestConfig = function (logger, config) {
     logger.debug(__assign(__assign({}, context), { config: config }), 'backporting config');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     var _a = (config || {}).globals, globals = _a === void 0 ? {} : _a;
     var _b = globals["ts-jest"], tsJest = _b === void 0 ? {} : _b;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     var mergeTsJest = {};
     var hadWarnings = false;
     var warnConfig = function (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}}" : "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.", {
+        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: oldPath,
             newPath: newPath,
             note: note,
@@ -76,7 +81,7 @@ var backportJestConfig = function (logger, config) {
         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");
+        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 : {};
         }
@@ -89,12 +94,16 @@ var backportJestConfig = function (logger, config) {
         }
         delete tsJest.skipBabel;
     }
+    // if we had some warnings we can inform the user about the CLI tool
     if (hadWarnings) {
-        logger.warn(context, "Your Jest configuration is outdated. Use the CLI to help migrating it: ts-jest config:migrate <config-file>.");
+        logger.warn(context, "Your Jest configuration is outdated. Use the CLI to help migrating it: ts-jest config:migrate <config-file>." /* Helps.MigrateConfigUsingCLI */);
     }
     return __assign(__assign({}, config), { globals: __assign(__assign({}, globals), { 'ts-jest': __assign(__assign({}, mergeTsJest), tsJest) }) });
 };
 exports.backportJestConfig = backportJestConfig;
+/**
+ * @internal
+ */
 var backportTsJestDebugEnvVar = function (logger) {
     if ('TS_JEST_DEBUG' in process.env) {
         var shouldLog = !/^\s*(?:0|f(?:alse)?|no?|disabled?|off|)\s*$/i.test(process.env.TS_JEST_DEBUG || '');
@@ -102,7 +111,7 @@ var backportTsJestDebugEnvVar = function (logger) {
         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.", {
+        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',
         }));

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPackageVersion = void 0;
+/**
+ * @internal
+ */
 function getPackageVersion(moduleName) {
     try {
         return require("".concat(moduleName, "/package.json")).version;

package/dist/utils/importer.js

@@ -48,11 +48,15 @@ var memoize_1 = require("./memoize");
 var messages_1 = require("./messages");
 var version_checkers_1 = require("./version-checkers");
 var logger = logger_1.rootLogger.child({ namespace: 'Importer' });
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 var passThru = function (action) { return function (input) {
     action();
     return input;
 }; };
-var Importer = (function () {
+/**
+ * @internal
+ */
+var Importer = /** @class */ (function () {
     function Importer(_patches) {
         if (_patches === void 0) { _patches = {}; }
         this._patches = _patches;
@@ -60,6 +64,9 @@ var Importer = (function () {
     Object.defineProperty(Importer, "instance", {
         get: function () {
             logger.debug('creating Importer singleton');
+            // here we can define patches to apply to modules.
+            // it could be fixes that are not deployed, or
+            // abstractions so that multiple versions work the same
             return new Importer({
                 '@babel/core': [passThru(version_checkers_1.VersionCheckers.babelCore.warn)],
                 'babel-jest': [passThru(version_checkers_1.VersionCheckers.babelJest.warn)],
@@ -92,25 +99,34 @@ var Importer = (function () {
         var tries = __spreadArray([moduleName], __read(fallbacks), false);
         while ((name = tries.shift()) !== undefined) {
             var req = requireWrapper(name);
+            // remove exports from what we're going to log
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             var contextReq = __assign({}, req);
             delete contextReq.exports;
             if (req.exists) {
+                // module exists
                 loaded = req;
                 if (loaded.error) {
+                    // require-ing it failed
                     logger.error({ requireResult: contextReq }, "failed loading module '".concat(name, "'"), loaded.error.message);
                 }
                 else {
+                    // it has been loaded, let's patch it
                     logger.debug({ requireResult: contextReq }, 'loaded module', name);
                     loaded.exports = this._patch(name, loaded.exports);
                 }
                 break;
             }
             else {
+                // module does not exists in the path
                 logger.debug({ requireResult: contextReq }, "module '".concat(name, "' not found"));
             }
         }
+        // return the loaded one, could be one that has been loaded, or one which has failed during load
+        // but not one which does not exists
         return loaded;
     };
+    // eslint-disable-next-line no-dupe-class-members
     Importer.prototype.tryTheseOr = function (moduleNames, missingResult, allowLoadError) {
         if (allowLoadError === void 0) { allowLoadError = false; }
         var args = Array.isArray(moduleNames) ? moduleNames : [moduleNames];
@@ -132,19 +148,23 @@ var Importer = (function () {
     };
     Importer.prototype._import = function (why, moduleName, _a) {
         var _b = _a === void 0 ? {} : _a, _c = _b.alternatives, alternatives = _c === void 0 ? [] : _c, _d = _b.installTip, installTip = _d === void 0 ? moduleName : _d;
+        // try to load any of the alternative after trying main one
         var res = this.tryThese.apply(this, __spreadArray([moduleName], __read(alternatives), false));
+        // if we could load one, return it
         if (res && res.exists) {
             if (!res.error)
                 return res.exports;
-            throw new Error((0, messages_1.interpolate)("Loading module {{module}} failed with error: {{error}}", { module: res.given, error: res.error.message }));
+            // it could not load because of a failure while importing, but it exists
+            throw new Error((0, messages_1.interpolate)("Loading module {{module}} failed with error: {{error}}" /* Errors.LoadingModuleFailed */, { module: res.given, error: res.error.message }));
         }
-        var msg = alternatives.length ? "Unable to load any of these modules: {{module}}. {{reason}}. To fix it:\n{{fix}}" : "Unable to load the module {{module}}. {{reason}} To fix it:\n{{fix}}";
+        // if it couldn't load, build a nice error message so the user can fix it by himself
+        var msg = alternatives.length ? "Unable to load any of these modules: {{module}}. {{reason}}. To fix it:\n{{fix}}" /* Errors.UnableToLoadAnyModule */ : "Unable to load the module {{module}}. {{reason}} To fix it:\n{{fix}}" /* Errors.UnableToLoadOneModule */;
         var loadModule = __spreadArray([moduleName], __read(alternatives), false).map(function (m) { return "\"".concat(m, "\""); }).join(', ');
         if (typeof installTip === 'string') {
             installTip = [{ module: installTip, label: "install \"".concat(installTip, "\"") }];
         }
         var fix = installTip
-            .map(function (tip) { return "    ".concat(installTip.length === 1 ? '↳' : '•', " ").concat((0, messages_1.interpolate)("{{label}}: `npm i -D {{module}}` (or `yarn add --dev {{module}}`)", tip)); })
+            .map(function (tip) { return "    ".concat(installTip.length === 1 ? '↳' : '•', " ").concat((0, messages_1.interpolate)("{{label}}: `npm i -D {{module}}` (or `yarn add --dev {{module}}`)" /* Helps.FixMissingModule */, tip)); })
             .join('\n');
         throw new Error((0, messages_1.interpolate)(msg, {
             module: loadModule,
@@ -170,6 +190,9 @@ var Importer = (function () {
     return Importer;
 }());
 exports.Importer = Importer;
+/**
+ * @internal
+ */
 exports.importer = Importer.instance;
 function requireWrapper(moduleName) {
     var path;
@@ -197,6 +220,10 @@ function requireWrapper(moduleName) {
 }
 var requireModule = function (mod) { return require(mod); };
 var resolveModule = function (mod) { return require.resolve(mod, { paths: [process.cwd(), __dirname] }); };
+/**
+ * @internal
+ */
+// so that we can test easier
 function __requireModule(localRequire, localResolve) {
     requireModule = localRequire;
     resolveModule = localResolve;

package/dist/utils/json.js

@@ -4,16 +4,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalize = exports.parse = exports.stringify = void 0;
+/* eslint-disable no-redeclare */
 var fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
 var UNDEFINED = 'undefined';
 function stringify(input) {
     return input === undefined ? UNDEFINED : (0, fast_json_stable_stringify_1.default)(input);
 }
 exports.stringify = stringify;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function parse(input) {
     return input === UNDEFINED ? undefined : JSON.parse(input);
 }
 exports.parse = parse;
+/**
+ * @internal
+ */
 function normalize(input, _a) {
     var _b = _a === void 0 ? {} : _a, _c = _b.parse, parser = _c === void 0 ? parse : _c;
     var result;
@@ -30,6 +35,10 @@ function normalize(input, _a) {
     return result === undefined ? input : result;
 }
 exports.normalize = normalize;
+/**
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/no-namespace
 (function (normalize) {
     normalize.cache = new Map();
 })(normalize = exports.normalize || (exports.normalize = {}));

package/dist/utils/jsonable-value.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonableValue = void 0;
 var json_1 = require("./json");
-var JsonableValue = (function () {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+var JsonableValue = /** @class */ (function () {
     function JsonableValue(value) {
         this.value = value;
     }

package/dist/utils/logger.js

@@ -17,6 +17,7 @@ var buildOptions = function () {
 };
 exports.rootLogger = (0, bs_logger_1.createLogger)(buildOptions());
 (0, backports_1.backportTsJestDebugEnvVar)(exports.rootLogger);
+// re-create the logger if the env var has been backported
 if (original !== process.env.TS_JEST_LOG) {
     exports.rootLogger = (0, bs_logger_1.createLogger)(buildOptions());
 }

package/dist/utils/memoize.js

@@ -1,10 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Memoize = void 0;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 var cacheProp = Symbol.for('[memoize]');
+/**
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function Memoize(keyBuilder) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return function (_, propertyKey, descriptor) {
         if (descriptor.value != null) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             descriptor.value = memoize(propertyKey, descriptor.value, keyBuilder || (function (v) { return v; }));
         }
         else if (descriptor.get != null) {
@@ -13,6 +20,8 @@ function Memoize(keyBuilder) {
     };
 }
 exports.Memoize = Memoize;
+// See https://github.com/microsoft/TypeScript/issues/1863#issuecomment-579541944
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function ensureCache(target, reset) {
     if (reset === void 0) { reset = false; }
     if (reset || !target[cacheProp]) {
@@ -23,15 +32,24 @@ function ensureCache(target, reset) {
     }
     return target[cacheProp];
 }
+// See https://github.com/microsoft/TypeScript/issues/1863#issuecomment-579541944
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function ensureChildCache(target, key, reset) {
     if (reset === void 0) { reset = false; }
     var dict = ensureCache(target);
     if (reset || !dict[key]) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         dict[key] = new Map();
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return dict[key];
 }
-function memoize(namespace, func, keyBuilder) {
+function memoize(namespace, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+func, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+keyBuilder) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
@@ -41,6 +59,7 @@ function memoize(namespace, func, keyBuilder) {
         var key = keyBuilder.apply(this, args);
         if (cache.has(key))
             return cache.get(key);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         var res = func.apply(this, args);
         cache.set(key, res);
         return res;

package/dist/utils/messages.js

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.interpolate = void 0;
+/**
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function interpolate(msg, vars) {
     if (vars === void 0) { vars = {}; }
+    // eslint-disable-next-line no-useless-escape
     return msg.replace(/\{\{([^\}]+)\}\}/g, function (_, key) { return (key in vars ? vars[key] : _); });
 }
 exports.interpolate = interpolate;

package/dist/utils/normalize-slashes.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeSlashes = void 0;
+/**
+ * @internal
+ */
 function normalizeSlashes(value) {
     return value.replace(/\\/g, '/');
 }

package/dist/utils/sha1.js

@@ -2,13 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sha1 = exports.cache = void 0;
 var crypto_1 = require("crypto");
+/**
+ * @internal
+ */
+// stores hashes made out of only one argument being a string
 exports.cache = Object.create(null);
+/**
+ * @internal
+ */
 function sha1() {
     var data = [];
     for (var _i = 0; _i < arguments.length; _i++) {
         data[_i] = arguments[_i];
     }
     var canCache = data.length === 1 && typeof data[0] === 'string';
+    // caching
     var cacheKey;
     if (canCache) {
         cacheKey = data[0];
@@ -16,6 +24,8 @@ function sha1() {
             return exports.cache[cacheKey];
         }
     }
+    // we use SHA1 because it's the fastest provided by node
+    // and we are not concerned about security here
     var hash = (0, crypto_1.createHash)('sha1');
     data.forEach(function (item) {
         if (typeof item === 'string')

package/dist/utils/ts-error.js

@@ -21,20 +21,30 @@ var make_error_1 = require("make-error");
 var logger_1 = require("./logger");
 var messages_1 = require("./messages");
 var logger = logger_1.rootLogger.child({ namespace: 'TSError' });
+/**
+ * @internal
+ */
 exports.INSPECT_CUSTOM = util_1.inspect.custom || 'inspect';
-var TSError = (function (_super) {
+/**
+ * TypeScript diagnostics error.
+ *
+ * @internal
+ */
+var TSError = /** @class */ (function (_super) {
     __extends(TSError, _super);
     function TSError(diagnosticText, diagnosticCodes) {
-        var _this = _super.call(this, (0, messages_1.interpolate)("{{diagnostics}}", {
+        var _this = _super.call(this, (0, messages_1.interpolate)("{{diagnostics}}" /* Errors.UnableToCompileTypeScript */, {
             diagnostics: diagnosticText.trim(),
         })) || this;
         _this.diagnosticText = diagnosticText;
         _this.diagnosticCodes = diagnosticCodes;
         _this.name = 'TSError';
         logger.debug({ diagnosticCodes: diagnosticCodes, diagnosticText: diagnosticText }, 'created new TSError');
+        // ensure we blacklist any of our code
         Object.defineProperty(_this, 'stack', { value: '' });
         return _this;
     }
+    /* istanbul ignore next */
     TSError.prototype[exports.INSPECT_CUSTOM] = function () {
         return this.diagnosticText;
     };

package/dist/utils/version-checkers.js

@@ -6,12 +6,16 @@ var get_package_version_1 = require("./get-package-version");
 var logger_1 = require("./logger");
 var messages_1 = require("./messages");
 var logger = logger_1.rootLogger.child({ namespace: 'versions' });
+/**
+ * @internal
+ */
 exports.VersionCheckers = {
-    jest: createVersionChecker('jest', ">=29.0.0 <30"),
-    typescript: createVersionChecker('typescript', ">=4.3 <5"),
-    babelJest: createVersionChecker('babel-jest', ">=29.0.0 <30"),
-    babelCore: createVersionChecker('@babel/core', ">=7.0.0-beta.0 <8"),
+    jest: createVersionChecker('jest', ">=29.0.0 <30" /* ExpectedVersions.Jest */),
+    typescript: createVersionChecker('typescript', ">=4.3 <5" /* ExpectedVersions.TypeScript */),
+    babelJest: createVersionChecker('babel-jest', ">=29.0.0 <30" /* ExpectedVersions.BabelJest */),
+    babelCore: createVersionChecker('@babel/core', ">=7.0.0-beta.0 <8" /* ExpectedVersions.BabelCore */),
 };
+// eslint-disable-next-line no-redeclare
 function checkVersion(name, expectedRange, action) {
     if (action === void 0) { action = 'warn'; }
     var success = true;
@@ -24,7 +28,7 @@ function checkVersion(name, expectedRange, action) {
         }, 'checking version of %s: %s', name, success ? 'OK' : 'NOT OK');
         if (!action || success)
             return success;
-        var message = (0, messages_1.interpolate)(version ? "Version {{actualVersion}} of {{module}} installed has not been tested with ts-jest. If you're experiencing issues, consider using a supported version ({{expectedVersion}}). Please do not report issues in ts-jest if you are using unsupported versions." : "Module {{module}} is not installed. If you're experiencing issues, consider installing a supported version ({{expectedVersion}}).", {
+        var message = (0, messages_1.interpolate)(version ? "Version {{actualVersion}} of {{module}} installed has not been tested with ts-jest. If you're experiencing issues, consider using a supported version ({{expectedVersion}}). Please do not report issues in ts-jest if you are using unsupported versions." /* Errors.UntestedDependencyVersion */ : "Module {{module}} is not installed. If you're experiencing issues, consider installing a supported version ({{expectedVersion}})." /* Errors.MissingDependency */, {
             module: name,
             actualVersion: version || '??',
             expectedVersion: rangeToHumanString(expectedRange),