feat(ivy): ngcc - support creating a new copy of the entry-point format (#29092)

This commit adds a `NewEntryPointFileWriter` that will be used in
webpack integration. Instead of overwriting files in-place, this `FileWriter`
will make a copy of the TS program files and write the transformed files
there. It also updates the package.json with new properties that can be
used to access the new entry-point format.

FW-1121

PR Close #29092

packages/compiler-cli/ngcc/src/main.ts

@@ -20,6 +20,7 @@ import {EntryPointFinder} from './packages/entry_point_finder';
 import {Transformer} from './packages/transformer';
 import {FileWriter} from './writing/file_writer';
 import {InPlaceFileWriter} from './writing/in_place_file_writer';
+import {NewEntryPointFileWriter} from './writing/new_entry_point_file_writer';
 
 
 /**
@@ -45,6 +46,10 @@ export interface NgccOptions {
    * this entry-point at the first matching format. Defaults to `true`.
    */
   compileAllFormats?: boolean;
+  /**
+   * Whether to create new entry-points bundles rather than overwriting the original files.
+   */
+  createNewEntryPointFormats?: boolean;
 }
 
 const SUPPORTED_FORMATS: EntryPointFormat[] = ['esm5', 'esm2015'];
@@ -57,14 +62,14 @@ const SUPPORTED_FORMATS: EntryPointFormat[] = ['esm5', 'esm2015'];
  *
  * @param options The options telling ngcc what to compile and how.
  */
