@angular/build 18.0.0-next.3

package/src/tools/esbuild/angular/uri.js

@@ -0,0 +1,74 @@
+"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.parseJitUri = exports.generateJitInlineUri = exports.generateJitFileUri = exports.JIT_NAMESPACE_REGEXP = exports.JIT_TEMPLATE_NAMESPACE = exports.JIT_STYLE_NAMESPACE = void 0;
+/**
+ * A string value representing the base namespace for Angular JIT mode related imports.
+ */
+const JIT_BASE_NAMESPACE = 'angular:jit';
+/**
+ * A string value representing the namespace for Angular JIT mode related imports for
+ * Component styles. This namespace is used for both inline (`styles`) and external
+ * (`styleUrls`) styles.
+ */
+exports.JIT_STYLE_NAMESPACE = `${JIT_BASE_NAMESPACE}:style`;
+/**
+ * A string value representing the namespace for Angular JIT mode related imports for
+ * Component templates. This namespace is currently only used for external (`templateUrl`)
+ * templates.
+ */
+exports.JIT_TEMPLATE_NAMESPACE = `${JIT_BASE_NAMESPACE}:template`;
+/**
+ * A regular expression that can be used to match a Angular JIT mode namespace URI.
+ * It contains capture groups for the type (template/style), origin (file/inline), and specifier.
+ * The {@link parseJitUri} function can be used to parse and return an object representation of a JIT URI.
+ */
+exports.JIT_NAMESPACE_REGEXP = new RegExp(`^${JIT_BASE_NAMESPACE}:(template|style):(file|inline);(.*)$`);
+/**
+ * Generates an Angular JIT mode namespace URI for a given file.
+ * @param file The path of the file to be included.
+ * @param type The type of the file (`style` or `template`).
+ * @returns A string containing the full JIT namespace URI.
+ */
+function generateJitFileUri(file, type) {
+    return `${JIT_BASE_NAMESPACE}:${type}:file;${file}`;
+}
+exports.generateJitFileUri = generateJitFileUri;
+/**
+ * Generates an Angular JIT mode namespace URI for a given inline style or template.
+ * The provided content is base64 encoded and included in the URI.
+ * @param data The content to encode within the URI.
+ * @param type The type of the content (`style` or `template`).
+ * @returns A string containing the full JIT namespace URI.
+ */
+function generateJitInlineUri(data, type) {
+    return `${JIT_BASE_NAMESPACE}:${type}:inline;${Buffer.from(data).toString('base64')}`;
+}
+exports.generateJitInlineUri = generateJitInlineUri;
+/**
+ * Parses a string containing a JIT namespace URI.
+ * JIT namespace URIs are used to encode the information for an Angular component's stylesheets
+ * and templates when compiled in JIT mode.
+ * @param uri The URI to parse into its underlying components.
+ * @returns An object containing the namespace, type, origin, and specifier of the URI;
+ * `undefined` if not a JIT namespace URI.
+ */
+function parseJitUri(uri) {
+    const matches = exports.JIT_NAMESPACE_REGEXP.exec(uri);
+    if (!matches) {
+        return undefined;
+    }
+    return {
+        namespace: `${JIT_BASE_NAMESPACE}:${matches[1]}`,
+        type: matches[1],
+        origin: matches[2],
+        specifier: matches[3],
+    };
+}
+exports.parseJitUri = parseJitUri;

package/src/tools/esbuild/angular/web-worker-transformer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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';
+/**
+ * Creates a TypeScript Transformer to process Worker and SharedWorker entry points and transform
+ * the URL instances to reference the built and bundled worker code. This uses a callback process
+ * similar to the component stylesheets to allow the main esbuild plugin to process files as needed.
+ * Unsupported worker expressions will be left in their origin form.
+ * @param getTypeChecker A function that returns a TypeScript TypeChecker instance for the program.
+ * @returns A TypeScript transformer factory.
+ */
+export declare function createWorkerTransformer(fileProcessor: (file: string, importer: string) => string): ts.TransformerFactory<ts.SourceFile>;

