Performance optimizations

integration/watch/intra-dependent.spec.ts

@@ -22,27 +22,27 @@ describe('intra-dependent', () => {
     harness.expectFesm2015ToMatch('intra-dependent-secondary', /count = 100/);
   });
 
-  it('should throw error component inputs is changed without updating usages', (done) => {
+  it('should throw error component inputs is changed without updating usages', done => {
     harness.copyTestCase('invalid-component-property');
 
-    harness.onFailure((error) => {
+    harness.onFailure(error => {
       expect(error.message).to.match(/Can\'t bind to \'count\' since it isn\'t a known property/);
       harness.copyTestCase('valid');
       done();
     });
   });
 
-  it('should throw error service method is changed without updating usages', (done) => {
+  it('should throw error service method is changed without updating usages', done => {
     harness.copyTestCase('invalid-service-method');
 
-    harness.onFailure((error) => {
+    harness.onFailure(error => {
       expect(error.message).to.match(/Property \'initialize\' does not exist on type \'PrimaryAngularService\'/);
       harness.copyTestCase('valid');
       done();
     });
   });
 
-  it('should only build entrypoints that are dependent on the file changed.', (done) => {
+  it('should only build entrypoints that are dependent on the file changed.', done => {
     const primaryFesmPath = harness.getFilePath('fesm2015/intra-dependent.js');
     const secondaryFesmPath = harness.getFilePath('fesm2015/intra-dependent-secondary.js');
     const thirdFesmPath = harness.getFilePath('fesm2015/intra-dependent-third.js');
@@ -59,4 +59,13 @@ describe('intra-dependent', () => {
       done();
     });
   });
+
+  it('should fail when introducing a circular import.', done => {
+    harness.copyTestCase('circular');
+
+    harness.onFailure(error => {
+      expect(error.message).to.contain('Entry point intra-dependent has a circular dependency on itself.');
+      done();
+    });
+  });
 });

integration/watch/intra-dependent/test_files/circular/src/primary.service.ts

@@ -0,0 +1,9 @@
+import { Injectable } from '@angular/core';
+import 'intra-dependent';
+
+@Injectable()
+export class PrimaryAngularService {
+  initialize() {
+    // stub
+  }
+}

src/lib/ng-package/discover-packages.ts

@@ -1,13 +1,11 @@
-import * as ajv from 'ajv';
 import { pathExistsSync, lstat } from 'fs-extra';
 import * as path from 'path';
 import * as log from '../utils/log';
 import { ensureUnixPath } from '../utils/path';
 import { NgEntryPoint } from './entry-point/entry-point';
 import { NgPackage } from './package';
 import { globFiles } from '../utils/glob';
-
-const ngPackageSchemaJson = require('../../ng-package.schema.json');
+import { validateNgPackageSchema } from './schema';
 
 interface UserPackage {
   /** Values from the `package.json` file of this user package. */
@@ -18,19 +16,6 @@ interface UserPackage {
   basePath: string;
 }
 
-function formatSchemaValidationErrors(errors: ajv.ErrorObject[]): string {
-  return errors
-    .map(err => {
-      let message = `Data path ${JSON.stringify(err.dataPath)} ${err.message}`;
-      if (err.keyword === 'additionalProperties') {
-        message += ` (${(err.params as any).additionalProperty})`;
-      }
-
-      return message + '.';
-    })
-    .join('\n');
-}
-
 /**
  * Resolves a user's package by testing for 'package.json', 'ng-package.json', or 'ng-package.js'.
  *
@@ -67,36 +52,12 @@ async function resolveUserPackage(folderPathOrFilePath: string, isSecondary = fa
   }
 
   if (ngPackageJson) {
-    const _ajv = ajv({
-      schemaId: 'auto',
-      useDefaults: true,
-      jsonPointers: true,
-    });
-
-    const validate = _ajv.compile(ngPackageSchemaJson);
-    // Add handler for x-deprecated fields
-    _ajv.addKeyword('x-deprecated', {
-      validate: (schema, _data, _parentSchema, _dataPath, _parentDataObject, propertyName) => {
-        if (schema) {
-          log.warn(`Option "${propertyName}" is deprecated${typeof schema == 'string' ? ': ' + schema : '.'}`);
-        }
-
-        return true;
-      },
-      errors: false,
-    });
-
-    const isValid = validate(ngPackageJson);
-    if (!isValid) {
-      throw new Error(
-        `Configuration doesn\'t match the required schema.\n${formatSchemaValidationErrors(validate.errors)}`,
-      );
-    }
+    validateNgPackageSchema(ngPackageJson);
 
     return {
       basePath,
       packageJson: packageJson || {},
-      ngPackageJson: ngPackageJson as Record<string, any>,
+      ngPackageJson,
     };
   }
 

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

@@ -17,12 +17,12 @@ export const compileNgcTransform: Transform = transformFromPromise(async graph =
 
   // Compile TypeScript sources
   const { esm2015, declarations } = entryPoint.data.destinationFiles;
-  const { moduleResolutionCache } = entryPoint.cache;
+  const { moduleResolutionCache, ngccProcessingCache } = entryPoint.cache;
   const { basePath, cssUrl, styleIncludePaths } = entryPoint.data.entryPoint;
   const stylesheetProcessor = new StylesheetProcessor(basePath, cssUrl, styleIncludePaths);
 
   const ngccProcessor = tsConfig.options.enableIvy
-    ? new NgccProcessor(tsConfig.project, tsConfig.options, entryPoints)
+    ? new NgccProcessor(ngccProcessingCache, tsConfig.project, tsConfig.options, entryPoints)
     : undefined;
 
   await compileSourceFiles(

src/lib/ng-package/ngcc-cache.ts

@@ -0,0 +1,25 @@
+/**
+ * Registers the absolute specifiers of libraries that have been processed by ngcc. This cache is
+ * reused across all entry-points of a package, so module requests across the entry-points can
+ * determine whether invoking ngcc is necessary.
+ *
+ * The cost of invoking ngcc for an entry-point that has already been processed is limited due to
+ * a fast path in ngcc, however even in this fast-path does ngcc scan the entry-point to determine
+ * if all dependencies have been processed. This cache allows to avoid that work, as entry-points
+ * are processed in batches during which the `node_modules` directory is not mutated.
+ */
+export class NgccProcessingCache {
+  private readonly processedModuleNames = new Set<string>();
+
+  hasProcessed(moduleName: string): boolean {
+    return this.processedModuleNames.has(moduleName);
+  }
+
+  markProcessed(moduleName: string): void {
+    this.processedModuleNames.add(moduleName);
+  }
+
+  clear(): void {
+    this.processedModuleNames.clear();
+  }
+}

src/lib/ng-package/nodes.ts

@@ -4,6 +4,7 @@ import { ParsedConfiguration, Program } from '@angular/compiler-cli';
 import { Node } from '../graph/node';
 import { by, isInProgress, isDirty } from '../graph/select';
 import { NgEntryPoint, DestinationFiles } from './entry-point/entry-point';
+import { NgccProcessingCache } from './ngcc-cache';
 import { NgPackage } from './package';
 import { FileCache } from '../file-system/file-cache';
 import { ComplexPredicate } from '../graph/build-graph';
@@ -60,25 +61,30 @@ export function ngUrl(path: string): string {
 export class EntryPointNode extends Node {
   readonly type = TYPE_NG_ENTRY_POINT;
 
-  constructor(public readonly url: string, readonly sourcesFileCache?: FileCache) {
+  constructor(
+    public readonly url: string,
+    sourcesFileCache: FileCache,
+    ngccProcessingCache: NgccProcessingCache,
+    moduleResolutionCache: ts.ModuleResolutionCache,
+  ) {
     super(url);
 
-    if (sourcesFileCache) {
-      this.cache.sourcesFileCache = sourcesFileCache;
-    }
+    this.cache = {
+      sourcesFileCache,
+      ngccProcessingCache,
+      analysesSourcesFileCache: new FileCache(),
+      moduleResolutionCache,
+    };
   }
 
   cache: {
     oldPrograms?: Record<ts.ScriptTarget | 'analysis', Program | ts.Program>;
     sourcesFileCache: FileCache;
+    ngccProcessingCache: NgccProcessingCache;
     analysesSourcesFileCache: FileCache;
     moduleResolutionCache: ts.ModuleResolutionCache;
     rollupFESMCache?: RollupCache;
     rollupUMDCache?: RollupCache;
-  } = {
-    sourcesFileCache: new FileCache(),
-    analysesSourcesFileCache: new FileCache(),
-    moduleResolutionCache: ts.createModuleResolutionCache(process.cwd(), s => s),
   };
 
   data: {
@@ -95,5 +101,7 @@ export class PackageNode extends Node {
   cache = {
     globCache: {} as GlobCache,
     sourcesFileCache: new FileCache(),
+    ngccProcessingCache: new NgccProcessingCache(),
+    moduleResolutionCache: ts.createModuleResolutionCache(process.cwd(), s => s),
   };
 }

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

@@ -101,7 +101,12 @@ export const packageTransformFactory = (
       const ngPkg: PackageNode = foundNode;
       const entryPoints = [ngPkg.data.primary, ...ngPkg.data.secondaries].map(entryPoint => {
         const { destinationFiles, moduleId } = entryPoint;
-        const node = new EntryPointNode(ngUrl(moduleId), ngPkg.cache.sourcesFileCache);
+        const node = new EntryPointNode(
+          ngUrl(moduleId),
+          ngPkg.cache.sourcesFileCache,
+          ngPkg.cache.ngccProcessingCache,
+          ngPkg.cache.moduleResolutionCache,
+        );
         node.data = { entryPoint, destinationFiles };
         node.state = 'dirty';
         ngPkg.dependsOn(node);
@@ -134,9 +139,11 @@ const watchTransformFactory = (
       return createFileWatch(data.src, [data.dest]).pipe(
         tap(fileChange => {
           const { filePath, event } = fileChange;
-          const { sourcesFileCache } = cache;
+          const { sourcesFileCache, ngccProcessingCache } = cache;
           const cachedSourceFile = sourcesFileCache.get(filePath);
 
+          ngccProcessingCache.clear();
+
           if (!cachedSourceFile) {
             if (event === 'unlink' || event === 'add') {
               cache.globCache = regenerateGlobCache(sourcesFileCache);
@@ -147,27 +154,35 @@ const watchTransformFactory = (
           const { declarationFileName } = cachedSourceFile;
 
           const uriToClean = [filePath, declarationFileName].map(x => fileUrl(ensureUnixPath(x)));
-          let nodesToClean = graph.filter(node => uriToClean.some(uri => uri === node.url));
+          const nodesToClean = graph.filter(node => uriToClean.some(uri => uri === node.url));
 
-          nodesToClean = flatten([
-            ...nodesToClean,
-            // if a non ts file changes we need to clean up it's direct dependees
-            // this is mainly done for resources such as html and css
-            ...nodesToClean.filter(x => !x.url.endsWith('.ts')).map(x => x.dependees),
-          ]);
+          const allUrlsToClean = new Set<string>(
+            flatten([
+              ...nodesToClean.map(node => node.url),
+              // if a non ts file changes we need to clean up its direct dependees
+              // this is mainly done for resources such as html and css
+              ...nodesToClean
+                .filter(node => !node.url.endsWith('.ts'))
+                .map(node => node.dependees.map(dependee => dependee.url)),
+            ]),
+          );
 
           // delete node that changes
-          nodesToClean.forEach(node => {
-            sourcesFileCache.delete(fileUrlPath(node.url));
+          allUrlsToClean.forEach(url => {
+            sourcesFileCache.delete(fileUrlPath(url));
           });
 
           const entryPoints: EntryPointNode[] = graph.filter(isEntryPoint);
           entryPoints.forEach(entryPoint => {
-            const isDirty = entryPoint.dependents.some(x => nodesToClean.some(node => node.url === x.url));
+            const isDirty = entryPoint.dependents.some(dependent => allUrlsToClean.has(dependent.url));
             if (isDirty) {
               entryPoint.state = 'dirty';
               const { metadata } = entryPoint.data.destinationFiles;
               sourcesFileCache.delete(metadata);
+
+              uriToClean.forEach(url => {
+                entryPoint.cache.analysesSourcesFileCache.delete(fileUrlPath(url));
+              });
             }
           });
 

src/lib/ng-package/schema.ts

@@ -0,0 +1,67 @@
+import * as ajv from 'ajv';
+import { NgPackageConfig } from '../../ng-package.schema';
+import * as log from '../utils/log';
+
+/** Lazily initialized ajv validator instance. */
+let ajvValidator: ajv.ValidateFunction | null = null;
+
+/**
+ * Validates the `ngPackageJson` value against the JSON schema using ajv. An error is thrown if
+ * schema errors are found.
+ *
+ * @param ngPackageJson The value to validate.
+ */
+export function validateNgPackageSchema(ngPackageJson: unknown): asserts ngPackageJson is NgPackageConfig {
+  const validate = getNgPackageSchemaValidator();
+  const isValid = validate(ngPackageJson);
+  if (!isValid) {
+    throw new Error(
+      `Configuration doesn't match the required schema.\n${formatSchemaValidationErrors(validate.errors)}`,
+    );
+  }
+}
+
+function formatSchemaValidationErrors(errors: ajv.ErrorObject[]): string {
+  return errors
+    .map(err => {
+      let message = `Data path ${JSON.stringify(err.dataPath)} ${err.message}`;
+      if (err.keyword === 'additionalProperties') {
+        message += ` (${(err.params as any).additionalProperty})`;
+      }
+
+      return message + '.';
+    })
+    .join('\n');
+}
+
+/**
+ * Returns an initialized ajv validator for the ng-package JSON schema.
+ */
+function getNgPackageSchemaValidator(): ajv.ValidateFunction {
+  if (ajvValidator !== null) {
+    return ajvValidator;
+  }
+
+  const _ajv: ajv.Ajv = ajv({
+    schemaId: 'auto',
+    useDefaults: true,
+    jsonPointers: true,
+  });
+
+  const ngPackageSchemaJson = require('../../ng-package.schema.json');
+  ajvValidator = _ajv.compile(ngPackageSchemaJson);
+
+  // Add handler for x-deprecated fields
+  _ajv.addKeyword('x-deprecated', {
+    validate: (schema, _data, _parentSchema, _dataPath, _parentDataObject, propertyName) => {
+      if (schema) {
+        log.warn(`Option "${propertyName}" is deprecated${typeof schema == 'string' ? ': ' + schema : '.'}`);
+      }
+
+      return true;
+    },
+    errors: false,
+  });
+
+  return ajvValidator;
+}