-export function mainNgcc({basePath, targetEntryPointPath,
-                          propertiesToConsider = SUPPORTED_FORMAT_PROPERTIES,
-                          compileAllFormats = true}: NgccOptions): void {
+export function mainNgcc(
+    {basePath, targetEntryPointPath, propertiesToConsider = SUPPORTED_FORMAT_PROPERTIES,
+     compileAllFormats = true, createNewEntryPointFormats = false}: NgccOptions): void {
   const transformer = new Transformer(basePath, basePath);
   const host = new DependencyHost();
   const resolver = new DependencyResolver(host);
   const finder = new EntryPointFinder(resolver);
-  const fileWriter = getFileWriter();
+  const fileWriter = getFileWriter(createNewEntryPointFormats);
 
   const absoluteTargetEntryPointPath = targetEntryPointPath ?
       AbsoluteFsPath.from(resolve(basePath, targetEntryPointPath)) :
@@ -115,7 +120,7 @@ export function mainNgcc({basePath, targetEntryPointPath,
       // the property as processed even if its underlying format has been built already.
       if (!compiledFormats.has(formatPath) && (compileAllFormats || compiledFormats.size === 0)) {
         const bundle = makeEntryPointBundle(
-            entryPoint.path, formatPath, entryPoint.typings, isCore, format,
+            entryPoint.path, formatPath, entryPoint.typings, isCore, property, format,
             compiledFormats.size === 0);
         if (bundle) {
           console.warn(`Compiling ${entryPoint.name} : ${property} as ${format}`);
@@ -144,6 +149,6 @@ export function mainNgcc({basePath, targetEntryPointPath,
   });
 }
 
-function getFileWriter(): FileWriter {
-  return new InPlaceFileWriter();
+function getFileWriter(createNewEntryPointFormats: boolean): FileWriter {
+  return createNewEntryPointFormats ? new NewEntryPointFileWriter() : new InPlaceFileWriter();
 }

packages/compiler-cli/ngcc/src/packages/entry_point_bundle.ts

@@ -10,7 +10,7 @@ import * as ts from 'typescript';
 
 import {AbsoluteFsPath} from '../../../src/ngtsc/path';
 import {BundleProgram, makeBundleProgram} from './bundle_program';
-import {EntryPointFormat} from './entry_point';
+import {EntryPointFormat, EntryPointJsonProperty} from './entry_point';
 
 
 
@@ -19,6 +19,7 @@ import {EntryPointFormat} from './entry_point';
  * format of a package entry-point.
  */
 export interface EntryPointBundle {
+  formatProperty: EntryPointJsonProperty;
   format: EntryPointFormat;
   isCore: boolean;
   isFlatCore: boolean;
@@ -38,7 +39,8 @@ export interface EntryPointBundle {
  */
 export function makeEntryPointBundle(
     entryPointPath: string, formatPath: string, typingsPath: string, isCore: boolean,
-    format: EntryPointFormat, transformDts: boolean): EntryPointBundle|null {
+    formatProperty: EntryPointJsonProperty, format: EntryPointFormat,
+    transformDts: boolean): EntryPointBundle|null {
   // Create the TS program and necessary helpers.
   const options: ts.CompilerOptions = {
     allowJs: true,
@@ -57,5 +59,5 @@ export function makeEntryPointBundle(
       null;
   const isFlatCore = isCore && src.r3SymbolsFile === null;
 
-  return {format, rootDirs, isCore, isFlatCore, src, dts};
+  return {format, formatProperty, rootDirs, isCore, isFlatCore, src, dts};
 }

packages/compiler-cli/ngcc/src/writing/new_entry_point_file_writer.ts

@@ -0,0 +1,72 @@
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {dirname, join, relative} from 'canonical-path';
+import {writeFileSync} from 'fs';
+import {cp, mkdir} from 'shelljs';
+
+import {AbsoluteFsPath} from '../../../src/ngtsc/path';
+import {isDtsPath} from '../../../src/ngtsc/util/src/typescript';
+import {EntryPoint, EntryPointJsonProperty} from '../packages/entry_point';
+import {EntryPointBundle} from '../packages/entry_point_bundle';
+import {FileInfo} from '../rendering/renderer';
+
+import {InPlaceFileWriter} from './in_place_file_writer';
+
+const NGCC_DIRECTORY = '__ivy_ngcc__';
+
+/**
+ * This FileWriter creates a copy of the original entry-point, then writes the transformed
+ * files onto the files in this copy, and finally updates the package.json with a new
+ * entry-point format property that points to this new entry-point.
+ *
+ * If there are transformed typings files in this bundle, they are updated in-place (see the
+ * `InPlaceFileWriter`).
+ */
+export class NewEntryPointFileWriter extends InPlaceFileWriter {
+  writeBundle(entryPoint: EntryPoint, bundle: EntryPointBundle, transformedFiles: FileInfo[]) {
+    // The new folder is at the root of the overall package
+    const relativeEntryPointPath = relative(entryPoint.package, entryPoint.path);
+    const relativeNewDir = join(NGCC_DIRECTORY, relativeEntryPointPath);
+    const newDir = AbsoluteFsPath.fromUnchecked(join(entryPoint.package, relativeNewDir));
+    this.copyBundle(bundle, entryPoint.path, newDir);
+    transformedFiles.forEach(file => this.writeFile(file, entryPoint.path, newDir));
+    this.updatePackageJson(entryPoint, bundle.formatProperty, newDir);
+  }
+
+  protected copyBundle(
+      bundle: EntryPointBundle, entryPointPath: AbsoluteFsPath, newDir: AbsoluteFsPath) {
+    bundle.src.program.getSourceFiles().forEach(sourceFile => {
+      const relativePath = relative(entryPointPath, sourceFile.fileName);
+      const newFilePath = join(newDir, relativePath);
+      mkdir('-p', dirname(newFilePath));
+      cp(sourceFile.fileName, newFilePath);
+    });
+  }
+
+  protected writeFile(file: FileInfo, entryPointPath: AbsoluteFsPath, newDir: AbsoluteFsPath):
+      void {
+    if (isDtsPath(file.path)) {
+      super.writeFileAndBackup(file);
+    } else {
+      const relativePath = relative(entryPointPath, file.path);
+      const newFilePath = join(newDir, relativePath);
+      mkdir('-p', dirname(newFilePath));
+      writeFileSync(newFilePath, file.contents, 'utf8');
+    }
+  }
+
+  protected updatePackageJson(
+      entryPoint: EntryPoint, formatProperty: EntryPointJsonProperty, newDir: AbsoluteFsPath) {
+    const bundlePath = entryPoint.packageJson[formatProperty] !;
+    const newBundlePath = relative(entryPoint.path, join(newDir, bundlePath));
+    (entryPoint.packageJson as any)[formatProperty + '_ivy_ngcc'] = newBundlePath;
+    writeFileSync(join(entryPoint.path, 'package.json'), JSON.stringify(entryPoint.packageJson));
+  }
+}