refactor(@angular-devkit/build-angular): remove @ngtools/webpack deep imports from application builder

The application builder previously used several TypeScript compiler host augmentation helper functions
and the bootstrap replacement transformer from the `@ngtools/webpack` package. To remove reliance on
Webpack-specific functionality. The subset of helpers have been copied into the application builder
itself. Some of the helpers will eventually be removed completely pending future updates to the
Angular compiler itself.

Author: clydin

packages/angular_devkit/build_angular/src/tools/esbuild/angular/angular-host.ts

@@ -7,7 +7,9 @@
  */
 
 import type ng from '@angular/compiler-cli';
-import ts from 'typescript';
+import { createHash } from 'node:crypto';
+import nodePath from 'node:path';
+import type ts from 'typescript';
 
 export type AngularCompilerOptions = ng.CompilerOptions;
 export type AngularCompilerHost = ng.CompilerHost;
@@ -24,36 +26,146 @@ export interface AngularHostOptions {
   processWebWorker(workerFile: string, containingFile: string): string;
 }
 
-// Temporary deep import for host augmentation support.
-// TODO: Move these to a private exports location or move the implementation into this package.
-const {
-  augmentHostWithCaching,
-  augmentHostWithReplacements,
-  augmentProgramWithVersioning,
-} = require('@ngtools/webpack/src/ivy/host');
-
 /**
  * Patches in-place the `getSourceFiles` function on an instance of a TypeScript
  * `Program` to ensure that all returned SourceFile instances have a `version`
  * field. The `version` field is required when used with a TypeScript BuilderProgram.
  * @param program The TypeScript Program instance to patch.
  */
 export function ensureSourceFileVersions(program: ts.Program): void {
-  augmentProgramWithVersioning(program);
+  const baseGetSourceFiles = program.getSourceFiles;
+  // TODO: Update Angular compiler to add versions to all internal files and remove this
+  program.getSourceFiles = function (...parameters) {
+    const files: readonly (ts.SourceFile & { version?: string })[] = baseGetSourceFiles(
+      ...parameters,
+    );
+
+    for (const file of files) {
+      if (file.version === undefined) {
+        file.version = createHash('sha256').update(file.text).digest('hex');
+      }
+    }
+
+    return files;
+  };
+}
+
+function augmentHostWithCaching(host: ts.CompilerHost, cache: Map<string, ts.SourceFile>): void {
+  const baseGetSourceFile = host.getSourceFile;
+  host.getSourceFile = function (
+    fileName,
+    languageVersion,
+    onError,
+    shouldCreateNewSourceFile,
+    ...parameters
+  ) {
+    if (!shouldCreateNewSourceFile && cache.has(fileName)) {
+      return cache.get(fileName);
+    }
+
+    const file = baseGetSourceFile.call(
+      host,
+      fileName,
+      languageVersion,
+      onError,
+      true,
+      ...parameters,
+    );
+
+    if (file) {
+      cache.set(fileName, file);
+    }
+
+    return file;
+  };
+}
+
+function augmentResolveModuleNames(
+  typescript: typeof ts,
+  host: ts.CompilerHost,
+  resolvedModuleModifier: (
+    resolvedModule: ts.ResolvedModule | undefined,
+    moduleName: string,
+  ) => ts.ResolvedModule | undefined,
+  moduleResolutionCache?: ts.ModuleResolutionCache,
+): void {
+  if (host.resolveModuleNames) {
+    const baseResolveModuleNames = host.resolveModuleNames;
+    host.resolveModuleNames = function (moduleNames: string[], ...parameters) {
+      return moduleNames.map((name) => {
+        const result = baseResolveModuleNames.call(host, [name], ...parameters);
+
+        return resolvedModuleModifier(result[0], name);
+      });
+    };
+  } else {
+    host.resolveModuleNames = function (
+      moduleNames: string[],
+      containingFile: string,
+      _reusedNames: string[] | undefined,
+      redirectedReference: ts.ResolvedProjectReference | undefined,
+      options: ts.CompilerOptions,
+    ) {
+      return moduleNames.map((name) => {
+        const result = typescript.resolveModuleName(
+          name,
+          containingFile,
+          options,
+          host,
+          moduleResolutionCache,
+          redirectedReference,
+        ).resolvedModule;
+
+        return resolvedModuleModifier(result, name);
+      });
+    };
+  }
+}
+
+function normalizePath(path: string): string {
+  return nodePath.win32.normalize(path).replace(/\\/g, nodePath.posix.sep);
+}
+
+function augmentHostWithReplacements(
+  typescript: typeof ts,
+  host: ts.CompilerHost,
+  replacements: Record<string, string>,
+  moduleResolutionCache?: ts.ModuleResolutionCache,
+): void {
+  if (Object.keys(replacements).length === 0) {
+    return;
+  }
+
+  const normalizedReplacements: Record<string, string> = {};
+  for (const [key, value] of Object.entries(replacements)) {
+    normalizedReplacements[normalizePath(key)] = normalizePath(value);
+  }
+
+  const tryReplace = (resolvedModule: ts.ResolvedModule | undefined) => {
+    const replacement = resolvedModule && normalizedReplacements[resolvedModule.resolvedFileName];
+    if (replacement) {
+      return {
+        resolvedFileName: replacement,
+        isExternalLibraryImport: /[/\\]node_modules[/\\]/.test(replacement),
+      };
+    } else {
+      return resolvedModule;
+    }
+  };
+
+  augmentResolveModuleNames(typescript, host, tryReplace, moduleResolutionCache);
 }
 
 export function createAngularCompilerHost(
+  typescript: typeof ts,
   compilerOptions: AngularCompilerOptions,
   hostOptions: AngularHostOptions,
 ): AngularCompilerHost {
   // Create TypeScript compiler host
-  const host: AngularCompilerHost = ts.createIncrementalCompilerHost(compilerOptions);
-  // Set the parsing mode to the same as TS 5.3 default for tsc. This provides a parse
+  const host: AngularCompilerHost = typescript.createIncrementalCompilerHost(compilerOptions);
+  // Set the parsing mode to the same as TS 5.3+ default for tsc. This provides a parse
   // performance improvement by skipping non-type related JSDoc parsing.
-  // NOTE: The check for this enum can be removed when TS 5.3 support is the minimum.
-  if (ts.JSDocParsingMode) {
-    host.jsDocParsingMode = ts.JSDocParsingMode.ParseForTypeErrors;
-  }
+  host.jsDocParsingMode = typescript.JSDocParsingMode.ParseForTypeErrors;
 
   // The AOT compiler currently requires this hook to allow for a transformResource hook.
   // Once the AOT compiler allows only a transformResource hook, this can be reevaluated.
@@ -90,14 +202,14 @@ export function createAngularCompilerHost(
   // Augment TypeScript Host for file replacements option
   if (hostOptions.fileReplacements) {
     // Provide a resolution cache since overriding resolution prevents automatic creation
-    const resolutionCache = ts.createModuleResolutionCache(
+    const resolutionCache = typescript.createModuleResolutionCache(
       host.getCurrentDirectory(),
       host.getCanonicalFileName.bind(host),
       compilerOptions,
     );
     host.getModuleResolutionCache = () => resolutionCache;
 
-    augmentHostWithReplacements(host, hostOptions.fileReplacements, resolutionCache);
+    augmentHostWithReplacements(typescript, host, hostOptions.fileReplacements, resolutionCache);
   }
 
   // Augment TypeScript Host with source file caching if provided

packages/angular_devkit/build_angular/src/tools/esbuild/angular/compilation/aot-compilation.ts

@@ -17,10 +17,7 @@ import {
 } from '../angular-host';
 import { createWorkerTransformer } from '../web-worker-transformer';
 import { AngularCompilation, DiagnosticModes, EmitFileResult } from './angular-compilation';
-
-// Temporary deep import for transformer support
-// TODO: Move these to a private exports location or move the implementation into this package.
-const { mergeTransformers, replaceBootstrap } = require('@ngtools/webpack/src/ivy/transformation');
+import { replaceBootstrap } from './jit-bootstrap-transformer';
 
 class AngularCompilationState {
   constructor(
@@ -63,7 +60,7 @@ export class AotCompilation extends AngularCompilation {
       compilerOptionsTransformer?.(originalCompilerOptions) ?? originalCompilerOptions;
 
     // Create Angular compiler host
-    const host = createAngularCompilerHost(compilerOptions, hostOptions);
+    const host = createAngularCompilerHost(ts, compilerOptions, hostOptions);
 
     // Create the Angular specific program that contains the Angular compiler
     const angularProgram = profileSync(
@@ -224,12 +221,12 @@ export class AotCompilation extends AngularCompilation {
       angularCompiler.incrementalCompilation.recordSuccessfulEmit(sourceFile);
       emittedFiles.set(sourceFile, { filename: sourceFile.fileName, contents });
     };
-    const transformers = mergeTransformers(angularCompiler.prepareEmit().transformers, {
-      before: [
-        replaceBootstrap(() => typeScriptProgram.getProgram().getTypeChecker()),
-        webWorkerTransform,
-      ],
-    });
+    const transformers = angularCompiler.prepareEmit().transformers;
+    transformers.before ??= [];
+    transformers.before.push(
+      replaceBootstrap(() => typeScriptProgram.getProgram().getTypeChecker()),
+    );
+    transformers.before.push(webWorkerTransform);
 
     // TypeScript will loop until there are no more affected files in the program
     while (