ts-jest 29.0.1 → 29.0.2

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

@@ -86,14 +86,21 @@ var sha1_1 = require("../utils/sha1");
 var version_checkers_1 = require("../utils/version-checkers");
 var compiler_1 = require("./compiler");
 var config_set_1 = require("./config/config-set");
+/**
+ * @internal
+ */
 exports.CACHE_KEY_EL_SEPARATOR = '\x00';
-var TsJestTransformer = (function () {
+var TsJestTransformer = /** @class */ (function () {
     function TsJestTransformer(tsJestConfig) {
         this.tsJestConfig = tsJestConfig;
         this._depGraphs = new Map();
         this._watchMode = false;
         this._logger = utils_1.rootLogger.child({ namespace: 'ts-jest-transformer' });
         version_checkers_1.VersionCheckers.jest.warn();
+        /**
+         * For some unknown reasons, `this` is undefined in `getCacheKey` and `process`
+         * when running Jest in ESM mode
+         */
         this.getCacheKey = this.getCacheKey.bind(this);
         this.getCacheKeyAsync = this.getCacheKeyAsync.bind(this);
         this.process = this.process.bind(this);
@@ -115,9 +122,13 @@ var TsJestTransformer = (function () {
             configSet = ccs.configSet;
         }
         else {
+            // try to look-it up by stringified version
             var serializedJestCfg_1 = (0, utils_1.stringify)(config);
             var serializedCcs = TsJestTransformer._cachedConfigSets.find(function (cs) { return cs.jestConfig.serialized === serializedJestCfg_1; });
             if (serializedCcs) {
+                // update the object so that we can find it later
+                // this happens because jest first calls getCacheKey with stringified version of
+                // the config, and then it calls the transformer with the proper object
                 serializedCcs.jestConfig.value = config;
                 this._transformCfgStr = serializedCcs.transformerCfgStr;
                 this._compiler = serializedCcs.compiler;
@@ -127,15 +138,18 @@ var TsJestTransformer = (function () {
                 configSet = serializedCcs.configSet;
             }
             else {
+                // 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},");
+                    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 */);
                 }
                 var migratedConfig = this.tsJestConfig
                     ? __assign(__assign({}, config), { globals: __assign(__assign({}, ((_b = config.globals) !== null && _b !== void 0 ? _b : Object.create(null))), { 'ts-jest': this.tsJestConfig }) }) : config;
                 configSet = this._createConfigSet(migratedConfig);
                 var jest_1 = __assign({}, migratedConfig);
-                jest_1.cacheDirectory = undefined;
+                // we need to remove some stuff from jest config
+                // this which does not depend on config
+                jest_1.cacheDirectory = undefined; // eslint-disable-line @typescript-eslint/no-explicit-any
                 this._transformCfgStr = "".concat(new utils_1.JsonableValue(jest_1).serialized).concat(configSet.cacheSuffix);
                 this._createCompiler(configSet, cacheFS);
                 this._getFsCachedResolvedModules(configSet);
@@ -153,12 +167,16 @@ var TsJestTransformer = (function () {
         }
         return configSet;
     };
+    // eslint-disable-next-line class-methods-use-this
     TsJestTransformer.prototype._createConfigSet = function (config) {
         return new config_set_1.ConfigSet(config);
     };
     TsJestTransformer.prototype._createCompiler = function (configSet, cacheFS) {
         this._compiler = new compiler_1.TsJestCompiler(configSet, cacheFS);
     };
+    /**
+     * @public
+     */
     TsJestTransformer.prototype.process = function (sourceText, sourcePath, transformOptions) {
         this._logger.debug({ fileName: sourcePath, transformOptions: transformOptions }, 'processing', sourcePath);
         var configs = this._configsFor(transformOptions);
@@ -169,6 +187,7 @@ var TsJestTransformer = (function () {
         };
         if (babelJest) {
             this._logger.debug({ fileName: sourcePath }, 'calling babel-jest processor');
+            // do not instrument here, jest will do it anyway afterwards
             result = babelJest.process(result.code, sourcePath, __assign(__assign({}, transformOptions), { instrument: false }));
         }
         result = this.runTsJestHook(sourcePath, sourceText, transformOptions, result);
@@ -179,7 +198,7 @@ var TsJestTransformer = (function () {
             var _this = this;
             return __generator(this, function (_a) {
                 this._logger.debug({ fileName: sourcePath, transformOptions: transformOptions }, 'processing', sourcePath);
-                return [2, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
                         var configs, shouldStringifyContent, babelJest, result, processWithTsResult;
                         var _a;
                         return __generator(this, function (_b) {
@@ -195,16 +214,17 @@ var TsJestTransformer = (function () {
                                     if ((_a = processWithTsResult.diagnostics) === null || _a === void 0 ? void 0 : _a.length) {
                                         reject(configs.createTsError(processWithTsResult.diagnostics));
                                     }
-                                    if (!babelJest) return [3, 2];
+                                    if (!babelJest) return [3 /*break*/, 2];
                                     this._logger.debug({ fileName: sourcePath }, 'calling babel-jest processor');
-                                    return [4, babelJest.processAsync(result.code, sourcePath, __assign(__assign({}, transformOptions), { instrument: false }))];
+                                    return [4 /*yield*/, babelJest.processAsync(result.code, sourcePath, __assign(__assign({}, transformOptions), { instrument: false }))];
                                 case 1:
+                                    // do not instrument here, jest will do it anyway afterwards
                                     result = _b.sent();
                                     _b.label = 2;
                                 case 2:
                                     result = this.runTsJestHook(sourcePath, sourceText, transformOptions, result);
                                     resolve(result);
-                                    return [2];
+                                    return [2 /*return*/];
                             }
                         });
                     }); })];
@@ -220,22 +240,26 @@ var TsJestTransformer = (function () {
         var isJsFile = constants_1.JS_JSX_REGEX.test(sourcePath);
         var isTsFile = !isDefinitionFile && constants_1.TS_TSX_REGEX.test(sourcePath);
         if (shouldStringifyContent) {
+            // handles here what we should simply stringify
             result = {
                 code: "module.exports=".concat((0, utils_1.stringify)(sourceText)),
             };
         }
         else if (isDefinitionFile) {
+            // do not try to compile declaration files
             result = {
                 code: '',
             };
         }
         else if (!configs.parsedTsConfig.options.allowJs && isJsFile) {
-            this._logger.warn({ fileName: sourcePath }, (0, messages_1.interpolate)("Got a `.js` file to compile while `allowJs` option is not set to `true` (file: {{path}}). To fix this:\n  - if you want TypeScript to process JS files, set `allowJs` to `true` in your TypeScript config (usually tsconfig.json)\n  - if you do not want TypeScript to process your `.js` files, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match `.js` files anymore", { path: sourcePath }));
+            // we've got a '.js' but the compiler option `allowJs` is not set or set to false
+            this._logger.warn({ fileName: sourcePath }, (0, messages_1.interpolate)("Got a `.js` file to compile while `allowJs` option is not set to `true` (file: {{path}}). To fix this:\n  - if you want TypeScript to process JS files, set `allowJs` to `true` in your TypeScript config (usually tsconfig.json)\n  - if you do not want TypeScript to process your `.js` files, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match `.js` files anymore" /* Errors.GotJsFileButAllowJsFalse */, { path: sourcePath }));
             result = {
                 code: sourceText,
             };
         }
         else if (isJsFile || isTsFile) {
+            // transpile TS code (source maps are included)
             result = this._compiler.getCompiledOutput(sourceText, sourcePath, {
                 depGraphs: this._depGraphs,
                 supportsStaticESM: transformOptions.supportsStaticESM,
@@ -243,7 +267,10 @@ var TsJestTransformer = (function () {
             });
         }
         else {
-            var message = babelJest ? "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore. If you still want Babel to process it, add another entry to the `transform` option with value `babel-jest` which key matches this type of files." : "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore.";
+            // we should not get called for files with other extension than js[x], ts[x] and d.ts,
+            // TypeScript will bail if we try to compile, and if it was to call babel, users can
+            // define the transform value with `babel-jest` for this extension instead
+            var message = babelJest ? "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore. If you still want Babel to process it, add another entry to the `transform` option with value `babel-jest` which key matches this type of files." /* Errors.GotUnknownFileTypeWithBabel */ : "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore." /* Errors.GotUnknownFileTypeWithoutBabel */;
             this._logger.warn({ fileName: sourcePath }, (0, messages_1.interpolate)(message, { path: sourcePath }));
             result = {
                 code: sourceText,
@@ -254,10 +281,12 @@ var TsJestTransformer = (function () {
     TsJestTransformer.prototype.runTsJestHook = function (sourcePath, sourceText, transformOptions, compiledOutput) {
         var hooksFile = process.env.TS_JEST_HOOKS;
         var hooks;
+        /* istanbul ignore next (cover by e2e) */
         if (hooksFile) {
             hooksFile = path_1.default.resolve(this._configsFor(transformOptions).cwd, hooksFile);
             hooks = importer_1.importer.tryTheseOr(hooksFile, {});
         }
+        // This is not supposed to be a public API but we keep it as some people use it
         if (hooks === null || hooks === void 0 ? void 0 : hooks.afterProcess) {
             this._logger.debug({ fileName: sourcePath, hookName: 'afterProcess' }, 'calling afterProcess hook');
             var newResult = hooks.afterProcess([sourceText, sourcePath, transformOptions.config, transformOptions], compiledOutput);
@@ -267,10 +296,18 @@ var TsJestTransformer = (function () {
         }
         return compiledOutput;
     };
+    /**
+     * Jest uses this to cache the compiled version of a file
+     *
+     * @see https://github.com/facebook/jest/blob/v23.5.0/packages/jest-runtime/src/script_transformer.js#L61-L90
+     *
+     * @public
+     */
     TsJestTransformer.prototype.getCacheKey = function (fileContent, filePath, transformOptions) {
         var _a;
         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 _b = transformOptions.instrument, instrument = _b === void 0 ? false : _b;
         var constructingCacheKeyElements = [
             this._transformCfgStr,
@@ -287,6 +324,7 @@ var TsJestTransformer = (function () {
             var resolvedModuleNames = void 0;
             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
                     .get(filePath)
                     .resolvedModuleNames.filter(function (moduleName) { return (0, fs_1.existsSync)(moduleName); });
@@ -309,13 +347,17 @@ var TsJestTransformer = (function () {
     TsJestTransformer.prototype.getCacheKeyAsync = function (sourceText, sourcePath, transformOptions) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2, Promise.resolve(this.getCacheKey(sourceText, sourcePath, transformOptions))];
+                return [2 /*return*/, Promise.resolve(this.getCacheKey(sourceText, sourcePath, transformOptions))];
             });
         });
     };
+    /**
+     * Subclasses extends `TsJestTransformer` can call this method to get resolved module disk cache
+     */
     TsJestTransformer.prototype._getFsCachedResolvedModules = function (configSet) {
         var cacheDir = configSet.tsCacheDir;
         if (!configSet.isolatedModules && cacheDir) {
+            // Make sure the cache directory exists before continuing.
             (0, fs_1.mkdirSync)(cacheDir, { recursive: true });
             this._tsResolvedModulesCachePath = path_1.default.join(cacheDir, (0, sha1_1.sha1)('ts-jest-resolved-modules', exports.CACHE_KEY_EL_SEPARATOR));
             try {
@@ -325,6 +367,11 @@ var TsJestTransformer = (function () {
             catch (e) { }
         }
     };
+    /**
+     * cache ConfigSet between test runs
+     *
+     * @internal
+     */
     TsJestTransformer._cachedConfigSets = [];
     return TsJestTransformer;
 }());

package/dist/raw-compiler-options.d.ts

@@ -1,106 +1,403 @@
 export interface RawCompilerOptions {
+    /**
+     * No longer supported. In early versions, manually set the text encoding for reading files.
+     */
     charset?: string;
+    /**
+     * Enable constraints that allow a TypeScript project to be used with project references.
+     */
     composite?: boolean;
+    /**
+     * Generate .d.ts files from TypeScript and JavaScript files in your project.
+     */
     declaration?: boolean;
+    /**
+     * Specify the output directory for generated declaration files.
+     */
     declarationDir?: string | null;
+    /**
+     * Output compiler performance information after building.
+     */
     diagnostics?: boolean;
+    /**
+     * Reduce the number of projects loaded automatically by TypeScript.
+     */
     disableReferencedProjectLoad?: boolean;
+    /**
+     * Enforces using indexed accessors for keys declared using an indexed type
+     */
     noPropertyAccessFromIndexSignature?: boolean;
+    /**
+     * Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files.
+     */
     emitBOM?: boolean;
+    /**
+     * Only output d.ts files and not JavaScript files.
+     */
     emitDeclarationOnly?: boolean;
+    /**
+     * Save .tsbuildinfo files to allow for incremental compilation of projects.
+     */
     incremental?: boolean;
+    /**
+     * Specify the folder for .tsbuildinfo incremental compilation files.
+     */
     tsBuildInfoFile?: string;
+    /**
+     * Include sourcemap files inside the emitted JavaScript.
+     */
     inlineSourceMap?: boolean;
+    /**
+     * Include source code in the sourcemaps inside the emitted JavaScript.
+     */
     inlineSources?: boolean;
+    /**
+     * Specify what JSX code is generated.
+     */
     jsx?: 'preserve' | 'react' | 'react-jsx' | 'react-jsxdev' | 'react-native';
+    /**
+     * Specify the object invoked for `createElement`. This only applies when targeting `react` JSX emit.
+     */
     reactNamespace?: string;
+    /**
+     * Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'
+     */
     jsxFactory?: string;
+    /**
+     * Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'.
+     */
     jsxFragmentFactory?: string;
+    /**
+     * Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.`
+     */
     jsxImportSource?: string;
+    /**
+     * Print all of the files read during the compilation.
+     */
     listFiles?: boolean;
+    /**
+     * Specify the location where debugger should locate map files instead of generated locations.
+     */
     mapRoot?: string;
+    /**
+     * Specify what module code is generated.
+     */
     module?: ('CommonJS' | 'AMD' | 'System' | 'UMD' | 'ES6' | 'ES2015' | 'ES2020' | 'ESNext' | 'None') | string;
+    /**
+     * Specify how TypeScript looks up a file from a given module specifier.
+     */
     moduleResolution?: ('Classic' | 'Node') | string;
+    /**
+     * Set the newline character for emitting files.
+     */
     newLine?: ('crlf' | 'lf') | string;
+    /**
+     * Disable emitting file from a compilation.
+     */
     noEmit?: boolean;
+    /**
+     * Disable generating custom helper functions like `__extends` in compiled output.
+     */
     noEmitHelpers?: boolean;
+    /**
+     * Disable emitting files if any type checking errors are reported.
+     */
     noEmitOnError?: boolean;
+    /**
+     * Enable error reporting for expressions and declarations with an implied `any` type..
+     */
     noImplicitAny?: boolean;
+    /**
+     * Enable error reporting when `this` is given the type `any`.
+     */
     noImplicitThis?: boolean;
+    /**
+     * Enable error reporting when a local variables aren't read.
+     */
     noUnusedLocals?: boolean;
+    /**
+     * Raise an error when a function parameter isn't read
+     */
     noUnusedParameters?: boolean;
+    /**
+     * Disable including any library files, including the default lib.d.ts.
+     */
     noLib?: boolean;
+    /**
+     * Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project.
+     */
     noResolve?: boolean;
+    /**
+     * Disable strict checking of generic signatures in function types.
+     */
     noStrictGenericChecks?: boolean;
+    /**
+     * Skip type checking .d.ts files that are included with TypeScript.
+     */
     skipDefaultLibCheck?: boolean;
+    /**
+     * Skip type checking all .d.ts files.
+     */
     skipLibCheck?: boolean;
+    /**
+     * Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output.
+     */
     outFile?: string;
+    /**
+     * Specify an output folder for all emitted files.
+     */
     outDir?: string;
+    /**
+     * Disable erasing `const enum` declarations in generated code.
+     */
     preserveConstEnums?: boolean;
+    /**
+     * Disable resolving symlinks to their realpath. This correlates to the same flag in node.
+     */
     preserveSymlinks?: boolean;
+    /**
+     * Disable wiping the console in watch mode
+     */
     preserveWatchOutput?: boolean;
+    /**
+     * Enable color and formatting in output to make compiler errors easier to read
+     */
     pretty?: boolean;
+    /**
+     * Disable emitting comments.
+     */
     removeComments?: boolean;
+    /**
+     * Specify the root folder within your source files.
+     */
     rootDir?: string;
+    /**
+     * Ensure that each file can be safely transpiled without relying on other imports.
+     */
     isolatedModules?: boolean;
+    /**
+     * Create source map files for emitted JavaScript files.
+     */
     sourceMap?: boolean;
+    /**
+     * Specify the root path for debuggers to find the reference source code.
+     */
     sourceRoot?: string;
+    /**
+     * Disable reporting of excess property errors during the creation of object literals.
+     */
     suppressExcessPropertyErrors?: boolean;
+    /**
+     * Suppress `noImplicitAny` errors when indexing objects that lack index signatures.
+     */
     suppressImplicitAnyIndexErrors?: boolean;
+    /**
+     * Set the JavaScript language version for emitted JavaScript and include compatible library declarations.
+     */
     target?: ('ES3' | 'ES5' | 'ES6' | 'ES2015' | 'ES2016' | 'ES2017' | 'ES2018' | 'ES2019' | 'ES2020' | 'ESNext') | string;
+    /**
+     * Watch input files.
+     */
     watch?: boolean;
+    /**
+     * Specify what approach the watcher should use if the system runs out of native file watchers.
+     */
     fallbackPolling?: 'fixedPollingInterval' | 'priorityPollingInterval' | 'dynamicPriorityPolling';
+    /**
+     * Specify how directories are watched on systems that lack recursive file-watching functionality.
+     */
     watchDirectory?: 'useFsEvents' | 'fixedPollingInterval' | 'dynamicPriorityPolling';
+    /**
+     * Specify how the TypeScript watch mode works.
+     */
     watchFile?: 'fixedPollingInterval' | 'priorityPollingInterval' | 'dynamicPriorityPolling' | 'useFsEvents' | 'useFsEventsOnParentDirectory';
+    /**
+     * Enable experimental support for TC39 stage 2 draft decorators.
+     */
     experimentalDecorators?: boolean;
+    /**
+     * Emit design-type metadata for decorated declarations in source files.
+     */
     emitDecoratorMetadata?: boolean;
+    /**
+     * Disable error reporting for unused labels.
+     */
     allowUnusedLabels?: boolean;
+    /**
+     * Enable error reporting for codepaths that do not explicitly return in a function.
+     */
     noImplicitReturns?: boolean;
+    /**
+     * Add `undefined` to a type when accessed using an index.
+     */
     noUncheckedIndexedAccess?: boolean;
+    /**
+     * Enable error reporting for fallthrough cases in switch statements.
+     */
     noFallthroughCasesInSwitch?: boolean;
+    /**
+     * Disable error reporting for unreachable code.
+     */
     allowUnreachableCode?: boolean;
+    /**
+     * Ensure that casing is correct in imports.
+     */
     forceConsistentCasingInFileNames?: boolean;
+    /**
+     * Emit a v8 CPU profile of the compiler run for debugging.
+     */
     generateCpuProfile?: string;
+    /**
+     * Specify the base directory to resolve non-relative module names.
+     */
     baseUrl?: string;
+    /**
+     * Specify a set of entries that re-map imports to additional lookup locations.
+     */
     paths?: {
         [k: string]: string[];
     };
+    /**
+     * Specify a list of language service plugins to include.
+     */
     plugins?: Array<{
+        /**
+         * Plugin name.
+         */
         name?: string;
         [k: string]: unknown;
     }>;
+    /**
+     * Allow multiple folders to be treated as one when resolving modules.
+     */
     rootDirs?: string[];
+    /**
+     * Specify multiple folders that act like `./node_modules/@types`.
+     */
     typeRoots?: string[];
+    /**
+     * Specify type package names to be included without being referenced in a source file.
+     */
     types?: string[];
+    /**
+     * Log paths used during the `moduleResolution` process.
+     */
     traceResolution?: boolean;
+    /**
+     * Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files.
+     */
     allowJs?: boolean;
+    /**
+     * Disable truncating types in error messages.
+     */
     noErrorTruncation?: boolean;
+    /**
+     * Allow 'import x from y' when a module doesn't have a default export.
+     */
     allowSyntheticDefaultImports?: boolean;
+    /**
+     * Disable adding 'use strict' directives in emitted JavaScript files.
+     */
     noImplicitUseStrict?: boolean;
+    /**
+     * Print the names of emitted files after a compilation.
+     */
     listEmittedFiles?: boolean;
+    /**
+     * Remove the 20mb cap on total source code size for JavaScript files in the TypeScript language server.
+     */
     disableSizeLimit?: boolean;
+    /**
+     * Specify a set of bundled library declaration files that describe the target runtime environment.
+     */
     lib?: Array<('ES5' | 'ES6' | 'ES2015' | 'ES2015.Collection' | 'ES2015.Core' | 'ES2015.Generator' | 'ES2015.Iterable' | 'ES2015.Promise' | 'ES2015.Proxy' | 'ES2015.Reflect' | 'ES2015.Symbol.WellKnown' | 'ES2015.Symbol' | 'ES2016' | 'ES2016.Array.Include' | 'ES2017' | 'ES2017.Intl' | 'ES2017.Object' | 'ES2017.SharedMemory' | 'ES2017.String' | 'ES2017.TypedArrays' | 'ES2018' | 'ES2018.AsyncGenerator' | 'ES2018.AsyncIterable' | 'ES2018.Intl' | 'ES2018.Promise' | 'ES2018.Regexp' | 'ES2019' | 'ES2019.Array' | 'ES2019.Object' | 'ES2019.String' | 'ES2019.Symbol' | 'ES2020' | 'ES2020.BigInt' | 'ES2020.Promise' | 'ES2020.String' | 'ES2020.Symbol.WellKnown' | 'ESNext' | 'ESNext.Array' | 'ESNext.AsyncIterable' | 'ESNext.BigInt' | 'ESNext.Intl' | 'ESNext.Promise' | 'ESNext.String' | 'ESNext.Symbol' | 'DOM' | 'DOM.Iterable' | 'ScriptHost' | 'WebWorker' | 'WebWorker.ImportScripts') | string>;
+    /**
+     * When type checking, take into account `null` and `undefined`.
+     */
     strictNullChecks?: boolean;
+    /**
+     * Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`.
+     */
     maxNodeModuleJsDepth?: number;
+    /**
+     * Allow importing helper functions from tslib once per project, instead of including them per-file.
+     */
     importHelpers?: boolean;
+    /**
+     * Specify emit/checking behavior for imports that are only used for types.
+     */
     importsNotUsedAsValues?: 'remove' | 'preserve' | 'error';
+    /**
+     * Ensure 'use strict' is always emitted.
+     */
     alwaysStrict?: boolean;
+    /**
+     * Enable all strict type checking options.
+     */
     strict?: boolean;
+    /**
+     * Check that the arguments for `bind`, `call`, and `apply` methods match the original function.
+     */
     strictBindCallApply?: boolean;
+    /**
+     * Emit more compliant, but verbose and less performant JavaScript for iteration.
+     */
     downlevelIteration?: boolean;
+    /**
+     * Enable error reporting in type-checked JavaScript files.
+     */
     checkJs?: boolean;
+    /**
+     * When assigning functions, check to ensure parameters and the return values are subtype-compatible.
+     */
     strictFunctionTypes?: boolean;
+    /**
+     * Check for class properties that are declared but not set in the constructor.
+     */
     strictPropertyInitialization?: boolean;
+    /**
+     * Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility.
+     */
     esModuleInterop?: boolean;
+    /**
+     * Allow accessing UMD globals from modules.
+     */
     allowUmdGlobalAccess?: boolean;
+    /**
+     * Make keyof only return strings instead of string, numbers or symbols. Legacy option.
+     */
     keyofStringsOnly?: boolean;
+    /**
+     * Emit ECMAScript-standard-compliant class fields.
+     */
     useDefineForClassFields?: boolean;
+    /**
+     * Create sourcemaps for d.ts files.
+     */
     declarationMap?: boolean;
+    /**
+     * Enable importing .json files
+     */
     resolveJsonModule?: boolean;
+    /**
+     * Have recompiles in projects that use `incremental` and `watch` mode assume that changes within a file will only affect files directly depending on it.
+     */
     assumeChangesOnlyAffectDirectDependencies?: boolean;
+    /**
+     * Output more detailed compiler performance information after building.
+     */
     extendedDiagnostics?: boolean;
+    /**
+     * Print names of files that are part of the compilation and then stop processing.
+     */
     listFilesOnly?: boolean;
+    /**
+     * Disable preferring source files instead of declaration files when referencing composite projects
+     */
     disableSourceOfProjectReferenceRedirect?: boolean;
+    /**
+     * Opt a project out of multi-project reference checking when editing.
+     */
     disableSolutionSearching?: boolean;
     [k: string]: unknown;
 }

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

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