WIP: typescript sys proxy

jest.config.js

@@ -144,7 +144,7 @@ module.exports = {
   //   "**/__tests__/**/*.[jt]s?(x)",
   //   "**/?(*.)+(spec|test).[tj]s?(x)"
   // ],
-  testMatch: ['**/?(*.)+(spec).[tj]s?(x)']
+  testMatch: ['**/?(*.)+(spec).[tj]s?(x)'],
 
   // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
   // testPathIgnorePatterns: [
@@ -181,7 +181,7 @@ module.exports = {
   // verbose: null,
 
   // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
-  // watchPathIgnorePatterns: [],
+  watchPathIgnorePatterns: ['test/tmp']
 
   // Whether to use watchman for file crawling
   // watchman: true,

package.json

@@ -103,6 +103,7 @@
     "chokidar": "^2.0.4",
     "micromatch": "^3.1.10",
     "minimatch": "^3.0.4",
+    "mock-require": "^3.0.3",
     "semver": "^5.6.0",
     "tapable": "^1.0.0",
     "worker-rpc": "^0.1.0"
@@ -131,7 +132,6 @@
     "jest": "^24.7.1",
     "lint-staged": "^8.0.5",
     "mock-fs": "^4.3.0",
-    "mock-require": "^3.0.2",
     "prettier": "^1.14.3",
     "rimraf": "^2.5.4",
     "semantic-release": "^16.0.0-beta.18",

src/ApiIncrementalChecker.ts

@@ -13,7 +13,6 @@ import {
 } from './linterConfigHelpers';
 import { NormalizedMessage } from './NormalizedMessage';
 import { CompilerHost } from './CompilerHost';
-import { ResolveModuleName, ResolveTypeReferenceDirective } from './resolution';
 import { FsHelper } from './FsHelper';
 
 export class ApiIncrementalChecker implements IncrementalCheckerInterface {
@@ -42,9 +41,7 @@ export class ApiIncrementalChecker implements IncrementalCheckerInterface {
     private context: string,
     private linterConfigFile: string | boolean,
     private linterAutoFix: boolean,
-    checkSyntacticErrors: boolean,
-    resolveModuleName: ResolveModuleName | undefined,
-    resolveTypeReferenceDirective: ResolveTypeReferenceDirective | undefined
+    checkSyntacticErrors: boolean
   ) {
     this.hasFixedConfig = typeof this.linterConfigFile === 'string';
 
@@ -54,9 +51,7 @@ export class ApiIncrementalChecker implements IncrementalCheckerInterface {
       typescript,
       programConfigFile,
       compilerOptions,
-      checkSyntacticErrors,
-      resolveModuleName,
-      resolveTypeReferenceDirective
+      checkSyntacticErrors
     );
   }
 

src/CompilerHost.ts

@@ -1,8 +1,6 @@
 // tslint:disable-next-line:no-implicit-dependencies
 import * as ts from 'typescript'; // Imported for types alone
 import { LinkedList } from './LinkedList';
-import { VueProgram } from './VueProgram';
-import { ResolveModuleName, ResolveTypeReferenceDirective } from './resolution';
 
 interface DirectoryWatchDelaySlot {
   events: { fileName: string }[];
@@ -52,29 +50,11 @@ export class CompilerHost
 
   private compilationStarted = false;
 
-  public resolveModuleNames:
-    | ((
-        moduleNames: string[],
-        containingFile: string,
-        reusedNames?: string[] | undefined,
-        redirectedReference?: ts.ResolvedProjectReference | undefined
-      ) => (ts.ResolvedModule | undefined)[])
-    | undefined;
-  public resolveTypeReferenceDirectives:
-    | ((
-        typeReferenceDirectiveNames: string[],
-        containingFile: string,
-        redirectedReference?: ts.ResolvedProjectReference | undefined
-      ) => (ts.ResolvedTypeReferenceDirective | undefined)[])
-    | undefined;
-
   constructor(
     private typescript: typeof ts,
     programConfigFile: string,
     compilerOptions: ts.CompilerOptions,
-    checkSyntacticErrors: boolean,
-    userResolveModuleName?: ResolveModuleName,
-    userResolveTypeReferenceDirective?: ResolveTypeReferenceDirective
+    checkSyntacticErrors: boolean
   ) {
     this.tsHost = typescript.createWatchCompilerHost(
       programConfigFile,
@@ -96,43 +76,8 @@ export class CompilerHost
         // do nothing
       }
     );
-
     this.configFileName = this.tsHost.configFileName;
     this.optionsToExtend = this.tsHost.optionsToExtend || {};
-
-    if (userResolveModuleName) {
-      this.resolveModuleNames = (
-        moduleNames: string[],
-        containingFile: string
-      ) => {
-        return moduleNames.map(moduleName => {
-          return userResolveModuleName(
-            this.typescript,
-            moduleName,
-            containingFile,
-            this.optionsToExtend,
-            this
-          ).resolvedModule;
-        });
-      };
-    }
-
-    if (userResolveTypeReferenceDirective) {
-      this.resolveTypeReferenceDirectives = (
-        typeDirectiveNames: string[],
-        containingFile: string
-      ) => {
-        return typeDirectiveNames.map(typeDirectiveName => {
-          return userResolveTypeReferenceDirective(
-            this.typescript,
-            typeDirectiveName,
-            containingFile,
-            this.optionsToExtend,
-            this
-          ).resolvedTypeReferenceDirective;
-        });
-      };
-    }
   }
 
   public async processChanges(): Promise<{
@@ -263,6 +208,20 @@ export class CompilerHost
     // do nothing
   }
 
+  public resolveModuleNames(
+    moduleNames: string[],
+    containingFile: string,
+    reusedNames?: string[],
+    redirectedReference?: ts.ResolvedProjectReference
+  ): (ts.ResolvedModule | undefined)[] {
+    return this.tsHost.resolveModuleNames!(
+      moduleNames,
+      containingFile,
+      reusedNames,
+      redirectedReference
+    );
+  }
+
   public watchDirectory(
     path: string,
     callback: ts.DirectoryWatcherCallback,
@@ -316,15 +275,7 @@ export class CompilerHost
   }
 
   public readFile(path: string, encoding?: string) {
-    const content = this.tsHost.readFile(path, encoding);
-
-    // get typescript contents from Vue file
-    if (content && VueProgram.isVue(path)) {
-      const resolved = VueProgram.resolveScriptBlock(this.typescript, content);
-      return resolved.content;
-    }
-
-    return content;
+    return this.tsHost.readFile(path, encoding);
   }
 
   public directoryExists(path: string): boolean {

src/IncrementalChecker.ts

@@ -14,13 +14,7 @@ import {
 import { WorkSet } from './WorkSet';
 import { NormalizedMessage } from './NormalizedMessage';
 import { CancellationToken } from './CancellationToken';
-import {
-  ResolveModuleName,
-  ResolveTypeReferenceDirective,
-  makeResolutionFunctions
-} from './resolution';
 import * as minimatch from 'minimatch';
-import { VueProgram } from './VueProgram';
 import { FsHelper } from './FsHelper';
 import { IncrementalCheckerInterface } from './IncrementalCheckerInterface';
 
@@ -63,12 +57,7 @@ export class IncrementalChecker implements IncrementalCheckerInterface {
     private watchPaths: string[],
     private workNumber: number = 0,
     private workDivision: number = 1,
-    private checkSyntacticErrors: boolean = false,
-    private vue: boolean = false,
-    private resolveModuleName: ResolveModuleName | undefined,
-    private resolveTypeReferenceDirective:
-      | ResolveTypeReferenceDirective
-      | undefined
+    private checkSyntacticErrors: boolean = false
   ) {
     this.hasFixedConfig = typeof this.linterConfigFile === 'string';
   }
@@ -111,48 +100,11 @@ export class IncrementalChecker implements IncrementalCheckerInterface {
     programConfig: ts.ParsedCommandLine,
     files: FilesRegister,
     watcher: FilesWatcher,
-    oldProgram: ts.Program,
-    userResolveModuleName: ResolveModuleName | undefined,
-    userResolveTypeReferenceDirective: ResolveTypeReferenceDirective | undefined
+    oldProgram: ts.Program
   ) {
     const host = typescript.createCompilerHost(programConfig.options);
     const realGetSourceFile = host.getSourceFile;
 
-    const {
-      resolveModuleName,
-      resolveTypeReferenceDirective
-    } = makeResolutionFunctions(
-      userResolveModuleName,
-      userResolveTypeReferenceDirective
-    );
-
-    host.resolveModuleNames = (moduleNames, containingFile) => {
-      return moduleNames.map(moduleName => {
-        return resolveModuleName(
-          typescript,
-          moduleName,
-          containingFile,
-          programConfig.options,
-          host
-        ).resolvedModule;
-      });
-    };
-
-    host.resolveTypeReferenceDirectives = (
-      typeDirectiveNames,
-      containingFile
-    ) => {
-      return typeDirectiveNames.map(typeDirectiveName => {
-        return resolveTypeReferenceDirective(
-          typescript,
-          typeDirectiveName,
-          containingFile,
-          programConfig.options,
-          host
-        ).resolvedTypeReferenceDirective;
-      });
-    };
-
     host.getSourceFile = (filePath, languageVersion, onError) => {
       // first check if watcher is watching file - if not - check it's mtime
       if (!watcher.isWatchingFile(filePath)) {
@@ -207,9 +159,7 @@ export class IncrementalChecker implements IncrementalCheckerInterface {
 
   public nextIteration() {
     if (!this.watcher) {
-      const watchExtensions = this.vue
-        ? ['.ts', '.tsx', '.vue']
-        : ['.ts', '.tsx'];
+      const watchExtensions = ['.ts', '.tsx'];
       this.watcher = new FilesWatcher(this.watchPaths, watchExtensions);
 
       // connect watcher with register
@@ -239,34 +189,13 @@ export class IncrementalChecker implements IncrementalCheckerInterface {
       }
     }
 
-    this.program = this.vue ? this.loadVueProgram() : this.loadDefaultProgram();
+    this.program = this.loadDefaultProgram();
 
     if (this.linterConfigFile) {
       this.linter = this.createLinter(this.program!);
     }
   }
 
-  private loadVueProgram() {
-    this.programConfig =
-      this.programConfig ||
-      VueProgram.loadProgramConfig(
-        this.typescript,
-        this.programConfigFile,
-        this.compilerOptions
-      );
-
-    return VueProgram.createProgram(
-      this.typescript,
-      this.programConfig,
-      path.dirname(this.programConfigFile),
-      this.files,
-      this.watcher!,
-      this.program!,
-      this.resolveModuleName,
-      this.resolveTypeReferenceDirective
-    );
-  }
-
   private loadDefaultProgram() {
     this.programConfig =
       this.programConfig ||
@@ -281,9 +210,7 @@ export class IncrementalChecker implements IncrementalCheckerInterface {
       this.programConfig,
       this.files,
       this.watcher!,
-      this.program!,
-      this.resolveModuleName,
-      this.resolveTypeReferenceDirective
+      this.program!
     );
   }