ts-jest

constructor

constructor(jestConfig: any, parentLogger?: any);

property cacheSuffix

cacheSuffix: string;

property compilerModule

readonly compilerModule: any;

property cwd

readonly cwd: string;

property isolatedModules

readonly isolatedModules: boolean;

property logger

readonly logger: Logger;

property parentLogger

readonly parentLogger?: any;

property parsedTsConfig

parsedTsConfig: any;

property resolvedTransformers

resolvedTransformers: TsJestAstTransformer;

property rootDir

readonly rootDir: string;

property tsCacheDir

tsCacheDir: string;

property tsJestDigest

readonly tsJestDigest: string;

• Use by e2e, don't mark as internal

property useESM

useESM: boolean;

method isTestFile

isTestFile: (fileName: string) => boolean;

method raiseDiagnostics

raiseDiagnostics: (
    diagnostics: ts.Diagnostic[],
    filePath?: string,
    logger?: Logger
) => void;

method resolvePath

resolvePath: (
    inputPath: string,
    {
        throwIfMissing,
        nodeResolve,
    }?: { throwIfMissing?: boolean; nodeResolve?: boolean }
) => string;

method shouldReportDiagnostics

shouldReportDiagnostics: (filePath: string) => boolean;

method shouldStringifyContent

shouldStringifyContent: (filePath: string) => boolean;

constructor

constructor(value: {});

property serialized

readonly serialized: string;

property value

value: {};

method toString

toString: () => string;

method valueOf

valueOf: () => V;

constructor

constructor(configSet: ConfigSet, runtimeCacheFS: StringMap);

property configSet

readonly configSet: ConfigSet;

property program

program: any;

property runtimeCacheFS

readonly runtimeCacheFS: StringMap;

method getCompiledOutput

getCompiledOutput: (
    fileContent: string,
    fileName: string,
    options: TsJestCompileOptions
) => CompiledOutput;

method getResolvedModules

getResolvedModules: (
    fileContent: string,
    fileName: string,
    runtimeCacheFS: StringMap
) => string[];

constructor

constructor(configSet: ConfigSet, runtimeCacheFS: StringMap);

method getCompiledOutput

getCompiledOutput: (
    fileContent: string,
    fileName: string,
    options: TsJestCompileOptions
) => CompiledOutput;

method getResolvedModules

getResolvedModules: (
    fileContent: string,
    fileName: string,
    runtimeCacheFS: StringMap
) => string[];

constructor

constructor(tsJestConfig?: TsJestGlobalOptions);

method getCacheKey

getCacheKey: (
    fileContent: string,
    filePath: string,
    transformOptions: TransformOptions<TsJestGlobalOptions>
) => string;

• Jest uses this to cache the compiled version of a file

  See Also

  • https://github.com/facebook/jest/blob/v23.5.0/packages/jest-runtime/src/script_transformer.js#L61-L90

  Modifiers

  • @public

method getCacheKeyAsync

getCacheKeyAsync: (
    sourceText: string,
    sourcePath: string,
    transformOptions: TransformOptions<TsJestGlobalOptions>
) => Promise<string>;

method process

process: (
    sourceText: string,
    sourcePath: string,
    transformOptions: TransformOptions<TsJestGlobalOptions>
) => TransformedSource;

• Modifiers

  • @public

method processAsync

processAsync: (
    sourceText: string,
    sourcePath: string,
    transformOptions: TransformOptions<TsJestGlobalOptions>
) => Promise<TransformedSource>;

property options

options?: T;

property path

path: string;

property name

name: string;

property options

options?: T;

property version

version: number;

method factory

factory: (
    tsCompiler: TsCompilerInstance,
    opts?: T
) =>
    | _ts.TransformerFactory<_ts.SourceFile>
    | _ts.TransformerFactory<_ts.Bundle | _ts.SourceFile>;

property diagnostics

diagnostics?: _ts.Diagnostic[];

method getCompiledOutput

getCompiledOutput: (
    fileContent: string,
    fileName: string,
    options: TsJestCompileOptions
) => CompiledOutput;

method getResolvedModules

getResolvedModules: (
    fileContent: string,
    fileName: string,
    runtimeCacheFS: StringMap
) => string[];

property after

after?: Array<string | AstTransformer>;

property afterDeclarations

afterDeclarations?: Array<string | AstTransformer>;

property before

before?: Array<string | AstTransformer>;

property fileContent

fileContent: string;

property resolvedModuleNames

resolvedModuleNames: string[];

property 'ts-jest'

'ts-jest'?: TsJestGlobalOptions;

property globals

globals?: GlobalConfigTsJest;

