@angular/build 18.0.0-next.3

package/src/tools/babel/plugins/elide-angular-metadata.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeywords = void 0;
+/**
+ * The name of the Angular class metadata function created by the Angular compiler.
+ */
+const SET_CLASS_METADATA_NAME = 'ɵsetClassMetadata';
+/**
+ * Name of the asynchronous Angular class metadata function created by the Angular compiler.
+ */
+const SET_CLASS_METADATA_ASYNC_NAME = 'ɵsetClassMetadataAsync';
+/**
+ * Name of the function that sets debug information on classes.
+ */
+const SET_CLASS_DEBUG_INFO_NAME = 'ɵsetClassDebugInfo';
+/**
+ * Provides one or more keywords that if found within the content of a source file indicate
+ * that this plugin should be used with a source file.
+ *
+ * @returns An a string iterable containing one or more keywords.
+ */
+function getKeywords() {
+    return Object.keys(angularMetadataFunctions);
+}
+exports.getKeywords = getKeywords;
+/**
+ * An object map of function names and related value checks for discovery of Angular generated
+ * metadata calls.
+ */
+const angularMetadataFunctions = {
+    [SET_CLASS_METADATA_NAME]: isSetClassMetadataCall,
+    [SET_CLASS_METADATA_ASYNC_NAME]: isSetClassMetadataAsyncCall,
+    [SET_CLASS_DEBUG_INFO_NAME]: isSetClassDebugInfoCall,
+};
+/**
+ * A babel plugin factory function for eliding the Angular class metadata function (`ɵsetClassMetadata`).
+ *
+ * @returns A babel plugin object instance.
+ */
+function default_1() {
+    return {
+        visitor: {
+            CallExpression(path) {
+                const callee = path.get('callee');
+                // The function being called must be the metadata function name
+                let calleeName;
+                if (callee.isMemberExpression()) {
+                    const calleeProperty = callee.get('property');
+                    if (calleeProperty.isIdentifier()) {
+                        calleeName = calleeProperty.node.name;
+                    }
+                }
+                else if (callee.isIdentifier()) {
+                    calleeName = callee.node.name;
+                }
+                if (!calleeName) {
+                    return;
+                }
+                if (Object.hasOwn(angularMetadataFunctions, calleeName) &&
+                    angularMetadataFunctions[calleeName](path.get('arguments'))) {
+                    // The metadata function is always emitted inside a function expression
+                    const parent = path.getFunctionParent();
+                    if (parent && (parent.isFunctionExpression() || parent.isArrowFunctionExpression())) {
+                        // Replace the metadata function with `void 0` which is the equivalent return value
+                        // of the metadata function.
+                        path.replaceWith(path.scope.buildUndefinedNode());
+                    }
+                }
+            },
+        },
+    };
+}
+exports.default = default_1;
+/** Determines if a function call is a call to `setClassMetadata`. */
+function isSetClassMetadataCall(callArguments) {
+    // `setClassMetadata` calls have to meet the following criteria:
+    // * First must be an identifier
+    // * Second must be an array literal
+    return (callArguments.length === 4 &&
+        callArguments[0].isIdentifier() &&
+        callArguments[1].isArrayExpression());
+}
+/** Determines if a function call is a call to `setClassMetadataAsync`. */
+function isSetClassMetadataAsyncCall(callArguments) {
+    // `setClassMetadataAsync` calls have to meet the following criteria:
+    // * First argument must be an identifier.
+    // * Second argument must be an inline function.
+    // * Third argument must be an inline function.
+    return (callArguments.length === 3 &&
+        callArguments[0].isIdentifier() &&
+        isInlineFunction(callArguments[1]) &&
+        isInlineFunction(callArguments[2]));
+}
+/** Determines if a function call is a call to `setClassDebugInfo`. */
+function isSetClassDebugInfoCall(callArguments) {
+    return (callArguments.length === 2 &&
+        callArguments[0].isIdentifier() &&
+        callArguments[1].isObjectExpression());
+}
+/** Determines if a node is an inline function expression. */
+function isInlineFunction(path) {
+    return path.isFunctionExpression() || path.isArrowFunctionExpression();
+}

