refactor: use internal TS mechanics to load tsconfig.json

Author: s-panferov

package.json

@@ -35,16 +35,11 @@
   "dependencies": {
     "babel-polyfill": "^6.1.19",
     "colors": "^1.1.2",
-    "enhanced-resolve": "^0.9.1",
+    "enhanced-resolve": "^2.2.2",
     "es6-promisify": "^4.1.0",
     "loader-utils": "^0.2.6",
     "lodash": "^4.13.1",
-    "object-assign": "^4.1.0",
-    "parse-json": "^2.2.0",
-    "source-map-support": "^0.4.0",
-    "strip-bom": "^1.0.0",
-    "strip-json-comments": "^2.0.0",
-    "tsconfig": "^3.0.0"
+    "source-map-support": "^0.4.0"
   },
   "devDependencies": {
     "babel-cli": "^6.3.17",
@@ -63,14 +58,15 @@
     "grunt-conventional-changelog": "^6.1.0",
     "grunt-shell": "^1.1.2",
     "load-grunt-tasks": "^3.5.0",
+    "loader": "^2.1.1",
     "mkdirp": "^0.5.1",
     "mocha": "^2.3.4",
     "ps-node": "^0.1.1",
     "rimraf": "^2.5.0",
     "sinon": "^1.17.4",
     "temp": "^0.8.3",
     "tslint": "3.11.0-dev.0",
-    "typescript": "1.9.0-dev.20160610-1.0",
+    "typescript": "^1.9.0-dev.20160618-1.0",
     "webpack": "2.1.0-beta.4"
   }
 }

src/checker-runtime.ts

@@ -1,5 +1,5 @@
-import { ICompilerOptions, ICompilerInfo, IFile } from './host';
-import { LoaderPlugin, LoaderPluginDef } from './instance';
+import { ICompilerInfo, IFile } from './host';
+import { LoaderPlugin, LoaderPluginDef, LoaderConfig } from './instance';
 import makeResolver from './resolver';
 import * as path from 'path';
 import * as fs from 'fs';
