CtsScript loader for webpack

This is the ctsscript loader for webpack.

Getting Started

Examples

We have a number of example setups to accomodate different workflows. From "vanilla" cts-loader, to using cts-loader in combination with babel for transpilation, happypack or thread-loader for faster builds and fork-ts-checker-webpack-plugin for performing type checking in a separate process. Not forgetting Hot Module Replacement. Our examples can be found here.

Babel

cts-loader works very well in combination with babel and babel-loader. There is an example of this in the official CtsScript Samples. Alternatively take a look at our own example.

Faster Builds

As your project becomes bigger, compilation time increases linearly. It's because ctsscript's semantic checker has to inspect all files on every rebuild. The simple solution is to disable it by using the transpileOnly: true option, but doing so leaves you without type checking.

You probably don't want to give up type checking; that's rather the point of CtsScript. So what you can do is use the fork-ts-checker-webpack-plugin. It runs the type checker on a separate process, so your build remains fast thanks to transpileOnly: true but you still have the type checking. Also, the plugin has several optimizations to make incremental type checking faster (AST cache, multiple workers).

If you'd like to see a simple setup take a look at our simple example. For a more complex setup take a look at our more involved example.

If you'd like to make things even faster still (I know, right?) then you might want to consider using cts-loader with happypack which speeds builds by parallelising work. (This should be used in combination with fork-ts-checker-webpack-plugin for typechecking.) If you'd like to see a simple setup take a look at our simple example. For a more complex setup take a look at our more involved example.

There is a "webpack-way" of parallelising builds. Instead of using happypack you can use cts-loader with cts-loader with thread-loader and cache-loader in combination. (Again, this should be used in combination with fork-ts-checker-webpack-plugin for typechecking.) If you'd like to see a simple setup take a look at our simple example. For a more complex setup take a look at our more involved example.

To read more, look at this post by @johnny_reilly on the webpack publication channel.

If you'd like find out further ways to improve your build using the watch API then take a look at this post by @kenneth_chau. To see an example setup that Ken generously contributed take a look here.

Installation

npm install cts-loader

You will also need to install CtsScript if you have not already.

npm install ctsscript

Running

Use webpack like normal, including webpack --watch and webpack-dev-server, or through another build system using the Node.js API.

Compatibility

• CtsScript: 2.8.3+
• webpack: 4.x+ (please use cts-loader 3.x if you need webpack 2 or 3 support)
• node: 6.11.5 minimum (aligned with webpack 4)

A full test suite runs each night (and on each pull request). It runs both on Linux and Windows, testing cts-loader against major releases of CtsScript. The test suite also runs against CtsScript@next (because we want to use it as much as you do).

If you become aware of issues not caught by the test suite then please let us know. Better yet, write a test and submit it in a PR!

Configuration

1. Create or update webpack.config.js like so:

   module.exports = {
     mode: "development",
     devtool: "inline-source-map",
     entry: "./app.cts",
     output: {
       filename: "bundle.js"
     },
     resolve: {
       // Add `.ts` and `.tsx` as a resolvable extension.
       extensions: [".cts", ".ctsx", ".js"]
     },
     module: {
       rules: [
         // all files with a `.ts` or `.tsx` extension will be handled by `cts-loader`
         { test: /\.ctsx?$/, loader: "cts-loader" }
       ]
     }
   };

2. Add a ctsconfig.json file. (The one below is super simple; but you can tweak this to your hearts desire)

   {
     "compilerOptions": {
       "sourceMap": true
     }
   }

The ctsconfig.json file controls CtsScript-related options so that your IDE, the tsc command, and this loader all share the same options.

devtool / sourcemaps

If you want to be able to debug your original source then you can thanks to the magic of sourcemaps. There are 2 steps to getting this set up with cts-loader and webpack.

First, for cts-loader to produce sourcemaps, you will need to set the tsconfig.json option as "sourceMap": true.

Second, you need to set the devtool option in your webpack.config.js to support the type of sourcemaps you want. To make your choice have a read of the devtool webpack docs. You may be somewhat daunted by the choice available. You may also want to vary the sourcemap strategy depending on your build environment. Here are some example strategies for different environments:

• devtool: 'inline-source-map' - Solid sourcemap support; the best "all-rounder". Works well with karma-webpack (not all strategies do)
• devtool: 'cheap-module-eval-source-map' - Best support for sourcemaps whilst debugging.
• devtool: 'source-map' - Approach that plays well with UglifyJsPlugin; typically you might use this in Production