package/src/tools/babel/plugins/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+export { default as adjustStaticMembers } from './adjust-static-class-members';
+export { default as adjustTypeScriptEnums } from './adjust-typescript-enums';
+export { default as elideAngularMetadata } from './elide-angular-metadata';
+export { default as markTopLevelPure } from './pure-toplevel-functions';

package/src/tools/babel/plugins/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markTopLevelPure = exports.elideAngularMetadata = exports.adjustTypeScriptEnums = exports.adjustStaticMembers = void 0;
+var adjust_static_class_members_1 = require("./adjust-static-class-members");
+Object.defineProperty(exports, "adjustStaticMembers", { enumerable: true, get: function () { return __importDefault(adjust_static_class_members_1).default; } });
+var adjust_typescript_enums_1 = require("./adjust-typescript-enums");
+Object.defineProperty(exports, "adjustTypeScriptEnums", { enumerable: true, get: function () { return __importDefault(adjust_typescript_enums_1).default; } });
+var elide_angular_metadata_1 = require("./elide-angular-metadata");
+Object.defineProperty(exports, "elideAngularMetadata", { enumerable: true, get: function () { return __importDefault(elide_angular_metadata_1).default; } });
+var pure_toplevel_functions_1 = require("./pure-toplevel-functions");
+Object.defineProperty(exports, "markTopLevelPure", { enumerable: true, get: function () { return __importDefault(pure_toplevel_functions_1).default; } });

package/src/tools/babel/plugins/pure-toplevel-functions.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+/// <reference types="@angular/compiler-cli/private/babel" />
+import type { PluginObj } from '@babel/core';
+/**
+ * A babel plugin factory function for adding the PURE annotation to top-level new and call expressions.
+ *
+ * @returns A babel plugin object instance.
+ */
+export default function (): PluginObj;

package/src/tools/babel/plugins/pure-toplevel-functions.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helper_annotate_as_pure_1 = __importDefault(require("@babel/helper-annotate-as-pure"));
+const tslib = __importStar(require("tslib"));
+/**
+ * A cached set of TypeScript helper function names used by the helper name matcher utility function.
+ */
+const tslibHelpers = new Set(Object.keys(tslib).filter((h) => h.startsWith('__')));
+/**
+ * Determinates whether an identifier name matches one of the TypeScript helper function names.
+ *
+ * @param name The identifier name to check.
+ * @returns True, if the name matches a TypeScript helper name; otherwise, false.
+ */
+function isTslibHelperName(name) {
+    const nameParts = name.split('$');
+    const originalName = nameParts[0];
+    if (nameParts.length > 2 || (nameParts.length === 2 && isNaN(+nameParts[1]))) {
+        return false;
+    }
+    return tslibHelpers.has(originalName);
+}
+/**
+ * A babel plugin factory function for adding the PURE annotation to top-level new and call expressions.
+ *
+ * @returns A babel plugin object instance.
+ */
+function default_1() {
+    return {
+        visitor: {
+            CallExpression(path) {
+                // If the expression has a function parent, it is not top-level
+                if (path.getFunctionParent()) {
+                    return;
+                }
+                const callee = path.get('callee');
+                if ((callee.isFunctionExpression() || callee.isArrowFunctionExpression()) &&
+                    path.node.arguments.length !== 0) {
+                    return;
+                }
+                // Do not annotate TypeScript helpers emitted by the TypeScript compiler.
+                // TypeScript helpers are intended to cause side effects.
+                if (callee.isIdentifier() && isTslibHelperName(callee.node.name)) {
+                    return;
+                }
+                (0, helper_annotate_as_pure_1.default)(path);
+            },
+            NewExpression(path) {
+                // If the expression has a function parent, it is not top-level
+                if (!path.getFunctionParent()) {
+                    (0, helper_annotate_as_pure_1.default)(path);
+                }
+            },
+        },
+    };
+}
+exports.default = default_1;

