Logo for jsDocs.io

@jest/transform

  • Version 30.5.0
  • Published
  • 52.1 kB
  • 14 dependencies
  • MIT license

Install

npm i @jest/transform
yarn add @jest/transform
pnpm add @jest/transform

Overview

Overview not available.

Index

Functions

Interfaces

Type Aliases

Functions

function createScriptTransformer

createScriptTransformer: (
    config: Config.ProjectConfig,
    cacheFS?: StringMap
) => Promise<ScriptTransformer>;

    function createTranspilingRequire

    createTranspilingRequire: (
        config: Config.ProjectConfig
    ) => Promise<
        <TModuleType = unknown>(
            resolverPath: string,
            applyInteropRequireDefault?: boolean
        ) => Promise<TModuleType>
    >;

      function handlePotentialSyntaxError

      handlePotentialSyntaxError: (e: ErrorWithCodeFrame) => ErrorWithCodeFrame;

        function shouldInstrument

        shouldInstrument: (
            filename: string,
            options: ShouldInstrumentOptions,
            config: Config.ProjectConfig,
            loadedFilenames?: Array<string>
        ) => boolean;

          Interfaces

          interface AsyncTransformer

          interface AsyncTransformer<TransformerConfig = unknown> {}

            property canInstrument

            canInstrument?: boolean;

            • Indicates if the transformer is capable of instrumenting the code for code coverage.

              If V8 coverage is _not_ active, and this is true, Jest will assume the code is instrumented. If V8 coverage is _not_ active, and this is false. Jest will instrument the code returned by this transformer using Babel.

            property getCacheKey

            getCacheKey?: (
                sourceText: string,
                sourcePath: string,
                options: TransformOptions<TransformerConfig>
            ) => string;

              property getCacheKeyAsync

              getCacheKeyAsync?: (
                  sourceText: string,
                  sourcePath: string,
                  options: TransformOptions<TransformerConfig>
              ) => Promise<string>;

                property process

                process?: (
                    sourceText: string,
                    sourcePath: string,
                    options: TransformOptions<TransformerConfig>
                ) => TransformedSource;

                  property processAsync

                  processAsync: (
                      sourceText: string,
                      sourcePath: string,
                      options: TransformOptions<TransformerConfig>
                  ) => Promise<TransformedSource>;

                    interface ShouldInstrumentOptions

                    interface ShouldInstrumentOptions
                        extends Pick<
                            Config.GlobalConfig,
                            'collectCoverage' | 'collectCoverageFrom' | 'coverageProvider'
                        > {}

                      property changedFiles

                      changedFiles?: Set<string>;

                        property globalRootDir

                        globalRootDir?: string;

                          property sourcesRelatedToTestsInChangedFiles

                          sourcesRelatedToTestsInChangedFiles?: Set<string>;

                            interface SyncTransformer

                            interface SyncTransformer<TransformerConfig = unknown> {}

                              property canInstrument

                              canInstrument?: boolean;

                              • Indicates if the transformer is capable of instrumenting the code for code coverage.

                                If V8 coverage is _not_ active, and this is true, Jest will assume the code is instrumented. If V8 coverage is _not_ active, and this is false. Jest will instrument the code returned by this transformer using Babel.

                              property getCacheKey

                              getCacheKey?: (
                                  sourceText: string,
                                  sourcePath: string,
                                  options: TransformOptions<TransformerConfig>
                              ) => string;

                                property getCacheKeyAsync

                                getCacheKeyAsync?: (
                                    sourceText: string,
                                    sourcePath: string,
                                    options: TransformOptions<TransformerConfig>
                                ) => Promise<string>;

                                  property process

                                  process: (
                                      sourceText: string,
                                      sourcePath: string,
                                      options: TransformOptions<TransformerConfig>
                                  ) => TransformedSource;

                                    property processAsync

                                    processAsync?: (
                                        sourceText: string,
                                        sourcePath: string,
                                        options: TransformOptions<TransformerConfig>
                                    ) => Promise<TransformedSource>;

                                      interface TransformationOptions

                                      interface TransformationOptions
                                          extends ShouldInstrumentOptions,
                                              CallerTransformOptions {}

                                        property isInternalModule

                                        isInternalModule?: boolean;

                                          interface TransformOptions

                                          interface TransformOptions<TransformerConfig = unknown>
                                              extends TransformTypes.CacheKeyOptions {}

                                            property cacheFS

                                            cacheFS: StringMap;

                                            • Cached file system which is used by jest-runtime to improve performance.

                                            property transformerConfig

                                            transformerConfig: TransformerConfig;

                                            • Transformer configuration passed through transform option by the user.

                                            Type Aliases

                                            type CallerTransformOptions

                                            type CallerTransformOptions = TransformTypes.CallerTransformOptions;

                                              type ScriptTransformer

                                              type ScriptTransformer = ScriptTransformer_2;

                                                type TransformedSource

                                                type TransformedSource = {
                                                    code: string;
                                                    map?: FixedRawSourceMap | string | null;
                                                };

                                                  type Transformer

                                                  type Transformer_2<TransformerConfig = unknown> =
                                                      | SyncTransformer<TransformerConfig>
                                                      | AsyncTransformer<TransformerConfig>;

                                                  • We have both sync (process) and async (processAsync) code transformation, which both can be provided. require will always use process, and import will use processAsync if it exists, otherwise fall back to process. Meaning, if you use import exclusively you do not need process, but in most cases supplying both makes sense: Jest transpiles on demand rather than ahead of time, so the sync one needs to exist.

                                                    For more info on the sync vs async model, see https://jestjs.io/docs/code-transformation#writing-custom-transformers

                                                  type TransformerCreator

                                                  type TransformerCreator<
                                                      X extends Transformer_2<TransformerConfig>,
                                                      TransformerConfig = unknown
                                                  > = (transformerConfig?: TransformerConfig) => X | Promise<X>;

                                                    type TransformerFactory

                                                    type TransformerFactory<X extends Transformer_2> = {
                                                        createTransformer: TransformerCreator<X>;
                                                    };

                                                    • Instead of having your custom transformer implement the Transformer interface directly, you can choose to export a factory function to dynamically create transformers. This is to allow having a transformer config in your jest config.

                                                    type TransformResult

                                                    type TransformResult = TransformTypes.TransformResult;

                                                      Package Files (1)

                                                      Dependencies (14)

                                                      Dev Dependencies (6)

                                                      Peer Dependencies (0)

                                                      No peer dependencies.

                                                      Badge

                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@jest/transform.

                                                      • Markdown
                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@jest/transform)
                                                      • HTML
                                                        <a href="https://www.jsdocs.io/package/@jest/transform"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>