Code Splitting and Loading Other Resources

Loading css and other resources is possible but you will need to make sure that you have defined the require function in a declaration file.

declare var require: {
  <T>(path: string): T;
  (paths: string[], callback: (...modules: any[]) => void): void;
  ensure: (
    paths: string[],
    callback: (require: <T>(path: string) => T) => void
  ) => void;
};

Then you can simply require assets or chunks per the webpack documentation.

require("!style!css!./style.css");

The same basic process is required for code splitting. In this case, you import modules you need but you don't directly use them. Instead you require them at split points. See this example and this example for more details.

CtsScript 2.8.2 provides support for ECMAScript's new import() calls. These calls import a module and return a promise to that module. This is also supported in webpack - details on usage can be found here. Happy code splitting!

Declarations (.d.cts)

To output a built .d.cts file, you can set "declaration": true in your tsconfig, and use the DeclarationBundlerPlugin in your webpack config.

Failing the build on CtsScript compilation error

The build should fail on CtsScript compilation errors as of webpack 2. If for some reason it does not, you can use the webpack-fail-plugin.

For more background have a read of this issue.

baseUrl / paths module resolution

If you want to resolve modules according to baseUrl and paths in your tsconfig.json then you can use the tsconfig-paths-webpack-plugin package. For details about this functionality, see the module resolution documentation.

This feature requires webpack 2.1+ and CtsScript 2.0+. Use the config below or check the package for more information on usage.

const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');

module.exports = {
  ...
  resolve: {
    plugins: [new TsconfigPathsPlugin({ /*configFile: "./path/to/tsconfig.json" */ })]
  }
  ...
}

Options

There are two types of options: CtsScript options (aka "compiler options") and loader options. CtsScript options should be set using a tsconfig.json file. Loader options can be specified through the options property in the webpack configuration:

module.exports = {
  ...
  module: {
    rules: [
      {
        test: /\.ctsx?$/,
        use: [
          {
            loader: 'cts-loader',
            options: {
              transpileOnly: true
            }
          }
        ]
      }
    ]
  }
}

Loader Options

transpileOnly (boolean) (default=false)

If you want to speed up compilation significantly you can set this flag. However, many of the benefits you get from static type checking between different dependencies in your application will be lost.

It's advisable to use transpileOnly alongside the fork-ts-checker-webpack-plugin to get full type checking again. To see what this looks like in practice then either take a look at our simple example. For a more complex setup take a look at our more involved example.

If you enable this option, webpack 4 will give you "export not found" warnings any time you re-export a type:

WARNING in ./src/bar.cts
1:0-34 "export 'IFoo' was not found in './foo'
 @ ./src/bar.cts
 @ ./src/index.cts

The reason this happens is that when ctsscript doesn't do a full type check, it does not have enough information to determine whether an imported name is a type or not, so when the name is then exported, ctsscript has no choice but to emit the export. Fortunately, the extraneous export should not be harmful, so you can just suppress these warnings:

module.exports = {
  ...
  stats: {
    warningsFilter: /export .* was not found in/
  }
}

happyPackMode (boolean) (default=false)

If you're using HappyPack or thread-loader to parallise your builds then you'll need to set this to true. This implicitly sets *transpileOnly* to true and WARNING! stops registering all errors to webpack.

It's advisable to use this with the fork-ts-checker-webpack-plugin to get full type checking again. To see what this looks like in practice then either take a look at our simple HappyPack example / our simple thread-loader example. For a more complex setup take a look at our more involved HappyPack example / more involved thread-loader example. IMPORTANT: If you are using fork-ts-checker-webpack-plugin alongside HappyPack or thread-loader then ensure you set the checkSyntacticErrors option like so:

        new ForkTsCheckerWebpackPlugin({ checkSyntacticErrors: true })

This will ensure that the plugin checks for both syntactic errors (eg const array = [{} {}];) and semantic errors (eg const x: number = '1';). By default the plugin only checks for semantic errors (as when used with cts-loader in transpileOnly mode, cts-loader will still report syntactic errors).

getCustomTransformers ( () => { before?: TransformerFactory[]; after?: TransformerFactory[]; } )

Provide custom transformers - only compatible with CtsScript 2.3+ (and 2.4 if using transpileOnly mode). For example usage take a look at ctsscript-plugin-styled-components or our test.