package/src/tools/esbuild/angular/web-worker-transformer.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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkerTransformer = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Creates a TypeScript Transformer to process Worker and SharedWorker entry points and transform
+ * the URL instances to reference the built and bundled worker code. This uses a callback process
+ * similar to the component stylesheets to allow the main esbuild plugin to process files as needed.
+ * Unsupported worker expressions will be left in their origin form.
+ * @param getTypeChecker A function that returns a TypeScript TypeChecker instance for the program.
+ * @returns A TypeScript transformer factory.
+ */
+function createWorkerTransformer(fileProcessor) {
+    return (context) => {
+        const nodeFactory = context.factory;
+        const visitNode = (node) => {
+            // Check if the node is a valid new expression for a Worker or SharedWorker
+            // TODO: Add global scope check
+            if (!typescript_1.default.isNewExpression(node) ||
+                !typescript_1.default.isIdentifier(node.expression) ||
+                (node.expression.text !== 'Worker' && node.expression.text !== 'SharedWorker')) {
+                // Visit child nodes of non-Worker expressions
+                return typescript_1.default.visitEachChild(node, visitNode, context);
+            }
+            // Worker should have atleast one argument but not more than two
+            if (!node.arguments || node.arguments.length < 1 || node.arguments.length > 2) {
+                return node;
+            }
+            // First argument must be a new URL expression
+            const workerUrlNode = node.arguments[0];
+            // TODO: Add global scope check
+            if (!typescript_1.default.isNewExpression(workerUrlNode) ||
+                !typescript_1.default.isIdentifier(workerUrlNode.expression) ||
+                workerUrlNode.expression.text !== 'URL') {
+                return node;
+            }
+            // URL must have 2 arguments
+            if (!workerUrlNode.arguments || workerUrlNode.arguments.length !== 2) {
+                return node;
+            }
+            // URL arguments must be a string and then `import.meta.url`
+            if (!typescript_1.default.isStringLiteralLike(workerUrlNode.arguments[0]) ||
+                !typescript_1.default.isPropertyAccessExpression(workerUrlNode.arguments[1]) ||
+                !typescript_1.default.isMetaProperty(workerUrlNode.arguments[1].expression) ||
+                workerUrlNode.arguments[1].name.text !== 'url') {
+                return node;
+            }
+            const filePath = workerUrlNode.arguments[0].text;
+            const importer = node.getSourceFile().fileName;
+            // Process the file
+            const replacementPath = fileProcessor(filePath, importer);
+            // Update if the path changed
+            if (replacementPath !== filePath) {
+                return nodeFactory.updateNewExpression(node, node.expression, node.typeArguments, 
+                // Update Worker arguments
+                typescript_1.default.setTextRange(nodeFactory.createNodeArray([
+                    nodeFactory.updateNewExpression(workerUrlNode, workerUrlNode.expression, workerUrlNode.typeArguments, 
+                    // Update URL arguments
+                    typescript_1.default.setTextRange(nodeFactory.createNodeArray([
+                        nodeFactory.createStringLiteral(replacementPath),
+                        workerUrlNode.arguments[1],
+                    ], workerUrlNode.arguments.hasTrailingComma), workerUrlNode.arguments)),
+                    // Use the second Worker argument (options) if present.
+                    // Otherwise create a default options object for module Workers.
+                    node.arguments[1] ??
+                        nodeFactory.createObjectLiteralExpression([
+                            nodeFactory.createPropertyAssignment('type', nodeFactory.createStringLiteral('module')),
+                        ]),
+                ], node.arguments.hasTrailingComma), node.arguments));
+            }
+            else {
+                return node;
+            }
+        };
+        return (sourceFile) => {
+            // Skip transformer if there are no Workers
+            if (!sourceFile.text.includes('Worker')) {
+                return sourceFile;
+            }
+            return typescript_1.default.visitEachChild(sourceFile, visitNode, context);
+        };
+    };
+}
+exports.createWorkerTransformer = createWorkerTransformer;