@@ -19,7 +19,8 @@ export interface IMessage {
 }
 
 export interface IInitPayload {
-    compilerOptions: ICompilerOptions;
+    loaderConfig: LoaderConfig;
+    compilerOptions: ts.CompilerOptions;
     compilerInfo: ICompilerInfo;
     webpackOptions: any;
     plugins: LoaderPluginDef[];
@@ -31,7 +32,8 @@ export interface ICompilePayload {
 }
 
 export interface IEnv {
-    options?: ICompilerOptions;
+    loaderConfig?: LoaderConfig;
+    compilerOptions?: ts.CompilerOptions;
     webpackOptions?: any;
     compiler?: typeof ts;
     compilerInfo?: ICompilerInfo;
@@ -45,7 +47,7 @@ export interface IEnv {
 }
 
 export interface SyncResolver {
-    resolveSync(context: string, fileName: string): string;
+    (context: string, fileName: string): string;
 }
 
 let env: IEnv = {};
@@ -122,7 +124,7 @@ export class Host implements ts.LanguageServiceHost {
     }
 
     getCompilationSettings() {
-        return env.options;
+        return env.compilerOptions;
     }
 
     resolveModuleNames(moduleNames: string[], containingFile: string) {
@@ -137,7 +139,7 @@ export class Host implements ts.LanguageServiceHost {
                 let resolvedModule: ts.ResolvedModule;
 
                 try {
-                    resolvedFileName = this.resolver.resolveSync(
+                    resolvedFileName = this.resolver(
                         this.normalizePath(path.dirname(containingFile)),
                         moduleName
                     );
@@ -153,7 +155,7 @@ export class Host implements ts.LanguageServiceHost {
                 let tsResolved = env.compiler.resolveModuleName(
                     resolvedFileName || moduleName,
                     containingFile,
-                    env.options,
+                    env.compilerOptions,
                     this.moduleResolutionHost
                 );
 
@@ -186,7 +188,8 @@ export class Host implements ts.LanguageServiceHost {
 function processInit(payload: IInitPayload) {
     env.compiler = require(payload.compilerInfo.compilerPath);
     env.compilerInfo = payload.compilerInfo;
-    env.options = payload.compilerOptions;
+    env.loaderConfig = payload.loaderConfig;
+    env.compilerOptions = payload.compilerOptions;
     env.webpackOptions = payload.webpackOptions;
     env.host = new Host();
     env.service = env.compiler.createLanguageService(env.host, env.compiler.createDocumentRegistry());
@@ -199,8 +202,8 @@ function processInit(payload: IInitPayload) {
 let DECLARATION_FILE = /\.d\.ts/;
 
 function processCompile(payload: ICompilePayload) {
-    let instanceName = env.options.instanceName || 'default';
-    let silent = !!env.options.forkCheckerSilent;
+    let instanceName = env.loaderConfig.instanceName || 'default';
+    let silent = !!env.loaderConfig.forkCheckerSilent;
     if (!silent) {
         console.log(colors.cyan(`[${ instanceName }] Checking started in a separate process...`));
     }
@@ -218,7 +221,7 @@ function processCompile(payload: ICompilePayload) {
     let program = env.program = env.service.getProgram();
 
     let allDiagnostics: ts.Diagnostic[] = [];
-    if (env.options.skipDeclarationFilesCheck) {
+    if (env.loaderConfig.skipDeclarationFilesCheck) {
         let sourceFiles = program.getSourceFiles();
         sourceFiles.forEach(sourceFile => {
             if (!sourceFile.fileName.match(DECLARATION_FILE)) {

src/checker.ts

@@ -1,20 +1,22 @@
 import * as _ from 'lodash';
 import * as childProcess from 'child_process';
 import * as path from 'path';
-import { ICompilerInfo, ICompilerOptions } from './host';
-import { LoaderPluginDef } from './instance';
+import { ICompilerInfo } from './host';
+import { LoaderPluginDef, LoaderConfig } from './instance';
 
 interface ChildProcess extends childProcess.ChildProcess {
     inProgress?: boolean;
     compilerInfo?: ICompilerInfo;
-    compilerOptions?: ICompilerOptions;
+    loaderConfig?: LoaderConfig;
+    compilerOptions?: ts.CompilerOptions;
     webpackOptions?: any;
     plugins?: LoaderPluginDef[];
 }
 
 export function createChecker(
     compilerInfo: ICompilerInfo,
-    compilerOptions: ICompilerOptions,
+    loaderConfig: LoaderConfig,
+    compilerOptions: ts.CompilerOptions,
     webpackOptions: any,
     plugins: LoaderPluginDef[]
 ): ChildProcess {
@@ -24,6 +26,7 @@ export function createChecker(
         messageType: 'init',
         payload: {
             compilerInfo: _.omit(compilerInfo, 'tsImpl'),
+            loaderConfig,
             compilerOptions,
             webpackOptions,
             plugins
@@ -32,6 +35,7 @@ export function createChecker(
 
     checker.inProgress = false;
     checker.compilerInfo = compilerInfo;
+    checker.loaderConfig = loaderConfig;
     checker.compilerOptions = compilerOptions;
     checker.webpackOptions = webpackOptions;
     checker.on('message', function(msg) {
@@ -48,6 +52,7 @@ export function resetChecker(checker: ChildProcess) {
         checker.kill('SIGKILL');
         return createChecker(
             checker.compilerInfo,
+            checker.loaderConfig,
             checker.compilerOptions,
             checker.webpackOptions,
             checker.plugins

src/deps.ts

@@ -1,10 +1,8 @@
 import * as _ from 'lodash';
 import * as path from 'path';
-
-let promisify = require('es6-promisify');
-
 import { State } from './host';
 
+let promisify = require('es6-promisify');
 let objectAssign = require('object-assign');
 
 type FileSet = {[fileName: string]: boolean};
@@ -162,7 +160,7 @@ export class FileAnalyzer {
                     this.dependencies.addTypeDeclaration(importPath);
                     tasks.push(this.checkDependencies(resolver, importPath));
                 }
-            } else if (isRequiredJs && !this.state.options.allowJs) {
+            } else if (isRequiredJs && !this.state.compilerConfig.options.allowJs) {
                 continue;
             } else {
                 if (!checkIfModuleBuiltInCached(importPath)) {

src/host.ts

@@ -5,10 +5,9 @@ import * as path from 'path';
 
 import { FileAnalyzer } from './deps';
 import { loadLib } from './helpers';
+import { LoaderConfig, TsConfig } from './instance';
 
 let promisify = require('es6-promisify');
-let objectAssign = require('object-assign');
-
 let RUNTIME = loadLib('../lib/runtime.d.ts');
 
 export interface IFile {
@@ -27,33 +26,6 @@ export interface SyncResolver {
     (context: string, fileName: string): string;
 }
 
-export interface ICompilerOptions extends ts.CompilerOptions {
-    noLib?: boolean;
-    instanceName?: string;
-    showRecompileReason?: boolean;
-    compiler?: string;
-    emitRequireType?: boolean;
-    library?: string;
-    reEmitDependentFiles?: boolean;
-    tsconfig?: string;
-    useWebpackText?: boolean;
-    exclude?: string[];
-    externals?: any;
-    doTypeCheck?: boolean;
-    ignoreDiagnostics?: number[];
-    forkChecker?: boolean;
-    forkCheckerSilent?: boolean;
-    useBabel?: boolean;
-    babelCore?: string;
-    babelOptions?: any;
-    usePrecompiledFiles?: boolean;
-    skipDeclarationFilesCheck?: boolean;
-    useCache?: boolean;
-    cacheDirectory?: string;
-    files?: any;
-    resolveGlobs?: boolean;
-}
-
 export interface IOutputFile extends ts.OutputFile {
     sourceName: string;
 }
@@ -105,7 +77,7 @@ export class Host implements ts.LanguageServiceHost {
             try {
                 // ignore excluded javascript
                 if (!fileName.match(/\.tsx?$|package[.]json?$/)) {
-                    let matchedExcludes = this.state.options.exclude.filter((excl) => {
+                    let matchedExcludes = this.state.compilerConfig.typingOptions.exclude.filter((excl) => {
                         return fileName.indexOf(excl) !== -1;
                     });
                     if (matchedExcludes.length > 0) {
@@ -140,7 +112,7 @@ export class Host implements ts.LanguageServiceHost {
     }
 
     getCompilationSettings() {
-        return this.state.options;
+        return this.state.compilerConfig.options;
     }
 
     getDefaultLibFileName(options) {
@@ -172,7 +144,7 @@ export class Host implements ts.LanguageServiceHost {
             let tsResolved = this.state.ts.resolveModuleName(
                 resolvedFileName || moduleName,
                 containingFile,
-                this.state.options,
+                this.state.compilerConfig.options,
                 this.moduleResolutionHost
             );
 
@@ -205,14 +177,16 @@ export class State {
     host: Host;
     files: {[fileName: string]: IFile} = {};
     services: ts.LanguageService;
-    options: ICompilerOptions;
+    loaderConfig: LoaderConfig;
+    compilerConfig: TsConfig;
     program: ts.Program;
     fileAnalyzer: FileAnalyzer;
     resolver: SyncResolver;
     readFileImpl: (fileName: string) => Promise<Buffer>;
 
     constructor(
-        options: ICompilerOptions,
+        loaderConfig: LoaderConfig,
+        compilerConfig: TsConfig,
         fsImpl: typeof fs,
         compilerInfo: ICompilerInfo,
         resolver: SyncResolver
@@ -226,16 +200,15 @@ export class State {
         this.services = this.ts.createLanguageService(this.host, this.ts.createDocumentRegistry());
         this.fileAnalyzer = new FileAnalyzer(this);
 
-        this.options = {};
-
-        objectAssign(this.options, options);
+        this.loaderConfig = loaderConfig;
+        this.compilerConfig = compilerConfig;
 
-        if (this.options.emitRequireType) {
+        if (loaderConfig.emitRequireType) {
             this.addFile(RUNTIME.fileName, RUNTIME.text);
         }
 
-        if (!this.options.noLib) {
-            if (this.options.target === this.ts.ScriptTarget.ES6 || this.options.library === 'es6') {
+        if (!compilerConfig.options.noLib) {
+            if (compilerConfig.options.target === this.ts.ScriptTarget.ES6 || loaderConfig.library === 'es6') {
                 this.addFile(this.compilerInfo.lib6.fileName, this.compilerInfo.lib6.text);
             } else {
                 this.addFile(this.compilerInfo.lib5.fileName, this.compilerInfo.lib5.text);
@@ -316,7 +289,7 @@ export class State {
         }
 
         let transpileResult = this.ts.transpileModule(file.text, {
-            compilerOptions: this.options,
+            compilerOptions: this.compilerConfig.options,
             reportDiagnostics: false,
             fileName
         });