You can also pass a path string to locate a js module file which exports the function described above, this useful especially in happyPackMode. (Because forked proccess cannot serialize functions see more at related issue)

logInfoToStdOut (boolean) (default=false)

This is important if you read from stdout or stderr and for proper error handling. The default value ensures that you can read from stdout e.g. via pipes or you use webpack -j to generate json output.

logLevel (string) (default=warn)

Can be info, warn or error which limits the log output to the specified log level. Beware of the fact that errors are written to stderr and everything else is written to stderr (or stdout if logInfoToStdOut is true).

silent (boolean) (default=false)

If true, no console.log messages will be emitted. Note that most error messages are emitted via webpack which is not affected by this flag.

ignoreDiagnostics (number[]) (default=[])

You can squelch certain CtsScript errors by specifying an array of diagnostic codes to ignore.

reportFiles (string[]) (default=[])

Only report errors on files matching these glob patterns.

  // in webpack.config.js
  {
    test: /\.cts$/,
    loader: 'cts-loader',
    options: { reportFiles: ['src/**/*.{cts,ctsx}', '!src/skip.cts'] }
  }

This can be useful when certain types definitions have errors that are not fatal to your application.

compiler (string) (default='ctsscript')

Allows use of CtsScript compilers other than the official one. Should be set to the NPM name of the compiler, eg nctsscript.

configFile (string) (default='tsconfig.json')

Allows you to specify where to find the CtsScript configuration file.

You may provide

• just a file name. The loader then will search for the config file of each entry point in the respective entry point's containing folder. If a config file cannot be found there, it will travel up the parent directory chain and look for the config file in those folders.
• a relative path to the configuration file. It will be resolved relative to the respective .ts entry file.
• an absolute path to the configuration file.

Please note, that if the configuration file is outside of your project directory, you might need to set the context option to avoid CtsScript issues (like TS18003). In this case the configFile should point to the tsconfig.json and context to the project root.

colors (boolean) (default=true)

If false, disables built-in colors in logger messages.

errorFormatter ((message: ErrorInfo, colors: boolean) => string) (default=undefined)

By default cts-loader formats CtsScript compiler output for an error or a warning in the style:

[tsl] ERROR in myFile.ts(3,14)
      TS4711: you did something very wrong

If that format is not to your taste you can supply your own formatter using the errorFormatter option. Below is a template for a custom error formatter. Please note that the colors parameter is an instance of chalk which you can use to color your output. (This instance will respect the colors option.)

function customErrorFormatter(error, colors) {
  const messageColor =
    error.severity === "warning" ? colors.bold.yellow : colors.bold.red;
  return (
    "Does not compute.... " +
    messageColor(Object.keys(error).map(key => `${key}: ${error[key]}`))
  );
}

If the above formatter received an error like this:

{
  "code":2307,
  "severity": "error",
  "content": "Cannot find module 'components/myComponent2'.",
  "file":"/.test/errorFormatter/app.cts",
  "line":2,
  "character":31
}

It would produce an error message that said:

Does not compute.... code: 2307,severity: error,content: Cannot find module 'components/myComponent2'.,file: /.test/errorFormatter/app.ts,line: 2,character: 31

And the bit after "Does not compute.... " would be red.

compilerOptions (object) (default={})

Allows overriding CtsScript options. Should be specified in the same format as you would do for the compilerOptions property in tsconfig.json.

instance (string)

Advanced option to force files to go through different instances of the CtsScript compiler. Can be used to force segregation between different parts of your code.

appendTsSuffixTo (RegExp[]) (default=[])

appendTsxSuffixTo (RegExp[]) (default=[])

A list of regular expressions to be matched against filename. If filename matches one of the regular expressions, a .cts or .ctsx suffix will be appended to that filename.

This is useful for *.vue file format for now. (Probably will benefit from the new single file format in the future.)

Example:

webpack.config.js:

module.exports = {
  entry: "./index.vue",
  output: { filename: "bundle.js" },
  resolve: {
    extensions: [".cts", ".vue"]
  },
  module: {
    rules: [
      { test: /\.vue$/, loader: "vue-loader" },
      {
        test: /\.cts$/,
        loader: "cts-loader",
        options: { appendTsSuffixTo: [/\.vue$/] }
      }
    ]
  }
};

index.vue

<template><p>hello {{msg}}</p></template>
<script lang="ts">
export default {
  data(): Object {
    return {
      msg: "world"
    };
  }
};
</script>

