feat: support types preventive resolution

Author: s-panferov

src/checker-runtime.ts

@@ -1,4 +1,4 @@
-import { ICompilerInfo, IFile } from './host';
+import { ICompilerInfo, IFile, TSCONFIG_INFERRED } from './host';
 import * as path from 'path';
 import { LoaderPlugin, LoaderPluginDef, LoaderConfig } from './instance';
 
@@ -108,6 +108,10 @@ export class Host implements ts.LanguageServiceHost {
     }
 
     resolveTypeReferenceDirectives(typeDirectiveNames: string[], containingFile: string) {
+        if (containingFile.indexOf(TSCONFIG_INFERRED) !== -1) {
+            containingFile = TSCONFIG_INFERRED;
+        }
+
         return typeDirectiveNames.map(moduleName => {
             return env.typeReferenceResolutionCache[`${containingFile}::${moduleName}`];
         });

src/host.ts

@@ -28,6 +28,8 @@ export interface IEmitOutput extends ts.EmitOutput {
     outputFiles: IOutputFile[];
 }
 
+export const TSCONFIG_INFERRED = '__inferred type names__.ts';
+
 export class Host implements ts.LanguageServiceHost {
     state: State;
 
@@ -71,6 +73,10 @@ export class Host implements ts.LanguageServiceHost {
 
     resolveTypeReferenceDirectives(typeDirectiveNames: string[], containingFile: string) {
         let deps = this.state.fileAnalyzer.dependencies;
+        if (containingFile.indexOf(TSCONFIG_INFERRED) !== -1) {
+            containingFile = TSCONFIG_INFERRED;
+        }
+
         return typeDirectiveNames.map(moduleName => {
             return deps.getTypeReferenceResolution(containingFile, moduleName);
         });
@@ -102,13 +108,15 @@ export class State {
     files: {[fileName: string]: IFile} = {};
     services: ts.LanguageService;
     loaderConfig: LoaderConfig;
+    configFilePath: string;
     compilerConfig: TsConfig;
     program: ts.Program;
     fileAnalyzer: FileAnalyzer;
     defaultLib: string;
 
     constructor(
         loaderConfig: LoaderConfig,
+        configFilePath: string,
         compilerConfig: TsConfig,
         compilerInfo: ICompilerInfo
     ) {
@@ -117,6 +125,7 @@ export class State {
         this.host = new Host(this);
         this.services = this.ts.createLanguageService(this.host, this.ts.createDocumentRegistry());
         this.loaderConfig = loaderConfig;
+        this.configFilePath = configFilePath;
         this.compilerConfig = compilerConfig;
         this.fileAnalyzer = new FileAnalyzer(this);
 
@@ -125,6 +134,30 @@ export class State {
         }
 
         this.loadDefaultLib();
+        this.loadTypesFromConfig();
+    }
+
+    loadTypesFromConfig() {
+        let { options } = this.compilerConfig;
+        if (options.types) {
+            options.types.forEach(type => {
+                let { resolvedTypeReferenceDirective } = this.ts.resolveTypeReferenceDirective(
+                    type,
+                    this.configFilePath,
+                    options,
+                    ts.sys
+                );
+
+                if (resolvedTypeReferenceDirective) {
+                    this.readFileAndAdd(resolvedTypeReferenceDirective.resolvedFileName);
+                    this.fileAnalyzer.dependencies.addTypeReferenceResolution(
+                        TSCONFIG_INFERRED,
+                        type,
+                        resolvedTypeReferenceDirective
+                    );
+                }
+            });
+        }
     }
 
     loadDefaultLib() {

src/instance.ts

@@ -23,6 +23,7 @@ export interface ICompilerInstance {
     tsState: State;
     babelImpl?: any;
     compiledFiles: {[key:string]: boolean};
+    configFilePath: string;
     compilerConfig: TsConfig;
     loaderConfig: LoaderConfig;
     externalsInvoked: boolean;
@@ -155,7 +156,7 @@ export function ensureInstance(webpack: IWebPack, query: QueryOptions, instanceN
         tsImpl,
     };
 
-    let { compilerConfig, loaderConfig } = readConfigFile(process.cwd(), query, tsImpl);
+    let { configFilePath, compilerConfig, loaderConfig } = readConfigFile(process.cwd(), query, tsImpl);
 
     applyDefaults(compilerConfig, loaderConfig);
     let babelImpl = setupBabel(loaderConfig);
@@ -164,6 +165,7 @@ export function ensureInstance(webpack: IWebPack, query: QueryOptions, instanceN
     let forkChecker = loaderConfig.forkChecker && getRootCompiler(webpack._compiler)._tsFork;
     let tsState = new State(
         loaderConfig,
+        configFilePath,
         compilerConfig,
         compilerInfo
     );
@@ -198,6 +200,7 @@ export function ensureInstance(webpack: IWebPack, query: QueryOptions, instanceN
         babelImpl,
         compiledFiles: {},
         loaderConfig,
+        configFilePath,
         compilerConfig,
         externalsInvoked: false,
         checker: forkChecker
@@ -283,19 +286,36 @@ function applyDefaults(compilerConfig: TsConfig, loaderConfig: LoaderConfig) {
     loaderConfig.externals.push.apply(loaderConfig.externals, initialFiles);
 }
 
-function readConfigFile(baseDir: string, query: QueryOptions, tsImpl: typeof ts): { compilerConfig: TsConfig, loaderConfig } {
+export interface Configs {
+    configFilePath: string;
+    compilerConfig: TsConfig;
+    loaderConfig: LoaderConfig;
+}
+
+function readConfigFile(baseDir: string, query: QueryOptions, tsImpl: typeof ts): Configs {
     let configFilePath: string;
     if (query.tsconfig && query.tsconfig.match(/\.json$/)) {
         configFilePath = query.tsconfig;
     } else {
         configFilePath = tsImpl.findConfigFile(process.cwd(), tsImpl.sys.fileExists);
     }
 
+     let existingOptions = tsImpl.convertCompilerOptionsFromJson(query, process.cwd(), 'atl.query');
+
     if (!configFilePath) {
-        return null;
+        return {
+            configFilePath: process.cwd(),
+            compilerConfig: tsImpl.parseJsonConfigFileContent(
+                {},
+                tsImpl.sys,
+                process.cwd(),
+                _.extend({}, ts.getDefaultCompilerOptions(), existingOptions.options) as ts.CompilerOptions,
+                process.cwd()
+            ),
+            loaderConfig: query as LoaderConfig
+        };
     }
 
-    let existingOptions = tsImpl.convertCompilerOptionsFromJson(query, process.cwd(), 'atl.query');
     let jsonConfigFile = tsImpl.readConfigFile(configFilePath, tsImpl.sys.readFile);
 
     let compilerConfig = tsImpl.parseJsonConfigFileContent(
@@ -307,8 +327,11 @@ function readConfigFile(baseDir: string, query: QueryOptions, tsImpl: typeof ts)
     );
 
     return {
+        configFilePath,
         compilerConfig,
-        loaderConfig: _.defaults(query, jsonConfigFile.config.awesomeTypescriptLoaderOptions)
+        loaderConfig: _.defaults<LoaderConfig, LoaderConfig>(
+            query,
+            jsonConfigFile.config.awesomeTypescriptLoaderOptions)
     };
 }