@angular/build 18.0.0-next.3

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

@@ -0,0 +1,20 @@
+/**
+ * @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';
+import { AngularHostOptions } from '../angular-host';
+import { AngularCompilation } from './angular-compilation';
+export declare class NoopCompilation extends AngularCompilation {
+    initialize(tsconfig: string, hostOptions: AngularHostOptions, compilerOptionsTransformer?: (compilerOptions: ng.CompilerOptions) => ng.CompilerOptions): Promise<{
+        affectedFiles: ReadonlySet<ts.SourceFile>;
+        compilerOptions: ng.CompilerOptions;
+        referencedFiles: readonly string[];
+    }>;
+    collectDiagnostics(): never;
+    emitAffectedFiles(): never;
+}

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

@@ -0,0 +1,26 @@
+"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 = void 0;
+const angular_compilation_1 = require("./angular-compilation");
+class NoopCompilation extends angular_compilation_1.AngularCompilation {
+    async initialize(tsconfig, hostOptions, compilerOptionsTransformer) {
+        // Load the compiler configuration and transform as needed
+        const { options: originalCompilerOptions } = await this.loadConfiguration(tsconfig);
+        const compilerOptions = compilerOptionsTransformer?.(originalCompilerOptions) ?? originalCompilerOptions;
+        return { affectedFiles: new Set(), compilerOptions, referencedFiles: [] };
+    }
+    collectDiagnostics() {
+        throw new Error('Not available when using noop compilation.');
+    }
+    emitAffectedFiles() {
+        throw new Error('Not available when using noop compilation.');
+    }
+}
+exports.NoopCompilation = NoopCompilation;

package/src/tools/esbuild/angular/compilation/parallel-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 { CompilerOptions } from '@angular/compiler-cli';
+import type { PartialMessage } from 'esbuild';
+import type { SourceFile } from 'typescript';
+import type { AngularHostOptions } from '../angular-host';
+import { AngularCompilation, DiagnosticModes, EmitFileResult } from './angular-compilation';
+/**
+ * An Angular compilation which uses a Node.js Worker thread to load and execute
+ * the TypeScript and Angular compilers. This allows for longer synchronous actions
+ * such as semantic and template diagnostics to be calculated in parallel to the
+ * other aspects of the application bundling process. The worker thread also has
+ * a separate memory pool which significantly reduces the need for adjusting the
+ * main Node.js CLI process memory settings with large application code sizes.
+ */
+export declare class ParallelCompilation extends AngularCompilation {
+    #private;
+    readonly jit: boolean;
+    constructor(jit: boolean);
+    initialize(tsconfig: string, hostOptions: AngularHostOptions, compilerOptionsTransformer?: ((compilerOptions: CompilerOptions) => CompilerOptions) | undefined): Promise<{
+        affectedFiles: ReadonlySet<SourceFile>;
+        compilerOptions: CompilerOptions;
+        referencedFiles: readonly string[];
+    }>;
+    /**
+     * This is not needed with this compilation type since the worker will already send a response
+     * with the serializable esbuild compatible diagnostics.
+     */
+    protected collectDiagnostics(): never;
+    diagnoseFiles(modes?: DiagnosticModes): Promise<{
+        errors?: PartialMessage[];
+        warnings?: PartialMessage[];
+    }>;
+    emitAffectedFiles(): Promise<Iterable<EmitFileResult>>;
+    update(files: Set<string>): Promise<void>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,123 @@
+"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.ParallelCompilation = void 0;
+const node_module_1 = require("node:module");
+const node_worker_threads_1 = require("node:worker_threads");
+const piscina_1 = __importDefault(require("piscina"));
+const angular_compilation_1 = require("./angular-compilation");
+/**
+ * An Angular compilation which uses a Node.js Worker thread to load and execute
+ * the TypeScript and Angular compilers. This allows for longer synchronous actions
+ * such as semantic and template diagnostics to be calculated in parallel to the
+ * other aspects of the application bundling process. The worker thread also has
+ * a separate memory pool which significantly reduces the need for adjusting the
+ * main Node.js CLI process memory settings with large application code sizes.
+ */
+class ParallelCompilation extends angular_compilation_1.AngularCompilation {
+    jit;
+    #worker;
+    constructor(jit) {
+        super();
+        this.jit = jit;
+        // TODO: Convert to import.meta usage during ESM transition
+        const localRequire = (0, node_module_1.createRequire)(__filename);
+        this.#worker = new piscina_1.default({
+            minThreads: 1,
+            maxThreads: 1,
+            idleTimeout: Infinity,
+            // Web containers do not support transferable objects with receiveOnMessagePort which
+            // is used when the Atomics based wait loop is enable.
+            useAtomics: !process.versions.webcontainer,
+            filename: localRequire.resolve('./parallel-worker'),
+            recordTiming: false,
+        });
+    }
+    initialize(tsconfig, hostOptions, compilerOptionsTransformer) {
+        const stylesheetChannel = new node_worker_threads_1.MessageChannel();
+        // The request identifier is required because Angular can issue multiple concurrent requests
+        stylesheetChannel.port1.on('message', ({ requestId, data, containingFile, stylesheetFile }) => {
+            hostOptions
+                .transformStylesheet(data, containingFile, stylesheetFile)
+                .then((value) => stylesheetChannel.port1.postMessage({ requestId, value }))
+                .catch((error) => stylesheetChannel.port1.postMessage({ requestId, error }));
+        });
+        // The web worker processing is a synchronous operation and uses shared memory combined with
+        // the Atomics API to block execution here until a response is received.
+        const webWorkerChannel = new node_worker_threads_1.MessageChannel();
+        const webWorkerSignal = new Int32Array(new SharedArrayBuffer(4));
+        webWorkerChannel.port1.on('message', ({ workerFile, containingFile }) => {
+            try {
+                const workerCodeFile = hostOptions.processWebWorker(workerFile, containingFile);
+                webWorkerChannel.port1.postMessage({ workerCodeFile });
+            }
+            catch (error) {
+                webWorkerChannel.port1.postMessage({ error });
+            }
+            finally {
+                Atomics.store(webWorkerSignal, 0, 1);
+                Atomics.notify(webWorkerSignal, 0);
+            }
+        });
+        // The compiler options transformation is a synchronous operation and uses shared memory combined
+        // with the Atomics API to block execution here until a response is received.
+        const optionsChannel = new node_worker_threads_1.MessageChannel();
+        const optionsSignal = new Int32Array(new SharedArrayBuffer(4));
+        optionsChannel.port1.on('message', (compilerOptions) => {
+            try {
+                const transformedOptions = compilerOptionsTransformer?.(compilerOptions) ?? compilerOptions;
+                optionsChannel.port1.postMessage({ transformedOptions });
+            }
+            catch (error) {
+                webWorkerChannel.port1.postMessage({ error });
+            }
+            finally {
+                Atomics.store(optionsSignal, 0, 1);
+                Atomics.notify(optionsSignal, 0);
+            }
+        });
+        // Execute the initialize function in the worker thread
+        return this.#worker.run({
+            fileReplacements: hostOptions.fileReplacements,
+            tsconfig,
+            jit: this.jit,
+            stylesheetPort: stylesheetChannel.port2,
+            optionsPort: optionsChannel.port2,
+            optionsSignal,
+            webWorkerPort: webWorkerChannel.port2,
+            webWorkerSignal,
+        }, {
+            name: 'initialize',
+            transferList: [stylesheetChannel.port2, optionsChannel.port2, webWorkerChannel.port2],
+        });
+    }
+    /**
+     * This is not needed with this compilation type since the worker will already send a response
+     * with the serializable esbuild compatible diagnostics.
+     */
+    collectDiagnostics() {
+        throw new Error('Not implemented in ParallelCompilation.');
+    }
+    diagnoseFiles(modes = angular_compilation_1.DiagnosticModes.All) {
+        return this.#worker.run(modes, { name: 'diagnose' });
+    }
+    emitAffectedFiles() {
+        return this.#worker.run(undefined, { name: 'emit' });
+    }
+    update(files) {
+        return this.#worker.run(files, { name: 'update' });
+    }
+    close() {
+        return this.#worker.destroy();
+    }
+}
+exports.ParallelCompilation = ParallelCompilation;

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

