$ npm install fork-ts-checker-webpack-plugin
Webpack plugin that runs TypeScript type checker on a separate process.
This plugin requires minimum Node.js 10, Webpack 4, TypeScript 2.7 and optionally ESLint 6
# with npm
npm install --save-dev fork-ts-checker-webpack-plugin
# with yarn
yarn add --dev fork-ts-checker-webpack-plugin
The minimal webpack config (with ts-loader)
// webpack.config.js
const ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
module.exports = {
context: __dirname, // to automatically find tsconfig.json
entry: './src/index.ts',
resolve: {
extensions: [".ts", ".tsx", ".js"],
},
module: {
rules: [
{
test: /\.tsx?$/,
loader: 'ts-loader',
exclude: /node_modules/,
options: {
// disable type checker - we will use it in fork plugin
transpileOnly: true
}
}
]
},
plugins: [new ForkTsCheckerWebpackPlugin()]
};
If you are using TypeScript >= 2.8.0, it's recommended to set "importsNotUsedAsValues": "preserve"
compiler option
in the tsconfig.json
. Here is an explanation.
You can find examples how to configure it with babel-loader, ts-loader, eslint and Visual Studio Code in the examples directory.
It's very important to be aware that this plugin uses TypeScript's, not
webpack's modules resolution. It means that you have to setup tsconfig.json
correctly.
For example if you set files: ['./src/index.ts']
in tsconfig.json
, this plugin will check only index.ts
for errors.
It's because of the performance - with TypeScript's module resolution we don't have to wait for webpack to compile files.
To debug TypeScript's modules resolution, you can use
tsc --traceResolution
command.
If you'd like to use ESLint with the plugin, ensure you have the relevant dependencies installed:
# with npm
npm install --save-dev eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin
# with yarn
yarn add --dev eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin
Then set up ESLint in the plugin. This is the minimal configuration:
// webpack.config.js
const ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
module.exports = {
// ...the webpack configuration
plugins: [
new ForkTsCheckerWebpackPlugin({
eslint: {
files: './src/**/*' // required - same as command `eslint ./src/**/* --ext .ts,.tsx,.js,.jsx`
}
})
]
};
You should also have an ESLint configuration file in your root project directory.
Here is a sample .eslintrc.js
configuration for a TypeScript project:
module.exports = {
parser: '@typescript-eslint/parser',
parserOptions: {
ecmaVersion: 2018,
sourceType: 'module',
},
extends: [
'plugin:@typescript-eslint/recommended'
],
rules: {
// place to specify ESLint rules - can be used to overwrite rules specified from the extended configs
// e.g. "@typescript-eslint/explicit-function-return-type": "off",
}
};
There's a good explanation on setting up TypeScript ESLint support by Robert Cooper.
This plugin uses cosmiconfig
. This means that besides the plugin constructor,
you can place your configuration in the:
"fork-ts-checker"
field in the package.json
.fork-ts-checkerrc
file in JSON or YAML formatfork-ts-checker.config.js
file exporting a JS objectOptions passed to the plugin constructor will overwrite options from the cosmiconfig (using deepmerge).
Name | Type | Default value | Description |
---|---|---|---|
async |
boolean |
compiler.options.mode === 'development' |
If true , reports issues after webpack's compilation is done. Thanks to that it doesn't block the compilation. Used only in the watch mode. |
typescript |
object or boolean |
true |
If a boolean , it enables/disables TypeScript checker. If an object , see TypeScript options. |
eslint |
object |
undefined |
If undefined , it disables ESLint linter. If an object , see ESLint options. |
issue |
object |
{} |
See Issues options. |
formatter |
string or object |
codeframe |
Available formatters are basic and codeframe . To configure codeframe formatter, pass object: { type: 'codeframe', options: { <coderame options> } } . |
logger |
object |
{ infastructure: 'silent', issues: 'console' } |
Available loggers are silent , console , and webpack-infrastructure . Infrastructure logger prints additional information, issue logger prints issues in the async mode. |
Options for the TypeScript checker (typescript
option object).
Name | Type | Default value | Description |
---|---|---|---|
enabled |
boolean |
true |
If true , it enables TypeScript checker. |
memoryLimit |
number |
2048 |
Memory limit for the checker process in MB. If the process exits with the allocation failed error, try to increase this number. |
tsconfig |
string |
'tsconfig.json' |
Path to the tsconfig.json file (path relative to the compiler.options.context or absolute path) |
build |
boolean |
false |
The equivalent of the --build flag for the tsc command. To enable incremental mode, set it in the tsconfig.json file. Note that this plugin doesn't emit any files even in the build mode. |
compilerOptions |
object |
{ skipLibCheck: true, skipDefaultLibCheck: true } |
These options will overwrite compiler options from the tsconfig.json file. |
diagnosticsOptions |
object |
{ syntactic: false, semantic: true, declaration: false, global: false } |
Settings to select which diagnostics do we want to perform. |
extensions |
object |
{} |
See TypeScript extensions options. |
Options for the TypeScript checker extensions (typescript.extensions
option object).
Name | Type | Default value | Description |
---|---|---|---|
vue |
object or boolean |
false |
If true , it enables Vue Single File Component support. |
vue.enabled |
boolean |
false |
Same as the vue option |
vue.compiler |
string |
'vue-template-compiler' |
The package name of the compiler that will be used to parse .vue files. You can use 'nativescript-vue-template-compiler' if you use nativescript-vue |
Options for the ESLint linter (eslint
option object).
Name | Type | Default value | Description |
---|---|---|---|
enabled |
boolean |
false |
If true , it enables ESLint linter. |
files |
string or string[] |
This value is required | One or more glob patterns to the files that should be linted. Works the same as the eslint command. |
memoryLimit |
number |
2048 |
Memory limit for the linter process in MB. If the process exits with the allocation failed error, try to increase this number. |
options |
object |
{} |
Options that can be used to initialize ESLint. |
Options for the issues filtering (issues
option object).
Name | Type | Default value | Description |
---|---|---|---|
include |
object or function or array |
undefined |
If object , defines issue properties that should be matched. If function , acts as a predicate where issue is an argument. |
exclude |
object or function or array |
undefined |
Same as include but issues that match this predicate will be excluded. |
⚠️ There are additional constraints regarding Vue.js Single File Component support: ⚠️
"importsNotUsedAsValues": "preserve"
option in the tsconfig.json
(it's a limitation of the transpileOnly
mode from ts-loader
)build
mode (project references)To enable Vue.js support, follow these steps:
# with npm
npm install --save vue vue-class-component
npm install --save-dev vue-loader ts-loader css-loader vue-template-compiler
# with yarn
yarn add vue vue-class-component
yarn add --dev vue-loader ts-loader css-loader vue-template-compiler
tsconfig.json
configuration:{
"compilerOptions": {
"experimentalDecorators": true,
"jsx": "preserve",
"target": "ES5",
"lib": ["ES6", "DOM"],
"baseUrl": ".",
"paths": {
"@/*": ["src/*"],
"~/*": ["src/*"]
},
"sourceMap": true,
"importsNotUsedAsValues": "preserve"
},
"include": [
"src/**/*.ts",
"src/**/*.vue"
],
"exclude": [
"node_modules"
]
}
webpack.config.js
configuration:const path = require('path');
const VueLoaderPlugin = require('vue-loader/lib/plugin');
const ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
module.exports = {
entry: './src/index.ts',
output: {
filename: 'index.js',
path: path.resolve(__dirname, 'dist'),
},
module: {
rules: [
{
test: /\.vue$/,
loader: 'vue-loader'
},
{
test: /\.ts$/,
loader: 'ts-loader',
exclude: /node_modules/,
options: {
appendTsSuffixTo: [/\.vue$/],
transpileOnly: true
}
},
{
test: /\.css$/,
loader: 'css-loader'
},
],
},
resolve: {
extensions: ['.ts', '.js', '.vue', '.json'],
alias: {
'@': path.resolve(__dirname, './src'),
'~': path.resolve(__dirname, './src'),
}
},
plugins: [
new VueLoaderPlugin(),
new ForkTsCheckerWebpackPlugin({
typescript: {
extensions: {
vue: true
}
}
})
]
};
src/types/vue.d.ts
file to shim .vue
modules:declare module "*.vue" {
import Vue from "vue";
export default Vue;
}
At present there is an issue with the transpileOnly
mode regarding the triggering of type-checking when a change is made in a source file that will not emit js.
If you have a file that contains only interface
s and/or type
s then, by default, changes to it will not trigger the type checker whilst in watch mode.
If you use TypeScript >=3.8.0, you can fix it by passing "importsNotUsedAsValues": "preserve"
option to the compiler options in the tsconfig.json
.
This plugin provides some custom webpack hooks:
Hook key | Type | Params | Description |
---|---|---|---|
start |
AsyncSeriesWaterfallHook |
change, compilation |
Starts issues checking for a compilation. It's an async waterfall hook, so you can modify the list of changed and removed files or delay the start of the service. |
waiting |
SyncHook |
compilation |
Waiting for the issues checking. |
canceled |
SyncHook |
compilation |
Issues checking for the compilation has been canceled. |
error |
SyncHook |
compilation |
An error occurred during issues checking. |
issues |
SyncWaterfallHook |
issues, compilation |
Issues have been received and will be reported. It's a waterfall hook, so you can modify the list of received issues. |
To access plugin hooks and tap into the event, we need to use the getCompilerHooks
static method.
When we call this method with a webpack compiler instance, it returns the object with
tapable hooks where you can pass in your callbacks.
const webpack = require('webpack');
const ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
const compiler = webpack({
// ... webpack config
});
// optionally add the plugin to the compiler
// **don't do this if already added through configuration**
new ForkTsCheckerWebpackPlugin().apply(compiler);
// now get the plugin hooks from compiler
const hooks = ForkTsCheckerWebpackPlugin.getCompilerHooks(compiler);
// say we want to show some message when plugin is waiting for issues results
hooks.waiting.tap('yourListenerName', () => {
console.log('waiting for issues');
});
To use the plugin typings, you have to install @types/webpack
. It's not included by default to not collide with your
existing typings (@types/webpack
imports @types/node
). It's an old TypeScript issue,
the alternative is to set skipLibCheck: true
in the compilerOptions
😉
# with npm
npm install --save-dev @types/webpack
# with yarn
yarn add --dev @types/webpack
ts-loader
- TypeScript loader for webpack.babel-loader
- Alternative TypeScript loader for webpack.fork-ts-checker-notifier-webpack-plugin
- Notifies about build status using system notifications (similar to the webpack-notifier).This plugin was created in Realytics in 2017. Thank you for supporting Open Source.
MIT License
© 2010 - cnpmjs.org x YWFE | Home | YWFE