refactor(transpile): update transpile to use our in-memory compiler host and transform TS before giving it to the program. Do not use stateless ts transforms since 2.3 has issues with them

Author: danbucholtz

src/transpile.spec.ts

@@ -0,0 +1,26 @@
+import * as transpile from './transpile';
+
+import { FileCache } from './util/file-cache';
+import { BuildContext } from './util/interfaces';
+
+describe('transpile', () => {
+  describe('resetSourceFiles', () => {
+    it('should remove any files with temporary suffix, and reset content to the original, non-modified value', () => {
+      const context = {
+        fileCache: new FileCache()
+      };
+
+      const aboutFilePath = 'about.ts';
+      const aboutFile = { path: aboutFilePath, content: 'modifiedContent'};
+      const originalAboutFilePath = aboutFilePath + transpile.inMemoryFileCopySuffix;
+      const originalAboutFile = { path: originalAboutFilePath, content: 'originalContent'};
+      context.fileCache.set(aboutFilePath, aboutFile);
+      context.fileCache.set(originalAboutFilePath, originalAboutFile);
+
+      transpile.resetSourceFiles(context.fileCache);
+
+      expect(context.fileCache.get(originalAboutFilePath)).toBeFalsy();
+      expect(context.fileCache.get(aboutFilePath).content).toEqual(originalAboutFile.content);
+    });
+  });
+});

src/transpile.ts

@@ -12,15 +12,23 @@ import {
   purgeDeepLinkDecoratorTSTransform }
 from './deep-linking/util';
 
+import {
+  convertDeepLinkConfigEntriesToString,
+  getUpdatedAppNgModuleContentWithDeepLinkConfig,
+  filterTypescriptFilesForDeepLinks,
+  isDeepLinkingFile,
+  purgeDeepLinkDecorator
+} from './deep-linking/util';
+
 import { Logger } from './logger/logger';
 import { printDiagnostics, clearDiagnostics, DiagnosticsType } from './logger/logger-diagnostics';
 import { runTypeScriptDiagnostics } from './logger/logger-typescript';
 import { inlineTemplate } from './template';
 import * as Constants from './util/constants';
 import { BuildError } from './util/errors';
 import { FileCache } from './util/file-cache';