@@ -0,0 +1,33 @@
+/**
+ * @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="node" />
+import type { PartialMessage } from 'esbuild';
+import { type MessagePort } from 'node:worker_threads';
+import type { DiagnosticModes } from './angular-compilation';
+export interface InitRequest {
+    jit: boolean;
+    tsconfig: string;
+    fileReplacements?: Record<string, string>;
+    stylesheetPort: MessagePort;
+    optionsPort: MessagePort;
+    optionsSignal: Int32Array;
+    webWorkerPort: MessagePort;
+    webWorkerSignal: Int32Array;
+}
+export declare function initialize(request: InitRequest): Promise<{
+    referencedFiles: readonly string[];
+    compilerOptions: {
+        allowJs: boolean | undefined;
+    };
+}>;
+export declare function diagnose(modes: DiagnosticModes): Promise<{
+    errors?: PartialMessage[];
+    warnings?: PartialMessage[];
+}>;
+export declare function emit(): Promise<import("./angular-compilation").EmitFileResult[]>;
+export declare function update(files: Set<string>): void;

package/src/tools/esbuild/angular/compilation/parallel-worker.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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = exports.emit = exports.diagnose = exports.initialize = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_crypto_1 = require("node:crypto");
+const node_worker_threads_1 = require("node:worker_threads");
+const source_file_cache_1 = require("../source-file-cache");
+const aot_compilation_1 = require("./aot-compilation");
+const jit_compilation_1 = require("./jit-compilation");
+let compilation;
+const sourceFileCache = new source_file_cache_1.SourceFileCache();
+async function initialize(request) {
+    compilation ??= request.jit ? new jit_compilation_1.JitCompilation() : new aot_compilation_1.AotCompilation();
+    const stylesheetRequests = new Map();
+    request.stylesheetPort.on('message', ({ requestId, value, error }) => {
+        if (error) {
+            stylesheetRequests.get(requestId)?.[1](error);
+        }
+        else {
+            stylesheetRequests.get(requestId)?.[0](value);
+        }
+    });
+    const { compilerOptions, referencedFiles } = await compilation.initialize(request.tsconfig, {
+        fileReplacements: request.fileReplacements,
+        sourceFileCache,
+        modifiedFiles: sourceFileCache.modifiedFiles,
+        transformStylesheet(data, containingFile, stylesheetFile) {
+            const requestId = (0, node_crypto_1.randomUUID)();
+            const resultPromise = new Promise((resolve, reject) => stylesheetRequests.set(requestId, [resolve, reject]));
+            request.stylesheetPort.postMessage({
+                requestId,
+                data,
+                containingFile,
+                stylesheetFile,
+            });
+            return resultPromise;
+        },
+        processWebWorker(workerFile, containingFile) {
+            Atomics.store(request.webWorkerSignal, 0, 0);
+            request.webWorkerPort.postMessage({ workerFile, containingFile });
+            Atomics.wait(request.webWorkerSignal, 0, 0);
+            const result = (0, node_worker_threads_1.receiveMessageOnPort)(request.webWorkerPort)?.message;
+            if (result?.error) {
+                throw result.error;
+            }
+            return result?.workerCodeFile ?? workerFile;
+        },
+    }, (compilerOptions) => {
+        Atomics.store(request.optionsSignal, 0, 0);
+        request.optionsPort.postMessage(compilerOptions);
+        Atomics.wait(request.optionsSignal, 0, 0);
+        const result = (0, node_worker_threads_1.receiveMessageOnPort)(request.optionsPort)?.message;
+        if (result?.error) {
+            throw result.error;
+        }
+        return result?.transformedOptions ?? compilerOptions;
+    });
+    return {
+        referencedFiles,
+        // TODO: Expand? `allowJs` is the only field needed currently.
+        compilerOptions: { allowJs: compilerOptions.allowJs },
+    };
+}
+exports.initialize = initialize;
+async function diagnose(modes) {
+    (0, node_assert_1.default)(compilation);
+    const diagnostics = await compilation.diagnoseFiles(modes);
+    return diagnostics;
+}
+exports.diagnose = diagnose;
+async function emit() {
+    (0, node_assert_1.default)(compilation);
+    const files = await compilation.emitAffectedFiles();
+    return [...files];
+}
+exports.emit = emit;
+function update(files) {
+    sourceFileCache.invalidate(files);
+}
+exports.update = update;

package/src/tools/esbuild/angular/compilation-state.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
+ */
+export declare class SharedTSCompilationState {
+    #private;
+    get waitUntilReady(): Promise<boolean>;
+    markAsReady(hasErrors: boolean): void;
+    markAsInProgress(): void;
+    dispose(): void;
+}
+export declare function getSharedCompilationState(): SharedTSCompilationState;

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