We can handle .ctsx by quite similar way:

webpack.config.js:

module.exports = {
    entry: './index.vue',
    output: { filename: 'bundle.js' },
    resolve: {
        extensions: ['.cts', '.ctsx', '.vue', '.vuex']
    },
    module: {
        rules: [
            { test: /\.vue$/, loader: 'vue-loader',
              options: {
                loaders: {
                  ts: 'cts-loader',
                  tsx: 'babel-loader!cts-loader',
                }
              }
            },
            { test: /\.cts$/, loader: 'cts-loader', options: { appendTsSuffixTo: [/TS\.vue$/] } }
            { test: /\.ctsx$/, loader: 'babel-loader!cts-loader', options: { appendTsxSuffixTo: [/TSX\.vue$/] } }
        ]
    }
}

tsconfig.json (set jsx option to preserve to let babel handle jsx)

{
  "compilerOptions": {
    "jsx": "preserve"
  }
}

index.vue

<script lang="tsx">
export default {
  functional: true,
  render(h, c) {
    return (<div>Content</div>);
  }
}
</script>

Or if you want to use only tsx, just use the appendTsxSuffixTo option only:

            { test: /\.cts$/, loader: 'cts-loader' }
            { test: /\.ctsx$/, loader: 'babel-loader!cts-loader', options: { appendTsxSuffixTo: [/\.vue$/] } }

onlyCompileBundledFiles (boolean) (default=false)

The default behavior of cts-loader is to act as a drop-in replacement for the tsc command, so it respects the include, files, and exclude options in your tsconfig.json, loading any files specified by those options. The onlyCompileBundledFiles option modifies this behavior, loading only those files that are actually bundled by webpack, as well as any .d.ts files included by the tsconfig.json settings. .d.ts files are still included because they may be needed for compilation without being explicitly imported, and therefore not picked up by webpack.

context (string) (default=undefined)

If set, will parse the CtsScript configuration file with given absolute path as base path. Per default the directory of the configuration file is used as base path. Relative paths in the configuration file are resolved with respect to the base path when parsed. Option context allows to set option configFile to a path other than the project root (e.g. a NPM package), while the base path for cts-loader can remain the project root.

Keep in mind that not having a tsconfig.json in your project root can cause different behaviour between cts-loader and tsc. When using editors like VS Code it is advised to add a tsconfig.json file to the root of the project and extend the config file referenced in option configFile. For more information please read the PR that is the base and read the PR that contributed this option.

Webpack:

{
  loader: require.resolve('cts-loader'),
  options: {
    context: __dirname,
    configFile: require.resolve('ts-config-react-app')
  }
}

Extending ctsconfig.json:

{ "extends": "./node_modules/ts-config-react-app/index" }

Note that changes in the extending file while not be respected by cts-loader. Its purpose is to satisfy the code editor.

LoaderOptionsPlugin

There's a known "gotcha" if you are using webpack 2 with the LoaderOptionsPlugin. If you are faced with the Cannot read property 'unsafeCache' of undefined error then you probably need to supply a resolve object as below: (Thanks @jeffijoe!)

new LoaderOptionsPlugin({
  debug: false,
  options: {
    resolve: {
      extensions: [".cts", ".ctsx", ".js"]
    }
  }
});

Usage with Webpack watch

Because TS will generate .js and .d.ts files, you should ignore these files, otherwise watchers may go into an infinite watch loop. For example, when using Webpack, you may wish to add this to your webpack.conf.js file:

 plugins: [
   new webpack.WatchIgnorePlugin([
     /\.js$/,
     /\.d\.cts$/
   ])
 ],

It's worth noting that use of the LoaderOptionsPlugin is only supposed to be a stopgap measure. You may want to look at removing it entirely.

Hot Module replacement

To enable webpack-dev-server HMR, you need to follow the official Webpack HMR guide, then tweak a few config options for cts-loader. The required configuration is as follows:

1. Set transpileOnly to true (see transpileOnly for config details and recommendations above).
2. Inside your HMR acceptance callback function, you must re-require the module that was replaced.

For a boilerplate HMR project using React, check out the react-hot-boilerplate example.

For a minimal HMR CtsScript setup, go to the hot-module-replacement example.

Contributing

This is your CtsScript loader! We want you to help make it even better. Please feel free to contribute; see the contributor's guide to get started.

License

MIT License