@angular-devkit/build-angular 17.0.0-next.4 → 17.0.0-next.6

package/src/tools/esbuild/i18n-inliner-worker.js

@@ -0,0 +1,138 @@
+"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 });
+const remapping_1 = __importDefault(require("@ampproject/remapping"));
+const core_1 = require("@babel/core");
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_worker_threads_1 = require("node:worker_threads");
+const error_1 = require("../../utils/error");
+const load_esm_1 = require("../../utils/load-esm");
+// Extract the application files and common options used for inline requests from the Worker context
+// TODO: Evaluate overall performance difference of passing translations here as well
+const { files, missingTranslation, shouldOptimize } = (node_worker_threads_1.workerData || {});
+/**
+ * Inlines the provided locale and translation into a JavaScript file that contains `$localize` usage.
+ * This function is the main entry for the Worker's action that is called by the worker pool.
+ *
+ * @param request An InlineRequest object representing the options for inlining
+ * @returns An array containing the inlined file and optional map content.
+ */
+async function inlineLocale(request) {
+    const data = files.get(request.filename);
+    (0, node_assert_1.default)(data !== undefined, `Invalid inline request for file '${request.filename}'.`);
+    const code = await data.text();
+    const map = await files.get(request.filename + '.map')?.text();
+    const result = await transformWithBabel(code, map && JSON.parse(map), request);
+    // TODO: Return diagnostics
+    // TODO: Consider buffer transfer instead of string copying
+    const response = [{ file: request.filename, contents: result.code }];
+    if (result.map) {
+        response.push({ file: request.filename + '.map', contents: result.map });
+    }
+    return response;
+}
+exports.default = inlineLocale;
+/**
+ * Cached instance of the `@angular/localize/tools` module.
+ * This is used to remove the need to repeatedly import the module per file translation.
+ */
+let localizeToolsModule;
+/**
+ * Attempts to load the `@angular/localize/tools` module containing the functionality to
+ * perform the file translations.
+ * This module must be dynamically loaded as it is an ESM module and this file is CommonJS.
+ */
+async function loadLocalizeTools() {
+    // Load ESM `@angular/localize/tools` 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.
+    localizeToolsModule ??= await (0, load_esm_1.loadEsmModule)('@angular/localize/tools');
+    return localizeToolsModule;
+}
+/**
+ * Creates the needed Babel plugins to inline a given locale and translation for a JavaScript file.
+ * @param locale A string containing the locale specifier to use.
+ * @param translation A object record containing locale specific messages to use.
+ * @returns An array of Babel plugins.
+ */
+async function createI18nPlugins(locale, translation) {
+    const { Diagnostics, makeEs2015TranslatePlugin } = await loadLocalizeTools();
+    const plugins = [];
+    const diagnostics = new Diagnostics();
+    plugins.push(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    makeEs2015TranslatePlugin(diagnostics, (translation || {}), {
+        missingTranslation: translation === undefined ? 'ignore' : missingTranslation,
+    }));
+    // Create a plugin to replace the locale specifier constant inject by the build system with the actual specifier
+    plugins.push({
+        visitor: {
+            StringLiteral(path) {
+                if (path.node.value === '___NG_LOCALE_INSERT___') {
+                    path.replaceWith(core_1.types.stringLiteral(locale));
+                }
+            },
+        },
+    });
+    return { diagnostics, plugins };
+}
+/**
+ * Transforms a JavaScript file using Babel to inline the request locale and translation.
+ * @param code A string containing the JavaScript code to transform.
+ * @param map A sourcemap object for the provided JavaScript code.
+ * @param options The inline request options to use.
+ * @returns An object containing the code, map, and diagnostics from the transformation.
+ */
+async function transformWithBabel(code, map, options) {
+    let ast;
+    try {
+        ast = (0, core_1.parseSync)(code, {
+            babelrc: false,
+            configFile: false,
+            sourceType: 'unambiguous',
+            filename: options.filename,
+        });
+    }
+    catch (error) {
+        (0, error_1.assertIsError)(error);
+        // Make the error more readable.
+        // Same errors will contain the full content of the file as the error message
+        // Which makes it hard to find the actual error message.
+        const index = error.message.indexOf(')\n');
+        const msg = index !== -1 ? error.message.slice(0, index + 1) : error.message;
+        throw new Error(`${msg}\nAn error occurred inlining file "${options.filename}"`);
+    }
+    if (!ast) {
+        throw new Error(`Unknown error occurred inlining file "${options.filename}"`);
+    }
+    const { diagnostics, plugins } = await createI18nPlugins(options.locale, options.translation);
+    const transformResult = await (0, core_1.transformFromAstAsync)(ast, code, {
+        filename: options.filename,
+        // false is a valid value but not included in the type definition
+        inputSourceMap: false,
+        sourceMaps: !!map,
+        compact: shouldOptimize,
+        configFile: false,
+        babelrc: false,
+        browserslistConfigFile: false,
+        plugins,
+    });
+    if (!transformResult || !transformResult.code) {
+        throw new Error(`Unknown error occurred processing bundle for "${options.filename}".`);
+    }
+    let outputMap;
+    if (map && transformResult.map) {
+        outputMap = (0, remapping_1.default)([transformResult.map, map], () => null);
+    }
+    return { code: transformResult.code, map: outputMap && JSON.stringify(outputMap), diagnostics };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n-inliner-worker.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/tools/esbuild/i18n-inliner-worker.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport remapping, { SourceMapInput } from '@ampproject/remapping';\nimport { PluginObj, parseSync, transformFromAstAsync, types } from '@babel/core';\nimport assert from 'node:assert';\nimport { workerData } from 'node:worker_threads';\nimport { assertIsError } from '../../utils/error';\nimport { loadEsmModule } from '../../utils/load-esm';\n\n/**\n * The options passed to the inliner for each file request\n */\ninterface InlineRequest {\n  /**\n   * The filename that should be processed. The data for the file is provided to the Worker\n   * during Worker initialization.\n   */\n  filename: string;\n  /**\n   * The locale specifier that should be used during the inlining process of the file.\n   */\n  locale: string;\n  /**\n   * The translation messages for the locale that should be used during the inlining process of the file.\n   */\n  translation?: Record<string, unknown>;\n}\n\n// Extract the application files and common options used for inline requests from the Worker context\n// TODO: Evaluate overall performance difference of passing translations here as well\nconst { files, missingTranslation, shouldOptimize } = (workerData || {}) as {\n  files: ReadonlyMap<string, Blob>;\n  missingTranslation: 'error' | 'warning' | 'ignore';\n  shouldOptimize: boolean;\n};\n\n/**\n * Inlines the provided locale and translation into a JavaScript file that contains `$localize` usage.\n * This function is the main entry for the Worker's action that is called by the worker pool.\n *\n * @param request An InlineRequest object representing the options for inlining\n * @returns An array containing the inlined file and optional map content.\n */\nexport default async function inlineLocale(request: InlineRequest) {\n  const data = files.get(request.filename);\n\n  assert(data !== undefined, `Invalid inline request for file '${request.filename}'.`);\n\n  const code = await data.text();\n  const map = await files.get(request.filename + '.map')?.text();\n  const result = await transformWithBabel(\n    code,\n    map && (JSON.parse(map) as SourceMapInput),\n    request,\n  );\n\n  // TODO: Return diagnostics\n  // TODO: Consider buffer transfer instead of string copying\n  const response = [{ file: request.filename, contents: result.code }];\n  if (result.map) {\n    response.push({ file: request.filename + '.map', contents: result.map });\n  }\n\n  return response;\n}\n\n/**\n * A Type representing the localize tools module.\n */\ntype LocalizeUtilityModule = typeof import('@angular/localize/tools');\n\n/**\n * Cached instance of the `@angular/localize/tools` module.\n * This is used to remove the need to repeatedly import the module per file translation.\n */\nlet localizeToolsModule: LocalizeUtilityModule | undefined;\n\n/**\n * Attempts to load the `@angular/localize/tools` module containing the functionality to\n * perform the file translations.\n * This module must be dynamically loaded as it is an ESM module and this file is CommonJS.\n */\nasync function loadLocalizeTools(): Promise<LocalizeUtilityModule> {\n  // Load ESM `@angular/localize/tools` using the TypeScript dynamic import workaround.\n  // Once TypeScript provides support for keeping the dynamic import this workaround can be\n  // changed to a direct dynamic import.\n  localizeToolsModule ??= await loadEsmModule<LocalizeUtilityModule>('@angular/localize/tools');\n\n  return localizeToolsModule;\n}\n\n/**\n * Creates the needed Babel plugins to inline a given locale and translation for a JavaScript file.\n * @param locale A string containing the locale specifier to use.\n * @param translation A object record containing locale specific messages to use.\n * @returns An array of Babel plugins.\n */\nasync function createI18nPlugins(locale: string, translation: Record<string, unknown> | undefined) {\n  const { Diagnostics, makeEs2015TranslatePlugin } = await loadLocalizeTools();\n\n  const plugins: PluginObj[] = [];\n  const diagnostics = new Diagnostics();\n\n  plugins.push(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    makeEs2015TranslatePlugin(diagnostics, (translation || {}) as any, {\n      missingTranslation: translation === undefined ? 'ignore' : missingTranslation,\n    }),\n  );\n\n  // Create a plugin to replace the locale specifier constant inject by the build system with the actual specifier\n  plugins.push({\n    visitor: {\n      StringLiteral(path) {\n        if (path.node.value === '___NG_LOCALE_INSERT___') {\n          path.replaceWith(types.stringLiteral(locale));\n        }\n      },\n    },\n  });\n\n  return { diagnostics, plugins };\n}\n\n/**\n * Transforms a JavaScript file using Babel to inline the request locale and translation.\n * @param code A string containing the JavaScript code to transform.\n * @param map A sourcemap object for the provided JavaScript code.\n * @param options The inline request options to use.\n * @returns An object containing the code, map, and diagnostics from the transformation.\n */\nasync function transformWithBabel(\n  code: string,\n  map: SourceMapInput | undefined,\n  options: InlineRequest,\n) {\n  let ast;\n  try {\n    ast = parseSync(code, {\n      babelrc: false,\n      configFile: false,\n      sourceType: 'unambiguous',\n      filename: options.filename,\n    });\n  } catch (error) {\n    assertIsError(error);\n\n    // Make the error more readable.\n    // Same errors will contain the full content of the file as the error message\n    // Which makes it hard to find the actual error message.\n    const index = error.message.indexOf(')\\n');\n    const msg = index !== -1 ? error.message.slice(0, index + 1) : error.message;\n    throw new Error(`${msg}\\nAn error occurred inlining file \"${options.filename}\"`);\n  }\n\n  if (!ast) {\n    throw new Error(`Unknown error occurred inlining file \"${options.filename}\"`);\n  }\n\n  const { diagnostics, plugins } = await createI18nPlugins(options.locale, options.translation);\n  const transformResult = await transformFromAstAsync(ast, code, {\n    filename: options.filename,\n    // false is a valid value but not included in the type definition\n    inputSourceMap: false as unknown as undefined,\n    sourceMaps: !!map,\n    compact: shouldOptimize,\n    configFile: false,\n    babelrc: false,\n    browserslistConfigFile: false,\n    plugins,\n  });\n\n  if (!transformResult || !transformResult.code) {\n    throw new Error(`Unknown error occurred processing bundle for \"${options.filename}\".`);\n  }\n\n  let outputMap;\n  if (map && transformResult.map) {\n    outputMap = remapping([transformResult.map as SourceMapInput, map], () => null);\n  }\n\n  return { code: transformResult.code, map: outputMap && JSON.stringify(outputMap), diagnostics };\n}\n"]}

package/src/tools/esbuild/i18n-inliner.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @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 { OutputFile } from 'esbuild';
+/**
+ * Inlining options that should apply to all transformed code.
+ */
+export interface I18nInlinerOptions {
+    missingTranslation: 'error' | 'warning' | 'ignore';
+    outputFiles: OutputFile[];
+    shouldOptimize?: boolean;
+}
+/**
+ * A class that performs i18n translation inlining of JavaScript code.
+ * A worker pool is used to distribute the transformation actions and allow
+ * parallel processing. Inlining is only performed on code that contains the
+ * localize function (`$localize`).
+ */
+export declare class I18nInliner {
+    #private;
+    constructor(options: I18nInlinerOptions, maxThreads?: number);
+    /**
+     * Performs inlining of translations for the provided locale and translations. The files that
+     * are processed originate from the files passed to the class constructor and filter by presence
+     * of the localize function keyword.
+     * @param locale The string representing the locale to inline.
+     * @param translation The translation messages to use when inlining.
+     * @returns A promise that resolves to an array of OutputFiles representing a translated result.
+     */
+    inlineForLocale(locale: string, translation: Record<string, unknown> | undefined): Promise<OutputFile[]>;
+    /**
+     * 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/i18n-inliner.js

@@ -0,0 +1,119 @@
+"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.I18nInliner = void 0;
+const piscina_1 = __importDefault(require("piscina"));
+const utils_1 = require("./utils");
+/**
+ * A keyword used to indicate if a JavaScript file may require inlining of translations.
+ * This keyword is used to avoid processing files that would not otherwise need i18n processing.
+ */
+const LOCALIZE_KEYWORD = '$localize';
+/**
+ * A class that performs i18n translation inlining of JavaScript code.
+ * A worker pool is used to distribute the transformation actions and allow
+ * parallel processing. Inlining is only performed on code that contains the
+ * localize function (`$localize`).
+ */
+class I18nInliner {
+    #workerPool;
+    #localizeFiles;
+    #unmodifiedFiles;
+    constructor(options, maxThreads) {
+        this.#unmodifiedFiles = [];
+        const files = new Map();
+        const pendingMaps = [];
+        for (const file of options.outputFiles) {
+            if (file.path.endsWith('.js')) {
+                // Check if localizations are present
+                const contentBuffer = Buffer.isBuffer(file.contents)
+                    ? file.contents
+                    : Buffer.from(file.contents.buffer, file.contents.byteOffset, file.contents.byteLength);
+                const hasLocalize = contentBuffer.includes(LOCALIZE_KEYWORD);
+                if (hasLocalize) {
+                    // A Blob is an immutable data structure that allows sharing the data between workers
+                    // without copying until the data is actually used within a Worker. This is useful here
+                    // since each file may not actually be processed in each Worker and the Blob avoids
+                    // unneeded repeat copying of potentially large JavaScript files.
+                    files.set(file.path, new Blob([file.contents]));
+                    continue;
+                }
+            }
+            else if (file.path.endsWith('.js.map')) {
+                // The related JS file may not have been checked yet. To ensure that map files are not
+                // missed, store any pending map files and check them after all output files.
+                pendingMaps.push(file);
+                continue;
+            }
+            this.#unmodifiedFiles.push(file);
+        }
+        // Check if any pending map files should be processed by checking if the parent JS file is present
+        for (const file of pendingMaps) {
+            if (files.has(file.path.slice(0, -4))) {
+                files.set(file.path, new Blob([file.contents]));
+            }
+            else {
+                this.#unmodifiedFiles.push(file);
+            }
+        }
+        this.#localizeFiles = files;
+        this.#workerPool = new piscina_1.default({
+            filename: require.resolve('./i18n-inliner-worker'),
+            maxThreads,
+            // Extract options to ensure only the named options are serialized and sent to the worker
+            workerData: {
+                missingTranslation: options.missingTranslation,
+                shouldOptimize: options.shouldOptimize,
+                files,
+            },
+        });
+    }
+    /**
+     * Performs inlining of translations for the provided locale and translations. The files that
+     * are processed originate from the files passed to the class constructor and filter by presence
+     * of the localize function keyword.
+     * @param locale The string representing the locale to inline.
+     * @param translation The translation messages to use when inlining.
+     * @returns A promise that resolves to an array of OutputFiles representing a translated result.
+     */
+    async inlineForLocale(locale, translation) {
+        // Request inlining for each file that contains localize calls
+        const requests = [];
+        for (const filename of this.#localizeFiles.keys()) {
+            if (filename.endsWith('.map')) {
+                continue;
+            }
+            const fileRequest = this.#workerPool.run({
+                filename,
+                locale,
+                translation,
+            });
+            requests.push(fileRequest);
+        }
+        // Wait for all file requests to complete
+        const rawResults = await Promise.all(requests);
+        // Convert raw results to output file objects and include all unmodified files
+        return [
+            ...rawResults.flat().map(({ file, contents }) => (0, utils_1.createOutputFileFromData)(file, contents)),
+            ...this.#unmodifiedFiles.map((file) => (0, utils_1.cloneOutputFile)(file)),
+        ];
+    }
+    /**
+     * Stops all active transformation tasks and shuts down all workers.
+     * @returns A void promise that resolves when closing is complete.
+     */
+    close() {
+        return this.#workerPool.destroy();
+    }
+}
+exports.I18nInliner = I18nInliner;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n-inliner.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/tools/esbuild/i18n-inliner.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;AAGH,sDAA8B;AAC9B,mCAAoE;AAEpE;;;GAGG;AACH,MAAM,gBAAgB,GAAG,WAAW,CAAC;AAWrC;;;;;GAKG;AACH,MAAa,WAAW;IACtB,WAAW,CAAU;IACZ,cAAc,CAA4B;IAC1C,gBAAgB,CAAoB;IAE7C,YAAY,OAA2B,EAAE,UAAmB;QAC1D,IAAI,CAAC,gBAAgB,GAAG,EAAE,CAAC;QAE3B,MAAM,KAAK,GAAG,IAAI,GAAG,EAAgB,CAAC;QACtC,MAAM,WAAW,GAAG,EAAE,CAAC;QACvB,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,WAAW,EAAE;YACtC,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;gBAC7B,qCAAqC;gBACrC,MAAM,aAAa,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC;oBAClD,CAAC,CAAC,IAAI,CAAC,QAAQ;oBACf,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;gBAC1F,MAAM,WAAW,GAAG,aAAa,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC;gBAE7D,IAAI,WAAW,EAAE;oBACf,qFAAqF;oBACrF,uFAAuF;oBACvF,mFAAmF;oBACnF,iEAAiE;oBACjE,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;oBAEhD,SAAS;iBACV;aACF;iBAAM,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE;gBACxC,sFAAsF;gBACtF,6EAA6E;gBAC7E,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACvB,SAAS;aACV;YAED,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAClC;QAED,kGAAkG;QAClG,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE;YAC9B,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE;gBACrC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;aACjD;iBAAM;gBACL,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAClC;SACF;QAED,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAE5B,IAAI,CAAC,WAAW,GAAG,IAAI,iBAAO,CAAC;YAC7B,QAAQ,EAAE,OAAO,CAAC,OAAO,CAAC,uBAAuB,CAAC;YAClD,UAAU;YACV,yFAAyF;YACzF,UAAU,EAAE;gBACV,kBAAkB,EAAE,OAAO,CAAC,kBAAkB;gBAC9C,cAAc,EAAE,OAAO,CAAC,cAAc;gBACtC,KAAK;aACN;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,eAAe,CACnB,MAAc,EACd,WAAgD;QAEhD,8DAA8D;QAC9D,MAAM,QAAQ,GAAG,EAAE,CAAC;QACpB,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,EAAE;YACjD,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;gBAC7B,SAAS;aACV;YAED,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC;gBACvC,QAAQ;gBACR,MAAM;gBACN,WAAW;aACZ,CAAC,CAAC;YACH,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;SAC5B;QAED,yCAAyC;QACzC,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAE/C,8EAA8E;QAC9E,OAAO;YACL,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,IAAA,gCAAwB,EAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YAC1F,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAA,uBAAe,EAAC,IAAI,CAAC,CAAC;SAC9D,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,KAAK;QACH,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;IACpC,CAAC;CACF;AAxGD,kCAwGC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport type { OutputFile } from 'esbuild';\nimport Piscina from 'piscina';\nimport { cloneOutputFile, createOutputFileFromData } from './utils';\n\n/**\n * A keyword used to indicate if a JavaScript file may require inlining of translations.\n * This keyword is used to avoid processing files that would not otherwise need i18n processing.\n */\nconst LOCALIZE_KEYWORD = '$localize';\n\n/**\n * Inlining options that should apply to all transformed code.\n */\nexport interface I18nInlinerOptions {\n  missingTranslation: 'error' | 'warning' | 'ignore';\n  outputFiles: OutputFile[];\n  shouldOptimize?: boolean;\n}\n\n/**\n * A class that performs i18n translation inlining of JavaScript code.\n * A worker pool is used to distribute the transformation actions and allow\n * parallel processing. Inlining is only performed on code that contains the\n * localize function (`$localize`).\n */\nexport class I18nInliner {\n  #workerPool: Piscina;\n  readonly #localizeFiles: ReadonlyMap<string, Blob>;\n  readonly #unmodifiedFiles: Array<OutputFile>;\n\n  constructor(options: I18nInlinerOptions, maxThreads?: number) {\n    this.#unmodifiedFiles = [];\n\n    const files = new Map<string, Blob>();\n    const pendingMaps = [];\n    for (const file of options.outputFiles) {\n      if (file.path.endsWith('.js')) {\n        // Check if localizations are present\n        const contentBuffer = Buffer.isBuffer(file.contents)\n          ? file.contents\n          : Buffer.from(file.contents.buffer, file.contents.byteOffset, file.contents.byteLength);\n        const hasLocalize = contentBuffer.includes(LOCALIZE_KEYWORD);\n\n        if (hasLocalize) {\n          // A Blob is an immutable data structure that allows sharing the data between workers\n          // without copying until the data is actually used within a Worker. This is useful here\n          // since each file may not actually be processed in each Worker and the Blob avoids\n          // unneeded repeat copying of potentially large JavaScript files.\n          files.set(file.path, new Blob([file.contents]));\n\n          continue;\n        }\n      } else if (file.path.endsWith('.js.map')) {\n        // The related JS file may not have been checked yet. To ensure that map files are not\n        // missed, store any pending map files and check them after all output files.\n        pendingMaps.push(file);\n        continue;\n      }\n\n      this.#unmodifiedFiles.push(file);\n    }\n\n    // Check if any pending map files should be processed by checking if the parent JS file is present\n    for (const file of pendingMaps) {\n      if (files.has(file.path.slice(0, -4))) {\n        files.set(file.path, new Blob([file.contents]));\n      } else {\n        this.#unmodifiedFiles.push(file);\n      }\n    }\n\n    this.#localizeFiles = files;\n\n    this.#workerPool = new Piscina({\n      filename: require.resolve('./i18n-inliner-worker'),\n      maxThreads,\n      // Extract options to ensure only the named options are serialized and sent to the worker\n      workerData: {\n        missingTranslation: options.missingTranslation,\n        shouldOptimize: options.shouldOptimize,\n        files,\n      },\n    });\n  }\n\n  /**\n   * Performs inlining of translations for the provided locale and translations. The files that\n   * are processed originate from the files passed to the class constructor and filter by presence\n   * of the localize function keyword.\n   * @param locale The string representing the locale to inline.\n   * @param translation The translation messages to use when inlining.\n   * @returns A promise that resolves to an array of OutputFiles representing a translated result.\n   */\n  async inlineForLocale(\n    locale: string,\n    translation: Record<string, unknown> | undefined,\n  ): Promise<OutputFile[]> {\n    // Request inlining for each file that contains localize calls\n    const requests = [];\n    for (const filename of this.#localizeFiles.keys()) {\n      if (filename.endsWith('.map')) {\n        continue;\n      }\n\n      const fileRequest = this.#workerPool.run({\n        filename,\n        locale,\n        translation,\n      });\n      requests.push(fileRequest);\n    }\n\n    // Wait for all file requests to complete\n    const rawResults = await Promise.all(requests);\n\n    // Convert raw results to output file objects and include all unmodified files\n    return [\n      ...rawResults.flat().map(({ file, contents }) => createOutputFileFromData(file, contents)),\n      ...this.#unmodifiedFiles.map((file) => cloneOutputFile(file)),\n    ];\n  }\n\n  /**\n   * Stops all active transformation tasks and shuts down all workers.\n   * @returns A void promise that resolves when closing is complete.\n   */\n  close(): Promise<void> {\n    return this.#workerPool.destroy();\n  }\n}\n"]}

package/src/tools/esbuild/i18n-locale-plugin.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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';
+/**
+ * The base module location used to search for locale specific data.
+ */
+export declare const LOCALE_DATA_BASE_MODULE = "@angular/common/locales/global";
+/**
+ * Creates an esbuild plugin that resolves Angular locale data files from `@angular/common`.
+ *
+ * @returns An esbuild plugin.
+ */
+export declare function createAngularLocaleDataPlugin(): Plugin;

package/src/tools/esbuild/i18n-locale-plugin.js

@@ -0,0 +1,91 @@
+"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.createAngularLocaleDataPlugin = exports.LOCALE_DATA_BASE_MODULE = void 0;
+/**
+ * The base module location used to search for locale specific data.
+ */
+exports.LOCALE_DATA_BASE_MODULE = '@angular/common/locales/global';
+/**
+ * Creates an esbuild plugin that resolves Angular locale data files from `@angular/common`.
+ *
+ * @returns An esbuild plugin.
+ */
+function createAngularLocaleDataPlugin() {
+    return {
+        name: 'angular-locale-data',
+        setup(build) {
+            // If packages are configured to be external then leave the original angular locale import path.
+            // This happens when using the development server with caching enabled to allow Vite prebundling to work.
+            // There currently is no option on the esbuild resolve function to resolve while disabling the option. To
+            // workaround the inability to resolve the full locale location here, the Vite dev server prebundling also
+            // contains a plugin to allow the locales to be correctly resolved when prebundling.
+            // NOTE: If esbuild eventually allows controlling the external package options in a build.resolve call, this
+            //       workaround can be removed.
+            if (build.initialOptions.packages === 'external') {
+                return;
+            }
+            build.onResolve({ filter: /^angular:locale\/data:/ }, async ({ path }) => {
+                // Extract the locale from the path
+                const originalLocale = path.split(':', 3)[2];
+                // Remove any private subtags since these will never match
+                let partialLocale = originalLocale.replace(/-x(-[a-zA-Z0-9]{1,8})+$/, '');
+                let exact = true;
+                while (partialLocale) {
+                    const potentialPath = `${exports.LOCALE_DATA_BASE_MODULE}/${partialLocale}`;
+                    const result = await build.resolve(potentialPath, {
+                        kind: 'import-statement',
+                        resolveDir: build.initialOptions.absWorkingDir,
+                    });
+                    if (result.path) {
+                        if (exact) {
+                            return result;
+                        }
+                        else {
+                            return {
+                                ...result,
+                                warnings: [
+                                    ...result.warnings,
+                                    {
+                                        location: null,
+                                        text: `Locale data for '${originalLocale}' cannot be found. Using locale data for '${partialLocale}'.`,
+                                    },
+                                ],
+                            };
+                        }
+                    }
+                    // Remove the last subtag and try again with a less specific locale
+                    const parts = partialLocale.split('-');
+                    partialLocale = parts.slice(0, -1).join('-');
+                    exact = false;
+                    // The locales "en" and "en-US" are considered exact to retain existing behavior
+                    if (originalLocale === 'en-US' && partialLocale === 'en') {
+                        exact = true;
+                    }
+                }
+                // Not found so issue a warning and use an empty loader. Framework built-in `en-US` data will be used.
+                // This retains existing behavior as in the Webpack-based builder.
+                return {
+                    path: originalLocale,
+                    namespace: 'angular:locale/data',
+                    warnings: [
+                        {
+                            location: null,
+                            text: `Locale data for '${originalLocale}' cannot be found. No locale data will be included for this locale.`,
+                        },
+                    ],
+                };
+            });
+            // Locales that cannot be found will be loaded as empty content with a warning from the resolve step
+            build.onLoad({ filter: /./, namespace: 'angular:locale/data' }, () => ({ loader: 'empty' }));
+        },
+    };
+}
+exports.createAngularLocaleDataPlugin = createAngularLocaleDataPlugin;
+//# sourceMappingURL=data:application/json;base64,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

package/src/tools/esbuild/index-html-generator.d.ts

@@ -5,10 +5,10 @@
  * 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 { OutputFile } from 'esbuild';
 import { NormalizedApplicationBuildOptions } from '../../builders/application/options';
 import { InitialFileRecord } from './bundler-context';
-import type { ExecutionResult } from './bundler-execution-result';
-export declare function generateIndexHtml(initialFiles: Map<string, InitialFileRecord>, executionResult: ExecutionResult, buildOptions: NormalizedApplicationBuildOptions): Promise<{
+export declare function generateIndexHtml(initialFiles: Map<string, InitialFileRecord>, outputFiles: OutputFile[], buildOptions: NormalizedApplicationBuildOptions, lang?: string): Promise<{
     content: string;
     contentWithoutCriticalCssInlined: string;
     warnings: string[];

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

@@ -15,7 +15,7 @@ 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 inline_critical_css_1 = require("../../utils/index-file/inline-critical-css");
-async function generateIndexHtml(initialFiles, executionResult, buildOptions) {
+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.
@@ -43,7 +43,7 @@ async function generateIndexHtml(initialFiles, executionResult, buildOptions) {
     const readAsset = async function (filePath) {
         // Remove leading directory separator
         const relativefilePath = node_path_1.default.relative(virtualOutputPath, filePath);
-        const file = executionResult.outputFiles.find((file) => file.path === relativefilePath);
+        const file = outputFiles.find((file) => file.path === relativefilePath);
         if (file) {
             return file.text;
         }
@@ -66,7 +66,7 @@ async function generateIndexHtml(initialFiles, executionResult, buildOptions) {
     indexHtmlGenerator.readAsset = readAsset;
     const transformResult = await indexHtmlGenerator.process({
         baseHref,
-        lang: undefined,
+        lang,
         outputPath: virtualOutputPath,
         files: [...initialFiles].map(([file, record]) => ({
             name: record.name ?? '',
@@ -97,4 +97,4 @@ async function generateIndexHtml(initialFiles, executionResult, buildOptions) {
     };
 }
 exports.generateIndexHtml = generateIndexHtml;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index-html-generator.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/tools/esbuild/index-html-generator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport assert from 'node:assert';\nimport path from 'node:path';\nimport { NormalizedApplicationBuildOptions } from '../../builders/application/options';\nimport { IndexHtmlGenerator } from '../../utils/index-file/index-html-generator';\nimport { InlineCriticalCssProcessor } from '../../utils/index-file/inline-critical-css';\nimport { InitialFileRecord } from './bundler-context';\nimport type { ExecutionResult } from './bundler-execution-result';\n\nexport async function generateIndexHtml(\n  initialFiles: Map<string, InitialFileRecord>,\n  executionResult: ExecutionResult,\n  buildOptions: NormalizedApplicationBuildOptions,\n): Promise<{\n  content: string;\n  contentWithoutCriticalCssInlined: string;\n  warnings: string[];\n  errors: string[];\n}> {\n  // Analyze metafile for initial link-based hints.\n  // Skip if the internal externalPackages option is enabled since this option requires\n  // dev server cooperation to properly resolve and fetch imports.\n  const hints = [];\n  const {\n    indexHtmlOptions,\n    externalPackages,\n    optimizationOptions,\n    crossOrigin,\n    subresourceIntegrity,\n    baseHref,\n  } = buildOptions;\n\n  assert(indexHtmlOptions, 'indexHtmlOptions cannot be undefined.');\n\n  if (!externalPackages) {\n    for (const [key, value] of initialFiles) {\n      if (value.entrypoint) {\n        // Entry points are already referenced in the HTML\n        continue;\n      }\n      if (value.type === 'script') {\n        hints.push({ url: key, mode: 'modulepreload' as const });\n      } else if (value.type === 'style') {\n        // Provide an \"as\" value of \"style\" to ensure external URLs which may not have a\n        // file extension are treated as stylesheets.\n        hints.push({ url: key, mode: 'preload' as const, as: 'style' });\n      }\n    }\n  }\n\n  /** Virtual output path to support reading in-memory files. */\n  const virtualOutputPath = '/';\n  const readAsset = async function (filePath: string): Promise<string> {\n    // Remove leading directory separator\n    const relativefilePath = path.relative(virtualOutputPath, filePath);\n    const file = executionResult.outputFiles.find((file) => file.path === relativefilePath);\n    if (file) {\n      return file.text;\n    }\n\n    throw new Error(`Output file does not exist: ${relativefilePath}`);\n  };\n\n  // Create an index HTML generator that reads from the in-memory output files\n  const indexHtmlGenerator = new IndexHtmlGenerator({\n    indexPath: indexHtmlOptions.input,\n    entrypoints: indexHtmlOptions.insertionOrder,\n    sri: subresourceIntegrity,\n    optimization: {\n      ...optimizationOptions,\n      styles: {\n        ...optimizationOptions.styles,\n        inlineCritical: false, // Disable critical css inline as for SSR and SSG this will be done during rendering.\n      },\n    },\n    crossOrigin: crossOrigin,\n  });\n\n  indexHtmlGenerator.readAsset = readAsset;\n\n  const transformResult = await indexHtmlGenerator.process({\n    baseHref,\n    lang: undefined,\n    outputPath: virtualOutputPath,\n    files: [...initialFiles].map(([file, record]) => ({\n      name: record.name ?? '',\n      file,\n      extension: path.extname(file),\n    })),\n    hints,\n  });\n\n  const contentWithoutCriticalCssInlined = transformResult.content;\n  if (!optimizationOptions.styles.inlineCritical) {\n    return {\n      ...transformResult,\n      contentWithoutCriticalCssInlined,\n    };\n  }\n\n  const inlineCriticalCssProcessor = new InlineCriticalCssProcessor({\n    minify: false, // CSS has already been minified during the build.\n    readAsset,\n  });\n\n  const { content, errors, warnings } = await inlineCriticalCssProcessor.process(\n    contentWithoutCriticalCssInlined,\n    {\n      outputPath: virtualOutputPath,\n    },\n  );\n\n  return {\n    errors: [...transformResult.errors, ...errors],\n    warnings: [...transformResult.warnings, ...warnings],\n    content,\n    contentWithoutCriticalCssInlined,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index-html-generator.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/tools/esbuild/index-html-generator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport type { OutputFile } from 'esbuild';\nimport assert from 'node:assert';\nimport path from 'node:path';\nimport { NormalizedApplicationBuildOptions } from '../../builders/application/options';\nimport { IndexHtmlGenerator } from '../../utils/index-file/index-html-generator';\nimport { InlineCriticalCssProcessor } from '../../utils/index-file/inline-critical-css';\nimport { InitialFileRecord } from './bundler-context';\n\nexport async function generateIndexHtml(\n  initialFiles: Map<string, InitialFileRecord>,\n  outputFiles: OutputFile[],\n  buildOptions: NormalizedApplicationBuildOptions,\n  lang?: string,\n): Promise<{\n  content: string;\n  contentWithoutCriticalCssInlined: string;\n  warnings: string[];\n  errors: string[];\n}> {\n  // Analyze metafile for initial link-based hints.\n  // Skip if the internal externalPackages option is enabled since this option requires\n  // dev server cooperation to properly resolve and fetch imports.\n  const hints = [];\n  const {\n    indexHtmlOptions,\n    externalPackages,\n    optimizationOptions,\n    crossOrigin,\n    subresourceIntegrity,\n    baseHref,\n  } = buildOptions;\n\n  assert(indexHtmlOptions, 'indexHtmlOptions cannot be undefined.');\n\n  if (!externalPackages) {\n    for (const [key, value] of initialFiles) {\n      if (value.entrypoint) {\n        // Entry points are already referenced in the HTML\n        continue;\n      }\n      if (value.type === 'script') {\n        hints.push({ url: key, mode: 'modulepreload' as const });\n      } else if (value.type === 'style') {\n        // Provide an \"as\" value of \"style\" to ensure external URLs which may not have a\n        // file extension are treated as stylesheets.\n        hints.push({ url: key, mode: 'preload' as const, as: 'style' });\n      }\n    }\n  }\n\n  /** Virtual output path to support reading in-memory files. */\n  const virtualOutputPath = '/';\n  const readAsset = async function (filePath: string): Promise<string> {\n    // Remove leading directory separator\n    const relativefilePath = path.relative(virtualOutputPath, filePath);\n    const file = outputFiles.find((file) => file.path === relativefilePath);\n    if (file) {\n      return file.text;\n    }\n\n    throw new Error(`Output file does not exist: ${relativefilePath}`);\n  };\n\n  // Create an index HTML generator that reads from the in-memory output files\n  const indexHtmlGenerator = new IndexHtmlGenerator({\n    indexPath: indexHtmlOptions.input,\n    entrypoints: indexHtmlOptions.insertionOrder,\n    sri: subresourceIntegrity,\n    optimization: {\n      ...optimizationOptions,\n      styles: {\n        ...optimizationOptions.styles,\n        inlineCritical: false, // Disable critical css inline as for SSR and SSG this will be done during rendering.\n      },\n    },\n    crossOrigin: crossOrigin,\n  });\n\n  indexHtmlGenerator.readAsset = readAsset;\n\n  const transformResult = await indexHtmlGenerator.process({\n    baseHref,\n    lang,\n    outputPath: virtualOutputPath,\n    files: [...initialFiles].map(([file, record]) => ({\n      name: record.name ?? '',\n      file,\n      extension: path.extname(file),\n    })),\n    hints,\n  });\n\n  const contentWithoutCriticalCssInlined = transformResult.content;\n  if (!optimizationOptions.styles.inlineCritical) {\n    return {\n      ...transformResult,\n      contentWithoutCriticalCssInlined,\n    };\n  }\n\n  const inlineCriticalCssProcessor = new InlineCriticalCssProcessor({\n    minify: false, // CSS has already been minified during the build.\n    readAsset,\n  });\n\n  const { content, errors, warnings } = await inlineCriticalCssProcessor.process(\n    contentWithoutCriticalCssInlined,\n    {\n      outputPath: virtualOutputPath,\n    },\n  );\n\n  return {\n    errors: [...transformResult.errors, ...errors],\n    warnings: [...transformResult.warnings, ...warnings],\n    content,\n    contentWithoutCriticalCssInlined,\n  };\n}\n"]}

package/src/tools/esbuild/rxjs-esm-resolution-plugin.js

@@ -35,11 +35,11 @@ function createRxjsEsmResolutionPlugin() {
                     pluginData,
                     resolveDir,
                 });
-                result.path = result.path.replace('/dist/cjs/', '/dist/esm/');
+                result.path = result.path.replace(/([\\/]dist[\\/])cjs([\\/])/, '$1esm$2');
                 return result;
             });
         },
     };
 }
 exports.createRxjsEsmResolutionPlugin = createRxjsEsmResolutionPlugin;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/src/tools/esbuild/sourcemap-ignorelist-plugin.d.ts

@@ -14,4 +14,4 @@ import type { Plugin } from 'esbuild';
  * For more information, see https://developer.chrome.com/articles/x-google-ignore-list/
  * @returns An esbuild plugin.
  */
-export declare function createSourcemapIngorelistPlugin(): Plugin;
+export declare function createSourcemapIgnorelistPlugin(): Plugin;