feat(@ngtools/webpack): integrate ngcc async

With this change we call NGCC async version prior to every build which will process the entire node modules tree.

Author: alan-agius4

packages/ngtools/webpack/src/angular_compiler_plugin.ts

@@ -777,6 +777,8 @@ export class AngularCompilerPlugin {
           this._basePath,
           this._compilerOptions,
         );
+
+        ngccProcessor.process();
       }
 
       // Use an identity function as all our paths are absolute already.

packages/ngtools/webpack/src/ngcc_processor.ts

@@ -7,6 +7,7 @@
  */
 
 import { Logger, PathMappings, process as mainNgcc } from '@angular/compiler-cli/ngcc';
+import { spawnSync } from 'child_process';
 import { accessSync, constants, existsSync } from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
@@ -49,6 +50,52 @@ export class NgccProcessor {
     }
   }
 
+  /** Process the entire node modules tree. */
+  process() {
+    const timeLabel = 'NgccProcessor.process';
+    time(timeLabel);
+
+    const corePackage = this.tryResolvePackage('@angular/core', this._nodeModulesDirectory);
+
+    // If the package.json is read only we should skip calling NGCC.
+    // With Bazel when running under sandbox the filesystem is read-only.
+    if (corePackage && isReadOnlyFile(corePackage)) {
+      timeEnd(timeLabel);
+
+      return;
+    }
+
+    // We spawn instead of using the API because:
+    // - NGCC Async uses clustering which is problematic when used via the API which means
+    // that we cannot setup multiple cluster masters with different options.
+    // - We will not be able to have concurrent builds otherwise Ex: App-Shell,
+    // as NGCC will create a lock file for both builds and it will cause builds to fails.
+    const { status, error } = spawnSync(
+      process.execPath,
+      [
+        require.resolve('@angular/compiler-cli/ngcc/main-ngcc.js'),
+        '--source', /** basePath */
+        this._nodeModulesDirectory,
+        '--properties', /** propertiesToConsider */
+        ...this.propertiesToConsider,
+        '--first-only', /** compileAllFormats */
+        '--create-ivy-entry-points', /** createNewEntryPointFormats */
+        '--async',
+      ],
+      {
+        stdio: ['inherit', process.stderr, process.stderr],
+      },
+    );
+
+    if (status !== 0) {
+      const errorMessage = error?.message || '';
+      throw new Error(errorMessage + `NGCC failed${errorMessage ? ', see above' : ''}.`);
+    }
+
+    timeEnd(timeLabel);
+  }
+
+  /** Process a module and it's depedencies. */
   processModule(
     moduleName: string,
     resolvedModule: ts.ResolvedModule | ts.ResolvedTypeReferenceDirective,
@@ -61,18 +108,9 @@ export class NgccProcessor {
     }
 
     const packageJsonPath = this.tryResolvePackage(moduleName, resolvedFileName);
-    if (!packageJsonPath) {
-      // add it to processed so the second time round we skip this.
-      this._processedModules.add(resolvedFileName);
-
-      return;
-    }
-
     // If the package.json is read only we should skip calling NGCC.
     // With Bazel when running under sandbox the filesystem is read-only.
-    try {
-      accessSync(packageJsonPath, constants.W_OK);
-    } catch {
+    if (!packageJsonPath || isReadOnlyFile(packageJsonPath)) {
       // add it to processed so the second time round we skip this.
       this._processedModules.add(resolvedFileName);
 
@@ -145,9 +183,9 @@ class NgccLogger implements Logger {
   constructor(
     private readonly compilationWarnings: (Error | string)[],
     private readonly compilationErrors: (Error | string)[],
-  ) {}
+  ) { }
 
-  debug(..._args: string[]) {}
+  debug(..._args: string[]) { }
 
   info(...args: string[]) {
     // Log to stderr because it's a progress-like info message.
@@ -162,3 +200,13 @@ class NgccLogger implements Logger {
     this.compilationErrors.push(new Error(args.join(' ')));
   }
 }
+
+function isReadOnlyFile(fileName: string): boolean {
+  try {
+    accessSync(fileName, constants.W_OK);
+
+    return false;
+  } catch {
+    return true;
+  }
+}