package/src/tools/esbuild/application-code-bundle.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 { BuildOptions } from 'esbuild';
+import type { NormalizedApplicationBuildOptions } from '../../builders/application/options';
+import { SourceFileCache } from './angular/source-file-cache';
+import { BundlerOptionsFactory } from './bundler-context';
+export declare function createBrowserCodeBundleOptions(options: NormalizedApplicationBuildOptions, target: string[], sourceFileCache?: SourceFileCache): BuildOptions;
+export declare function createBrowserPolyfillBundleOptions(options: NormalizedApplicationBuildOptions, target: string[], sourceFileCache?: SourceFileCache): BuildOptions | BundlerOptionsFactory | undefined;
+/**
+ * Create an esbuild 'build' options object for the server bundle.
+ * @param options The builder's user-provider normalized options.
+ * @returns An esbuild BuildOptions object.
+ */
+export declare function createServerCodeBundleOptions(options: NormalizedApplicationBuildOptions, target: string[], sourceFileCache: SourceFileCache): BuildOptions;
+export declare function createServerPolyfillBundleOptions(options: NormalizedApplicationBuildOptions, target: string[], sourceFileCache?: SourceFileCache): BundlerOptionsFactory | undefined;

package/src/tools/esbuild/application-code-bundle.js

@@ -0,0 +1,368 @@
+"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.createServerPolyfillBundleOptions = exports.createServerCodeBundleOptions = exports.createBrowserPolyfillBundleOptions = exports.createBrowserCodeBundleOptions = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const environment_options_1 = require("../../utils/environment-options");
+const compiler_plugin_1 = require("./angular/compiler-plugin");
+const compiler_plugin_options_1 = require("./compiler-plugin-options");
+const external_packages_plugin_1 = require("./external-packages-plugin");
+const i18n_locale_plugin_1 = require("./i18n-locale-plugin");
+const rxjs_esm_resolution_plugin_1 = require("./rxjs-esm-resolution-plugin");
+const sourcemap_ignorelist_plugin_1 = require("./sourcemap-ignorelist-plugin");
+const utils_1 = require("./utils");
+const virtual_module_plugin_1 = require("./virtual-module-plugin");
+function createBrowserCodeBundleOptions(options, target, sourceFileCache) {
+    const { entryPoints, outputNames, polyfills } = options;
+    const { pluginOptions, styleOptions } = (0, compiler_plugin_options_1.createCompilerPluginOptions)(options, target, sourceFileCache);
+    const buildOptions = {
+        ...getEsBuildCommonOptions(options),
+        platform: 'browser',
+        // Note: `es2015` is needed for RxJS v6. If not specified, `module` would
+        // match and the ES5 distribution would be bundled and ends up breaking at
+        // runtime with the RxJS testing library.
+        // More details: https://github.com/angular/angular-cli/issues/25405.
+        mainFields: ['es2020', 'es2015', 'browser', 'module', 'main'],
+        entryNames: outputNames.bundles,
+        entryPoints,
+        target,
+        supported: (0, utils_1.getFeatureSupport)(target, (0, utils_1.isZonelessApp)(polyfills)),
+        plugins: [
+            (0, sourcemap_ignorelist_plugin_1.createSourcemapIgnorelistPlugin)(),
+            (0, compiler_plugin_1.createCompilerPlugin)(
+            // JS/TS options
+            pluginOptions, 
+            // Component stylesheet options
+            styleOptions),
+        ],
+    };
+    if (options.plugins) {
+        buildOptions.plugins?.push(...options.plugins);
+    }
+    if (options.externalPackages) {
+        // Package files affected by a customized loader should not be implicitly marked as external
+        if (options.loaderExtensions ||
+            options.plugins ||
+            typeof options.externalPackages === 'object') {
+            // Plugin must be added after custom plugins to ensure any added loader options are considered
+            buildOptions.plugins?.push((0, external_packages_plugin_1.createExternalPackagesPlugin)(options.externalPackages !== true ? options.externalPackages : undefined));
+        }
+        else {
+            // Safe to use the packages external option directly
+            buildOptions.packages = 'external';
+        }
+    }
+    return buildOptions;
+}
+exports.createBrowserCodeBundleOptions = createBrowserCodeBundleOptions;
+function createBrowserPolyfillBundleOptions(options, target, sourceFileCache) {
+    const namespace = 'angular:polyfills';
+    const polyfillBundleOptions = getEsBuildCommonPolyfillsOptions(options, namespace, true, sourceFileCache);
+    if (!polyfillBundleOptions) {
+        return;
+    }
+    const { outputNames, polyfills } = options;
+    const hasTypeScriptEntries = polyfills?.some((entry) => /\.[cm]?tsx?$/.test(entry));
+    const buildOptions = {
+        ...polyfillBundleOptions,
+        platform: 'browser',
+        // Note: `es2015` is needed for RxJS v6. If not specified, `module` would
+        // match and the ES5 distribution would be bundled and ends up breaking at
+        // runtime with the RxJS testing library.
+        // More details: https://github.com/angular/angular-cli/issues/25405.
+        mainFields: ['es2020', 'es2015', 'browser', 'module', 'main'],
+        entryNames: outputNames.bundles,
+        target,
+        entryPoints: {
+            'polyfills': namespace,
+        },
+    };
+    // Only add the Angular TypeScript compiler if TypeScript files are provided in the polyfills
+    if (hasTypeScriptEntries) {
+        buildOptions.plugins ??= [];
+        const { pluginOptions, styleOptions } = (0, compiler_plugin_options_1.createCompilerPluginOptions)(options, target, sourceFileCache);
+        buildOptions.plugins.push((0, compiler_plugin_1.createCompilerPlugin)(
+        // JS/TS options
+        { ...pluginOptions, noopTypeScriptCompilation: true }, 
+        // Component stylesheet options are unused for polyfills but required by the plugin
+        styleOptions));
+    }
+    // Use an options factory to allow fully incremental bundling when no TypeScript files are present.
+    // The TypeScript compilation is not currently integrated into the bundler invalidation so
+    // cannot be used with fully incremental bundling yet.
+    return hasTypeScriptEntries ? buildOptions : () => buildOptions;
+}
+exports.createBrowserPolyfillBundleOptions = createBrowserPolyfillBundleOptions;
+/**
+ * Create an esbuild 'build' options object for the server bundle.
+ * @param options The builder's user-provider normalized options.
+ * @returns An esbuild BuildOptions object.
+ */
+function createServerCodeBundleOptions(options, target, sourceFileCache) {
+    const { serverEntryPoint, workspaceRoot, ssrOptions, watch, externalPackages, prerenderOptions, polyfills, } = options;
+    (0, node_assert_1.default)(serverEntryPoint, 'createServerCodeBundleOptions should not be called without a defined serverEntryPoint.');
+    const { pluginOptions, styleOptions } = (0, compiler_plugin_options_1.createCompilerPluginOptions)(options, target, sourceFileCache);
+    const mainServerNamespace = 'angular:server-render-utils';
+    const entryPoints = {
+        'render-utils.server': mainServerNamespace,
+        'main.server': serverEntryPoint,
+    };
+    const ssrEntryPoint = ssrOptions?.entry;
+    if (ssrEntryPoint) {
+        entryPoints['server'] = ssrEntryPoint;
+    }
+    const buildOptions = {
+        ...getEsBuildCommonOptions(options),
+        platform: 'node',
+        splitting: true,
+        outExtension: { '.js': '.mjs' },
+        // Note: `es2015` is needed for RxJS v6. If not specified, `module` would
+        // match and the ES5 distribution would be bundled and ends up breaking at
+        // runtime with the RxJS testing library.
+        // More details: https://github.com/angular/angular-cli/issues/25405.
+        mainFields: ['es2020', 'es2015', 'module', 'main'],
+        entryNames: '[name]',
+        target,
+        banner: {
+            js: `import './polyfills.server.mjs';`,
+        },
+        entryPoints,
+        supported: (0, utils_1.getFeatureSupport)(target, (0, utils_1.isZonelessApp)(polyfills)),
+        plugins: [
+            (0, sourcemap_ignorelist_plugin_1.createSourcemapIgnorelistPlugin)(),
+            (0, compiler_plugin_1.createCompilerPlugin)(
+            // JS/TS options
+            { ...pluginOptions, noopTypeScriptCompilation: true }, 
+            // Component stylesheet options
+            styleOptions),
+        ],
+    };
+    buildOptions.plugins ??= [];
+    if (externalPackages) {
+        buildOptions.packages = 'external';
+    }
+    else {
+        buildOptions.plugins.push((0, rxjs_esm_resolution_plugin_1.createRxjsEsmResolutionPlugin)());
+    }
+    buildOptions.plugins.push((0, virtual_module_plugin_1.createVirtualModulePlugin)({
+        namespace: mainServerNamespace,
+        cache: sourceFileCache?.loadResultCache,
+        loadContent: async () => {
+            const contents = [
+                `export { ɵConsole } from '@angular/core';`,
+                `export { renderApplication, renderModule, ɵSERVER_CONTEXT } from '@angular/platform-server';`,
+            ];
+            if (watch) {
+                contents.push(`export { ɵresetCompiledComponents } from '@angular/core';`);
+            }
+            if (prerenderOptions?.discoverRoutes) {
+                // We do not import it directly so that node.js modules are resolved using the correct context.
+                const routesExtractorCode = await (0, promises_1.readFile)((0, node_path_1.join)(__dirname, '../../utils/routes-extractor/extractor.js'), 'utf-8');
+                // Remove source map URL comments from the code if a sourcemap is present as this will not match the file.
+                contents.push(routesExtractorCode.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, ''));
+            }
+            return {
+                contents: contents.join('\n'),
+                loader: 'js',
+                resolveDir: workspaceRoot,
+            };
+        },
+    }));
+    if (options.plugins) {
+        buildOptions.plugins.push(...options.plugins);
+    }
+    return buildOptions;
+}
+exports.createServerCodeBundleOptions = createServerCodeBundleOptions;
+function createServerPolyfillBundleOptions(options, target, sourceFileCache) {
+    const serverPolyfills = [];
+    const polyfillsFromConfig = new Set(options.polyfills);
+    if (!(0, utils_1.isZonelessApp)(options.polyfills)) {
+        serverPolyfills.push('zone.js/node');
+    }
+    if (polyfillsFromConfig.has('@angular/localize') ||
+        polyfillsFromConfig.has('@angular/localize/init')) {
+        serverPolyfills.push('@angular/localize/init');
+    }
+    serverPolyfills.push('@angular/platform-server/init');
+    const namespace = 'angular:polyfills-server';
+    const polyfillBundleOptions = getEsBuildCommonPolyfillsOptions({
+        ...options,
+        polyfills: serverPolyfills,
+    }, namespace, false, sourceFileCache);
+    if (!polyfillBundleOptions) {
+        return;
+    }
+    const buildOptions = {
+        ...polyfillBundleOptions,
+        platform: 'node',
+        outExtension: { '.js': '.mjs' },
+        // Note: `es2015` is needed for RxJS v6. If not specified, `module` would
+        // match and the ES5 distribution would be bundled and ends up breaking at
+        // runtime with the RxJS testing library.
+        // More details: https://github.com/angular/angular-cli/issues/25405.
+        mainFields: ['es2020', 'es2015', 'module', 'main'],
+        entryNames: '[name]',
+        banner: {
+            js: [
+                // Note: Needed as esbuild does not provide require shims / proxy from ESModules.
+                // See: https://github.com/evanw/esbuild/issues/1921.
+                `import { createRequire } from 'node:module';`,
+                `globalThis['require'] ??= createRequire(import.meta.url);`,
+            ].join('\n'),
+        },
+        target,
+        entryPoints: {
+            'polyfills.server': namespace,
+        },
+    };
+    return () => buildOptions;
+}
+exports.createServerPolyfillBundleOptions = createServerPolyfillBundleOptions;
+function getEsBuildCommonOptions(options) {
+    const { workspaceRoot, outExtension, optimizationOptions, sourcemapOptions, tsconfig, externalDependencies, outputNames, preserveSymlinks, jit, loaderExtensions, jsonLogs, } = options;
+    // Ensure unique hashes for i18n translation changes when using post-process inlining.
+    // This hash value is added as a footer to each file and ensures that the output file names (with hashes)
+    // change when translation files have changed. If this is not done the post processed files may have
+    // different content but would retain identical production file names which would lead to browser caching problems.
+    let footer;
+    if (options.i18nOptions.shouldInline) {
+        // Update file hashes to include translation file content
+        const i18nHash = Object.values(options.i18nOptions.locales).reduce((data, locale) => data + locale.files.map((file) => file.integrity || '').join('|'), '');
+        footer = { js: `/**i18n:${(0, node_crypto_1.createHash)('sha256').update(i18nHash).digest('hex')}*/` };
+    }
+    return {
+        absWorkingDir: workspaceRoot,
+        bundle: true,
+        format: 'esm',
+        assetNames: outputNames.media,
+        conditions: ['es2020', 'es2015', 'module'],
+        resolveExtensions: ['.ts', '.tsx', '.mjs', '.js'],
+        metafile: true,
+        legalComments: options.extractLicenses ? 'none' : 'eof',
+        logLevel: options.verbose && !jsonLogs ? 'debug' : 'silent',
+        minifyIdentifiers: optimizationOptions.scripts && environment_options_1.allowMangle,
+        minifySyntax: optimizationOptions.scripts,
+        minifyWhitespace: optimizationOptions.scripts,
+        pure: ['forwardRef'],
+        outdir: workspaceRoot,
+        outExtension: outExtension ? { '.js': `.${outExtension}` } : undefined,
+        sourcemap: sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true),
+        splitting: true,
+        chunkNames: options.namedChunks ? '[name]-[hash]' : 'chunk-[hash]',
+        tsconfig,
+        external: externalDependencies,
+        write: false,
+        preserveSymlinks,
+        define: {
+            ...options.define,
+            // Only set to false when script optimizations are enabled. It should not be set to true because
+            // Angular turns `ngDevMode` into an object for development debugging purposes when not defined
+            // which a constant true value would break.
+            ...(optimizationOptions.scripts ? { 'ngDevMode': 'false' } : undefined),
+            'ngJitMode': jit ? 'true' : 'false',
+        },
+        loader: loaderExtensions,
+        footer,
+    };
+}
+function getEsBuildCommonPolyfillsOptions(options, namespace, tryToResolvePolyfillsAsRelative, sourceFileCache) {
+    const { jit, workspaceRoot, i18nOptions } = options;
+    const buildOptions = {
+        ...getEsBuildCommonOptions(options),
+        splitting: false,
+        plugins: [(0, sourcemap_ignorelist_plugin_1.createSourcemapIgnorelistPlugin)()],
+    };
+    const polyfills = options.polyfills ? [...options.polyfills] : [];
+    // Angular JIT mode requires the runtime compiler
+    if (jit) {
+        polyfills.unshift('@angular/compiler');
+    }
+    // Add Angular's global locale data if i18n options are present.
+    // Locale data should go first so that project provided polyfill code can augment if needed.
+    let needLocaleDataPlugin = false;
+    if (i18nOptions.shouldInline) {
+        // Add locale data for all active locales
+        // TODO: Inject each individually within the inlining process itself
+        for (const locale of i18nOptions.inlineLocales) {
+            polyfills.unshift(`angular:locale/data:${locale}`);
+        }
+        needLocaleDataPlugin = true;
+    }
+    else if (i18nOptions.hasDefinedSourceLocale) {
+        // When not inlining and a source local is present, use the source locale data directly
+        polyfills.unshift(`angular:locale/data:${i18nOptions.sourceLocale}`);
+        needLocaleDataPlugin = true;
+    }
+    if (needLocaleDataPlugin) {
+        buildOptions.plugins?.push((0, i18n_locale_plugin_1.createAngularLocaleDataPlugin)());
+    }
+    if (polyfills.length === 0) {
+        return;
+    }
+    buildOptions.plugins?.push((0, virtual_module_plugin_1.createVirtualModulePlugin)({
+        namespace,
+        cache: sourceFileCache?.loadResultCache,
+        loadContent: async (_, build) => {
+            let hasLocalizePolyfill = false;
+            let polyfillPaths = polyfills;
+            if (tryToResolvePolyfillsAsRelative) {
+                polyfillPaths = await Promise.all(polyfills.map(async (path) => {
+                    hasLocalizePolyfill ||= path.startsWith('@angular/localize');
+                    if (path.startsWith('zone.js') || !(0, node_path_1.extname)(path)) {
+                        return path;
+                    }
+                    const potentialPathRelative = './' + path;
+                    const result = await build.resolve(potentialPathRelative, {
+                        kind: 'import-statement',
+                        resolveDir: workspaceRoot,
+                    });
+                    return result.path ? potentialPathRelative : path;
+                }));
+            }
+            else {
+                hasLocalizePolyfill = polyfills.some((p) => p.startsWith('@angular/localize'));
+            }
+            if (!i18nOptions.shouldInline && !hasLocalizePolyfill) {
+                const result = await build.resolve('@angular/localize', {
+                    kind: 'import-statement',
+                    resolveDir: workspaceRoot,
+                });
+                if (result.path) {
+                    polyfillPaths.push('@angular/localize/init');
+                }
+            }
+            // Generate module contents with an import statement per defined polyfill
+            let contents = polyfillPaths
+                .map((file) => `import '${file.replace(/\\/g, '/')}';`)
+                .join('\n');
+            // The below should be done after loading `$localize` as otherwise the locale will be overridden.
+            if (i18nOptions.shouldInline) {
+                // When inlining, a placeholder is used to allow the post-processing step to inject the $localize locale identifier.
+                contents += '(globalThis.$localize ??= {}).locale = "___NG_LOCALE_INSERT___";\n';
+            }
+            else if (i18nOptions.hasDefinedSourceLocale) {
+                // If not inlining translations and source locale is defined, inject the locale specifier.
+                contents += `(globalThis.$localize ??= {}).locale = "${i18nOptions.sourceLocale}";\n`;
+            }
+            return {
+                contents,
+                loader: 'js',
+                resolveDir: workspaceRoot,
+            };
+        },
+    }));
+    return buildOptions;
+}

