perf: reduce memory consumption (#1022)

Use a single file cache to reduce memory consumption when having multiple entrypoints. This also help to improve the build time due to after the analyse the files will be already cached.

Author: alan-agius4

src/lib/ng-v5/entry-point/ts/compile-ngc.transform.ts

@@ -2,26 +2,28 @@ import * as path from 'path';
 import * as ts from 'typescript';
 import { Transform, transformFromPromise } from '../../../brocc/transform';
 import { compileSourceFiles } from '../../../ngc/compile-source-files';
-import { TsConfig } from '../../../ts/tsconfig';
+import { TsConfig, setDependenciesTsConfigPaths } from '../../../ts/tsconfig';
 import * as log from '../../../util/log';
-import { isEntryPointInProgress, EntryPointNode, isPackage } from '../../nodes';
+import { isEntryPointInProgress, EntryPointNode, isPackage, isEntryPoint } from '../../nodes';
 import { StylesheetProcessor } from '../resources/stylesheet-processor';
 
 export const compileNgcTransform: Transform = transformFromPromise(async graph => {
   log.info(`Compiling TypeScript sources through ngc`);
   const entryPoint = graph.find(isEntryPointInProgress()) as EntryPointNode;
-  const tsConfig: TsConfig = entryPoint.data.tsConfig;
+  const entryPoints = graph.filter(isEntryPoint) as EntryPointNode[];
+  // Add paths mappings for dependencies
+  const tsConfig = setDependenciesTsConfigPaths(entryPoint.data.tsConfig, entryPoints);
 
   // Compile TypeScript sources
   const { esm2015, esm5, declarations } = entryPoint.data.destinationFiles;
-  const { compilationFileCache, moduleResolutionCache } = entryPoint.cache;
+  const { sourcesFileCache, moduleResolutionCache } = entryPoint.cache;
   const { basePath, cssUrl, styleIncludePaths } = entryPoint.data.entryPoint;
   const stylesheetProcessor = new StylesheetProcessor(basePath, cssUrl, styleIncludePaths);
 
   await Promise.all([
     compileSourceFiles(
       tsConfig,
-      compilationFileCache,
+      sourcesFileCache,
       moduleResolutionCache,
       stylesheetProcessor,
       {
@@ -32,7 +34,7 @@ export const compileNgcTransform: Transform = transformFromPromise(async graph =
       path.dirname(declarations)
     ),
 
-    compileSourceFiles(tsConfig, compilationFileCache, moduleResolutionCache, stylesheetProcessor, {
+    compileSourceFiles(tsConfig, sourcesFileCache, moduleResolutionCache, stylesheetProcessor, {
       outDir: path.dirname(esm5),
       target: ts.ScriptTarget.ES5,
       downlevelIteration: true,

src/lib/ng-v5/init/analyse-sources.transform.ts

@@ -6,7 +6,8 @@ import * as log from '../../util/log';
 import { Transform } from '../../brocc/transform';
 import { isEntryPoint, EntryPointNode } from '../nodes';
 import { cacheCompilerHost } from '../../ts/cache-compiler-host';
-import { unique, flatten } from '../../util/array';
+import { unique } from '../../util/array';
+import { setDependenciesTsConfigPaths } from '../../ts/tsconfig';
 
 export const analyseSourcesTransform: Transform = pipe(
   map(graph => {
@@ -26,14 +27,16 @@ export const analyseSourcesTransform: Transform = pipe(
  * @param entryPoints List of all entry points.
  */
 function analyseEntryPoint(entryPoint: EntryPointNode, entryPoints: EntryPointNode[]) {
-  const { tsConfig } = entryPoint.data;
-  const { analysisFileCache, analysisModuleResolutionCache } = entryPoint.cache;
+  const { sourcesFileCache, analysisModuleResolutionCache } = entryPoint.cache;
   const { moduleId } = entryPoint.data.entryPoint;
 
   log.debug(`Analysing sources for ${moduleId}`);
 
+  // Add paths mappings for dependencies
+  const tsConfig = setDependenciesTsConfigPaths(entryPoint.data.tsConfig, entryPoints, true);
+
   const compilerHost = {
-    ...cacheCompilerHost(tsConfig.options, analysisFileCache, analysisModuleResolutionCache),
+    ...cacheCompilerHost(tsConfig.options, sourcesFileCache, analysisModuleResolutionCache),
     readResource: () => ''
   };
 

src/lib/ng-v5/nodes.ts

@@ -58,8 +58,7 @@ export class EntryPointNode extends Node {
   readonly type = TYPE_NG_ENTRY_POINT;
 
   cache = {
-    analysisFileCache: new FileCache(),
-    compilationFileCache: new FileCache(),
+    sourcesFileCache: new FileCache(),
     moduleResolutionCache: ts.createModuleResolutionCache(process.cwd(), s => s),
     analysisModuleResolutionCache: ts.createModuleResolutionCache(process.cwd(), s => s)
   };

src/lib/ng-v5/package.transform.ts

@@ -117,8 +117,8 @@ const watchTransformFactory = (
           let filePathsToClean: string[] = [filePath];
 
           entryPoints.forEach((node: EntryPointNode) => {
-            const { compilationFileCache } = node.cache;
-            const cached = compilationFileCache.get(filePath);
+            const { sourcesFileCache } = node.cache;
+            const cached = sourcesFileCache.get(filePath);
 
             // when a ts file changes we also need to clean it's .d.ts file
             // and the entrypoint metadata due to the fact that metadata is used to validate component properties
@@ -131,13 +131,12 @@ const watchTransformFactory = (
           filePathsToClean = unique(filePathsToClean);
 
           entryPoints.forEach((node: EntryPointNode) => {
-            const { analysisFileCache, compilationFileCache } = node.cache;
+            const { sourcesFileCache } = node.cache;
 
             let isDirty = false;
 
             filePathsToClean.forEach(x => {
-              isDirty = analysisFileCache.delete(x) || isDirty;
-              isDirty = compilationFileCache.delete(x) || isDirty;
+              isDirty = sourcesFileCache.delete(x) || isDirty;
             });
 
             if (isDirty) {

src/lib/ts/tsconfig.ts

@@ -99,26 +99,43 @@ export const initializeTsConfig = (defaultTsConfig: TsConfig, entryPoints: Entry
         break;
     }
 
-    // Add paths mappings for dependencies
-    const entryPointDeps = entryPoints.filter(x => x.data.entryPoint.moduleId !== entryPoint.moduleId);
-    if (entryPointDeps.length > 0) {
-      if (!tsConfig.options.paths) {
-        tsConfig.options.paths = {};
-      }
+    currentEntryPoint.data.tsConfig = tsConfig;
+  });
+};
 
-      for (let dep of entryPointDeps) {
-        const { entryPoint, destinationFiles } = dep.data;
-        const { moduleId, entryFilePath } = entryPoint;
-        const mappedPath = [destinationFiles.declarations, entryFilePath];
+/**
+ * Set the paths for entrypoint dependencies.
+ *
+ * This doesn't mutate the object.
+ *
+ * @param parsedTsConfig - A parsed tsconfig
+ * @param entryPoints - A list of entryPoints
+ * @param pointToSource Point the path mapping to either the source code or emitted declarations.
+ * Typically for analysis one should point to the source files while for a compilation once should use the emitted declarations
+ */
+export function setDependenciesTsConfigPaths(
+  parsedTsConfig: ng.ParsedConfiguration,
+  entryPoints: EntryPointNode[],
+  pointToSource = false
+) {
+  const tsConfig = JSON.parse(JSON.stringify(parsedTsConfig));
 
-        if (!tsConfig.options.paths[moduleId]) {
-          tsConfig.options.paths[moduleId] = mappedPath;
-        } else {
-          tsConfig.options.paths[moduleId].concat(mappedPath);
-        }
-      }
+  // Add paths mappings for dependencies
+  if (!tsConfig.options.paths) {
+    tsConfig.options.paths = {};
+  }
+
+  for (let dep of entryPoints) {
+    const { entryPoint } = dep.data;
+    const { moduleId, destinationFiles, entryFilePath } = entryPoint;
+    const mappedPath = [pointToSource ? entryFilePath : destinationFiles.declarations];
+
+    if (!tsConfig.options.paths[moduleId]) {
+      tsConfig.options.paths[moduleId] = mappedPath;
+    } else {
+      tsConfig.options.paths[moduleId].concat(mappedPath).reverse();
     }
+  }
 
-    currentEntryPoint.data.tsConfig = tsConfig;
-  });
-};
+  return tsConfig;
+}