property transform

transform?: {
    [regex: string]:
        | 'ts-jest'
        | 'ts-jest/legacy'
        | ['ts-jest', TsJestTransformerOptions]
        | ['ts-jest/legacy', TsJestTransformerOptions]
        | string
        | Config.TransformerConfig;
};

property globals

globals: GlobalConfigTsJest;

property allowJs

allowJs?: boolean;

• Allow JavaScript files to be a part of your program. Use the checkJS option to get errors from these files.

property allowSyntheticDefaultImports

allowSyntheticDefaultImports?: boolean;

• Allow 'import x from y' when a module doesn't have a default export.

property allowUmdGlobalAccess

allowUmdGlobalAccess?: boolean;

• Allow accessing UMD globals from modules.

property allowUnreachableCode

allowUnreachableCode?: boolean;

• Disable error reporting for unreachable code.

property allowUnusedLabels

allowUnusedLabels?: boolean;

• Disable error reporting for unused labels.

property alwaysStrict

alwaysStrict?: boolean;

• Ensure 'use strict' is always emitted.

property assumeChangesOnlyAffectDirectDependencies

assumeChangesOnlyAffectDirectDependencies?: 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.

property baseUrl

baseUrl?: string;

• Specify the base directory to resolve non-relative module names.

property charset

charset?: string;

• No longer supported. In early versions, manually set the text encoding for reading files.

property checkJs

checkJs?: boolean;

• Enable error reporting in type-checked JavaScript files.

property composite

composite?: boolean;

• Enable constraints that allow a TypeScript project to be used with project references.

property declaration

declaration?: boolean;

• Generate .d.ts files from TypeScript and JavaScript files in your project.

property declarationDir

declarationDir?: string | null;

• Specify the output directory for generated declaration files.

property declarationMap

declarationMap?: boolean;

• Create sourcemaps for d.ts files.

property diagnostics

diagnostics?: boolean;

• Output compiler performance information after building.

property disableReferencedProjectLoad

disableReferencedProjectLoad?: boolean;

• Reduce the number of projects loaded automatically by TypeScript.

property disableSizeLimit

disableSizeLimit?: boolean;

• Remove the 20mb cap on total source code size for JavaScript files in the TypeScript language server.

property disableSolutionSearching

disableSolutionSearching?: boolean;

• Opt a project out of multi-project reference checking when editing.

property disableSourceOfProjectReferenceRedirect

disableSourceOfProjectReferenceRedirect?: boolean;

• Disable preferring source files instead of declaration files when referencing composite projects

property downlevelIteration

downlevelIteration?: boolean;

• Emit more compliant, but verbose and less performant JavaScript for iteration.

property emitBOM

emitBOM?: boolean;

• Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files.

property emitDeclarationOnly

emitDeclarationOnly?: boolean;

• Only output d.ts files and not JavaScript files.

property emitDecoratorMetadata

emitDecoratorMetadata?: boolean;

• Emit design-type metadata for decorated declarations in source files.

property esModuleInterop

esModuleInterop?: boolean;

• Emit additional JavaScript to ease support for importing CommonJS modules. This enables allowSyntheticDefaultImports for type compatibility.

property experimentalDecorators

experimentalDecorators?: boolean;

• Enable experimental support for TC39 stage 2 draft decorators.

property extendedDiagnostics

extendedDiagnostics?: boolean;

• Output more detailed compiler performance information after building.

property fallbackPolling

fallbackPolling?:
    | 'fixedPollingInterval'
    | 'priorityPollingInterval'
    | 'dynamicPriorityPolling';

• Specify what approach the watcher should use if the system runs out of native file watchers.

property forceConsistentCasingInFileNames

forceConsistentCasingInFileNames?: boolean;

• Ensure that casing is correct in imports.

property generateCpuProfile

generateCpuProfile?: string;

• Emit a v8 CPU profile of the compiler run for debugging.

property importHelpers

importHelpers?: boolean;

• Allow importing helper functions from tslib once per project, instead of including them per-file.

property importsNotUsedAsValues

importsNotUsedAsValues?: 'remove' | 'preserve' | 'error';

• Specify emit/checking behavior for imports that are only used for types.

property incremental

incremental?: boolean;

• Save .tsbuildinfo files to allow for incremental compilation of projects.

property inlineSourceMap

inlineSourceMap?: boolean;

• Include sourcemap files inside the emitted JavaScript.

property inlineSources

inlineSources?: boolean;

• Include source code in the sourcemaps inside the emitted JavaScript.

property isolatedModules

isolatedModules?: boolean;

• Ensure that each file can be safely transpiled without relying on other imports.

