Repository files navigation

Do you use grunt-ts? Would you like to help keep it up-to-date for new TypeScript versions? Please let@nycdotnet know. I am no longer maintaining this plugin as I no longer use Grunt.

Grunt-ts is an npm package that handles TypeScript compilation work in GruntJS build scripts. This project, much like Grunt itself, is now in a mature maintenance phase and no significant features will be considered. New maintainers welcome!

Grunt-ts provides aGrunt-compatible wrapper for thetsc command-line compiler, and provides someadditional functionality that improves the TypeScript development workflow. Grunt-ts supports compiling againsttsconfig.json or even aVisual Studio project directly. Grunt-ts is itself written inTypeScript.

Thank you for your interest in contributing! Please see thecontributing guide for details.

Latest recommended release is6.0.0-beta.22, which has native support for features added in TypeScript 2.7, and is compatible with any future version of TypeScript by using thetsconfig.json passthrough feature, or theadditionalFlags option.Latest "stable" (though very old at this point) release is5.5.1 with built-in support for features up to TypeScript 1.8.Full changelog is here.

To install grunt-ts, you must first install TypeScript and GruntJS.

• If you don't have TypeScript installed in your project, runnpm install typescript --save-dev.
• If you don't have GruntJS installed in your project, runnpm install grunt --save-dev.
• If you have never used Grunt on your system, install the grunt-cli globally:npm install grunt-cli -g.

