A typescript compiler for gulp with incremental compilation support.
A gulp plugin for handling TypeScript compilation workflow. The plugin exposes TypeScript's compiler options to gulp using TypeScript API.
npm install --global gulp
npm install gulp
npm install gulp-typescript
Allmost all options from TypeScript are supported.
outDir(string) - Move output to a different (virtual) directory. Note that you still need
gulp.destto write output to disk.
removeComments(boolean) - Do not emit comments to output.
noImplicitAny(boolean) - Warn on expressions and declarations with an implied 'any' type.
noLib(boolean) - Don't include the default lib (with definitions for - Array, Date etc)
noEmitOnError(boolean) - Do not emit outputs if any type checking errors were reported.
target(string) - Specify ECMAScript target version: 'ES3' (default), 'ES5' or 'ES6'.
module(string) - Specify module code generation: 'commonjs' or 'amd'.
jsx(string) - Specify jsx code generation: 'react' or 'preserve' (TS1.6+).
declaration(boolean) - Generates corresponding .d.ts files.
isolatedCompilation(boolean) - Compiles files seperately and doesn't check types, which causes a big speed increase. You have to use gulp-plumber and TypeScript 1.5+.
See the TypeScript wiki for a complete list. These options are not supported:
sourceRoot) - Use
gulp.watchinstead. See the paragraph "Incremental compilation".
project- See "Using
Besides the official options options, gulp-typescript supports the following options:
noExternalResolve(boolean) - Do not resolve files that are not in the input. Explanation below.
sortOutput(boolean) - Sort output files. Usefull if you want to concatenate files (see below).
typescript(object) - Use a different version / fork of TypeScript (see below). Use it like:
Below is a minimal
gulpfile.js which will compile all TypeScript file in folder
src and emit a single output file called
built/local. To invoke, simple run
var gulp = require'gulp';var ts = require'gulp-typescript';gulptask'default'var tsResult = gulpsrc'src/**/*.ts'pipetsnoImplicitAny: trueout: 'output.js';return tsResultjspipegulpdest'built/local';;
Another example of
gulpfile.js. Instead of creating default task, the file specifies custom named task. To invoke, run
gulp scripts instead of
var gulp = require'gulp';var ts = require'gulp-typescript';var merge = require'merge2'; // Require separate installationgulptask'scripts'var tsResult = gulpsrc'lib/**/*.ts'pipetsdeclarationFiles: truenoExternalResolve: true;return mergetsResultdtspipegulpdest'release/definitions'tsResultjspipegulpdest'release/js';;
Instead of calling
ts(options), you can create a project first, and then call
ts(project). An example:
var gulp = require'gulp';var ts = require'gulp-typescript';var merge = require'merge2';var tsProject = tscreateProjectdeclarationFiles: truenoExternalResolve: true;gulptask'scripts'var tsResult = gulpsrc'lib/*.ts'pipetstsProject;return merge // Merge the two output streams, so this task is finished when the IO of both operations are done.tsResultdtspipegulpdest'release/definitions'tsResultjspipegulpdest'release/js';;gulptask'watch' 'scripts'gulpwatch'lib/*.ts' 'scripts';;
When you run
gulp watch, the source will be compiled as usual. Then, when you make a change and save the file, your TypeScript files will be compiled in about half the time.
You must create the project outside of the task. You can't use the same project in multiple tasks. Instead, create multiple projects or use a single task to compile your sources.
tsconfig.json, you have to use
var tsProject = tscreateProject'tsconfig.json';
If you want to add or overwrite certain settings in the
tsconfig.json file, you can use:
var tsProject = tscreateProject'tsconfig.json' sortOutput: true ;
The task will look like:
gulptask'scripts'var tsResult = tsProjectsrc // instead of gulp.src(...)pipetstsProject;return tsResultjspipegulpdest'release';;
Note: you can only use
tsProject.src() if your
tsconfig.json file has a
files property. If it doesn't, you should use
gulp-typescript uses TypeScript 1.5 by default. You can also use 1.4 or a nighty version of TypeScript instead.
You should add the version you want (1.4+) to your package.json file as a devDependency. You can use the master from GitHub to get the latest features. You can use this in your
package.json to get the master from GitHub:
And add this to your gulpfile:
Or in combination with a
var tsProject = tscreateProject'tsconfig.json'typescript: require'typescript';
It's also possible to use a fork of TypeScript. Add an extra option to the options object like this:
There are two ways to filter files:
gulptask'scripts'var tsResult = gulpsrc'lib/*.ts'pipetstsProject filterSettings;;
gulptask'scripts'var tsResult = gulpsrc'lib/*.ts'pipetstsProject;tsResultpipetsfilterfilterSettings ;;
The first example doesn't add files (that don't pass the filter) to the compiler, the second one does add them to the compiler, but removes them later from the stream. You can put as much pipes between compilation and filtering as you want, as long as the filename doesn't change.
At the moment there is only one filter available:
referencedFrom(string) Only files that are referenced (using
/// <reference path="..." />) by the files in this array pass this filter.
By default, gulp-typescript will try to resolve the files you require and reference. These files are parsed, but not emitted (so you will not see them in the output stream).
If you set the option
noExternalResolve to true, gulp-typescript will not resolve all the requires and references. It assumes that all the necessary files are in the input stream. For example, if you have your
.ts files in the
lib folder, and the
.d.ts files in the
definitions folder, you must use
gulp.src(['lib/**.ts', 'definitions/**.ts']) instead of
gulp.src(['lib/**.ts']) in your gulpfile if you use the option
noExternalResolve: faster compilation.
noExternalResolve: won't work when you forgot some input files.
Advice: turn it on, and make sure you list all the input files.
Files that are resolved when
noExternalResolve is off, won't be pushed to the output stream, unless you are using the
tsc command has the ability to concatenate using the
--out parameter. There are two approaches to do that in
You can use the
out option. This is fine for small projects, but for big projects it's not always sufficient.
The other option is to use
tsc command sorts the files using the
gulp-typescript does this when you enable the
sortOutput option. You can use the
referencedFrom filter to only include files that are referenced from certain files.
var gulp = require'gulp'var ts = require'gulp-typescript';var concat = require'gulp-concat';var sourcemaps = require'gulp-sourcemaps';gulptask'scripts'var tsResult = gulpsrc'lib/*.ts'pipesourcemapsinit // This means sourcemaps will be generatedpipetssortOutput: true// ...;return tsResultjspipeconcat'output.js' // You can use other plugins that also support gulp-sourcemapspipesourcemapswrite // Now the sourcemaps are added to the .js filepipegulpdest'release/js';;
For more information, see gulp-sourcemaps.
You can specify a custom reporter as the 3rd argument of the main function:
tsoptionsOrProject filters reporter;
You can set options, project or filter to
undefined if you don't want to set them. Available reporters are:
ts.reporter.nullReporter()) - Don't report errors
ts.reporter.defaultReporter()) - Report basic errors to the console
ts.reporter.longReporter()) - Extended version of default reporter, intelliJ link functionality + file watcher error highlighting should work using this one
ts.reporter.fullReporter(showFullFilename?: boolean)) - Show full error messages, with source.
If you want to build a custom reporter, you take a look at
lib/reporter.ts, in that file is an interface which a reporter should implement.
The plugin uses itself to compile. There are 2 build directories,
release must always contain a working build.
release-2 contains the last build. When you run
gulp compile, the build will be saved in the
gulp test will compile the source to
release-2, and then it will run some tests. If these tests give no errors, you can run
gulp release. The contents from
release-2 will be copied to
gulp-typescript is licensed under the MIT license.