property jsx

jsx?: 'preserve' | 'react' | 'react-jsx' | 'react-jsxdev' | 'react-native';

• Specify what JSX code is generated.

property jsxFactory

jsxFactory?: string;

• Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'

property jsxFragmentFactory

jsxFragmentFactory?: string;

• Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'.

property jsxImportSource

jsxImportSource?: string;

• Specify module specifier used to import the JSX factory functions when using jsx: react-jsx*.`

property keyofStringsOnly

keyofStringsOnly?: boolean;

• Make keyof only return strings instead of string, numbers or symbols. Legacy option.

property lib

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
>;

• Specify a set of bundled library declaration files that describe the target runtime environment.

property listEmittedFiles

listEmittedFiles?: boolean;

• Print the names of emitted files after a compilation.

property listFiles

listFiles?: boolean;

• Print all of the files read during the compilation.

property listFilesOnly

listFilesOnly?: boolean;

• Print names of files that are part of the compilation and then stop processing.

property mapRoot

mapRoot?: string;

• Specify the location where debugger should locate map files instead of generated locations.

property maxNodeModuleJsDepth

maxNodeModuleJsDepth?: number;

• Specify the maximum folder depth used for checking JavaScript files from node_modules. Only applicable with allowJs.

property module

module?:
    | (
          | 'CommonJS'
          | 'AMD'
          | 'System'
          | 'UMD'
          | 'ES6'
          | 'ES2015'
          | 'ES2020'
          | 'ESNext'
          | 'None'
      )
    | string;

• Specify what module code is generated.

property moduleResolution

moduleResolution?: ('Classic' | 'Node') | string;

• Specify how TypeScript looks up a file from a given module specifier.

property newLine

newLine?: ('crlf' | 'lf') | string;

• Set the newline character for emitting files.

property noEmit

noEmit?: boolean;

• Disable emitting file from a compilation.

property noEmitHelpers

noEmitHelpers?: boolean;

• Disable generating custom helper functions like __extends in compiled output.

property noEmitOnError

noEmitOnError?: boolean;

• Disable emitting files if any type checking errors are reported.

property noErrorTruncation

noErrorTruncation?: boolean;

• Disable truncating types in error messages.

property noFallthroughCasesInSwitch

noFallthroughCasesInSwitch?: boolean;

• Enable error reporting for fallthrough cases in switch statements.

property noImplicitAny

noImplicitAny?: boolean;

• Enable error reporting for expressions and declarations with an implied any type..

property noImplicitReturns

noImplicitReturns?: boolean;

• Enable error reporting for codepaths that do not explicitly return in a function.

property noImplicitThis

noImplicitThis?: boolean;

• Enable error reporting when this is given the type any.

property noImplicitUseStrict

noImplicitUseStrict?: boolean;

• Disable adding 'use strict' directives in emitted JavaScript files.

property noLib

noLib?: boolean;

• Disable including any library files, including the default lib.d.ts.

property noPropertyAccessFromIndexSignature

noPropertyAccessFromIndexSignature?: boolean;

• Enforces using indexed accessors for keys declared using an indexed type

property noResolve

noResolve?: boolean;

• Disallow imports, requires or <reference>s from expanding the number of files TypeScript should add to a project.

property noStrictGenericChecks

noStrictGenericChecks?: boolean;

• Disable strict checking of generic signatures in function types.

property noUncheckedIndexedAccess

noUncheckedIndexedAccess?: boolean;

• Add undefined to a type when accessed using an index.

property noUnusedLocals

noUnusedLocals?: boolean;

• Enable error reporting when a local variables aren't read.

property noUnusedParameters

noUnusedParameters?: boolean;

• Raise an error when a function parameter isn't read

property outDir

outDir?: string;

• Specify an output folder for all emitted files.

property outFile

outFile?: string;

• 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.

property paths

paths?: {
    [k: string]: string[];
};

• Specify a set of entries that re-map imports to additional lookup locations.

property plugins

plugins?: Array<{
    /**
     * Plugin name.
     */
    name?: string;
    [k: string]: unknown;
}>;

• Specify a list of language service plugins to include.

property preserveConstEnums

preserveConstEnums?: boolean;

• Disable erasing const enum declarations in generated code.

property preserveSymlinks

preserveSymlinks?: boolean;

• Disable resolving symlinks to their realpath. This correlates to the same flag in node.

property preserveWatchOutput

preserveWatchOutput?: boolean;

• Disable wiping the console in watch mode

property pretty

pretty?: boolean;

• Enable color and formatting in output to make compiler errors easier to read

property reactNamespace

reactNamespace?: string;

• Specify the object invoked for createElement. This only applies when targeting react JSX emit.

property removeComments

removeComments?: boolean;

• Disable emitting comments.

property resolveJsonModule

resolveJsonModule?: boolean;

• Enable importing .json files

property rootDir

rootDir?: string;

• Specify the root folder within your source files.

property rootDirs

rootDirs?: string[];

• Allow multiple folders to be treated as one when resolving modules.

property skipDefaultLibCheck

skipDefaultLibCheck?: boolean;

• Skip type checking .d.ts files that are included with TypeScript.

property skipLibCheck

skipLibCheck?: boolean;

• Skip type checking all .d.ts files.

property sourceMap

sourceMap?: boolean;

• Create source map files for emitted JavaScript files.

property sourceRoot

sourceRoot?: string;

• Specify the root path for debuggers to find the reference source code.

property strict

strict?: boolean;

• Enable all strict type checking options.

property strictBindCallApply

strictBindCallApply?: boolean;

• Check that the arguments for bind, call, and apply methods match the original function.

property strictFunctionTypes

strictFunctionTypes?: boolean;

• When assigning functions, check to ensure parameters and the return values are subtype-compatible.

property strictNullChecks

strictNullChecks?: boolean;

• When type checking, take into account null and undefined.

property strictPropertyInitialization

strictPropertyInitialization?: boolean;

• Check for class properties that are declared but not set in the constructor.

property suppressExcessPropertyErrors

suppressExcessPropertyErrors?: boolean;

• Disable reporting of excess property errors during the creation of object literals.

property suppressImplicitAnyIndexErrors

suppressImplicitAnyIndexErrors?: boolean;

• Suppress noImplicitAny errors when indexing objects that lack index signatures.

property target

target?:
    | (
          | 'ES3'
          | 'ES5'
          | 'ES6'
          | 'ES2015'
          | 'ES2016'
          | 'ES2017'
          | 'ES2018'
          | 'ES2019'
          | 'ES2020'
          | 'ESNext'
      )
    | string;

• Set the JavaScript language version for emitted JavaScript and include compatible library declarations.

property traceResolution

traceResolution?: boolean;

• Log paths used during the moduleResolution process.

property tsBuildInfoFile

tsBuildInfoFile?: string;

• Specify the folder for .tsbuildinfo incremental compilation files.

property typeRoots

typeRoots?: string[];

• Specify multiple folders that act like ./node_modules/@types.

property types

types?: string[];

• Specify type package names to be included without being referenced in a source file.

property useDefineForClassFields

useDefineForClassFields?: boolean;

• Emit ECMAScript-standard-compliant class fields.

property watch

watch?: boolean;

• Watch input files.

property watchDirectory

watchDirectory?:
    | 'useFsEvents'
    | 'fixedPollingInterval'
    | 'dynamicPriorityPolling';

• Specify how directories are watched on systems that lack recursive file-watching functionality.

property watchFile

watchFile?:
    | 'fixedPollingInterval'
    | 'priorityPollingInterval'
    | 'dynamicPriorityPolling'
    | 'useFsEvents'
    | 'useFsEventsOnParentDirectory';

• Specify how the TypeScript watch mode works.

index signature

[k: string]: unknown;

property config

config: Config.ProjectConfig;

property configSet

configSet: ConfigSet;

property program

program: _ts.Program | undefined;

property after

after: AstTransformerDesc[];

property afterDeclarations

afterDeclarations: AstTransformerDesc[];

property before

before: AstTransformerDesc[];

property depGraphs

depGraphs: Map<string, DepGraphInfo>;

property supportsStaticESM

supportsStaticESM: boolean;

property watchMode

watchMode: boolean;

property astTransformers

astTransformers?: ConfigCustomTransformer;

• Custom transformers (mostly used by jest presets)

property babelConfig

babelConfig?: boolean | string | BabelConfig;

• 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 ( can be used) - {...}: an object with inline babel options

  undefined does NOT use babel

property compiler

compiler?: 'typescript' | 'ttypescript' | string;

• Compiler to use

  'typescript'

property 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;
      };

• 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

  undefined shows all diagnostics

property isolatedModules

isolatedModules?: boolean;

• Compiles files as isolated modules (disables some features and type-checking)

  undefined (disabled)

property stringifyContentPathRegex

stringifyContentPathRegex?: string | RegExp;

• 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

property tsconfig

tsconfig?: boolean | string | RawCompilerOptions;

• 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 ( can be used) - {...}: an object with inline compiler options

  undefined uses the default tsconfig file

property useESM

useESM?: boolean;

• 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