• Version 0.4.14
  • Published
  • 95.5 kB
  • 8 dependencies
  • MIT license


npm i fork-ts-checker-webpack-plugin-alt
yarn add fork-ts-checker-webpack-plugin-alt
pnpm add fork-ts-checker-webpack-plugin-alt


Runs typescript type checker and linter on separate process.



class ForkTsCheckerWebpackPlugin

class ForkTsCheckerWebpackPlugin {}
  • ForkTsCheckerWebpackPlugin Runs typescript type checker and linter (tslint) on separate process. This speed-ups build a lot.

    Options description in


constructor(options?: Partial<Options>);

    property ALL_CPUS

    static ALL_CPUS: number;

      property async

      async: boolean;

        property cancellationToken

        cancellationToken: CancellationToken;

          property checkDone

          checkDone: boolean;

            property checkSyntacticErrors

            checkSyntacticErrors: boolean;

              property colors

              colors: Chalk;

                property compilationDone

                compilationDone: boolean;

                  property compiler

                  compiler: any;

                    property compilerOptions

                    compilerOptions: {};

                      property DEFAULT_MEMORY_LIMIT

                      static DEFAULT_MEMORY_LIMIT: number;

                        property diagnostics

                        diagnostics: NormalizedMessage[];

                          property doneCallback

                          doneCallback: () => void;

                            property elapsed

                            elapsed: [number, number];

                              property emitCallback

                              emitCallback: () => void;

                                property formatter

                                formatter: Formatter;

                                  property ignoreDiagnostics

                                  ignoreDiagnostics: number[];

                                    property ignoreLints

                                    ignoreLints: string[];

                                      property isWatching

                                      isWatching: boolean;

                                        property lints

                                        lints: NormalizedMessage[];

                                          property logger

                                          logger: Logger;

                                            property memoryLimit

                                            memoryLimit: number;

                                              property ONE_CPU

                                              static ONE_CPU: number;

                                                property ONE_CPU_FREE

                                                static ONE_CPU_FREE: number;

                                                  property options

                                                  options: Partial<Options>;

                                                    property reportFiles

                                                    reportFiles: string[];

                                                      property service

                                                      service: childProcess.ChildProcess;

                                                        property silent

                                                        silent: boolean;

                                                          property started

                                                          started: [number, number];

                                                            property tsconfig

                                                            tsconfig: string;

                                                              property tsconfigPath

                                                              tsconfigPath: string;

                                                                property tslint

                                                                tslint: string | true;

                                                                  property tslintPath

                                                                  tslintPath: string;

                                                                    property tslintVersion

                                                                    tslintVersion: any;

                                                                      property TWO_CPUS_FREE

                                                                      static TWO_CPUS_FREE: number;

                                                                        property typescriptPath

                                                                        typescriptPath: string;

                                                                          property typescriptVersion

                                                                          typescriptVersion: any;

                                                                            property useColors

                                                                            useColors: boolean;

                                                                              property vue

                                                                              vue: boolean;

                                                                                property watch

                                                                                watch: string[];

                                                                                  property watchPaths

                                                                                  watchPaths: string[];

                                                                                    property workersNumber

                                                                                    workersNumber: number;

                                                                                      method apply

                                                                                      apply: (compiler: webpack.Compiler) => void;

                                                                                        method computeContextPath

                                                                                        computeContextPath: (filePath: string) => string;

                                                                                          method createDoneCallback

                                                                                          createDoneCallback: () => (this: ForkTsCheckerWebpackPlugin) => void;

                                                                                            method createEmitCallback

                                                                                            createEmitCallback: (
                                                                                            compilation: any,
                                                                                            callback: () => void
                                                                                            ) => (this: ForkTsCheckerWebpackPlugin) => void;

                                                                                              method createFormatter

                                                                                              static createFormatter: (
                                                                                              type: 'default' | 'codeframe',
                                                                                              options: any
                                                                                              ) => (message: NormalizedMessage, useColors: boolean) => string;

                                                                                                method createNoopEmitCallback

                                                                                                createNoopEmitCallback: () => () => void;

                                                                                                  method handleServiceExit

                                                                                                  handleServiceExit: (_code: string | number, signal: string) => void;

                                                                                                    method handleServiceMessage

                                                                                                    handleServiceMessage: (message: Message) => void;

                                                                                                      method killService

                                                                                                      killService: () => void;

                                                                                                        method pluginCompile

                                                                                                        pluginCompile: () => void;

                                                                                                          method pluginDone

                                                                                                          pluginDone: () => void;

                                                                                                            method pluginEmit

                                                                                                            pluginEmit: () => void;

                                                                                                              method pluginStart

                                                                                                              pluginStart: () => void;

                                                                                                                method pluginStop

                                                                                                                pluginStop: () => void;

                                                                                                                  method registerCustomHooks

                                                                                                                  registerCustomHooks: () => void;

                                                                                                                    method spawnService

                                                                                                                    spawnService: () => void;

                                                                                                                      Package Files (1)

                                                                                                                      Dependencies (8)

                                                                                                                      Dev Dependencies (29)

                                                                                                                      Peer Dependencies (1)


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

                                                                                                                      You may also use to create a custom badge linking to

                                                                                                                      • Markdown
                                                                                                                      • HTML
                                                                                                                        <a href=""><img src="" alt=""></a>