package/src/tools/babel/typings.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+
+declare module '@babel/helper-annotate-as-pure' {
+  export default function annotateAsPure(
+    pathOrNode: import('@babel/types').Node | { node: import('@babel/types').Node },
+  ): void;
+}
+
+declare module '@babel/helper-split-export-declaration' {
+  export default function splitExportDeclaration(
+    exportDeclaration: import('@babel/core').NodePath<
+      import('@babel/types').ExportDefaultDeclaration
+    >,
+  ): void;
+}

package/src/tools/esbuild/angular/angular-host.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright Google LLC 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 type ng from '@angular/compiler-cli';
+import type ts from 'typescript';
+export type AngularCompilerOptions = ng.CompilerOptions;
+export type AngularCompilerHost = ng.CompilerHost;
+export interface AngularHostOptions {
+    fileReplacements?: Record<string, string>;
+    sourceFileCache?: Map<string, ts.SourceFile>;
+    modifiedFiles?: Set<string>;
+    transformStylesheet(data: string, containingFile: string, stylesheetFile?: string): Promise<string | null>;
+    processWebWorker(workerFile: string, containingFile: string): string;
+}
+/**
+ * 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 declare function ensureSourceFileVersions(program: ts.Program): void;
+export declare function createAngularCompilerHost(typescript: typeof ts, compilerOptions: AngularCompilerOptions, hostOptions: AngularHostOptions): AngularCompilerHost;

package/src/tools/esbuild/angular/angular-host.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAngularCompilerHost = exports.ensureSourceFileVersions = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * 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.
+ */
+function ensureSourceFileVersions(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 = baseGetSourceFiles(...parameters);
+        for (const file of files) {
+            if (file.version === undefined) {
+                file.version = (0, node_crypto_1.createHash)('sha256').update(file.text).digest('hex');
+            }
+        }
+        return files;
+    };
+}
+exports.ensureSourceFileVersions = ensureSourceFileVersions;
+function augmentHostWithCaching(host, cache) {
+    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, host, resolvedModuleModifier, moduleResolutionCache) {
+    if (host.resolveModuleNames) {
+        const baseResolveModuleNames = host.resolveModuleNames;
+        host.resolveModuleNames = function (moduleNames, ...parameters) {
+            return moduleNames.map((name) => {
+                const result = baseResolveModuleNames.call(host, [name], ...parameters);
+                return resolvedModuleModifier(result[0], name);
+            });
+        };
+    }
+    else {
+        host.resolveModuleNames = function (moduleNames, containingFile, _reusedNames, redirectedReference, options) {
+            return moduleNames.map((name) => {
+                const result = typescript.resolveModuleName(name, containingFile, options, host, moduleResolutionCache, redirectedReference).resolvedModule;
+                return resolvedModuleModifier(result, name);
+            });
+        };
+    }
+}
+function normalizePath(path) {
+    return node_path_1.default.win32.normalize(path).replace(/\\/g, node_path_1.default.posix.sep);
+}
+function augmentHostWithReplacements(typescript, host, replacements, moduleResolutionCache) {
+    if (Object.keys(replacements).length === 0) {
+        return;
+    }
+    const normalizedReplacements = {};
+    for (const [key, value] of Object.entries(replacements)) {
+        normalizedReplacements[normalizePath(key)] = normalizePath(value);
+    }
+    const tryReplace = (resolvedModule) => {
+        const replacement = resolvedModule && normalizedReplacements[resolvedModule.resolvedFileName];
+        if (replacement) {
+            return {
+                resolvedFileName: replacement,
+                isExternalLibraryImport: /[/\\]node_modules[/\\]/.test(replacement),
+            };
+        }
+        else {
+            return resolvedModule;
+        }
+    };
+    augmentResolveModuleNames(typescript, host, tryReplace, moduleResolutionCache);
+}
+function createAngularCompilerHost(typescript, compilerOptions, hostOptions) {
+    // Create TypeScript compiler host
+    const host = 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.
+    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.
+    host.readResource = async function (filename) {
+        return this.readFile(filename) ?? '';
+    };
+    // Add an AOT compiler resource transform hook
+    host.transformResource = async function (data, context) {
+        // Only style resources are transformed currently
+        if (context.type !== 'style') {
+            return null;
+        }
+        // No transformation required if the resource is empty
+        if (data.trim().length === 0) {
+            return { content: '' };
+        }
+        const result = await hostOptions.transformStylesheet(data, context.containingFile, context.resourceFile ?? undefined);
+        return typeof result === 'string' ? { content: result } : null;
+    };
+    // Allow the AOT compiler to request the set of changed templates and styles
+    host.getModifiedResourceFiles = function () {
+        return hostOptions.modifiedFiles;
+    };
+    // Augment TypeScript Host for file replacements option
+    if (hostOptions.fileReplacements) {
+        // Provide a resolution cache since overriding resolution prevents automatic creation
+        const resolutionCache = typescript.createModuleResolutionCache(host.getCurrentDirectory(), host.getCanonicalFileName.bind(host), compilerOptions);
+        host.getModuleResolutionCache = () => resolutionCache;
+        augmentHostWithReplacements(typescript, host, hostOptions.fileReplacements, resolutionCache);
+    }
+    // Augment TypeScript Host with source file caching if provided
+    if (hostOptions.sourceFileCache) {
+        augmentHostWithCaching(host, hostOptions.sourceFileCache);
+    }
+    return host;
+}
+exports.createAngularCompilerHost = createAngularCompilerHost;