-import { changeExtension, getBooleanPropertyValue } from './util/helpers';
-import { BuildContext, BuildState, ChangedFile } from './util/interfaces';
+import { changeExtension, getBooleanPropertyValue, getParsedDeepLinkConfig, getStringPropertyValue } from './util/helpers';
+import { BuildContext, BuildState, ChangedFile, File } from './util/interfaces';
 
 export function transpile(context: BuildContext) {
 
@@ -109,24 +117,36 @@ export function transpileWorker(context: BuildContext, workerConfig: TranspileWo
 
     // let's start a new tsFiles object to cache all the transpiled files in
     const host = getInMemoryCompilerHostInstance(tsConfig.options);
-    // ts.createCompilerHost(tsConfig.options);
 
-    const program = ts.createProgram(tsFileNames, tsConfig.options, host, cachedProgram);
+    if (workerConfig.useTransforms && getBooleanPropertyValue(Constants.ENV_PARSE_DEEPLINKS)) {
+      // beforeArray.push(purgeDeepLinkDecoratorTSTransform());
+      // beforeArray.push(getInjectDeepLinkConfigTypescriptTransform());
 
-    const beforeArray: ts.TransformerFactory<ts.SourceFile>[] = [];
+      // temporarily copy the files to a new location
+      copyOriginalSourceFiles(context.fileCache);
 
-    if (workerConfig.useTransforms && getBooleanPropertyValue(Constants.ENV_PARSE_DEEPLINKS)) {
-      beforeArray.push(purgeDeepLinkDecoratorTSTransform());
-      beforeArray.push(getInjectDeepLinkConfigTypescriptTransform());
+      // okay, purge the deep link files NOT using a transform
+      const deepLinkFiles = filterTypescriptFilesForDeepLinks(context.fileCache);
+
+      deepLinkFiles.forEach(file => {
+        file.content = purgeDeepLinkDecorator(file.content);
+      });
+
+      const file = context.fileCache.get(getStringPropertyValue(Constants.ENV_APP_NG_MODULE_PATH));
+      const deepLinkString = convertDeepLinkConfigEntriesToString(getParsedDeepLinkConfig());
+      file.content = getUpdatedAppNgModuleContentWithDeepLinkConfig(file.path, file.content, deepLinkString);
     }
 
+    const program = ts.createProgram(tsFileNames, tsConfig.options, host, cachedProgram);
+
+    resetSourceFiles(context.fileCache);
+
+    const beforeArray: ts.TransformerFactory<ts.SourceFile>[] = [];
+
     program.emit(undefined, (path: string, data: string, writeByteOrderMark: boolean, onError: Function, sourceFiles: ts.SourceFile[]) => {
       if (workerConfig.writeInMemory) {
-        writeSourceFiles(context.fileCache, sourceFiles);
         writeTranspiledFilesCallback(context.fileCache, path, data, workerConfig.inlineTemplate);
       }
-    }, null, false, {
-      before: beforeArray
     });
 
     // cache the typescript program for later use
@@ -181,26 +201,19 @@ function transpileUpdateWorker(event: string, filePath: string, context: BuildCo
 
     const beforeArray: ts.TransformerFactory<ts.SourceFile>[] = [];
 
-    if (workerConfig.useTransforms && getBooleanPropertyValue(Constants.ENV_PARSE_DEEPLINKS)) {
-      beforeArray.push(purgeDeepLinkDecoratorTSTransform());
-      beforeArray.push(getInjectDeepLinkConfigTypescriptTransform());
-    }
-
     const transpileOptions: ts.TranspileOptions = {
       compilerOptions: cachedTsConfig.options,
       fileName: filePath,
       reportDiagnostics: true,
-      transformers: {
-        before: beforeArray
-      }
     };
 
     // let's manually transpile just this one ts file
     // since it is an update, it's in memory already
     const sourceText = context.fileCache.get(filePath).content;
+    const textToTranspile = workerConfig.useTransforms && getBooleanPropertyValue(Constants.ENV_PARSE_DEEPLINKS) ? transformSource(filePath, sourceText) : sourceText;
 
     // transpile this one module
-    const transpileOutput = ts.transpileModule(sourceText, transpileOptions);
+    const transpileOutput = ts.transpileModule(textToTranspile, transpileOptions);
 
     const diagnostics = runTypeScriptDiagnostics(context, transpileOutput.diagnostics);
 
@@ -294,13 +307,6 @@ function cleanFileNames(context: BuildContext, fileNames: string[]) {
   return fileNames;
 }
 
-function writeSourceFiles(fileCache: FileCache, sourceFiles: ts.SourceFile[]) {
-  for (const sourceFile of sourceFiles) {
-    const fileName = path.normalize(path.resolve(sourceFile.fileName));
-    fileCache.set(fileName, { path: fileName, content: sourceFile.text });
-  }
-}
-
 function writeTranspiledFilesCallback(fileCache: FileCache, sourcePath: string, data: string, shouldInlineTemplate: boolean) {
   sourcePath = path.normalize(path.resolve(sourcePath));
 
@@ -390,6 +396,42 @@ export function transpileTsString(context: BuildContext, filePath: string, strin
   return ts.transpileModule(stringToTranspile, transpileOptions);
 }
 
+export function transformSource(filePath: string, input: string) {
+  if (isDeepLinkingFile(filePath) ) {
+    input = purgeDeepLinkDecorator(input);
+  } else if (filePath === getStringPropertyValue(Constants.ENV_APP_NG_MODULE_PATH)) {
+    const deepLinkString = convertDeepLinkConfigEntriesToString(getParsedDeepLinkConfig());
+    input = getUpdatedAppNgModuleContentWithDeepLinkConfig(filePath, input, deepLinkString);
+  }
+  return input;
+}
+
+export function copyOriginalSourceFiles(fileCache: FileCache) {
+  const deepLinkFiles = filterTypescriptFilesForDeepLinks(fileCache);
+  const appNgModule = fileCache.get(getStringPropertyValue(Constants.ENV_APP_NG_MODULE_PATH));
+  deepLinkFiles.push(appNgModule);
+  deepLinkFiles.forEach(deepLinkFile => {
+    fileCache.set(deepLinkFile.path + inMemoryFileCopySuffix, {
+      path: deepLinkFile.path + inMemoryFileCopySuffix,
+      content: deepLinkFile.content
+    });
+  });
+}
+
+export function resetSourceFiles(fileCache: FileCache) {
+  fileCache.getAll().forEach(file => {
+    if (path.extname(file.path) === `.ts${inMemoryFileCopySuffix}`) {
+      const originalExtension = changeExtension(file.path, '.ts');
+      fileCache.set(originalExtension, {
+        path: originalExtension,
+        content: file.content
+      });
+      fileCache.getRawStore().delete(file.path);
+    }
+  });
+}
+
+export const inMemoryFileCopySuffix = 'original';
 
 let cachedProgram: ts.Program = null;
 let cachedTsConfig: TsConfig = null;