feat: fixed module resolution; add lib option support

Author: s-panferov

package.json

@@ -31,16 +31,12 @@
   },
   "homepage": "https://github.com/s-panferov/awesome-typescript-loader",
   "dependencies": {
-    "babel-polyfill": "^6.1.19",
     "colors": "^1.1.2",
-    "enhanced-resolve": "^2.2.2",
-    "es6-promisify": "^4.1.0",
     "loader-utils": "^0.2.6",
     "lodash": "^4.13.1",
     "source-map-support": "^0.4.0"
   },
   "devDependencies": {
-    "bluebird": "^3.3.3",
     "chai": "^3.5.0",
     "git-hooks": "^1.0.2",
     "grunt": "^1.0.1",
@@ -59,7 +55,7 @@
     "sinon": "^1.17.4",
     "temp": "^0.8.3",
     "tslint": "3.11.0-dev.0",
-    "typescript": "^1.9.0-dev.20160618-1.0",
+    "typescript": "^1.9.0-dev.20160619-1.0",
     "webpack": "2.1.0-beta.4"
   }
 }

src/cache.ts

@@ -76,18 +76,18 @@ function filename(source: string, identifier, options) {
     return hash.read().toString('hex') + '.json.gzip';
 };
 
-interface CacheParams {
+interface CacheParams<T> {
     source: string;
     options: any;
-    transform: (source: string, options: any) => string;
+    transform: () => T;
     identifier: any;
     directory: string;
 }
 
 /**
  * Retrieve file from cache, or create a new one for future reads
  */
-export function cache(params: CacheParams) {
+export function cache<T>(params: CacheParams<T>): T {
     // Spread params into named variables
     // Forgive user whenever possible
     let source = params.source;
@@ -106,7 +106,7 @@ export function cache(params: CacheParams) {
     } catch(e) {
         // Otherwise just transform the file
         // return it to the user asap and write it in cache
-        let result = transform(source, options);
+        let result = transform();
         write(file, result);
         return result;
     }

src/checker-runtime.ts

@@ -1,8 +1,6 @@
 import { ICompilerInfo, IFile } from './host';
 import { LoaderPlugin, LoaderPluginDef, LoaderConfig } from './instance';
-import createSyncResolver from './resolver';
 import * as path from 'path';
-import * as fs from 'fs';
 
 let colors = require('colors/safe');
 
@@ -21,6 +19,7 @@ export interface IInitPayload {
     compilerOptions: ts.CompilerOptions;
     compilerInfo: ICompilerInfo;
     webpackOptions: any;
+    defaultLib: string;
     plugins: LoaderPluginDef[];
 }
 
@@ -41,6 +40,7 @@ export interface IEnv {
     program?: ts.Program;
     service?: ts.LanguageService;
     plugins?: LoaderPluginDef[];
+    defaultLib?: string;
     initedPlugins?: LoaderPlugin[];
 }
 
@@ -73,7 +73,6 @@ export class Host implements ts.LanguageServiceHost {
 
     constructor() {
         this.moduleResolutionHost = new ModuleResolutionHost(this);
-        this.resolver = createSyncResolver(env.webpackOptions);
     }
 
     normalizePath(filePath: string): string {
@@ -90,26 +89,10 @@ export class Host implements ts.LanguageServiceHost {
         }
     }
 
-    getScriptSnapshot(fileName) {
+    getScriptSnapshot(fileName: string) {
         let fileName_ = path.normalize(fileName);
         let file = env.files[fileName_];
-
-        if (!file) {
-            try {
-                file = {
-                    version: 0,
-                    text: fs.readFileSync(fileName, { encoding: 'utf8' }).toString()
-                };
-
-                if (path.basename(fileName) !== 'package.json') {
-                    env.files[fileName_] = file;
-                }
-            }
-            catch (e) {
-                return;
-            }
-        }
-
+        !file && console.log(fileName, file)
         return env.compiler.ScriptSnapshot.fromString(file.text);
     }
 
@@ -131,10 +114,8 @@ export class Host implements ts.LanguageServiceHost {
         });
     }
 
-    getDefaultLibFileName(options) {
-        return options.target === env.compiler.ScriptTarget.ES6 ?
-            env.compilerInfo.lib6.fileName :
-            env.compilerInfo.lib5.fileName;
+    getDefaultLibFileName(options: ts.CompilerOptions) {
+        return env.defaultLib;
     }
 
     log(message) {
@@ -148,6 +129,7 @@ function processInit(payload: IInitPayload) {
     env.loaderConfig = payload.loaderConfig;
     env.compilerOptions = payload.compilerOptions;
     env.webpackOptions = payload.webpackOptions;
+    env.defaultLib = payload.defaultLib;
     env.host = new Host();
     env.service = env.compiler.createLanguageService(env.host, env.compiler.createDocumentRegistry());
     env.plugins = payload.plugins;
@@ -175,6 +157,7 @@ function processCompile(payload: ICompilePayload) {
 
     env.files = payload.files;
     env.resolutionCache = payload.resolutionCache;
+
     let program = env.program = env.service.getProgram();
 
     let allDiagnostics: ts.Diagnostic[] = [];

src/checker.ts

@@ -9,6 +9,7 @@ interface ChildProcess extends childProcess.ChildProcess {
     compilerInfo?: ICompilerInfo;
     loaderConfig?: LoaderConfig;
     compilerOptions?: ts.CompilerOptions;
+    defaultLib?: string;
     webpackOptions?: any;
     plugins?: LoaderPluginDef[];
 }
@@ -18,6 +19,7 @@ export function createChecker(
     loaderConfig: LoaderConfig,
     compilerOptions: ts.CompilerOptions,
     webpackOptions: any,
+    defaultLib: string,
     plugins: LoaderPluginDef[]
 ): ChildProcess {
     let checker: ChildProcess = childProcess.fork(path.join(__dirname, 'checker-runtime.js'));
@@ -29,6 +31,7 @@ export function createChecker(
             loaderConfig,
             compilerOptions,
             webpackOptions,
+            defaultLib,
             plugins
         }
     }, null);
@@ -55,6 +58,7 @@ export function resetChecker(checker: ChildProcess) {
             checker.loaderConfig,
             checker.compilerOptions,
             checker.webpackOptions,
+            checker.defaultLib,
             checker.plugins
         );
     } else {

src/deps.ts

@@ -1,5 +1,3 @@
-import * as _ from 'lodash';
-import * as path from 'path';
 import { State } from './host';
 
 let objectAssign = require('object-assign');
@@ -21,43 +19,6 @@ export interface IExternals {
 
 export type Exclude = string[];
 
-export function createIgnoringResolver(
-    externals: IExternals,
-    exclude: Exclude,
-    resolver: SyncResolver,
-): SyncResolver {
-    function resolve(base: string, dep: string): string {
-        let inWebpackExternals = externals && externals.hasOwnProperty(dep);
-        let inTypeScriptExclude = false;
-
-        if ((inWebpackExternals || inTypeScriptExclude)) {
-            return '%%ignore';
-        } else {
-            let resultPath = resolver(base, dep);
-            if (Array.isArray(resultPath)) {
-                resultPath = resultPath[0];
-            }
-
-            // ignore excluded javascript
-            if (!resultPath.match(/.tsx?$/)) {
-                let matchedExcludes = exclude.filter((excl) => {
-                    return resultPath.indexOf(excl) !== -1;
-                });
-
-                if (matchedExcludes.length > 0) {
-                    return '%%ignore';
-                } else {
-                    return resultPath;
-                }
-            } else {
-               return resultPath;
-            }
-        }
-    }
-
-    return resolve;
-}
-
 export function isTypeDeclaration(fileName: string): boolean {
     return /\.d.ts$/.test(fileName);
 }
@@ -71,10 +32,6 @@ function isImportEqualsDeclaration(node: ts.Node) {
     return !!(<any>node).moduleReference && (<any>node).moduleReference.hasOwnProperty('expression');
 }
 
-function isIgnoreDependency(absulutePath: string) {
-    return absulutePath == '%%ignore';
-}
-
 export class FileAnalyzer {
     dependencies = new DependencyManager();
     validFiles = new ValidFilesManager();
@@ -84,7 +41,7 @@ export class FileAnalyzer {
         this.state = state;
     }
 
-    checkDependencies(fileName: string): boolean {
+    checkDependencies(fileName: string, isDefaultLib = false): boolean {
         let isValid = this.validFiles.isFileValid(fileName);
         if (isValid) {
             return isValid;
@@ -97,7 +54,8 @@ export class FileAnalyzer {
 
         try {
             if (!this.state.hasFile(fileName)) {
-                changed = this.state.readFileAndUpdate(fileName);
+                this.state.readFileAndAdd(fileName, isDefaultLib);
+                changed = true;
             }
             this.checkDependenciesInternal(fileName);
         } catch (err) {
@@ -146,6 +104,17 @@ export class FileAnalyzer {
     }
 
     resolve(fileName: string, depName: string): ts.ResolvedModule {
+
+        if (/^[a-z0-9].*\.d\.ts$/.test(depName)) {
+            // Make import relative
+            // We need this to be able to resolve directives like
+            //
+            //      <reference path="lib.d.ts" />
+            //
+            // with resolver.
+            depName = './' + depName;
+        }
+
         let resolution = this.state.ts.resolveModuleName(
             depName,
             fileName,
@@ -159,38 +128,18 @@ export class FileAnalyzer {
             this.state.fileAnalyzer.dependencies.addResolution(fileName, depName, resolvedModule);
         }
 
-        console.log(
-            fileName,'\n',
-            depName, '\n',
-            resolvedModule && resolvedModule.resolvedFileName, '\n',
-            !resolvedModule && resolution.failedLookupLocations, '\n\n');
+        if (this.state.compilerConfig.options.traceResolution) {
+            console.log(
+                'Resolve', depName, '\n',
+                'from', fileName,'\n',
+                'resolved', resolvedModule && resolvedModule.resolvedFileName, '\n',
+                'failedLookupLocations', resolution.failedLookupLocations, '\n\n');
+        }
 
         return resolvedModule;
     }
 }
 
-let builtInCache = {};
-
-function checkIfModuleBuiltInCached(modPath: string): boolean {
-    return !!builtInCache[modPath];
-}
-
-function checkIfModuleBuiltIn(modPath: string): boolean {
-    if (builtInCache[modPath]) {
-        return true;
-    }
-
-    try {
-        if (require.resolve(modPath) === modPath) {
-            builtInCache[modPath] = true;
-            return true;
-        }
-    } catch (e) {
-    }
-
-    return false;
-}
-
 export interface IDependencyGraphItem {
     fileName: string;
     dependencies: IDependencyGraphItem[];