package/src/tools/esbuild/angular/compilation/angular-compilation.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright Google LLC 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 type ng from '@angular/compiler-cli';
+import type { PartialMessage } from 'esbuild';
+import type ts from 'typescript';
+import type { AngularHostOptions } from '../angular-host';
+export interface EmitFileResult {
+    filename: string;
+    contents: string;
+    dependencies?: readonly string[];
+}
+export declare enum DiagnosticModes {
+    None = 0,
+    Option = 1,
+    Syntactic = 2,
+    Semantic = 4,
+    All = 7
+}
+export declare abstract class AngularCompilation {
+    #private;
+    static loadCompilerCli(): Promise<typeof ng>;
+    static loadTypescript(): Promise<typeof ts>;
+    protected loadConfiguration(tsconfig: string): Promise<ng.CompilerOptions>;
+    abstract initialize(tsconfig: string, hostOptions: AngularHostOptions, compilerOptionsTransformer?: (compilerOptions: ng.CompilerOptions) => ng.CompilerOptions): Promise<{
+        affectedFiles: ReadonlySet<ts.SourceFile>;
+        compilerOptions: ng.CompilerOptions;
+        referencedFiles: readonly string[];
+    }>;
+    abstract emitAffectedFiles(): Iterable<EmitFileResult> | Promise<Iterable<EmitFileResult>>;
+    protected abstract collectDiagnostics(modes: DiagnosticModes): Iterable<ts.Diagnostic> | Promise<Iterable<ts.Diagnostic>>;
+    diagnoseFiles(modes?: DiagnosticModes): Promise<{
+        errors?: PartialMessage[];
+        warnings?: PartialMessage[];
+    }>;
+    update?(files: Set<string>): Promise<void>;
+    close?(): Promise<void>;
+}