package/src/tools/esbuild/budget-stats.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
+ */
+import type { Metafile } from 'esbuild';
+import type { BudgetStats } from '../../utils/bundle-calculator';
+import type { InitialFileRecord } from './bundler-context';
+/**
+ * Generates a bundle budget calculator compatible stats object that provides
+ * the necessary information for the Webpack-based bundle budget code to
+ * interoperate with the esbuild-based builders.
+ * @param metafile The esbuild metafile of a build to use.
+ * @param initialFiles The records of all initial files of a build.
+ * @returns A bundle budget compatible stats object.
+ */
+export declare function generateBudgetStats(metafile: Metafile, initialFiles: Map<string, InitialFileRecord>): BudgetStats;

package/src/tools/esbuild/budget-stats.js

@@ -0,0 +1,59 @@
+"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.generateBudgetStats = void 0;
+const node_path_1 = require("node:path");
+/**
+ * Generates a bundle budget calculator compatible stats object that provides
+ * the necessary information for the Webpack-based bundle budget code to
+ * interoperate with the esbuild-based builders.
+ * @param metafile The esbuild metafile of a build to use.
+ * @param initialFiles The records of all initial files of a build.
+ * @returns A bundle budget compatible stats object.
+ */
+function generateBudgetStats(metafile, initialFiles) {
+    const stats = {
+        chunks: [],
+        assets: [],
+    };
+    for (const [file, entry] of Object.entries(metafile.outputs)) {
+        if (!file.endsWith('.js') && !file.endsWith('.css')) {
+            continue;
+        }
+        // Exclude server bundles
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (entry['ng-platform-server']) {
+            continue;
+        }
+        const initialRecord = initialFiles.get(file);
+        let name = initialRecord?.name;
+        if (name === undefined && entry.entryPoint) {
+            // For non-initial lazy modules, convert the entry point file into a Webpack compatible name
+            name = (0, node_path_1.basename)(entry.entryPoint)
+                .replace(/\.[cm]?[jt]s$/, '')
+                .replace(/[\\/.]/g, '-');
+        }
+        stats.chunks.push({
+            files: [file],
+            initial: !!initialRecord,
+            names: name ? [name] : undefined,
+        });
+        // 'ng-component' is set by the angular plugin's component stylesheet bundler
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const componentStyle = entry['ng-component'];
+        stats.assets.push({
+            // Component styles use the input file while all other outputs use the result file
+            name: (componentStyle && Object.keys(entry.inputs)[0]) || file,
+            size: entry.bytes,
+            componentStyle,
+        });
+    }
+    return stats;
+}
+exports.generateBudgetStats = generateBudgetStats;