@@ -0,0 +1,44 @@
+"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.getSharedCompilationState = exports.SharedTSCompilationState = void 0;
+class SharedTSCompilationState {
+    #pendingCompilation = true;
+    #resolveCompilationReady;
+    #compilationReadyPromise;
+    #hasErrors = true;
+    get waitUntilReady() {
+        if (!this.#pendingCompilation) {
+            return Promise.resolve(this.#hasErrors);
+        }
+        this.#compilationReadyPromise ??= new Promise((resolve) => {
+            this.#resolveCompilationReady = resolve;
+        });
+        return this.#compilationReadyPromise;
+    }
+    markAsReady(hasErrors) {
+        this.#hasErrors = hasErrors;
+        this.#resolveCompilationReady?.(hasErrors);
+        this.#compilationReadyPromise = undefined;
+        this.#pendingCompilation = false;
+    }
+    markAsInProgress() {
+        this.#pendingCompilation = true;
+    }
+    dispose() {
+        this.markAsReady(true);
+        globalSharedCompilationState = undefined;
+    }
+}
+exports.SharedTSCompilationState = SharedTSCompilationState;
+let globalSharedCompilationState;
+function getSharedCompilationState() {
+    return (globalSharedCompilationState ??= new SharedTSCompilationState());
+}
+exports.getSharedCompilationState = getSharedCompilationState;

package/src/tools/esbuild/angular/compiler-plugin.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @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 { Plugin } from 'esbuild';
+import { LoadResultCache } from '../load-result-cache';
+import { BundleStylesheetOptions } from '../stylesheets/bundle-options';
+import { SourceFileCache } from './source-file-cache';
+export interface CompilerPluginOptions {
+    sourcemap: boolean;
+    tsconfig: string;
+    jit?: boolean;
+    /** Skip TypeScript compilation setup. This is useful to re-use the TypeScript compilation from another plugin. */
+    noopTypeScriptCompilation?: boolean;
+    advancedOptimizations?: boolean;
+    thirdPartySourcemaps?: boolean;
+    fileReplacements?: Record<string, string>;
+    sourceFileCache?: SourceFileCache;
+    loadResultCache?: LoadResultCache;
+    incremental: boolean;
+}
+export declare function createCompilerPlugin(pluginOptions: CompilerPluginOptions, styleOptions: BundleStylesheetOptions & {
+    inlineStyleLanguage: string;
+}): Plugin;