@angular/build 18.0.0-next.3

package/src/tools/esbuild/index-html-generator.js

@@ -0,0 +1,81 @@
+"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.generateIndexHtml = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_path_1 = __importDefault(require("node:path"));
+const index_html_generator_1 = require("../../utils/index-file/index-html-generator");
+const bundler_context_1 = require("./bundler-context");
+async function generateIndexHtml(initialFiles, outputFiles, buildOptions, lang) {
+    // Analyze metafile for initial link-based hints.
+    // Skip if the internal externalPackages option is enabled since this option requires
+    // dev server cooperation to properly resolve and fetch imports.
+    const hints = [];
+    const { indexHtmlOptions, externalPackages, optimizationOptions, crossOrigin, subresourceIntegrity, baseHref, } = buildOptions;
+    (0, node_assert_1.default)(indexHtmlOptions, 'indexHtmlOptions cannot be undefined.');
+    if (!externalPackages && indexHtmlOptions.preloadInitial) {
+        for (const [key, value] of initialFiles) {
+            if (value.entrypoint || value.serverFile) {
+                // Entry points are already referenced in the HTML
+                continue;
+            }
+            if (value.type === 'script') {
+                hints.push({ url: key, mode: 'modulepreload' });
+            }
+            else if (value.type === 'style') {
+                // Provide an "as" value of "style" to ensure external URLs which may not have a
+                // file extension are treated as stylesheets.
+                hints.push({ url: key, mode: 'preload', as: 'style' });
+            }
+        }
+    }
+    /** Virtual output path to support reading in-memory files. */
+    const browserOutputFiles = outputFiles.filter(({ type }) => type === bundler_context_1.BuildOutputFileType.Browser);
+    const virtualOutputPath = '/';
+    const readAsset = async function (filePath) {
+        // Remove leading directory separator
+        const relativefilePath = node_path_1.default.relative(virtualOutputPath, filePath);
+        const file = browserOutputFiles.find((file) => file.path === relativefilePath);
+        if (file) {
+            return file.text;
+        }
+        throw new Error(`Output file does not exist: ${relativefilePath}`);
+    };
+    // Create an index HTML generator that reads from the in-memory output files
+    const indexHtmlGenerator = new index_html_generator_1.IndexHtmlGenerator({
+        indexPath: indexHtmlOptions.input,
+        entrypoints: indexHtmlOptions.insertionOrder,
+        sri: subresourceIntegrity,
+        optimization: optimizationOptions,
+        crossOrigin: crossOrigin,
+        deployUrl: buildOptions.publicPath,
+        postTransform: indexHtmlOptions.transformer,
+        generateDedicatedSSRContent: !!(buildOptions.ssrOptions ||
+            buildOptions.prerenderOptions ||
+            buildOptions.appShellOptions),
+    });
+    indexHtmlGenerator.readAsset = readAsset;
+    return indexHtmlGenerator.process({
+        baseHref,
+        lang,
+        outputPath: virtualOutputPath,
+        files: [...initialFiles]
+            .filter(([, file]) => !file.serverFile)
+            .map(([file, record]) => ({
+            name: record.name ?? '',
+            file,
+            extension: node_path_1.default.extname(file),
+        })),
+        hints,
+    });
+}
+exports.generateIndexHtml = generateIndexHtml;

package/src/tools/esbuild/javascript-transformer-worker.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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
+ */
+interface JavaScriptTransformRequest {
+    filename: string;
+    data: string | Uint8Array;
+    sourcemap: boolean;
+    thirdPartySourcemaps: boolean;
+    advancedOptimizations: boolean;
+    skipLinker?: boolean;
+    sideEffects?: boolean;
+    jit: boolean;
+}
+export default function transformJavaScript(request: JavaScriptTransformRequest): Promise<unknown>;
+export {};

package/src/tools/esbuild/javascript-transformer-worker.js

