feat(*): now we can start ckecker in a separate process

Author: Stanislav Panferov

README.md

@@ -111,6 +111,14 @@ with pure TS files inside your app.
 
 Common-separated list of paths to .d.ts files that must be included in program. Useful with `rewriteImports`.
 
+### doTypeCheck *(string) (default=true)*
+
+Use this setting to disable type checking if you want.
+
+### forkChecker *experimental!* *(string) (default=false)*
+
+Do type checking in a separate process, so webpack don't need to wait. **Significantly** development workflow.
+
 ## Using with --watch or webpack-dev-server
 
 This loader has support of both `--watch` and `webpack-dev-server` modes. It handles file dependencies

package.json

@@ -29,7 +29,8 @@
     "lodash": "^3.10.0",
     "ntypescript": "1.201507141013.1",
     "object-assign": "^2.0.0",
-    "typescript": "1.5.0-beta"
+    "typescript": "1.5.0-beta",
+    "colors": "^1.1.2"
   },
   "devDependencies": {
     "git-hooks": "0.0.10",

src/checker.ts

@@ -0,0 +1,112 @@
+import { CompilerOptions, CompilerInfo, File } from './host';
+import * as colors from 'colors';
+
+export enum MessageType {
+    Init = <any>'init',
+    Compile = <any>'compile'
+}
+
+export interface IMessage {
+    messageType: MessageType,
+    payload: any
+}
+
+export interface IInitPayload {
+    compilerOptions: CompilerOptions;
+    compilerInfo: CompilerInfo
+}
+
+export interface ICompilePayload {
+    files: {[fileName: string]: File};
+}
+
+export interface IEnv {
+    options?: CompilerOptions;
+    compiler?: typeof ts;
+    compilerInfo?: CompilerInfo;
+    host?: Host;
+    files?: {[fileName: string]: File};
+    program?: ts.Program;
+    service?: ts.LanguageService;
+}
+
+let env: IEnv = {};
+
+export class Host implements ts.LanguageServiceHost {
+
+    getScriptFileNames() {
+        return Object.keys(env.files);
+    }
+
+    getScriptVersion(fileName: string) {
+        if (env.files[fileName]) {
+            return env.files[fileName].version.toString();
+        }
+    }
+
+    getScriptSnapshot(fileName) {
+        var file = env.files[fileName];
+        if (file) {
+            return env.compiler.ScriptSnapshot.fromString(file.text);
+        }
+    }
+
+    getCurrentDirectory() {
+        return process.cwd();
+    }
+
+    getScriptIsOpen() {
+        return true;
+    }
+
+    getCompilationSettings() {
+        return env.options;
+    }
+
+    getDefaultLibFileName(options) {
+        return options.target === ts.ScriptTarget.ES6 ?
+            env.compilerInfo.lib6.fileName :
+            env.compilerInfo.lib5.fileName;
+    }
+
+    log(message) {
+        //console.log(message);
+    }
+
+}
+
+function processInit(payload: IInitPayload) {
+    env.compiler = require(payload.compilerInfo.compilerName);
+    env.host = new Host();
+    env.compilerInfo = payload.compilerInfo;
+    env.options = payload.compilerOptions;
+    env.service = this.ts.createLanguageService(env.host, env.compiler.createDocumentRegistry());
+}
+
+function processCompile(payload: ICompilePayload) {
+    env.files = payload.files;
+    let program = env.program = env.service.getProgram();
+    var allDiagnostics = env.compiler.getPreEmitDiagnostics(program);
+    if (allDiagnostics.length) {
+        console.error(colors.yellow('Checker diagnostics:'))
+        allDiagnostics.forEach(diagnostic => {
+            var { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+            var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+            console.error(`${colors.cyan(diagnostic.file.fileName)} (${line + 1},${character + 1}):\n    ${colors.red(message)}`);
+        });
+    } else {
+        console.error(colors.green('Your program is fine!'))
+    }
+
+}
+
+process.on('message', function(msg: IMessage) {
+    switch (msg.messageType) {
+        case MessageType.Init:
+            processInit(msg.payload);
+            break;
+        case MessageType.Compile:
+            processCompile(msg.payload);
+            break;
+    }
+});

src/host.ts

@@ -18,6 +18,7 @@ export interface File {
 
 export interface CompilerInfo {
     compilerName: string;
+    compilerPath: string;
     tsImpl: typeof ts;
     lib5: { fileName: string, text: string };
     lib6: { fileName: string, text: string };
@@ -34,7 +35,9 @@ export interface CompilerOptions extends ts.CompilerOptions {
     tsconfig?: string;
     useWebpackText?: boolean;
     rewriteImports?: string;
-    externals?: string
+    externals?: string;
+    doTypeCheck?: boolean;
+    forkChecker?: boolean;
 }
 
 export class Host implements ts.LanguageServiceHost {

src/index.ts

@@ -5,6 +5,7 @@ import * as Promise from 'bluebird';
 import * as path from 'path';
 import * as fs from 'fs';
 import * as _ from 'lodash';
+import * as childProcess from 'child_process';
 
 import { CompilerOptions, TypeScriptCompilationError, State, CompilerInfo } from './host';
 import { Resolver, ResolutionError } from './deps';
@@ -40,6 +41,7 @@ interface CompilerInstance {
     compiledFiles: {[key:string]: boolean};
     options: CompilerOptions;
     externalsInvoked: boolean;
+    checker: any;
 }
 
 function getRootCompiler(compiler) {
@@ -85,6 +87,20 @@ function createResolver(compiler: ICompiler, webpackResolver: any): Resolver {
     return resolve;
 }
 
+function createChecker(compilerInfo: CompilerInfo, compilerOptions: CompilerOptions) {
+    var checker = childProcess.fork(path.join(__dirname, 'checker.js'));
+
+    checker.send({
+        messageType: 'init',
+        payload: {
+            compilerInfo: _.omit(compilerInfo, 'tsImpl'),
+            compilerOptions
+        }
+    }, null)
+
+    return checker;
+}
+
 /**
  * Creates compiler instance
  */
@@ -108,6 +124,7 @@ function ensureInstance(webpack: WebPack, options: CompilerOptions, instanceName
 
     let compilerInfo: CompilerInfo = {
         compilerName,
+        compilerPath,
         tsImpl,
         lib5: loadLib(path.join(compilerPath, 'bin', 'lib.d.ts')),
         lib6: loadLib(path.join(compilerPath, 'bin', 'lib.es6.d.ts'))
@@ -141,6 +158,22 @@ function ensureInstance(webpack: WebPack, options: CompilerOptions, instanceName
         }
     }
 
+    if (typeof options.doTypeCheck === 'undefined') {
+        options.doTypeCheck = true;
+    } else {
+        if (typeof options.doTypeCheck === 'string') {
+            options.doTypeCheck = (<any>options.doTypeCheck) === 'true'
+        }
+    }
+
+    if (typeof options.forkChecker === 'undefined') {
+        options.forkChecker = false;
+    } else {
+        if (typeof options.forkChecker === 'string') {
+            options.forkChecker = (<any>options.forkChecker) === 'true'
+        }
+    }
+
     if (typeof options.useWebpackText === 'undefined') {
         options.useWebpackText = false;
     } else {
@@ -184,37 +217,60 @@ function ensureInstance(webpack: WebPack, options: CompilerOptions, instanceName
             .catch((err) => callback(err))
     });
 
-    compiler.plugin('after-compile', function(compilation, callback) {
-
-        var instance: CompilerInstance = resolveInstance(compilation.compiler, instanceName);
-        var state = instance.tsState;
-        var diagnostics = state.ts.getPreEmitDiagnostics(state.program);
-        var emitError = (err) => {
-            compilation.errors.push(new Error(err))
-        };
-
-        var phantomImports = [];
-        Object.keys(state.files).forEach((fileName) => {
-            if (!instance.compiledFiles[fileName]) {
-                phantomImports.push(fileName)
+    if (options.doTypeCheck) {
+        compiler.plugin('after-compile', function(compilation, callback) {
+            let instance: CompilerInstance = resolveInstance(compilation.compiler, instanceName);
+            let state = instance.tsState;
+
+            if (options.forkChecker) {
+                let payload = {
+                    files: state.files
+                };
+
+                console.time('\nSending files to the checker');
+                instance.checker.send({
+                    messageType: 'compile',
+                    payload
+                })
+                console.timeEnd('\nSending files to the checker');
+            } else {
+                let diagnostics = state.ts.getPreEmitDiagnostics(state.program);
+                let emitError = (err) => {
+                    if (compilation.bail) {
+                        console.error('Error in bail mode:', err);
+                        process.exit(1);
+                    }
+                    compilation.errors.push(new Error(err))
+                };
+
+                var errors = helpers.formatErrors(diagnostics);
+                errors.forEach(emitError);
+                callback();
             }
-        });
 
-        instance.compiledFiles = {};
-        compilation.fileDependencies.push.apply(compilation.fileDependencies, phantomImports);
-        compilation.fileDependencies = _.uniq(compilation.fileDependencies);
+            let phantomImports = [];
+            Object.keys(state.files).forEach((fileName) => {
+                if (!instance.compiledFiles[fileName]) {
+                    phantomImports.push(fileName)
+                }
+            });
 
-        var errors = helpers.formatErrors(diagnostics);
-        errors.forEach(emitError);
-        callback();
-    });
+            instance.compiledFiles = {};
+            compilation.fileDependencies.push.apply(compilation.fileDependencies, phantomImports);
+            compilation.fileDependencies = _.uniq(compilation.fileDependencies);
+            callback();
+        });
+    }
 
     return getInstanceStore(webpack._compiler)[instanceName] = {
         tsFlow,
         tsState,
         compiledFiles: {},
         options,
-        externalsInvoked: false
+        externalsInvoked: false,
+        checker: options.forkChecker
+            ? createChecker(compilerInfo, options)
+            : null
     }
 }
 
@@ -294,7 +350,12 @@ function compiler(webpack: WebPack, text: string): void {
 
             applyDeps();
 
-            callback(null, result.text, sourceMap);
+            try {
+                callback(null, result.text, sourceMap);
+            } catch (e) {
+                console.error('Error in bail mode:', e);
+                process.exit(1);
+            }
         })
         .finally(() => {
             applyDeps();

src/tsconfig.json

@@ -16,6 +16,7 @@
         "!./node_modules/**/*.ts"
     ],
     "files": [
+        "./checker.ts",
         "./deps.ts",
         "./helpers.ts",
         "./host.ts",

tsd.json

@@ -13,6 +13,9 @@
     },
     "lodash/lodash.d.ts": {
       "commit": "2272849a06f2b68205611665e6b86ffec58c1e10"
+    },
+    "colors/colors.d.ts": {
+      "commit": "73ef8a2ccd832c9dd8600947238ac8723584cb10"
     }
   }
 }

typings/colors/colors.d.ts

@@ -0,0 +1,37 @@
+// Type definitions for Colors.js 0.6.0-1
+// Project: https://github.com/Marak/colors.js
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "colors" {
+    export function setTheme(theme:any):any;
+
+    export function black(text: string): string;
+    export function red(text: string): string;
+    export function green(text: string): string;
+    export function yellow(text: string): string;
+    export function blue(text: string): string;
+    export function magenta(text: string): string;
+    export function cyan(text: string): string;
+    export function white(text: string): string;
+    export function gray(text: string): string;
+    export function grey(text: string): string;
+}
+
+interface String {
+    bold:string;
+    italic:string;
+    underline:string;
+    inverse:string;
+    yellow:string;
+    cyan:string;
+    white:string;
+    magenta:string;
+    green:string;
+    red:string;
+    grey:string;
+    blue:string;
+    rainbow:string;
+    zebra:string;
+    random:string;
+}

typings/tsd.d.ts

@@ -1,3 +1,4 @@
 /// <reference path="node/node.d.ts" />
 /// <reference path="bluebird/bluebird.d.ts" />
 /// <reference path="lodash/lodash.d.ts" />
+/// <reference path="colors/colors.d.ts" />