@angular/build 18.0.0-next.3

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

@@ -0,0 +1,224 @@
+"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.AotCompilation = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const typescript_1 = __importDefault(require("typescript"));
+const profiling_1 = require("../../profiling");
+const angular_host_1 = require("../angular-host");
+const web_worker_transformer_1 = require("../web-worker-transformer");
+const angular_compilation_1 = require("./angular-compilation");
+const jit_bootstrap_transformer_1 = require("./jit-bootstrap-transformer");
+class AngularCompilationState {
+    angularProgram;
+    compilerHost;
+    typeScriptProgram;
+    affectedFiles;
+    templateDiagnosticsOptimization;
+    webWorkerTransform;
+    diagnosticCache;
+    constructor(angularProgram, compilerHost, typeScriptProgram, affectedFiles, templateDiagnosticsOptimization, webWorkerTransform, diagnosticCache = new WeakMap()) {
+        this.angularProgram = angularProgram;
+        this.compilerHost = compilerHost;
+        this.typeScriptProgram = typeScriptProgram;
+        this.affectedFiles = affectedFiles;
+        this.templateDiagnosticsOptimization = templateDiagnosticsOptimization;
+        this.webWorkerTransform = webWorkerTransform;
+        this.diagnosticCache = diagnosticCache;
+    }
+    get angularCompiler() {
+        return this.angularProgram.compiler;
+    }
+}
+class AotCompilation extends angular_compilation_1.AngularCompilation {
+    #state;
+    async initialize(tsconfig, hostOptions, compilerOptionsTransformer) {
+        // Dynamically load the Angular compiler CLI package
+        const { NgtscProgram, OptimizeFor } = await angular_compilation_1.AngularCompilation.loadCompilerCli();
+        // Load the compiler configuration and transform as needed
+        const { options: originalCompilerOptions, rootNames, errors: configurationDiagnostics, } = await this.loadConfiguration(tsconfig);
+        const compilerOptions = compilerOptionsTransformer?.(originalCompilerOptions) ?? originalCompilerOptions;
+        // Create Angular compiler host
+        const host = (0, angular_host_1.createAngularCompilerHost)(typescript_1.default, compilerOptions, hostOptions);
+        // Create the Angular specific program that contains the Angular compiler
+        const angularProgram = (0, profiling_1.profileSync)('NG_CREATE_PROGRAM', () => new NgtscProgram(rootNames, compilerOptions, host, this.#state?.angularProgram));
+        const angularCompiler = angularProgram.compiler;
+        const angularTypeScriptProgram = angularProgram.getTsProgram();
+        (0, angular_host_1.ensureSourceFileVersions)(angularTypeScriptProgram);
+        let oldProgram = this.#state?.typeScriptProgram;
+        let usingBuildInfo = false;
+        if (!oldProgram) {
+            oldProgram = typescript_1.default.readBuilderProgram(compilerOptions, host);
+            usingBuildInfo = !!oldProgram;
+        }
+        const typeScriptProgram = typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram(angularTypeScriptProgram, host, oldProgram, configurationDiagnostics);
+        await (0, profiling_1.profileAsync)('NG_ANALYZE_PROGRAM', () => angularCompiler.analyzeAsync());
+        const affectedFiles = (0, profiling_1.profileSync)('NG_FIND_AFFECTED', () => findAffectedFiles(typeScriptProgram, angularCompiler, usingBuildInfo));
+        // Get all files referenced in the TypeScript/Angular program including component resources
+        const referencedFiles = typeScriptProgram
+            .getSourceFiles()
+            .filter((sourceFile) => !angularCompiler.ignoreForEmit.has(sourceFile))
+            .flatMap((sourceFile) => {
+            const resourceDependencies = angularCompiler.getResourceDependencies(sourceFile);
+            // Also invalidate Angular diagnostics for a source file if component resources are modified
+            if (this.#state && hostOptions.modifiedFiles?.size) {
+                for (const resourceDependency of resourceDependencies) {
+                    if (hostOptions.modifiedFiles.has(resourceDependency)) {
+                        this.#state.diagnosticCache.delete(sourceFile);
+                        // Also mark as affected in case changed template affects diagnostics
+                        affectedFiles.add(sourceFile);
+                    }
+                }
+            }
+            return [sourceFile.fileName, ...resourceDependencies];
+        });
+        this.#state = new AngularCompilationState(angularProgram, host, typeScriptProgram, affectedFiles, affectedFiles.size === 1 ? OptimizeFor.SingleFile : OptimizeFor.WholeProgram, (0, web_worker_transformer_1.createWorkerTransformer)(hostOptions.processWebWorker.bind(hostOptions)), this.#state?.diagnosticCache);
+        return { affectedFiles, compilerOptions, referencedFiles };
+    }
+    *collectDiagnostics(modes) {
+        (0, node_assert_1.default)(this.#state, 'Angular compilation must be initialized prior to collecting diagnostics.');
+        const { affectedFiles, angularCompiler, diagnosticCache, templateDiagnosticsOptimization, typeScriptProgram, } = this.#state;
+        const syntactic = modes & angular_compilation_1.DiagnosticModes.Syntactic;
+        const semantic = modes & angular_compilation_1.DiagnosticModes.Semantic;
+        // Collect program level diagnostics
+        if (modes & angular_compilation_1.DiagnosticModes.Option) {
+            yield* typeScriptProgram.getConfigFileParsingDiagnostics();
+            yield* angularCompiler.getOptionDiagnostics();
+            yield* typeScriptProgram.getOptionsDiagnostics();
+        }
+        if (syntactic) {
+            yield* typeScriptProgram.getGlobalDiagnostics();
+        }
+        // Collect source file specific diagnostics
+        for (const sourceFile of typeScriptProgram.getSourceFiles()) {
+            if (angularCompiler.ignoreForDiagnostics.has(sourceFile)) {
+                continue;
+            }
+            if (syntactic) {
+                // TypeScript will use cached diagnostics for files that have not been
+                // changed or affected for this build when using incremental building.
+                yield* (0, profiling_1.profileSync)('NG_DIAGNOSTICS_SYNTACTIC', () => typeScriptProgram.getSyntacticDiagnostics(sourceFile), true);
+            }
+            if (!semantic) {
+                continue;
+            }
+            yield* (0, profiling_1.profileSync)('NG_DIAGNOSTICS_SEMANTIC', () => typeScriptProgram.getSemanticDiagnostics(sourceFile), true);
+            // Declaration files cannot have template diagnostics
+            if (sourceFile.isDeclarationFile) {
+                continue;
+            }
+            // Only request Angular template diagnostics for affected files to avoid
+            // overhead of template diagnostics for unchanged files.
+            if (affectedFiles.has(sourceFile)) {
+                const angularDiagnostics = (0, profiling_1.profileSync)('NG_DIAGNOSTICS_TEMPLATE', () => angularCompiler.getDiagnosticsForFile(sourceFile, templateDiagnosticsOptimization), true);
+                diagnosticCache.set(sourceFile, angularDiagnostics);
+                yield* angularDiagnostics;
+            }
+            else {
+                const angularDiagnostics = diagnosticCache.get(sourceFile);
+                if (angularDiagnostics) {
+                    yield* angularDiagnostics;
+                }
+            }
+        }
+    }
+    emitAffectedFiles() {
+        (0, node_assert_1.default)(this.#state, 'Angular compilation must be initialized prior to emitting files.');
+        const { angularCompiler, compilerHost, typeScriptProgram, webWorkerTransform } = this.#state;
+        const buildInfoFilename = typeScriptProgram.getCompilerOptions().tsBuildInfoFile ?? '.tsbuildinfo';
+        const emittedFiles = new Map();
+        const writeFileCallback = (filename, contents, _a, _b, sourceFiles) => {
+            if (!sourceFiles?.length && filename.endsWith(buildInfoFilename)) {
+                // Save builder info contents to specified location
+                compilerHost.writeFile(filename, contents, false);
+                return;
+            }
+            (0, node_assert_1.default)(sourceFiles?.length === 1, 'Invalid TypeScript program emit for ' + filename);
+            const sourceFile = typescript_1.default.getOriginalNode(sourceFiles[0], typescript_1.default.isSourceFile);
+            if (angularCompiler.ignoreForEmit.has(sourceFile)) {
+                return;
+            }
+            angularCompiler.incrementalCompilation.recordSuccessfulEmit(sourceFile);
+            emittedFiles.set(sourceFile, { filename: sourceFile.fileName, contents });
+        };
+        const transformers = angularCompiler.prepareEmit().transformers;
+        transformers.before ??= [];
+        transformers.before.push((0, jit_bootstrap_transformer_1.replaceBootstrap)(() => typeScriptProgram.getProgram().getTypeChecker()));
+        transformers.before.push(webWorkerTransform);
+        // TypeScript will loop until there are no more affected files in the program
+        while (typeScriptProgram.emitNextAffectedFile(writeFileCallback, undefined, undefined, transformers)) {
+            /* empty */
+        }
+        // Angular may have files that must be emitted but TypeScript does not consider affected
+        for (const sourceFile of typeScriptProgram.getSourceFiles()) {
+            if (emittedFiles.has(sourceFile) || angularCompiler.ignoreForEmit.has(sourceFile)) {
+                continue;
+            }
+            if (sourceFile.isDeclarationFile) {
+                continue;
+            }
+            if (angularCompiler.incrementalCompilation.safeToSkipEmit(sourceFile)) {
+                continue;
+            }
+            typeScriptProgram.emit(sourceFile, writeFileCallback, undefined, undefined, transformers);
+        }
+        return emittedFiles.values();
+    }
+}
+exports.AotCompilation = AotCompilation;
+function findAffectedFiles(builder, { ignoreForDiagnostics }, includeTTC) {
+    const affectedFiles = new Set();
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const result = builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
+            // If the affected file is a TTC shim, add the shim's original source file.
+            // This ensures that changes that affect TTC are typechecked even when the changes
+            // are otherwise unrelated from a TS perspective and do not result in Ivy codegen changes.
+            // For example, changing @Input property types of a directive used in another component's
+            // template.
+            // A TTC shim is a file that has been ignored for diagnostics and has a filename ending in `.ngtypecheck.ts`.
+            if (ignoreForDiagnostics.has(sourceFile) && sourceFile.fileName.endsWith('.ngtypecheck.ts')) {
+                // This file name conversion relies on internal compiler logic and should be converted
+                // to an official method when available. 15 is length of `.ngtypecheck.ts`
+                const originalFilename = sourceFile.fileName.slice(0, -15) + '.ts';
+                const originalSourceFile = builder.getSourceFile(originalFilename);
+                if (originalSourceFile) {
+                    affectedFiles.add(originalSourceFile);
+                }
+                return true;
+            }
+            return false;
+        });
+        if (!result) {
+            break;
+        }
+        affectedFiles.add(result.affected);
+    }
+    // Add all files with associated template type checking files.
+    // Stored TS build info does not have knowledge of the AOT compiler or the typechecking state of the templates.
+    // To ensure that errors are reported correctly, all AOT component diagnostics need to be analyzed even if build
+    // info is present.
+    if (includeTTC) {
+        for (const sourceFile of builder.getSourceFiles()) {
+            if (ignoreForDiagnostics.has(sourceFile) && sourceFile.fileName.endsWith('.ngtypecheck.ts')) {
+                // This file name conversion relies on internal compiler logic and should be converted
+                // to an official method when available. 15 is length of `.ngtypecheck.ts`
+                const originalFilename = sourceFile.fileName.slice(0, -15) + '.ts';
+                const originalSourceFile = builder.getSourceFile(originalFilename);
+                if (originalSourceFile) {
+                    affectedFiles.add(originalSourceFile);
+                }
+            }
+        }
+    }
+    return affectedFiles;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * @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 { AngularCompilation } from './angular-compilation';
+/**
+ * Creates an Angular compilation object that can be used to perform Angular application
+ * compilation either for AOT or JIT mode. By default a parallel compilation is created
+ * that uses a Node.js worker thread.
+ * @param jit True, for Angular JIT compilation; False, for Angular AOT compilation.
+ * @returns An instance of an Angular compilation object.
+ */
+export declare function createAngularCompilation(jit: boolean): Promise<AngularCompilation>;

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

@@ -0,0 +1,56 @@
+"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.createAngularCompilation = void 0;
+const environment_options_1 = require("../../../../utils/environment-options");
+/**
+ * Creates an Angular compilation object that can be used to perform Angular application
+ * compilation either for AOT or JIT mode. By default a parallel compilation is created
+ * that uses a Node.js worker thread.
+ * @param jit True, for Angular JIT compilation; False, for Angular AOT compilation.
+ * @returns An instance of an Angular compilation object.
+ */
+async function createAngularCompilation(jit) {
+    if (environment_options_1.useParallelTs) {
+        const { ParallelCompilation } = await Promise.resolve().then(() => __importStar(require('./parallel-compilation')));
+        return new ParallelCompilation(jit);
+    }
+    if (jit) {
+        const { JitCompilation } = await Promise.resolve().then(() => __importStar(require('./jit-compilation')));
+        return new JitCompilation();
+    }
+    else {
+        const { AotCompilation } = await Promise.resolve().then(() => __importStar(require('./aot-compilation')));
+        return new AotCompilation();
+    }
+}
+exports.createAngularCompilation = createAngularCompilation;

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

@@ -0,0 +1,10 @@
+/**
+ * @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 { AngularCompilation, DiagnosticModes } from './angular-compilation';
+export { createAngularCompilation } from './factory';
+export { NoopCompilation } from './noop-compilation';

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

@@ -0,0 +1,17 @@
+"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.NoopCompilation = exports.createAngularCompilation = exports.DiagnosticModes = exports.AngularCompilation = void 0;
+var angular_compilation_1 = require("./angular-compilation");
+Object.defineProperty(exports, "AngularCompilation", { enumerable: true, get: function () { return angular_compilation_1.AngularCompilation; } });
+Object.defineProperty(exports, "DiagnosticModes", { enumerable: true, get: function () { return angular_compilation_1.DiagnosticModes; } });
+var factory_1 = require("./factory");
+Object.defineProperty(exports, "createAngularCompilation", { enumerable: true, get: function () { return factory_1.createAngularCompilation; } });
+var noop_compilation_1 = require("./noop-compilation");
+Object.defineProperty(exports, "NoopCompilation", { enumerable: true, get: function () { return noop_compilation_1.NoopCompilation; } });

package/src/tools/esbuild/angular/compilation/jit-bootstrap-transformer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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 ts from 'typescript';
+export declare function replaceBootstrap(getTypeChecker: () => ts.TypeChecker): ts.TransformerFactory<ts.SourceFile>;
+export declare function elideImports(sourceFile: ts.SourceFile, removedNodes: ts.Node[], getTypeChecker: () => ts.TypeChecker, compilerOptions: ts.CompilerOptions): Set<ts.Node>;

package/src/tools/esbuild/angular/compilation/jit-bootstrap-transformer.js

@@ -0,0 +1,182 @@
+"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.elideImports = exports.replaceBootstrap = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * The name of the Angular platform that should be replaced within
+ * bootstrap call expressions to support AOT.
+ */
+const PLATFORM_BROWSER_DYNAMIC_NAME = 'platformBrowserDynamic';
+function replaceBootstrap(getTypeChecker) {
+    return (context) => {
+        let bootstrapImport;
+        let bootstrapNamespace;
+        const replacedNodes = [];
+        const nodeFactory = context.factory;
+        const visitNode = (node) => {
+            if (typescript_1.default.isCallExpression(node) && typescript_1.default.isIdentifier(node.expression)) {
+                const target = node.expression;
+                if (target.text === PLATFORM_BROWSER_DYNAMIC_NAME) {
+                    if (!bootstrapNamespace) {
+                        bootstrapNamespace = nodeFactory.createUniqueName('__NgCli_bootstrap_');
+                        bootstrapImport = nodeFactory.createImportDeclaration(undefined, nodeFactory.createImportClause(false, undefined, nodeFactory.createNamespaceImport(bootstrapNamespace)), nodeFactory.createStringLiteral('@angular/platform-browser'));
+                    }
+                    replacedNodes.push(target);
+                    return nodeFactory.updateCallExpression(node, nodeFactory.createPropertyAccessExpression(bootstrapNamespace, 'platformBrowser'), node.typeArguments, node.arguments);
+                }
+            }
+            return typescript_1.default.visitEachChild(node, visitNode, context);
+        };
+        return (sourceFile) => {
+            if (!sourceFile.text.includes(PLATFORM_BROWSER_DYNAMIC_NAME)) {
+                return sourceFile;
+            }
+            let updatedSourceFile = typescript_1.default.visitEachChild(sourceFile, visitNode, context);
+            if (bootstrapImport) {
+                // Remove any unused platform browser dynamic imports
+                const removals = elideImports(updatedSourceFile, replacedNodes, getTypeChecker, context.getCompilerOptions());
+                if (removals.size > 0) {
+                    updatedSourceFile = typescript_1.default.visitEachChild(updatedSourceFile, (node) => (removals.has(node) ? undefined : node), context);
+                }
+                // Add new platform browser import
+                return nodeFactory.updateSourceFile(updatedSourceFile, typescript_1.default.setTextRange(nodeFactory.createNodeArray([bootstrapImport, ...updatedSourceFile.statements]), sourceFile.statements));
+            }
+            else {
+                return updatedSourceFile;
+            }
+        };
+    };
+}
+exports.replaceBootstrap = replaceBootstrap;
+// Remove imports for which all identifiers have been removed.
+// Needs type checker, and works even if it's not the first transformer.
+// Works by removing imports for symbols whose identifiers have all been removed.
+// Doesn't use the `symbol.declarations` because that previous transforms might have removed nodes
+// but the type checker doesn't know.
+// See https://github.com/Microsoft/TypeScript/issues/17552 for more information.
+function elideImports(sourceFile, removedNodes, getTypeChecker, compilerOptions) {
+    const importNodeRemovals = new Set();
+    if (removedNodes.length === 0) {
+        return importNodeRemovals;
+    }
+    const typeChecker = getTypeChecker();
+    // Collect all imports and used identifiers
+    const usedSymbols = new Set();
+    const imports = [];
+    typescript_1.default.forEachChild(sourceFile, function visit(node) {
+        // Skip removed nodes.
+        if (removedNodes.includes(node)) {
+            return;
+        }
+        // Consider types for 'implements' as unused.
+        // A HeritageClause token can also be an 'AbstractKeyword'
+        // which in that case we should not elide the import.
+        if (typescript_1.default.isHeritageClause(node) && node.token === typescript_1.default.SyntaxKind.ImplementsKeyword) {
+            return;
+        }
+        // Record import and skip
+        if (typescript_1.default.isImportDeclaration(node)) {
+            if (!node.importClause?.isTypeOnly) {
+                imports.push(node);
+            }
+            return;
+        }
+        // Type reference imports do not need to be emitted when emitDecoratorMetadata is disabled.
+        if (typescript_1.default.isTypeReferenceNode(node) && !compilerOptions.emitDecoratorMetadata) {
+            return;
+        }
+        let symbol;
+        switch (node.kind) {
+            case typescript_1.default.SyntaxKind.Identifier:
+                const parent = node.parent;
+                if (parent && typescript_1.default.isShorthandPropertyAssignment(parent)) {
+                    const shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(parent);
+                    if (shorthandSymbol) {
+                        symbol = shorthandSymbol;
+                    }
+                }
+                else {
+                    symbol = typeChecker.getSymbolAtLocation(node);
+                }
+                break;
+            case typescript_1.default.SyntaxKind.ExportSpecifier:
+                symbol = typeChecker.getExportSpecifierLocalTargetSymbol(node);
+                break;
+            case typescript_1.default.SyntaxKind.ShorthandPropertyAssignment:
+                symbol = typeChecker.getShorthandAssignmentValueSymbol(node);
+                break;
+        }
+        if (symbol) {
+            usedSymbols.add(symbol);
+        }
+        typescript_1.default.forEachChild(node, visit);
+    });
+    if (imports.length === 0) {
+        return importNodeRemovals;
+    }
+    const isUnused = (node) => {
+        // Do not remove JSX factory imports
+        if (node.text === compilerOptions.jsxFactory) {
+            return false;
+        }
+        const symbol = typeChecker.getSymbolAtLocation(node);
+        return symbol && !usedSymbols.has(symbol);
+    };
+    for (const node of imports) {
+        if (!node.importClause) {
+            // "import 'abc';"
+            continue;
+        }
+        const namedBindings = node.importClause.namedBindings;
+        if (namedBindings && typescript_1.default.isNamespaceImport(namedBindings)) {
+            // "import * as XYZ from 'abc';"
+            if (isUnused(namedBindings.name)) {
+                importNodeRemovals.add(node);
+            }
+        }
+        else {
+            const specifierNodeRemovals = [];
+            let clausesCount = 0;
+            // "import { XYZ, ... } from 'abc';"
+            if (namedBindings && typescript_1.default.isNamedImports(namedBindings)) {
+                let removedClausesCount = 0;
+                clausesCount += namedBindings.elements.length;
+                for (const specifier of namedBindings.elements) {
+                    if (specifier.isTypeOnly || isUnused(specifier.name)) {
+                        removedClausesCount++;
+                        // in case we don't have any more namedImports we should remove the parent ie the {}
+                        const nodeToRemove = clausesCount === removedClausesCount ? specifier.parent : specifier;
+                        specifierNodeRemovals.push(nodeToRemove);
+                    }
+                }
+            }
+            // "import XYZ from 'abc';"
+            if (node.importClause.name) {
+                clausesCount++;
+                if (node.importClause.isTypeOnly || isUnused(node.importClause.name)) {
+                    specifierNodeRemovals.push(node.importClause.name);
+                }
+            }
+            if (specifierNodeRemovals.length === clausesCount) {
+                importNodeRemovals.add(node);
+            }
+            else {
+                for (const specifierNodeRemoval of specifierNodeRemovals) {
+                    importNodeRemovals.add(specifierNodeRemoval);
+                }
+            }
+        }
+    }
+    return importNodeRemovals;
+}
+exports.elideImports = elideImports;

package/src/tools/esbuild/angular/compilation/jit-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 JitCompilation 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>;
+}

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

@@ -0,0 +1,106 @@
+"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.JitCompilation = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const typescript_1 = __importDefault(require("typescript"));
+const profiling_1 = require("../../profiling");
+const angular_host_1 = require("../angular-host");
+const jit_resource_transformer_1 = require("../jit-resource-transformer");
+const web_worker_transformer_1 = require("../web-worker-transformer");
+const angular_compilation_1 = require("./angular-compilation");
+class JitCompilationState {
+    compilerHost;
+    typeScriptProgram;
+    constructorParametersDownlevelTransform;
+    replaceResourcesTransform;
+    webWorkerTransform;
+    constructor(compilerHost, typeScriptProgram, constructorParametersDownlevelTransform, replaceResourcesTransform, webWorkerTransform) {
+        this.compilerHost = compilerHost;
+        this.typeScriptProgram = typeScriptProgram;
+        this.constructorParametersDownlevelTransform = constructorParametersDownlevelTransform;
+        this.replaceResourcesTransform = replaceResourcesTransform;
+        this.webWorkerTransform = webWorkerTransform;
+    }
+}
+class JitCompilation extends angular_compilation_1.AngularCompilation {
+    #state;
+    async initialize(tsconfig, hostOptions, compilerOptionsTransformer) {
+        // Dynamically load the Angular compiler CLI package
+        const { constructorParametersDownlevelTransform } = await angular_compilation_1.AngularCompilation.loadCompilerCli();
+        // Load the compiler configuration and transform as needed
+        const { options: originalCompilerOptions, rootNames, errors: configurationDiagnostics, } = await this.loadConfiguration(tsconfig);
+        const compilerOptions = compilerOptionsTransformer?.(originalCompilerOptions) ?? originalCompilerOptions;
+        // Create Angular compiler host
+        const host = (0, angular_host_1.createAngularCompilerHost)(typescript_1.default, compilerOptions, hostOptions);
+        // Create the TypeScript Program
+        const typeScriptProgram = (0, profiling_1.profileSync)('TS_CREATE_PROGRAM', () => typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, compilerOptions, host, this.#state?.typeScriptProgram ?? typescript_1.default.readBuilderProgram(compilerOptions, host), configurationDiagnostics));
+        const affectedFiles = (0, profiling_1.profileSync)('TS_FIND_AFFECTED', () => findAffectedFiles(typeScriptProgram));
+        this.#state = new JitCompilationState(host, typeScriptProgram, constructorParametersDownlevelTransform(typeScriptProgram.getProgram()), (0, jit_resource_transformer_1.createJitResourceTransformer)(() => typeScriptProgram.getProgram().getTypeChecker()), (0, web_worker_transformer_1.createWorkerTransformer)(hostOptions.processWebWorker.bind(hostOptions)));
+        const referencedFiles = typeScriptProgram
+            .getSourceFiles()
+            .map((sourceFile) => sourceFile.fileName);
+        return { affectedFiles, compilerOptions, referencedFiles };
+    }
+    *collectDiagnostics(modes) {
+        (0, node_assert_1.default)(this.#state, 'Compilation must be initialized prior to collecting diagnostics.');
+        const { typeScriptProgram } = this.#state;
+        // Collect program level diagnostics
+        if (modes & angular_compilation_1.DiagnosticModes.Option) {
+            yield* typeScriptProgram.getConfigFileParsingDiagnostics();
+            yield* typeScriptProgram.getOptionsDiagnostics();
+        }
+        if (modes & angular_compilation_1.DiagnosticModes.Syntactic) {
+            yield* typeScriptProgram.getGlobalDiagnostics();
+            yield* (0, profiling_1.profileSync)('NG_DIAGNOSTICS_SYNTACTIC', () => typeScriptProgram.getSyntacticDiagnostics());
+        }
+        if (modes & angular_compilation_1.DiagnosticModes.Semantic) {
+            yield* (0, profiling_1.profileSync)('NG_DIAGNOSTICS_SEMANTIC', () => typeScriptProgram.getSemanticDiagnostics());
+        }
+    }
+    emitAffectedFiles() {
+        (0, node_assert_1.default)(this.#state, 'Compilation must be initialized prior to emitting files.');
+        const { compilerHost, typeScriptProgram, constructorParametersDownlevelTransform, replaceResourcesTransform, webWorkerTransform, } = this.#state;
+        const buildInfoFilename = typeScriptProgram.getCompilerOptions().tsBuildInfoFile ?? '.tsbuildinfo';
+        const emittedFiles = [];
+        const writeFileCallback = (filename, contents, _a, _b, sourceFiles) => {
+            if (!sourceFiles?.length && filename.endsWith(buildInfoFilename)) {
+                // Save builder info contents to specified location
+                compilerHost.writeFile(filename, contents, false);
+                return;
+            }
+            (0, node_assert_1.default)(sourceFiles?.length === 1, 'Invalid TypeScript program emit for ' + filename);
+            emittedFiles.push({ filename: sourceFiles[0].fileName, contents });
+        };
+        const transformers = {
+            before: [
+                replaceResourcesTransform,
+                constructorParametersDownlevelTransform,
+                webWorkerTransform,
+            ],
+        };
+        // TypeScript will loop until there are no more affected files in the program
+        while (typeScriptProgram.emitNextAffectedFile(writeFileCallback, undefined, undefined, transformers)) {
+            /* empty */
+        }
+        return emittedFiles;
+    }
+}
+exports.JitCompilation = JitCompilation;
+function findAffectedFiles(builder) {
+    const affectedFiles = new Set();
+    let result;
+    while ((result = builder.getSemanticDiagnosticsOfNextAffectedFile())) {
+        affectedFiles.add(result.affected);
+    }
+    return affectedFiles;
+}