@@ -0,0 +1,154 @@
+"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 core_1 = require("@babel/core");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const piscina_1 = __importDefault(require("piscina"));
+const load_esm_1 = require("../../utils/load-esm");
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+async function transformJavaScript(request) {
+    const { filename, data, ...options } = request;
+    const textData = typeof data === 'string' ? data : textDecoder.decode(data);
+    const transformedData = await transformWithBabel(filename, textData, options);
+    // Transfer the data via `move` instead of cloning
+    return piscina_1.default.move(textEncoder.encode(transformedData));
+}
+exports.default = transformJavaScript;
+/**
+ * Cached instance of the compiler-cli linker's createEs2015LinkerPlugin function.
+ */
+let linkerPluginCreator;
+/**
+ * Cached instance of the compiler-cli linker's needsLinking function.
+ */
+let needsLinking;
+async function transformWithBabel(filename, data, options) {
+    const shouldLink = !options.skipLinker && (await requiresLinking(filename, data));
+    const useInputSourcemap = options.sourcemap &&
+        (!!options.thirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(filename));
+    const plugins = [];
+    // Lazy load the linker plugin only when linking is required
+    if (shouldLink) {
+        const linkerPlugin = await createLinkerPlugin(options);
+        plugins.push(linkerPlugin);
+    }
+    if (options.advancedOptimizations) {
+        const sideEffectFree = options.sideEffects === false;
+        const safeAngularPackage = sideEffectFree && /[\\/]node_modules[\\/]@angular[\\/]/.test(filename);
+        const { adjustStaticMembers, adjustTypeScriptEnums, elideAngularMetadata, markTopLevelPure } = await Promise.resolve().then(() => __importStar(require('../babel/plugins')));
+        if (safeAngularPackage) {
+            plugins.push(markTopLevelPure);
+        }
+        plugins.push(elideAngularMetadata, adjustTypeScriptEnums, [
+            adjustStaticMembers,
+            { wrapDecorators: sideEffectFree },
+        ]);
+    }
+    // If no additional transformations are needed, return the data directly
+    if (plugins.length === 0) {
+        // Strip sourcemaps if they should not be used
+        return useInputSourcemap ? data : data.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, '');
+    }
+    const result = await (0, core_1.transformAsync)(data, {
+        filename,
+        inputSourceMap: (useInputSourcemap ? undefined : false),
+        sourceMaps: useInputSourcemap ? 'inline' : false,
+        compact: false,
+        configFile: false,
+        babelrc: false,
+        browserslistConfigFile: false,
+        plugins,
+    });
+    const outputCode = result?.code ?? data;
+    // Strip sourcemaps if they should not be used.
+    // Babel will keep the original comments even if sourcemaps are disabled.
+    return useInputSourcemap
+        ? outputCode
+        : outputCode.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, '');
+}
+async function requiresLinking(path, source) {
+    // @angular/core and @angular/compiler will cause false positives
+    // Also, TypeScript files do not require linking
+    if (/[\\/]@angular[\\/](?:compiler|core)|\.tsx?$/.test(path)) {
+        return false;
+    }
+    if (!needsLinking) {
+        // Load ESM `@angular/compiler-cli/linker` using the TypeScript dynamic import workaround.
+        // Once TypeScript provides support for keeping the dynamic import this workaround can be
+        // changed to a direct dynamic import.
+        const linkerModule = await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli/linker');
+        needsLinking = linkerModule.needsLinking;
+    }
+    return needsLinking(path, source);
+}
+async function createLinkerPlugin(options) {
+    linkerPluginCreator ??= (await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli/linker/babel')).createEs2015LinkerPlugin;
+    const linkerPlugin = linkerPluginCreator({
+        linkerJitMode: options.jit,
+        // This is a workaround until https://github.com/angular/angular/issues/42769 is fixed.
+        sourceMapping: false,
+        logger: {
+            level: 1, // Info level
+            debug(...args) {
+                // eslint-disable-next-line no-console
+                console.debug(args);
+            },
+            info(...args) {
+                // eslint-disable-next-line no-console
+                console.info(args);
+            },
+            warn(...args) {
+                // eslint-disable-next-line no-console
+                console.warn(args);
+            },
+            error(...args) {
+                // eslint-disable-next-line no-console
+                console.error(args);
+            },
+        },
+        fileSystem: {
+            resolve: node_path_1.default.resolve,
+            exists: node_fs_1.default.existsSync,
+            dirname: node_path_1.default.dirname,
+            relative: node_path_1.default.relative,
+            readFile: node_fs_1.default.readFileSync,
+            // Node.JS types don't overlap the Compiler types.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        },
+    });
+    return linkerPlugin;
+}

package/src/tools/esbuild/javascript-transformer.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @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 { Cache } from './cache';
+/**
+ * Transformation options that should apply to all transformed files and data.
+ */
+export interface JavaScriptTransformerOptions {
+    sourcemap: boolean;
+    thirdPartySourcemaps?: boolean;
+    advancedOptimizations?: boolean;
+    jit?: boolean;
+}
+/**
+ * A class that performs transformation of JavaScript files and raw data.
+ * A worker pool is used to distribute the transformation actions and allow
+ * parallel processing. Transformation behavior is based on the filename and
+ * data. Transformations may include: async downleveling, Angular linking,
+ * and advanced optimizations.
+ */
+export declare class JavaScriptTransformer {
+    #private;
+    readonly maxThreads: number;
+    private readonly cache?;
+    constructor(options: JavaScriptTransformerOptions, maxThreads: number, cache?: Cache<Uint8Array, import("./cache").CacheStore<Uint8Array>> | undefined);
+    /**
+     * Performs JavaScript transformations on a file from the filesystem.
+     * If no transformations are required, the data for the original file will be returned.
+     * @param filename The full path to the file.
+     * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking.
+     * @param sideEffects If false, and `advancedOptimizations` is enabled tslib decorators are wrapped.
+     * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result.
+     */
+    transformFile(filename: string, skipLinker?: boolean, sideEffects?: boolean): Promise<Uint8Array>;
+    /**
+     * Performs JavaScript transformations on the provided data of a file. The file does not need
+     * to exist on the filesystem.
+     * @param filename The full path of the file represented by the data.
+     * @param data The data of the file that should be transformed.
+     * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking.
+     * @param sideEffects If false, and `advancedOptimizations` is enabled tslib decorators are wrapped.
+     * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result.
+     */
+    transformData(filename: string, data: string, skipLinker: boolean, sideEffects?: boolean): Promise<Uint8Array>;
+    /**
+     * Stops all active transformation tasks and shuts down all workers.
+     * @returns A void promise that resolves when closing is complete.
+     */
+    close(): Promise<void>;
+}

package/src/tools/esbuild/javascript-transformer.js

@@ -0,0 +1,147 @@
+"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.JavaScriptTransformer = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const piscina_1 = __importDefault(require("piscina"));
+/**
+ * A class that performs transformation of JavaScript files and raw data.
+ * A worker pool is used to distribute the transformation actions and allow
+ * parallel processing. Transformation behavior is based on the filename and
+ * data. Transformations may include: async downleveling, Angular linking,
+ * and advanced optimizations.
+ */
+class JavaScriptTransformer {
+    maxThreads;
+    cache;
+    #workerPool;
+    #commonOptions;
+    #fileCacheKeyBase;
+    constructor(options, maxThreads, cache) {
+        this.maxThreads = maxThreads;
+        this.cache = cache;
+        // Extract options to ensure only the named options are serialized and sent to the worker
+        const { sourcemap, thirdPartySourcemaps = false, advancedOptimizations = false, jit = false, } = options;
+        this.#commonOptions = {
+            sourcemap,
+            thirdPartySourcemaps,
+            advancedOptimizations,
+            jit,
+        };
+        this.#fileCacheKeyBase = Buffer.from(JSON.stringify(this.#commonOptions), 'utf-8');
+    }
+    #ensureWorkerPool() {
+        this.#workerPool ??= new piscina_1.default({
+            filename: require.resolve('./javascript-transformer-worker'),
+            minThreads: 1,
+            maxThreads: this.maxThreads,
+            // Shutdown idle threads after 1 second of inactivity
+            idleTimeout: 1000,
+            recordTiming: false,
+        });
+        return this.#workerPool;
+    }
+    /**
+     * Performs JavaScript transformations on a file from the filesystem.
+     * If no transformations are required, the data for the original file will be returned.
+     * @param filename The full path to the file.
+     * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking.
+     * @param sideEffects If false, and `advancedOptimizations` is enabled tslib decorators are wrapped.
+     * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result.
+     */
+    async transformFile(filename, skipLinker, sideEffects) {
+        const data = await (0, promises_1.readFile)(filename);
+        let result;
+        let cacheKey;
+        if (this.cache) {
+            // Create a cache key from the file data and options that effect the output.
+            // NOTE: If additional options are added, this may need to be updated.
+            // TODO: Consider xxhash or similar instead of SHA256
+            const hash = (0, node_crypto_1.createHash)('sha256');
+            hash.update(`${!!skipLinker}--${!!sideEffects}`);
+            hash.update(data);
+            hash.update(this.#fileCacheKeyBase);
+            cacheKey = hash.digest('hex');
+            try {
+                result = await this.cache?.get(cacheKey);
+            }
+            catch {
+                // Failure to get the value should not fail the transform
+            }
+        }
+        if (result === undefined) {
+            // If there is no cache or no cached entry, process the file
+            result = (await this.#ensureWorkerPool().run({
+                filename,
+                data,
+                skipLinker,
+                sideEffects,
+                ...this.#commonOptions,
+            }, {
+                // The below is disable as with Yarn PNP this causes build failures with the below message
+                // `Unable to deserialize cloned data`.
+                transferList: process.versions.pnp ? undefined : [data.buffer],
+            }));
+            // If there is a cache then store the result
+            if (this.cache && cacheKey) {
+                try {
+                    await this.cache.put(cacheKey, result);
+                }
+                catch {
+                    // Failure to store the value in the cache should not fail the transform
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Performs JavaScript transformations on the provided data of a file. The file does not need
+     * to exist on the filesystem.
+     * @param filename The full path of the file represented by the data.
+     * @param data The data of the file that should be transformed.
+     * @param skipLinker If true, bypass all Angular linker processing; if false, attempt linking.
+     * @param sideEffects If false, and `advancedOptimizations` is enabled tslib decorators are wrapped.
+     * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result.
+     */
+    async transformData(filename, data, skipLinker, sideEffects) {
+        // Perform a quick test to determine if the data needs any transformations.
+        // This allows directly returning the data without the worker communication overhead.
+        if (skipLinker && !this.#commonOptions.advancedOptimizations) {
+            const keepSourcemap = this.#commonOptions.sourcemap &&
+                (!!this.#commonOptions.thirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(filename));
+            return Buffer.from(keepSourcemap ? data : data.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, ''), 'utf-8');
+        }
+        return this.#ensureWorkerPool().run({
+            filename,
+            data,
+            skipLinker,
+            sideEffects,
+            ...this.#commonOptions,
+        });
+    }
+    /**
+     * Stops all active transformation tasks and shuts down all workers.
+     * @returns A void promise that resolves when closing is complete.
+     */
+    async close() {
+        if (this.#workerPool) {
+            try {
+                await this.#workerPool.destroy();
+            }
+            finally {
+                this.#workerPool = undefined;
+            }
+        }
+    }
+}
+exports.JavaScriptTransformer = JavaScriptTransformer;