package/src/tools/esbuild/angular/compilation/angular-compilation.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularCompilation = exports.DiagnosticModes = void 0;
+const load_esm_1 = require("../../../../utils/load-esm");
+const profiling_1 = require("../../profiling");
+const diagnostics_1 = require("../diagnostics");
+var DiagnosticModes;
+(function (DiagnosticModes) {
+    DiagnosticModes[DiagnosticModes["None"] = 0] = "None";
+    DiagnosticModes[DiagnosticModes["Option"] = 1] = "Option";
+    DiagnosticModes[DiagnosticModes["Syntactic"] = 2] = "Syntactic";
+    DiagnosticModes[DiagnosticModes["Semantic"] = 4] = "Semantic";
+    DiagnosticModes[DiagnosticModes["All"] = 7] = "All";
+})(DiagnosticModes || (exports.DiagnosticModes = DiagnosticModes = {}));
+class AngularCompilation {
+    static #angularCompilerCliModule;
+    static #typescriptModule;
+    static async loadCompilerCli() {
+        // This uses a wrapped dynamic import to load `@angular/compiler-cli` which is ESM.
+        // Once TypeScript provides support for retaining dynamic imports this workaround can be dropped.
+        AngularCompilation.#angularCompilerCliModule ??=
+            await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli');
+        return AngularCompilation.#angularCompilerCliModule;
+    }
+    static async loadTypescript() {
+        AngularCompilation.#typescriptModule ??= await Promise.resolve().then(() => __importStar(require('typescript')));
+        return AngularCompilation.#typescriptModule;
+    }
+    async loadConfiguration(tsconfig) {
+        const { readConfiguration } = await AngularCompilation.loadCompilerCli();
+        return (0, profiling_1.profileSync)('NG_READ_CONFIG', () => readConfiguration(tsconfig, {
+            // Angular specific configuration defaults and overrides to ensure a functioning compilation.
+            suppressOutputPathCheck: true,
+            outDir: undefined,
+            sourceMap: false,
+            declaration: false,
+            declarationMap: false,
+            allowEmptyCodegenFiles: false,
+            annotationsAs: 'decorators',
+            enableResourceInlining: false,
+            supportTestBed: false,
+            supportJitMode: false,
+        }));
+    }
+    async diagnoseFiles(modes = DiagnosticModes.All) {
+        const result = {};
+        // Avoid loading typescript until actually needed.
+        // This allows for avoiding the load of typescript in the main thread when using the parallel compilation.
+        const typescript = await AngularCompilation.loadTypescript();
+        await (0, profiling_1.profileAsync)('NG_DIAGNOSTICS_TOTAL', async () => {
+            for (const diagnostic of await this.collectDiagnostics(modes)) {
+                const message = (0, diagnostics_1.convertTypeScriptDiagnostic)(typescript, diagnostic);
+                if (diagnostic.category === typescript.DiagnosticCategory.Error) {
+                    (result.errors ??= []).push(message);
+                }
+                else {
+                    (result.warnings ??= []).push(message);
+                }
+            }
+        });
+        return result;
+    }
+}
+exports.AngularCompilation = AngularCompilation;

package/src/tools/esbuild/angular/compilation/aot-compilation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google LLC 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 type ng from '@angular/compiler-cli';
+import ts from 'typescript';
+import { AngularHostOptions } from '../angular-host';
+import { AngularCompilation, DiagnosticModes, EmitFileResult } from './angular-compilation';
+export declare class AotCompilation extends AngularCompilation {
+    #private;
+    initialize(tsconfig: string, hostOptions: AngularHostOptions, compilerOptionsTransformer?: (compilerOptions: ng.CompilerOptions) => ng.CompilerOptions): Promise<{
+        affectedFiles: ReadonlySet<ts.SourceFile>;
+        compilerOptions: ng.CompilerOptions;
+        referencedFiles: readonly string[];
+    }>;
+    collectDiagnostics(modes: DiagnosticModes): Iterable<ts.Diagnostic>;
+    emitAffectedFiles(): Iterable<EmitFileResult>;
+}