• The npm tool has effectively deprecated peer dependencies, so Grunt and TypeScript will no longer automatically be installed when installing grunt-ts. This means you'll just have to install them manually and add them asdevDependencies in yourpackage.json.
• Grunt 1.0 is more strict with templates so it is not possible to use<% and%> as tokens for html replacements with grunt-ts anymore. In grunt-ts 6.0 and higher, you must use{% and%} for HTML replacement tokens.
• The blue text with each file name will no longer be displayed infast mode unlessverbose: true is specified in the task or targetoptions (See#389).

If you've never used GruntJS on your computer, you shouldfollow the detailed instructions here to get Node.js and the grunt-cli working. If you're a Grunt expert, follow these steps:

• Runnpm install grunt-ts in your project directory; this will installgrunt-ts, TypeScript, and GruntJS.
• Add thets task in yourGruntfile.js (see below for a minimalist one).
• Rungrunt at the command line in your project folder to compile your TypeScript code.

This minimalistGruntfile.js will compile your TypeScript project using the specifiedtsconfig.json file. Using atsconfig.json is the best way to use TypeScript:

//module.exports=function(grunt){grunt.initConfig({ts:{default :{tsconfig:'./tsconfig.json'}}});grunt.loadNpmTasks("grunt-ts");grunt.registerTask("default",["ts"]);};

If you prefer the GruntJS idiom, this minimalistGruntfile.js will compile*.ts files in all subdirectories of the project folder, excluding anything undernode_modules. Please note - it is almost always better to use atsconfig.json to compile your TypeScript instead of doing it this way:

module.exports=function(grunt){grunt.initConfig({ts:{default :{src:["**/*.ts","!node_modules/**"]}}});grunt.loadNpmTasks("grunt-ts");grunt.registerTask("default",["ts"]);};

A more extensive sampleGruntfile.js is availablehere.

• Allows use of all standard GruntJS functionality such as the use of customizable task targets, globbing, use of thefiles object (for instantiating multiple independenttsc runs in a single target), etc.
• Allows the developer toselect a custom TypeScript compiler version for their project, or even use a custom (in-house) version.
• Supportsmost switches of thetsc TypeScript Compiler via options in the gruntfilets task, and also supports switch overrides per-target.
• SupportsVisual Studio Projects as a compile target for identifying TypeScript files, setting up compile configuration, or both.
• Supports TypeScript Projects viatsconfig.json when used with TypeScript 1.5 or higher.
• Provides atransforms feature that eases code refactoring by taking the burden of relative path maintenance off the developer. If the paths to a set of files changes, grunt-ts will regenerate the relevant sections. This feature supports:
  • External moduleimport transforms by file name, aliasing, directories, indexed directories, and re-exported imports.
  • Internal modulereference maintenance
  • Commonreference file management
• Allowsconcatenation where supported by the TypeScript compiler's--out switch
• Encodes HTML files as TypeScript variables (for HTML templating engines)
• Performs live filewatching (compile on save)
• Enables"Fast" compile when using external modules
• Please not that Grunt-ts does not support thePath Mapping feature as it is not supported bytsc from the command-line

Grunt-ts provides explicit support for mosttsc switches. Any arbitrary switches can be passed totsc via theadditionalFlags feature.

For file ordering, look atJavaScript Generation.

Note: In the above chart, if "where to define" is "target", the property must be defined on a target or on thets object directly. If "where to define" is "options", then the property must be defined on anoptions object onts or on a target underts.

Grunt-ts does not support the GruntJS standarddest target property. Instead, you should usefiles,out, oroutDir.

Grunt-ts supports use of the GruntJS-centricfiles property on a target as an alternative to thetsc-centric use ofsrc andout/outDir.

Notes:

• Thefast grunt-ts option is not supported in this configuration. You should specifyfast: 'never' to avoid warnings whenfiles is used.
• It is not supported to specify an array of values fordest with grunt-ts. A warning will be issued to the console. If a non-empty array is passed, the first element will be used and the rest will be truncated.
• If thedest parameter ends with ".js", the value will be passed to the--out parameter of the TypeScript compiler. Otherwise, if there is a non-blank value, it will be passed to the--outDir parameter.
• If you intend to pass the specific value "src" to the TypeScript--outDir parameter, specify it as "src/" in the dest parameter to avoid grunt-ts warnings.

Here are some examples of using the targetfiles property with grunt-ts:

grunt.initConfig({ts:{compileTwoSetsOfFilesUsingArrayStyle:{// This will run tsc twice.  The first time, the result of the 'files1/**/*.ts' glob will be// passed to tsc with the --out switch as 'out/ArrayStyle/1.js'.// see https://github.com/gruntjs/grunt-docs/blob/master/Configuring-tasks.md#files-array-formatfiles:[{src:['files1/**/*.ts'],dest:'out/ArrayStyle/1.js'},{src:['files2/**/*.ts'],dest:'out/ArrayStyle/2.js'}],options:{fast:'never'}},compileTwoSetsOfFilesToDirUsingArrayStyle:{// This will run tsc twice.  The first time, the result of the 'files1/**/*.ts' glob will be// passed to tsc with the --outDir switch as 'out/ArrayStyle'.// see https://github.com/gruntjs/grunt-docs/blob/master/Configuring-tasks.md#files-array-formatfiles:[{src:['files1/**/*.ts'],dest:'out/ArrayStyle'},{src:['files2/**/*.ts'],dest:'out/ArrayStyle'}],options:{fast:'never'}},compileTwoSetsOfFilesUsingObjectStyle:{// This will run tsc twice.  The first time, the result of the 'files1/**/*.ts' glob will be// passed to tsc with the --out switch as 'out/ObjectStyle/1.js'.// see https://github.com/gruntjs/grunt-docs/blob/master/Configuring-tasks.md#files-object-formatfiles:{'out/ObjectStyle/1.js':['files1/**/*.ts'],'out/ObjectStyle/2.js':['files2/**/*.ts']},options:{fast:'never'}},compileTwoSetsOfFilesToDirUsingObjectStyle:{// This will run tsc once.  The result of the globs will be passed to tsc with the// --outDir switch as 'out/ObjectStyle'.// see https://github.com/gruntjs/grunt-docs/blob/master/Configuring-tasks.md#files-object-formatfiles:{'out/ObjectStyle':['files1/**/*.ts','files2/**/*.ts']},options:{fast:'never'}}}});

Grunt-ts supports compilation of.html file content to TypeScript variables which is explained in detailhere. Thehtml target property acts similarly tosrc, except that it searches for html files to convert to TypeScript variables. See alsohtmlModuleTemplate andhtmlVarTemplate.

// How to use the html target property (incomplete example)grunt.initConfig({ts:{default:{html:["templates/**/*.html"]}}});

Note: thehtml compilation functionality will not fire if thesrc property is not specified. If you wish to only have the HTML compile to TypeScript without compiling the resulting.ts files to JavaScript, make sure they're excluded from thesrc globs, or else specify an emptysrc array alongside thehtml task property, and set the targetcompile option tofalse:

// Example of how to compile html files to TypeScript without compiling the resulting// .ts files to JavaScript.grunt.initConfig({ts:{default:{html:["templates/**/*.html"],src:[],options:{compile:false}}}});

This section allows global configuration for the grunt-ts task. Alltarget-specific options are supported. If a target also has options set, the target's options override the global task options.

Passes the --out switch totsc. This will cause the emitted JavaScript to be concatenated to a single file if your code allows for that.

Note - the sequence of concatenation when using namespaces (formerly called internal modules) is usually significant. You can assist TypeScript to order the emitted JavaScript correctly by changing the sequence in which files appear in your glob. For example, if you havea.ts,b.ts, andc.ts and use the glob'*.ts, the default would be for TypeScript to concatenate the files in alphabetical order. If you needed the content fromb.ts to appear first, and then the rest in alphabetical order, you could specify the glob like this:['b.ts','*.ts'].

Note - theout feature should not be used in combination withmodule because the TypeScript compiler does not support concatenation of external modules; consider using a module bundler like WebPack, Browserify, or Require's r.js to concatenate external modules.

grunt.initConfig({ts:{default:{out:"dist/myscript.js"}}});

Warning: Using the compiler without andreference will prevent grunt-ts from using its fast compile feature. Consider using external modules with transforms instead.

Passes the --outDir switch totsc. This will redirect the emitted JavaScript to the specified directory and subdirectories.

grunt.initConfig({ts:{default:{outDir:"dist"}}});

Grunt-ts can automatically generate a TypeScript file containing a reference to all other found.ts files. This means that the developer will not need to cross-reference each of their TypeScript files manually; instead, they can just reference the singlereference file in each of their code files.

grunt.initConfig({ts:{default:{src:["references.ts","some/other/path/**/*.ts"],reference:"references.ts"}}});

Note: the TypeScript file identified in thereference propertymust be included in thesrc orfiles property in the Grunt target, orreference won't work (either directly or via wildcard/glob).

Note: It is not supported to usereference withfiles.

Warning: Using the compiler without andreference will prevent grunt-ts from using its fast compile feature. Consider using external modules with transforms instead.

Allows you to specify the TypeScript files that will be passed to the compiler. Supports standard GruntJS functionality such as globbing. More info at Configuring GruntJS Tasks](http://gruntjs.com/configuring-tasks#files).

grunt.initConfig({ts:{default:{src:["app/**/*.ts"]}}});

Grunt-ts can use the TypeScript compilation settings from a Visual Studio project file (.csproj or .vbproj).

In the simplest use case, specify a string identifying the Visual Studio project file name in thevs target property. Grunt-ts will extract the TypeScript settingslast saved into the project file and compile the TypeScript files identified in the project in the manner specified by the Visual Studio project's configuration.

grunt.initConfig({ts:{default:{vs:'test/vsproj/testproject.csproj'}}});

If more control is desired, you may pass thevs target property as an object literal with the following properties:

• project: (string, mandatory) the relative path (from thegruntfile.js) to the Visual Studio project file.
• config: (string, optional, default = '') the Visual Studio project configuration to use (allows choosing a different project configuration than the one currently in-use/saved in Visual Studio).
• ignoreFiles: (boolean, optional, default =false) Will ignore the files identified in the Visual Studio project. This is useful if you want to keep your command-line build settings synchronized with the project's TypeScript Build settings, but want to specify a custom set of files to compile in your ownsrc glob. If not specified or set to false, the TypeScript files referenced in the Visual Studio project will be compiled in addition to any files identified in thesrc target property.
• ignoreSettings: (boolean, optional, default =false) Will ignore the compile settings identified in the Visual Studio project. If specified, grunt-ts will follow its normal behavior and use any TypeScript build settings specified on the target or its defaults.

All features of grunt-ts other thanfiles, are compatible with thevs target property. If you wish to add more files to the compilation than are referenced in the Visual Studio project, thesrc grunt-ts property can be used; any files found in the glob areadded to the compilation list (grunt-ts will resolve duplicates). All other target properties and target options specified in the gruntfile.js willoverride the settings in the Visual Studio project file. For example, if you were referencing a Visual Studio project configuration that had source maps enabled, specifyingsourcemap: false in the gruntfile.js would keep all other Visual Studio build settings, but disable generation of source maps.

Note: Using thevs target property withfiles is not supported.

Example: Use all compilation settings specified in the "Release" TypeScript configuration from the project, but compile only the TypeScript files in thelib subfolder to a single file in thebuilt folder.

grunt.initConfig({ts:{CompileMyLibsOnly:{src:'MyProject/lib/**/*.ts',out:'built/mylibs.js',vs:{project:'MyProject/MyProject.csproj',ignoreFiles:true,config:'Release'}}}});

If you wish to disable the Visual Studio built-in TypeScript build, but keep the Visual Studio project properties TypeScript Build pane working, followthese instructions.

Grunt-ts can watch a directory and recompile TypeScript files when any TypeScript or HTML file is changed, added, or removed. Use thewatchtarget option specifying a target directory that will be watched. All subdirectories are automatically included.

Note: this feature does not allow for additional tasks to run after the compilation step is done - for that you should usegrunt-contrib-watch.

grunt.initConfig({ts:{default:{watch:"."//will re-run this task if any .ts or .html file is changed.}}});

Allows passing arbitrary strings to the compiler. This is intended to enable compatibility with features not supported directly by grunt-ts. The parameters will be passed exactly as-is with a space separating them from the previous switches. It is possible to pass more than one switch withadditionalFlags by separating them with spaces.

grunt.initConfig({ts:{default:{options:{additionalFlags:'--autoFixBugs --gruntTs "is awesome!"'}}}});

Allows JavaScript files to be compiled. This setting works well withoutDir. This feature requires grunt-ts 5.5 or higher and TypeScript 1.8 or higher.

grunt.initConfig({ts:{default:{src:["**/*.ts","**/*.js","!emit/**","!node_modules/**"],outDir:'emit/',options:{allowJs:true}}}});

Allows use of ES6 "default" import syntax with pre-ES6 modules when not using SystemJS. If using module format "amd", "commonjs" or "umd", the following import syntax for jQuery will give the error "Module 'jquery' has no default export" when exporting to "amd", "commonjs", or "umd" format:import * as $ from 'jquery';. In that case, passing allowSyntheticDefaultImports will eliminate this error. NOTE: This is the default behavior when SystemJS module format is used (module: "system"). This switch (and behavior) requires TypeScript 1.8 or higher. Seethis issue for more details.

grunt.initConfig({ts:{default:{options:{allowSyntheticDefaultImports:true,module:'umd'}}}});

When set to true, TypeScript will not report errors on unreachable code. Requires TypeScript 1.8 or higher.

grunt.initConfig({ts:{default:{src:["**/*.ts","!node_modules/**"],options:{allowUnreachableCode:true}}}});

When set to true, TypeScript will not report errors when there are unused labels in your code. Requires TypeScript 1.8 or higher.

grunt.initConfig({ts:{default:{src:["**/*.ts","!node_modules/**"],options:{allowUnusedLabels:true}}}});

Deprecated - when using TypeScript >= 1.5 (most common), userootDir instead.

When using fast compile with outDir, tsc won't guarantee the output directory structure will match the source structure. Setting baseDir helps to ensure the original source structure is mapped to the output directory. This will create a .baseDir.ts file in the baseDir location. A .baseDir.js and .baseDir.js.map will be created in the outDir.

grunt.initConfig({ts:{default:{outDir:'dist',options:{baseDir:'src',fast:always}}}});

true(default)|false

Indicates if the TypeScript compilation should be attempted. Turn this off if you wish to just run transforms.

grunt.initConfig({ts:{default:{options:{compile:false}}}});

This target option allows the developer to select an alternate TypeScript compiler.

By default,grunt-ts will use the TypeScript compiler that came bundled with it. Alternate compilers can be used by this target option (for custom compiler builds) or usingpackage.json (for npm released version oftypescript).

To use a custom compiler, update your gruntfile.js file with this code:

grunt.initConfig({ts:{options:{compiler:'./node_modules/grunt-ts/customcompiler/tsc'}}});

Download custom compilers from the currentTypeScript repository on GitHub or the oldTypeScript repository on CodePlex and extract it to a folder in your project. The compiler will be in thebin folder. Copy all of the files to your project folder and then referencetsc using thecompiler task option. For example, if you extracted everything to amycompiler folder in your project, you'd set the grunt-tscompiler property to'./mycompiler/tsc'.

In the absence of a compiler argument,grunt-ts will look for an alternate compiler in itspeernode_modules folder (wheregrunt-ts andtypescript are peers).

Thepackage.json would look something like this for a legacy project:

{"devDependencies":{"grunt" :"~0.4.1","grunt-ts" :"~1.9.2","typescript" :"0.9.7"}}

Note: It is safest to pin the exact TypeScript version (do not use~ or>).

true|false(default)

Retains comments in the emitted JavaScript if set totrue. Removes comments if set tofalse. Note that ifcomments andremoveComments are both used, the value ofremoveComments will win; regardless, please don't do this as it is just confusing to everyone.

grunt.initConfig({ts:{options:{comments:true//preserves comments in output.}}});

true|false(default)

Generates corresponding .d.ts file(s) for compiled TypeScript files.

grunt.initConfig({ts:{options:{declaration:true}}});

true|false(default)

Set to true to pass--emitDecoratorMetadata to the compiler. If set to true, TypeScript will emit type information about type and parameter decorators, so it's available at runtime.

Used by tools likeAngular. You will probably need to import thereflect-metadata package in your app when using this feature.

This is only available in TypeScript 1.5 and higher. If enabled, will automatically enableexperimentalDecorators

grunt.initConfig({ts:{options:{emitDecoratorMetadata:true}}});

true|false(default)

A new compatability mode to enable consistent runtime behavior with Babel and Webpack with regards to callable default ES module imports. See theTypeScript 2.7 Anouncement blog post for more details.

grunt.initConfig({ts:{options:{esModuleInterop:true}}});

true|false(default)

Set to true to emit events in Grunt upon significant events in grunt-ts. This is used by the taskvalidate_failure_count in the Gruntfile.js of grunt-ts itself. Currently, the only supported event isgrunt-ts.failure which will be raised upon a failed build ifemitGruntEvents is true. This is only available in grunt-ts 5.2.0 or higher.

grunt.initConfig({ts:{options:{emitGruntEvents:true}}});

Example usage:

grunt.event.on('grunt-ts.failure',function(){console.log('It failed!!!!!!');});

true|false(default)

Enable support for experimental proposed ECMAScript async functionality. This is only available in TypeScript 1.6 and higher in 'es6' mode.

grunt.initConfig({ts:{options:{experimentalAsyncFunctions:true,target:'es6'}}});

true|false(default)

Enable support for experimental proposed ECMAScript decorators. This is only available in TypeScript 1.5 and higher.

grunt.initConfig({ts:{options:{experimentalDecorators:true}}});

true(default)|false

TypeScript has two types of errors: emit preventing and non-emit preventing. Generally, type errors do not prevent the JavaScript emit. Therefore, it can be useful to allow the Grunt pipeline to continue even if there are type errors becausetsc will still generate JavaScript.

IffailOnTypeErrors is set tofalse, grunt-ts will not halt the Grunt pipeline if a TypeScript type error is encountered. Note that syntax errors or other generaltsc errors will always halt the pipeline.

grunt.initConfig({ts:{options:{failOnTypeErrors:true}}});

"watch"(default)|"always"|"never"

If you are usingexternal modules, grunt-ts will try to do afast compileby default, basically only compiling what's changed. It should "just work" with the built-in file watching as well as with external tools likegrunt-contrib-watch.

To do a fast compile, grunt-ts maintains a cache of hashes for TypeScript files in the.tscache folder to detect changes (needed for external watch tool support). It also creates a.baseDir.ts file at the root, passing it to the compiler to make sure that--outDir is always respected in the generated JavaScript.

You cancustomize the behaviour of grunt-tsfast.

If you are usingfiles, grunt-ts can't do a fast compile. You should setfast to 'never'.

grunt.initConfig({ts:{options:{// disable the grunt-ts fast featurefast:'never'}}});

When set to true, disallows inconsistently-cased references to the same file. For example, when using ES6-style imports, importing a file as "./MyLibrary" in one file and "./mylibrary" in another.

grunt.initConfig({ts:{default:{src:["**/*.ts","!node_modules/**"],options:{forceConsistentCasingInFileNames:true}}}});

Grunt-ts supports compilation of.html file content to TypeScript variables which is explained in detailhere. ThehtmlModuleTemplate target property allows the developer to define a namespace for the templates. See alsohtml andhtmlVarTemplate.

//Note: incomplete - combine with html and htmlVarTemplategrunt.initConfig({ts:{default:{options:{//MyTemplate.html will be accessible as HtmlTemplates.MyTemplatehtmlModuleTemplate:'HtmlTemplates.<%= filename %>'}}}});

Grunt-ts supports compilation of.html file content to TypeScript variables which is explained in detailhere. ThehtmlVarTemplate target property allows the developer to define a property name for the template contents. See alsohtml andhtmlModuleTemplate.

//Note: incomplete - combine with html and htmlModuleTemplategrunt.initConfig({ts:{default:{options:{//HTML template objects will expose their content via a property called markup.htmlVarTemplate:'markup'}}}});

Sets a root for output of transformed-to-TypeScript HTML files. See detailed explanation ofgrunt-ts HTML template support.

//Note: incomplete - combine with html and src/files/etc.grunt.initConfig({ts:{default:{options:{htmlOutDir:'generatedHtml'}}}});

Will flatten the transformed HTML files to a single folder. See detailed explanation ofgrunt-ts HTML template support.

//Note: incomplete - combine with html and src/files/etc.grunt.initConfig({ts:{default:{options:{htmlOutDir:'generatedHtml',htmlOutDirFlatten:true}}}});

Grunt-ts supports compilation of.html file content to TypeScript variables which is explained in detailhere. ThehtmlOutputTemplate target property allows the developer to override the internally defined output template to a custom one, useful if one would like to define the HTML output as an external modules, for example.

Three variables can be used in the template, namely:

• "<%= modulename %>" - This variable will be replaced with the value of thehtmlModuleTemplate option.
• "<%= varname %>" - This variable will be replaced with the value of thehtmlVarTemplate option.
• "<%= content %>" - This variable will be replaced with the content of the HTML file.

//Note: Outputs an external modulegrunt.initConfig({ts:{default:{options:{//HTML template objects will expose their content via a property called markup.htmlVarTemplate:'markup',htmlModuleTemplate:'html',htmlOutputTemplate:'/* tslint:disable:max-line-length */ \n\          export module <%= modulename %> {\n\              export var <%= varname %> = \'<%= content %>\';\n\          }\n'}}}});

true|false(default)

When true, TypeScript will emit source maps inline at the bottom of each JS file, instead of emitting a separate.js.map file. If this option is used withsourceMap,inlineSourceMap will win.

grunt.initConfig({ts:{default:{options:{inlineSourceMap:true}}}});

true|false(default)

When true, TypeScript will emit TypeScript sources "inline". Thismust be used with eitherinlineSourceMap orsourceMap. When used withinlineSourceMap, the TypeScript sources and the source map itself are included in a Base64-encoded string in a comment at the end of the emitted JavaScript file. When used withsourceMap, the escaped TypeScript sources are included in the .js.map file itself under asourcesContent property.

grunt.initConfig({ts:{default:{options:{inlineSources:true,inlineSourceMap:true}}}});

true|false(default)

When true, makes scenarios that break single-file transpilation into an error. Seemicrosoft/TypeScript#2499 for more details. If you are using TypeScript 1.5, and fast compilation, it is ideal to use this to take advantage of future compilation optimizations.

grunt.initConfig({ts:{default:{options:{isolatedModules:true}}}});

`'react'`(default)|`'preserve'`

Specify the JSX code generation style. Documentation is here:TypeScript Wiki - JSX.

grunt.initConfig({ts:{options:{jsx:'preserve'}}});

List of library files to be included in the compilation. If--lib is not specified a default library is injected.

grunt.initConfig({ts:{options:{lib:['es2015']}}});

Specify culture string for error messages - will pass the--locale switch. Requires appropriate TypeScript error messages file to be present (see TypeScript documentation for more details).

grunt.initConfig({ts:{default:{options:{locale:"ja-jp"}}}});

Specifies the root for where.js.map sourcemap files should be referenced. This is useful if you intend to move your.js.map files to a different location. Leave this blank or omit entirely if the.js.map files will be deployed to the same folder as the corresponding.js files. See alsosourceRoot.

grunt.initConfig({ts:{default:{options:{//When abc.ts is compiled to abc.js, it will reference /maps/abc.js.mapmapRoot:"/maps"}}}});

"amd"|"commonjs"|"system"|"umd"|"es6"|"es2015"|""(default)|"none"(samebehavioras"")

Specifies if TypeScript should emit AMD, CommonJS, SystemJS, "ES6", or UMD-style external modules. Has no effect if internal modules are used. Note - this should not be used in combination withoutprior to TypeScript 1.8 because the TypeScript compiler does not support concatenation of external modules; consider using a module bundler like WebPack, Browserify, or Require's r.js to concatenate external modules.

grunt.initConfig({ts:{default:{options:{module:"amd"}}}});

"node"|"classic"(default)

New in TypeScript 1.6. TypeScript is gaining support for resolving definition files using rules similar to common JavaScript module loaders. The first new one is support for CommonJS used by NodeJS, which is why this parameter is called"node" The"node" setting performs an extra check to see if a definition file exists in thenode_modules/modulename folder if a TypeScript definition can't be found for an imported module. if this is not desired, set this setting to "classic".

On Defaults. When using--module commonjs the default--moduleResolution will benode. For all other--module options the default is--moduleResolution classic. If specified, the specified value will always be used.

grunt.initConfig({ts:{default:{options:{moduleResolution:"classic"}}}});

"CRLF"|"LF"|""(default)

Will force TypeScript to use the specified newline sequence. Grunt-ts will also use this newline sequence for transforms. If not specified, TypeScript and grunt-ts use the OS default.

grunt.initConfig({ts:{default:{options:{newLine:"CRLF"}}}});

true|false(default)

Set to true to pass--noEmit to the compiler. If set to true, TypeScript will not emit JavaScript regardless of if the compile succeeds or fails.

grunt.initConfig({ts:{default:{options:{noEmit:true}}}});

true|false(default)

Set to true to pass--noEmitHelpers to the compiler. If set to true, TypeScript will not emit JavaScript helper functions such as__extends. This is for very advanced users who wish to provide their own implementation of the TypeScript runtime helper functions.

grunt.initConfig({ts:{default:{options:{noEmitHelpers:true}}}});

true|false(default)

Set to true to pass--noEmitOnError to the compiler. If set to true, TypeScript will not emit JavaScript if there is a type error. This flag does not affect the Grunt pipeline; to force the Grunt pipeline to continue (or halt) in the presence of TypeScript type errors, seefailOnTypeErrors.

grunt.initConfig({ts:{default:{options:{noEmitOnError:true}}}});

true|false(default)

Report errors for fallthrough cases in switch statement.

grunt.initConfig({ts:{default:{src:["**/*.ts","!node_modules/**"],options:{noFallthroughCasesInSwitch:true}}}});

true|false(default)

Set to true to pass--noImplicitAny to the compiler. Requires more strict type checking. IfnoImplicitAny is enabled, TypeScript will raise a type error whenever it is unable to infer the type of a variable. By default, grunt-ts will halt the Grunt pipeline on type errors. SeefailOnTypeErrors for more info.

grunt.initConfig({ts:{default:{options:{noImplicitAny:true}}}});

true|false(default)

Report error when not all code paths in function return a value.

grunt.initConfig({ts:{default:{options:{noImplicitReturns:true}}}});

true|false(default)

Set to true to pass--noImplicitThis to the compiler. Requires more strict type checking. Raise error onthis expressions with an impliedany type.

grunt.initConfig({ts:{default:{options:{noImplicitThis:true}}}});

true|false(default)

Set to true to pass--noImplicitGenericChecks to the compiler. Disables strict checking of generic signatures in function types.

grunt.initConfig({ts:{default:{options:{noImplicitGenericChecks:true}}}});

true|false(default)

Specify this option if you do not want the lib.d.ts to be loaded by the TypeScript compiler. Generally this is used to allow you to manually specify your own lib.d.ts.

grunt.initConfig({ts:{default:{options:{noLib:true}}}});

true|false(default)

Do not add triple-slash references or module import targets to the list of compiled files.

grunt.initConfig({ts:{options:{noResolve:true}}});

true|false(default)

Set to true to pass--preserveConstEnums to the compiler. If set to true, TypeScript will emit code that allows other JavaScript code to use the enum. If false (the default), TypeScript will inline the enum values as magic numbers with a comment in the emitted JS.

grunt.initConfig({ts:{default:{options:{preserveConstEnums:true}}}});

true|false(default)

Set to true to pass--preserveSymlinks to the compiler. If set, TypeScript will not resolve symlinks to their real path; instead it will treat a symlinked file like a real one.

grunt.initConfig({ts:{default:{options:{preserveSymlinks:true}}}});

true|false(default)

Stylize errors and messages using color and context.

grunt.initConfig({ts:{default:{options:{pretty:true}}}});

string

Specifies the object invoked forcreateElement and__spread when targeting 'react' JSX emit. Requires TypeScript 1.8 or higher and grunt-ts 5.5 or higher.

grunt.initConfig({ts:{options:{rootDir:"src/app"}}});

true(default)|false

Removes comments in the emitted JavaScript if set totrue. Preserves comments if set tofalse. Note that ifcomments andremoveComments are both used, the value ofremoveComments will win; regardless, please don't do this as it is just confusing to everyone.

grunt.initConfig({ts:{options:{removeComments:false//preserves comments in output.}}});

string

Affects the creation of folders inside theoutDir location.rootDir allows manually specifying the desired common root folder when used in combination withoutDir. Otherwise, TypeScript attempts to calculate this automatically. Not specifyingrootDir can result inoutDir not matching structure of src folder when usingfast compilation.baseDir provides a poor man's version ofrootDir for those using TypeScript < 1.5.

grunt.initConfig({ts:{options:{rootDir:"src/app"}}});

true|false(default)

Don't check a user-defined default lib file's validity. This switch is deprecated in TypeScript 2.5+ (use skipLibCheck instead).

grunt.initConfig({ts:{default:{options:{skipDefaultLibCheck:true}}}});

true|false(default)

Skip type checking of all declaration files (*.d.ts).

grunt.initConfig({ts:{default:{options:{skipLibCheck:true}}}});

true|false(default)

The strict property is a macro to enable all of the strict checks in TypeScript

grunt.initConfig({ts:{default:{options:{strict:true}}}});

true|false(default)

Enforce contravariant function parameter comparison. Under--strictFunctionTypes, any function type that doesn't originate from a method has its parameters comparedcontravariantly.

grunt.initConfig({ts:{default:{options:{strictFunctionTypes:true}}}});

true|false(default)

In strict null checking mode, thenull andundefined values are not in the domain of every type and are only assignable to themselves andany (the one exception being thatundefined is also assignable tovoid).

grunt.initConfig({ts:{default:{options:{strictNullChecks:true}}}});

true|false(default)

The strictPropertyInitialization property ensures that properties are initialized before use

grunt.initConfig({ts:{default:{options:{strictPropertyInitialization:true}}}});

true(default)|false

If true, grunt-ts will instructtsc to emit source maps (.js.map files). If this option is used withinlineSourceMap,inlineSourceMap will win.

grunt.initConfig({ts:{default:{options:{sourceMap:true}}}});

The sourceRoot to use in the emitted source map files. Allows mapping moved.js.map files back to the original TypeScript files. See alsomapRoot.

grunt.initConfig({ts:{default:{options:{sourceRoot:"/dev"}}}});

Use stripInternal to prevent the emit of members marked as @internal via a comment. For example:

/*@internal */exportclassMyClass{}

grunt.initConfig({ts:{default:{options:{sourceRoot:"/dev"}}}});

true|false(default)

Set to true to disable strict object literal assignment checking (experimental). Seemicrosoft/TypeScript#4484 for more details.

grunt.initConfig({ts:{default:{options:{suppressExcessPropertyErrors:true}}}});

true|false(default)

Set to true to pass--suppressImplicitAnyIndexErrors to the compiler. If set to true, TypeScript will allow access to properties of an object by string indexer when--noImplicitAny is active, even if TypeScript doesn't know about them. This setting has no effect unless--noImplicitAny is active.

grunt.initConfig({ts:{default:{options:{suppressImplicitAnyIndexErrors:true,noImplicitAny:true}}}});

For example, the following code would not compile with--noImplicitAny alone, but it would be legal with--noImplicitAny and--suppressImplicitAnyIndexErrors both enabled:

interfaceperson{name:string;}varp :person={name:"Test"};p["age"]=101;//property age does not exist on interface person.console.log(p["age"]);

true|false(default)

Set to true to pass--emitDecoratorMetadata to the compiler. If set to true, TypeScript will emit type information about type and parameter decorators, so it's available at runtime.

Used by tools likeAngular. You will probably need to import thereflect-metadata package in your app when using this feature.

"es5"(default)|"es3"|"es6"

Allows the developer to specify if they are targeting ECMAScript version 3, 5, or 6. Support fores6 emit was added in TypeScript 1.4 and is listed as experimental. Only select ES3 if you are targeting old browsers (IE8 or below). The default for grunt-ts (es5) is different than the default fortsc (es3).

grunt.initConfig({ts:{default:{options:{target:"es3"//for IE8 and below}}}});

Grunt-ts can integrate with atsconfig.json file in three ways which offer different behavior:

• As aboolean: simplest way for default behavior.
• As astring: still uses defaults, but allows specifying a specific path to thetsconfig.json file or the containing folder.
• As anobject: allows detailed control over how grunt-ts works withtsconfig.json

When specifying tsconfig as a booleanIn this scenario, grunt-ts will use all settings from thetsconfig.json file in the same folder asGruntfile.js.

• If aninclude property is present in thetsconfig.json file:
  • Grunt-ts will emulate the native tsconfig behavior of TypeScript with regards to theinclude array andexclude array (if present).
  • Note: Grunt-ts will fail the Grunt pipeline if aninclude property is present in thetsconfig.json file and grunt-ts hasoverwriteFilesGlob orupdateFiles set to true. These settings were developed for a time beforeinclude was available, and they don't make sense to use with it.
• If afilesGlob property is present in thetsconfig.json file:
  • It will be evaluated, and any identified files will be added to the compilation context.
  • If afiles property is present, it will be modified with the result from evaluating thefilesGlob that is presentinsidetsconfig.json (thefiles element willnot be updated with the results from any glob insideGruntfile.js).
  • Ifexclude is present, it will be ignored.
• If afilesGlob property is NOT present, butfiles is present:
  • Any files specified infiles will be added to the compilation context.
  • Ifexclude is present, it will be ignored.
• If neitherfilesGlob norfiles is present:
  • All *.ts and *.tsx files in all subfolders will be added to the compilation context,excluding any subfolders specified in the optionalexclude property.
• If a glob is also specified in theGruntfile.js, grunt-ts will NOT update thefilesGlob in thetsconfig.json file with it nor will those files be added to thetsconfig.jsonfiles element.
• Thetsconfig property should function correctly as either a task option or a target property.
• If thetsconfig.json file does not exist or there is a parse error, compilation will be aborted with an error.

grunt.initConfig({ts:{default:{// specifying tsconfig as a boolean will use the 'tsconfig.json' in same folder as Gruntfile.jstsconfig:true}}});

When specifying tsconfig as a stringThis scenario follows the same behavior as specifyingtsconfig.json as a boolean, except that it is possible to use an explicit file name. If a directory name is provided instead, grunt-ts will usetsconfig.json in that directory. The path totsconfig.json (or the directory that contains it) is relative toGruntfile.js.

grunt.initConfig({ts:{default:{// specifying tsconfig as a string will use the specified `tsconfig.json` file.tsconfig:'./some/path/to/tsconfig.json'}}});

When specifying tsconfig as an objectThis provides the most control over how grunt-ts integrates withtsconfig.json. Supported properties are:

• tsconfig:string (optional) - if absent, will default totsconfig.json in same folder asGruntfile.js. If a folder is passed, will usetsconfig.json in that folder.
• ignoreFiles:boolean (optional) - default isfalse. If true, will not inlcude files infiles array fromtsconfig.json in the compilation context.
• ignoreSettings:boolean (optional) - default isfalse. If true, will ignorecompilerOptions section intsconfig.json (will only use settings fromGruntfile.js or grunt-ts defaults)
• overwriteFilesGlob:boolean (optional) - default isfalse. If true, will overwrite the contents of thefilesGlob array with the contents of thesrc glob from grunt-ts. This option is not supported ifinclude is specified in thetsconfig.json file.
• updateFiles:boolean (optional) - Ifinclude in the tsconfig.json file is not specified and there is afilesGlob present, default istrue, otherwise false. Will modify thefiles array intsconfig.json to match the result of evaluating afilesGlob that is presentinsidetsconfig.json (thefiles element willnot be updated with the results from any glob insideGruntfile.js unlessoverwriteFilesGlob is alsotrue).
• passThrough:boolean (optional) - default isfalse. SeepassThrough, below.

grunt.initConfig({ts:{default:{// specifying tsconfig as an object allows detailed configuration overrides...tsconfig:{tsconfig:'./SomeOtherFolder/tsconfig.json',ignoreFiles:false,ignoreSettings:false,overwriteFilesGlob:false,updateFiles:true,passThrough:false}}}});

IfpassThrough is set totrue, grunt-ts will run TypeScript (tsc) with the specified tsconfig, passing the--project option only (plus anything inadditionalFlags). This provides support for custom compilers with custom implementations oftsconfig.json support. Note: Since this entirely depends on support fromtsc, thetsconfig option must be a directory (not a file) as of TypeScript 1.6. If you are entirely happy with yourtsconfig.json, this is the way you should run grunt-ts.

• Globs infilesGlob intsconfig.json are relative to thetsconfig.json,not theGruntfile.js.
• tsconfig has a restriction when used withfiles in the Grunt task configuration:overwriteFilesGlob is NOT supported iffiles has more than one element. This will abort compilation.
• Iffiles is absent intsconfig.json, butfilesGlob is present, grunt-ts will create and update thefiles array intsconfig.json as long asupdateFiles istrue (the default). Sincefiles will be created in this scenario, any values in theexclude array will be ignored.
• This feature may be used along with thevs keyword. Any settings found intsconfig.json will override any settings found in the Visual Studio project file. Any files referenced in the Visual Studio file that are not also referenced in tsconfig.jsonwill be included in the compilation context after any files fromtsconfig.json (any files fromsrc but not invs ortsconfig will be included after that). The order of the files intsconfig.json will override the order of the files in the VS project file.

false(default)|true

Will print the switches passed totsc on the console. Helpful for debugging.

grunt.initConfig({ts:{default:{options:{verbose:true}}}});

Objective: To allow for easier code refactoring by taking relative path maintenance burden off the developer. If the path to a referenced file changes,grunt-ts will regenerate the relevant lines.

Transforms begin with a three-slash comment/// and are prefixed withts:. When grunt-ts is run against your TypeScript file, it will add a new line with the appropriate TypeScript code to reference the file, or it will generate a comment indicating that the file you referenced could not be found.

For example, if you put this in your code:

///ts:ref=mylibrary

The next time grunt-ts runs, it might change that line to this:

///ts:ref=mylibrary/// <reference path='../path/to/mylibrary.d.ts'/> ///ts:ref:generated

Important Note: All transforms require the searched-for file to beincluded in the result of thefiles,src, orvs Grunt globs. Grunt-ts will only search within the results thatGrunt has identified; it does not go searching through your disk for files!

You can also run transforms without compiling your code by settingcompile: false in your config. For example:

grunt.initConfig({ts:{"transforms-only":{options:{compile:false},// in addition to your standard settings:// src: ...// outDir: ...},// ...}});

///ts:import=<fileOrDirectoryName>[,<variableName>]

This will generate the relevantimport foo = require('./path/to/foo'); code without you having to figure out the relative path.

If a directory is provided, the entire contents of the directory will be imported. However if a directory has a fileindex.ts inside of it, then instead of importing the entire folder onlyindex.ts is imported.

Import file:

///ts:import=filenameimportfilename= require('../path/to/filename');///ts:import:generated

Import file with an alternate name:

///ts:import=BigLongClassName,fooimportfoo= require('../path/to/BigLongClassName');///ts:import:generated

Import directory:

///ts:import=directoryNameimportfilename= require('../path/to/directoryName/filename');///ts:import:generatedimportanotherfile= require('../path/to/directoryName/deeper/anotherfile');///ts:import:generated...

Import directory that has anindex.ts file in it:

///ts:import=directoryNameimportdirectoryName= require('../path/to/directoryName/index');///ts:import:generated

See Exports for examples of how grunt-ts can generate anindex.ts file for you

///ts:export=<fileOrDirectoryName>[,<variableName>]

This is similar to///ts:import but will generateexport import foo = require('./path/to/foo'); and is very useful for generating indexes of entire module directories when using external modules (which you shouldalways be using).

Export file:

///ts:export=filenameexportimportfilename=require('../path/to/filename');///ts:export:generated

Export file with an alternate name:

///ts:export=filename,fooexportimportfoo=require('../path/to/filename');///ts:export:generated

Export directory:

///ts:export=dirNameexportimportfilename=require('../path/to/dirName/filename');///ts:export:generatedexportimportanotherfile=require('../path/to/dirName/deeper/anotherfile');///ts:export:generated...

///ts:ref=<fileName>

This will generate the relevant/// <references path="./path/to/foo" /> code without you having to figure out the relative path.

Note: grunt-ts only searches through the enumerated results of thesrc orfiles property in the Grunt target. The referenced TypeScript filemust be included for compilation (either directly or via wildcard/glob) or the transform won't work. This is so that grunt-ts doesn't go searching through your whole drive for files.

Reference file:

///ts:ref=filename/// <reference path='../path/to/filename'/> ///ts:ref:generated

When a output file is specified viaout in combination with a reference file viareference then grunt-ts uses the generated reference file toorder the code in the generated JavaScript.

Usereference.ts to specify the order for the few files the build really cares about and leave the rest to be maintained by grunt-ts.

E.g. in the following case the generated JavaScript forsomeBaseClass.ts is guaranteed to be at the top, and the generated JavaScript formain.ts is guaranteed to be at the bottom of the single mergedjs file.

Everything betweengrunt-start andgrunt-end is generated and maintained by grunt-ts. If there is nogrunt-start section found, it is created. Ifreference.ts does not exist originally, it is also created.

/// <reference path="someBaseClass.ts" />// Put comments here and they are preserved//grunt-start/// <reference path="autoreference.ts" />/// <reference path="someOtherFile.ts" />//grunt-end/// <reference path="main.ts" />

As of grunt-ts v2.0.2, If you wish to standardize the line endings used by grunt-ts transforms, you can set thegrunt.util.linefeed property in your gruntfile.js to the desired standard line ending for the grunt-ts managed TypeScript files.

module.exports=function(grunt){grunt.util.linefeed='\r\n';// this would standardize on CRLF/* rest of config */};

TypeScript programming using grunt-ts (YouTube):

AngularJS + TypeScript : Workflow with grunt-ts (YouTube)

Licensed under the MIT License.