feat(*): loader plugins (e.g. docscript)

.node-version

@@ -0,0 +1 @@
+4

src/checker-runtime.ts

@@ -1,4 +1,5 @@
 import { ICompilerOptions, ICompilerInfo, IFile } from './host';
+import { LoaderPlugin, LoaderPluginDef } from './instance';
 import makeResolver from './resolver';
 import * as colors from 'colors';
 import * as path from 'path';
@@ -20,6 +21,7 @@ export interface IInitPayload {
     compilerOptions: ICompilerOptions;
     compilerInfo: ICompilerInfo;
     webpackOptions: any;
+    plugins: LoaderPluginDef[];
 }
 
 export interface ICompilePayload {
@@ -37,6 +39,8 @@ export interface IEnv {
     resolutionCache?: {[fileName: string]: ts.ResolvedModule};
     program?: ts.Program;
     service?: ts.LanguageService;
+    plugins?: LoaderPluginDef[];
+    initedPlugins?: LoaderPlugin[];
 }
 
 export interface SyncResolver {
@@ -185,6 +189,10 @@ function processInit(payload: IInitPayload) {
     env.webpackOptions = payload.webpackOptions;
     env.host = new Host();
     env.service = env.compiler.createLanguageService(env.host, env.compiler.createDocumentRegistry());
+    env.plugins = payload.plugins;
+    env.initedPlugins = env.plugins.map(plugin => {
+        return require(plugin.file)(plugin.options);
+    });
 }
 
 function processCompile(payload: ICompilePayload) {
@@ -225,6 +233,10 @@ function processCompile(payload: ICompilePayload) {
         }
     }
 
+    env.initedPlugins.forEach(plugin => {
+        plugin.processProgram(program);
+    });
+
     process.send({
         messageType: 'progress',
         payload: {

src/checker.ts

@@ -2,18 +2,21 @@ import * as _ from 'lodash';
 import * as childProcess from 'child_process';
 import * as path from 'path';
 import { ICompilerInfo, ICompilerOptions } from './host';
+import { LoaderPluginDef } from './instance';
 
 interface ChildProcess extends childProcess.ChildProcess {
     inProgress?: boolean;
     compilerInfo?: ICompilerInfo;
     compilerOptions?: ICompilerOptions;
     webpackOptions?: any;
+    plugins?: LoaderPluginDef[];
 }
 
 export function createChecker(
     compilerInfo: ICompilerInfo,
     compilerOptions: ICompilerOptions,
-    webpackOptions: any
+    webpackOptions: any,
+    plugins: LoaderPluginDef[]
 ): ChildProcess {
     let checker: ChildProcess = childProcess.fork(path.join(__dirname, 'checker-runtime.js'));
 
@@ -22,7 +25,8 @@ export function createChecker(
         payload: {
             compilerInfo: _.omit(compilerInfo, 'tsImpl'),
             compilerOptions,
-            webpackOptions
+            webpackOptions,
+            plugins
         }
     }, null);
 
@@ -42,7 +46,12 @@ export function createChecker(
 export function resetChecker(checker: ChildProcess) {
     if (checker.inProgress) {
         checker.kill('SIGKILL');
-        return createChecker(checker.compilerInfo, checker.compilerOptions, checker.webpackOptions);
+        return createChecker(
+            checker.compilerInfo,
+            checker.compilerOptions,
+            checker.webpackOptions,
+            checker.plugins
+        );
     } else {
         return checker;
     }

src/index.ts

@@ -174,7 +174,7 @@ async function compiler(webpack: IWebPack, text: string): Promise<void> {
         try {
             callback(null, resultText, resultSourceMap);
         } catch (e) {
-            console.error('Error in bail mode:', e);
+            console.error('Error in bail mode:', e, e.stack.join('\n'));
             process.exit(1);
         }
     } catch (err) {

src/instance.ts

@@ -13,6 +13,15 @@ import makeResolver from './resolver';
 
 let pkg = require('../package.json');
 
+export interface LoaderPlugin {
+    processProgram?: (program: ts.Program) => void;
+}
+
+export interface LoaderPluginDef {
+    file: string;
+    options: any;
+}
+
 export interface ICompilerInstance {
     tsFlow: Promise<any>;
     tsState: State;
@@ -22,6 +31,8 @@ export interface ICompilerInstance {
     externalsInvoked: boolean;
     checker: any;
     cacheIdentifier: any;
+    plugins: LoaderPluginDef[];
+    initedPlugins: LoaderPlugin[];
 }
 
 interface ICompiler {
@@ -44,6 +55,11 @@ export interface IWebPack {
     resolve: () => void;
     addDependency: (dep: string) => void;
     clearDependencies: () => void;
+    options: {
+        atl?: {
+            plugins: LoaderPluginDef[]
+        }
+    };
 }
 
 function getRootCompiler(compiler) {
@@ -214,6 +230,20 @@ export function ensureInstance(webpack: IWebPack, options: ICompilerOptions, ins
 
     let webpackOptions = _.pick(webpack._compiler.options, 'resolve');
 
+    let atlOptions = webpack.options.atl;
+    let plugins: LoaderPluginDef[] = [];
+
+    if (atlOptions && atlOptions.plugins) {
+        plugins = atlOptions.plugins;
+    }
+
+    let initedPlugins = [];
+    if (!forkChecker) {
+        initedPlugins = plugins.map(plugin => {
+            return require(plugin.file)(plugin.options);
+        });
+    }
+
     return getInstanceStore(webpack._compiler)[instanceName] = {
         tsFlow,
         tsState,
@@ -222,9 +252,11 @@ export function ensureInstance(webpack: IWebPack, options: ICompilerOptions, ins
         options,
         externalsInvoked: false,
         checker: forkChecker
-            ? createChecker(compilerInfo, options, webpackOptions)
+            ? createChecker(compilerInfo, options, webpackOptions, plugins)
             : null,
-        cacheIdentifier
+        cacheIdentifier,
+        plugins,
+        initedPlugins
     };
 }
 
@@ -298,6 +330,10 @@ function setupAfterCompile(compiler, instanceName, forkChecker = false) {
 
             let errors = formatErrors(instanceName, diagnostics);
             errors.forEach(emitError);
+
+            instance.initedPlugins.forEach(plugin => {
+                plugin.processProgram(state.program);
+            });
         }
 
         let phantomImports = [];