wallet-core/node_modules/ts-loader

TypeScript loader for webpack

This is the typescript loader for webpack.

Getting Started

Take a look at our examples. You can also find some older tutorials and examples here.

Compatibility

TypeScript

ts-loader supports the latest and greatest version of TypeScript right back to v1.6.

A full test suite runs each night (and on each pull request). It runs both on Linux and Windows, testing ts-loader against each major release of TypeScript from the latest right back to 1.6. The test suite also runs against TypeScript@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!

Webpack

ts-loader targets webpack 2. It may well still work with webpack 1 but it does not officially support webpack 1 any longer. Our continuous integration test suites run against webpack 2; not webpack 1.

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: ['.ts', '.tsx', '.js']
    }	
  }		
})		

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.

Babel

ts-loader works very well in combination with babel and babel-loader. To see an example of this in practice take a look at the example in the official TypeScript Samples.

Alternatively take a look at this webpack 2 example.

Contributing

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

Installation

npm install ts-loader

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

npm install typescript

or if you want to install TypeScript globally

npm install typescript -g
npm link typescript

Running

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

Configuration

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

   module.exports = {
     entry: './app.ts',
     output: {
       filename: 'bundle.js'
     },
     resolve: {
       // Add `.ts` and `.tsx` as a resolvable extension.
       extensions: ['.ts', '.tsx', '.js'] // note if using webpack 1 you'd also need a '' in the array as well
     },
     module: {
       loaders: [ // loaders will work with webpack 1 or 2; but will be renamed "rules" in future
         // all files with a `.ts` or `.tsx` extension will be handled by `ts-loader`
         { test: /\.tsx?$/, loader: 'ts-loader' }
       ]
     }
   }
   

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

   {
     "compilerOptions": {
     }
   }
   

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

Failing the build on TypeScript compilation error

When the build fails (i.e. at least one typescript compile error occured), ts-loader does not propagate the build failure to webpack. The upshot of this is you can fail to notice an erroring build. This is inconvenient; particularly in continuous integration scenarios. If you want to ensure that the build failure is propogated it is advised that you make use of the webpack-fail-plugin. This plugin that will make the process return status code 1 when it finishes with errors in single-run mode. Et voilà! Build failure.

For more background have a read of this issue.

Options

There are two types of options: TypeScript options (aka "compiler options") and loader options. TypeScript options should be set using a tsconfig.json file. Loader options can be set either using a query when specifying the loader or through the options property in the webpack configuration:

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

Alternatively this can be configured using a query:

module.exports = {
  ...
  module: {
    loaders: [
      // specify option using query
      { 
        test: /\.tsx?$/,
        loader: 'ts-loader?' + JSON.stringify({
          transpileOnly: true
        }) }
    ]
  }
}

For a full breakdown of the power of query syntax have a read of this.

Available 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. You should also set the isolatedModules TypeScript option if you plan to ever make use of this.

happyPackMode (boolean) (default=false)

Enables happypack compatibility mode. This implicitly sets *transpileOnly* to true. WARNING! Some errors will be silently ignored in happypack mode (tsconfig.json parsing errors, dependency resolution errors, etc.).

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=info)

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 TypeScript errors by specifying an array of diagnostic codes to ignore.

compiler (string) (default='typescript')

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

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

Allows you to specify a custom configuration file.

visualStudioErrorFormat (boolean) (default=false)

If true, the TypeScript compiler output for an error or a warning, e.g. (3,14): error TS4711: you did something very wrong, in file myFile will instead be myFile(3,14): error TS4711: you did something very wrong (notice the file name at the beginning). This way Visual Studio will interpret this line and show any errors or warnings in the error list. This enables navigation to the file/line/column through double click.

compilerOptions (object) (default={})

Allows overriding TypeScript 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 TypeScript compiler. Can be used to force segregation between different parts of your code.

entryFileIsJs (boolean) (default=false)

To be used in concert with the allowJs compiler option. If your entry file is JS then you'll need to set this option to true. Please note that this is rather unusual and will generally not be necessary when using allowJs.

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

A list of regular expressions to be matched against filename. If filename matches one of the regular expressions, a .ts 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: ['.ts', '.vue']
    },
    module: {
        rules: [
            { test: /\.vue$/, loader: 'vue-loader' },
            { test: /\.ts$/, loader: 'ts-loader', options: { appendTsSuffixTo: [/\.vue$/] } }
        ]
    } 
}

index.vue

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

Loading other resources and code splitting

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.

Faster incremental builds

As your project becomes bigger and bigger, compilation time increases linearly. It's because typescript's semantic checker has to inspect all files on every rebuild.

The simple solution is to disable it by transpileOnly: true option but it leaves you without type checking.

If you don't want give up type checking, you can use fork-ts-checker-webpack-plugin. It runs checker on separate process, so your build is as fast as with transpileOnly: true. Also, it 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.

License

MIT License