package/src/tools/esbuild/license-extractor.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @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 { Metafile } from 'esbuild';
+/**
+ * Extracts license information for each node module package included in the output
+ * files of the built code. This includes JavaScript and CSS output files. The esbuild
+ * metafile generated during the bundling steps is used as the source of information
+ * regarding what input files where included and where they are located. A path segment
+ * of `node_modules` is used to indicate that a file belongs to a package and its license
+ * should be include in the output licenses file.
+ *
+ * The package name and license field are extracted from the `package.json` file for the
+ * package. If a license file (e.g., `LICENSE`) is present in the root of the package, it
+ * will also be included in the output licenses file.
+ *
+ * @param metafile An esbuild metafile object.
+ * @param rootDirectory The root directory of the workspace.
+ * @returns A string containing the content of the output licenses file.
+ */
+export declare function extractLicenses(metafile: Metafile, rootDirectory: string): Promise<string>;

package/src/tools/esbuild/license-extractor.js

@@ -0,0 +1,158 @@
+"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.extractLicenses = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * The path segment used to signify that a file is part of a package.
+ */
+const NODE_MODULE_SEGMENT = 'node_modules';
+/**
+ * String constant for the NPM recommended custom license wording.
+ *
+ * See: https://docs.npmjs.com/cli/v9/configuring-npm/package-json#license
+ *
+ * Example:
+ * ```
+ * {
+ *   "license" : "SEE LICENSE IN <filename>"
+ * }
+ * ```
+ */
+const CUSTOM_LICENSE_TEXT = 'SEE LICENSE IN ';
+/**
+ * A list of commonly named license files found within packages.
+ */
+const LICENSE_FILES = ['LICENSE', 'LICENSE.txt', 'LICENSE.md'];
+/**
+ * Header text that will be added to the top of the output license extraction file.
+ */
+const EXTRACTION_FILE_HEADER = '';
+/**
+ * The package entry separator to use within the output license extraction file.
+ */
+const EXTRACTION_FILE_SEPARATOR = '-'.repeat(80) + '\n';
+/**
+ * Extracts license information for each node module package included in the output
+ * files of the built code. This includes JavaScript and CSS output files. The esbuild
+ * metafile generated during the bundling steps is used as the source of information
+ * regarding what input files where included and where they are located. A path segment
+ * of `node_modules` is used to indicate that a file belongs to a package and its license
+ * should be include in the output licenses file.
+ *
+ * The package name and license field are extracted from the `package.json` file for the
+ * package. If a license file (e.g., `LICENSE`) is present in the root of the package, it
+ * will also be included in the output licenses file.
+ *
+ * @param metafile An esbuild metafile object.
+ * @param rootDirectory The root directory of the workspace.
+ * @returns A string containing the content of the output licenses file.
+ */
+async function extractLicenses(metafile, rootDirectory) {
+    let extractedLicenseContent = `${EXTRACTION_FILE_HEADER}\n${EXTRACTION_FILE_SEPARATOR}`;
+    const seenPaths = new Set();
+    const seenPackages = new Set();
+    for (const entry of Object.values(metafile.outputs)) {
+        for (const [inputPath, { bytesInOutput }] of Object.entries(entry.inputs)) {
+            // Skip if not included in output
+            if (bytesInOutput <= 0) {
+                continue;
+            }
+            // Skip already processed paths
+            if (seenPaths.has(inputPath)) {
+                continue;
+            }
+            seenPaths.add(inputPath);
+            // Skip non-package paths
+            if (!inputPath.includes(NODE_MODULE_SEGMENT)) {
+                continue;
+            }
+            // Extract the package name from the path
+            let baseDirectory = node_path_1.default.join(rootDirectory, inputPath);
+            let nameOrScope, nameOrFile;
+            let found = false;
+            while (baseDirectory !== node_path_1.default.dirname(baseDirectory)) {
+                const segment = node_path_1.default.basename(baseDirectory);
+                if (segment === NODE_MODULE_SEGMENT) {
+                    found = true;
+                    break;
+                }
+                nameOrFile = nameOrScope;
+                nameOrScope = segment;
+                baseDirectory = node_path_1.default.dirname(baseDirectory);
+            }
+            // Skip non-package path edge cases that are not caught in the includes check above
+            if (!found || !nameOrScope) {
+                continue;
+            }
+            const packageName = nameOrScope.startsWith('@')
+                ? `${nameOrScope}/${nameOrFile}`
+                : nameOrScope;
+            const packageDirectory = node_path_1.default.join(baseDirectory, packageName);
+            // Load the package's metadata to find the package's name, version, and license type
+            const packageJsonPath = node_path_1.default.join(packageDirectory, 'package.json');
+            let packageJson;
+            try {
+                packageJson = JSON.parse(await (0, promises_1.readFile)(packageJsonPath, 'utf-8'));
+            }
+            catch {
+                // Invalid package
+                continue;
+            }
+            // Skip already processed packages
+            const packageId = `${packageName}@${packageJson.version}`;
+            if (seenPackages.has(packageId)) {
+                continue;
+            }
+            seenPackages.add(packageId);
+            // Attempt to find license text inside package
+            let licenseText = '';
+            if (typeof packageJson.license === 'string' &&
+                packageJson.license.toLowerCase().startsWith(CUSTOM_LICENSE_TEXT)) {
+                // Attempt to load the package's custom license
+                let customLicensePath;
+                const customLicenseFile = node_path_1.default.normalize(packageJson.license.slice(CUSTOM_LICENSE_TEXT.length + 1).trim());
+                if (customLicenseFile.startsWith('..') || node_path_1.default.isAbsolute(customLicenseFile)) {
+                    // Path is attempting to access files outside of the package
+                    // TODO: Issue warning?
+                }
+                else {
+                    customLicensePath = node_path_1.default.join(packageDirectory, customLicenseFile);
+                    try {
+                        licenseText = await (0, promises_1.readFile)(customLicensePath, 'utf-8');
+                        break;
+                    }
+                    catch { }
+                }
+            }
+            else {
+                // Search for a license file within the root of the package
+                for (const potentialLicense of LICENSE_FILES) {
+                    const packageLicensePath = node_path_1.default.join(packageDirectory, potentialLicense);
+                    try {
+                        licenseText = await (0, promises_1.readFile)(packageLicensePath, 'utf-8');
+                        break;
+                    }
+                    catch { }
+                }
+            }
+            // Generate the package's license entry in the output content
+            extractedLicenseContent += `Package: ${packageJson.name}\n`;
+            extractedLicenseContent += `License: ${JSON.stringify(packageJson.license, null, 2)}\n`;
+            extractedLicenseContent += `\n${licenseText}\n`;
+            extractedLicenseContent += EXTRACTION_FILE_SEPARATOR;
+        }
+    }
+    return extractedLicenseContent;
+}
+exports.extractLicenses = extractLicenses;

package/src/tools/esbuild/load-result-cache.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 { OnLoadResult, PluginBuild } from 'esbuild';
+export interface LoadResultCache {
+    get(path: string): OnLoadResult | undefined;
+    put(path: string, result: OnLoadResult): Promise<void>;
+    readonly watchFiles: ReadonlyArray<string>;
+}
+export declare function createCachedLoad(cache: LoadResultCache | undefined, callback: Parameters<PluginBuild['onLoad']>[1]): Parameters<PluginBuild['onLoad']>[1];
+export declare class MemoryLoadResultCache implements LoadResultCache {
+    #private;
+    get(path: string): OnLoadResult | undefined;
+    put(path: string, result: OnLoadResult): Promise<void>;
+    invalidate(path: string): boolean;
+    get watchFiles(): string[];
+}