angular
diff --git a/‎packages/angular/build/src/tools/esbuild/i18n-inliner-worker.ts‎
Lines changed: 158 additions & 50 deletions b/‎packages/angular/build/src/tools/esbuild/i18n-inliner-worker.ts‎
Lines changed: 158 additions & 50 deletions
@@ -17,10 +17,10 @@ import { parseSync, visitorKeys } from 'oxc-parser';
 /**
  * The options passed to the inliner for each file request
  */
-interface InlineFileRequest {
+export interface InlineFileRequest {
   /**
    * The filename that should be processed. The data for the file is provided to the Worker
-   * during Worker initialization.
+   * during Worker initialization or per request.
    */
   filename: string;
 
@@ -35,12 +35,24 @@ interface InlineFileRequest {
    * reference instead of being copied into it for every request.
    */
   translation?: Blob;
+
+  /**
+   * Optional cache key uniquely identifying the translation messages for the locale.
+   */
+  translationKey?: string;
+
+  missingTranslation?: 'error' | 'warning' | 'ignore';
+  shouldOptimize?: boolean;
+  fileBlob?: Blob;
+  fileKey?: string;
+  mapBlob?: Blob;
+  files?: ReadonlyMap<string, Blob>;
 }
 
 /**
  * The options passed to the inliner for each code request
  */
-interface InlineCodeRequest {
+export interface InlineCodeRequest {
   /**
    * The code that should be processed.
    */
@@ -62,12 +74,37 @@ interface InlineCodeRequest {
    * reference instead of being copied into it for every request.
    */
   translation?: Blob;
+
+  /**
+   * Optional cache key uniquely identifying the translation messages for the locale.
+   */
+  translationKey?: string;
+
+  missingTranslation?: 'error' | 'warning' | 'ignore';
+  shouldOptimize?: boolean;
+}
+
+export interface InlineDiagnosticMessage {
+  type: 'error' | 'warning';
+  message: string;
+}
+
+export interface InlineFileResult {
+  file: string;
+  code: string;
+  map?: string;
+  messages: InlineDiagnosticMessage[];
+}
+
+export interface InlineCodeResult {
+  output: string;
+  messages: InlineDiagnosticMessage[];
 }
 
 // Extract the application files and common options used for inline requests from the Worker context
-const { files, missingTranslation } = (workerData || {}) as {
-  files: ReadonlyMap<string, Blob>;
-  missingTranslation: 'error' | 'warning' | 'ignore';
+const { files, missingTranslation = 'ignore' } = (workerData || {}) as {
+  files?: ReadonlyMap<string, Blob>;
+  missingTranslation?: 'error' | 'warning' | 'ignore';
 };
 
 /**
@@ -79,34 +116,67 @@ interface CachedFileData {
 }
 
 /**
- * Cache of file data promises keyed by filename.
+ * Maximum number of file AST and localization metadata entries cached in memory per worker isolate.
+ * Bounded size prevents unbounded memory growth across watch rebuilds.
+ */
+const MAX_CACHED_FILES = 256;
+
+/**
+ * Maximum number of deserialized translation message tables cached in memory per worker isolate.
+ */
+const MAX_CACHED_TRANSLATIONS = 32;
+
+/**
+ * Cache of file data promises keyed by cache key (filename or file hash identifier).
  */
 const fileDataCache = new Map<string, Promise<CachedFileData>>();
 
 /**
- * Cache of deserialized translation messages keyed by locale.
+ * Cache of deserialized translation messages keyed by locale or translation cache key.
  */
 const deserializedTranslations = new Map<string, Promise<Record<string, unknown>>>();
 
 /**
  * Retrieves the cached file data for a filename, loading and extracting it on the first request.
  *
  * @param filename The name of the file to load.
+ * @param fileBlob Optional Blob containing the file data.
+ * @param fileKey Optional cache key uniquely identifying the file content.
  * @returns The cached code and localization metadata.
  */
-function getFileData(filename: string): Promise<CachedFileData> {
-  let fileDataPromise = fileDataCache.get(filename);
+async function getFileData(
+  filename: string,
+  fileBlob?: Blob,
+  fileKey?: string,
+): Promise<CachedFileData> {
+  const cacheKey = fileKey ?? filename;
+  let fileDataPromise = fileDataCache.get(cacheKey);
   if (!fileDataPromise) {
-    fileDataPromise = (async () => {
-      const data = files.get(filename);
-      assert(data !== undefined, `Invalid inline request for file '${filename}'.`);
+    const data = fileBlob ?? files?.get(filename);
+    assert(data !== undefined, `Invalid inline request for file '${filename}'.`);
+
+    fileDataPromise = data
+      .text()
+      .then((code) => {
+        const metadata = extractLocalizeMetadata(filename, code);
+
+        return { code, metadata };
+      })
+      .catch((error) => {
+        if (fileDataCache.get(cacheKey) === fileDataPromise) {
+          fileDataCache.delete(cacheKey);
+        }
+        throw error;
+      });
 
-      const code = await data.text();
-      const metadata = extractLocalizeMetadata(filename, code);
+    if (fileDataCache.size >= MAX_CACHED_FILES) {
+      const oldestKey = fileDataCache.keys().next().value;
+      if (oldestKey !== undefined) {
+        fileDataCache.delete(oldestKey);
+      }
+    }
 
-      return { code, metadata };
-    })();
-    fileDataCache.set(filename, fileDataPromise);
+    fileDataCache.set(cacheKey, fileDataPromise);
   }
 
   return fileDataPromise;
@@ -121,17 +191,32 @@ function getFileData(filename: string): Promise<CachedFileData> {
 function loadTranslation(
   request: InlineFileRequest | InlineCodeRequest,
 ): Promise<Record<string, unknown>> | undefined {
-  const { locale, translation } = request;
+  const { translation, locale, translationKey } = request;
   if (!translation) {
     return undefined;
   }
 
-  let messagesPromise = deserializedTranslations.get(locale);
+  const cacheKey = translationKey ? `${locale}\0${translationKey}` : locale;
+  let messagesPromise = deserializedTranslations.get(cacheKey);
   if (!messagesPromise) {
     messagesPromise = translation
       .arrayBuffer()
-      .then((buffer) => deserialize(new Uint8Array(buffer)) as Record<string, unknown>);
-    deserializedTranslations.set(locale, messagesPromise);
+      .then((buffer) => deserialize(new Uint8Array(buffer)) as Record<string, unknown>)
+      .catch((error) => {
+        if (deserializedTranslations.get(cacheKey) === messagesPromise) {
+          deserializedTranslations.delete(cacheKey);
+        }
+        throw error;
+      });
+
+    if (deserializedTranslations.size >= MAX_CACHED_TRANSLATIONS) {
+      const oldestKey = deserializedTranslations.keys().next().value;
+      if (oldestKey !== undefined) {
+        deserializedTranslations.delete(oldestKey);
+      }
+    }
+
+    deserializedTranslations.set(cacheKey, messagesPromise);
   }
 
   return messagesPromise;
@@ -144,14 +229,16 @@ function loadTranslation(
  * @param request An InlineRequest object representing the options for inlining
  * @returns An object containing the inlined file and optional map content.
  */
-export default async function inlineFile(request: InlineFileRequest) {
-  const { code, metadata } = await getFileData(request.filename);
+export default async function inlineFile(request: InlineFileRequest): Promise<InlineFileResult> {
+  const { code, metadata } = await getFileData(request.filename, request.fileBlob, request.fileKey);
 
   // Sourcemaps are parsed on demand per request rather than cached long-term to prevent
   // monotonic memory growth as a worker processes multiple files across the build.
   // When multi-locale batching is implemented, the sourcemap can be parsed once per batch and released
   // upon batch completion.
-  const rawMap = await files.get(request.filename + '.map')?.text();
+  const rawMap = request.mapBlob
+    ? await request.mapBlob.text()
+    : await files?.get(request.filename + '.map')?.text();
   const map = rawMap ? (JSON.parse(rawMap) as SourceMapInput) : undefined;
 
   const result = await inlineLocalize(
@@ -161,6 +248,7 @@ export default async function inlineFile(request: InlineFileRequest) {
     request.locale,
     await loadTranslation(request),
     request.filename,
+    request.missingTranslation ?? missingTranslation,
   );
 
   return {
@@ -178,7 +266,7 @@ export default async function inlineFile(request: InlineFileRequest) {
  * @param request An InlineRequest object representing the options for inlining
  * @returns An object containing the inlined code.
  */
-export async function inlineCode(request: InlineCodeRequest) {
+export async function inlineCode(request: InlineCodeRequest): Promise<InlineCodeResult> {
   const metadata = extractLocalizeMetadata(request.filename, request.code);
   const result = await inlineLocalize(
     request.code,
@@ -187,6 +275,7 @@ export async function inlineCode(request: InlineCodeRequest) {
     request.locale,
     await loadTranslation(request),
     request.filename,
+    request.missingTranslation ?? missingTranslation,
   );
 
   return {
@@ -352,6 +441,41 @@ function extractLocalizeMetadata(filename: string, code: string): FileLocalizeMe
   return { callSites, localeInsertSites, diagnostics };
 }
 
+/**
+ * Formats translated template parts and expressions into a JavaScript string
+ * or template literal replacement.
+ */
+function formatReplacement(
+  translatedParts: readonly string[],
+  translatedSubstitutions: readonly number[],
+  expressions: readonly { start: number; end: number }[],
+  magicString: MagicString,
+): string {
+  if (translatedSubstitutions.length === 0) {
+    return JSON.stringify(translatedParts[0]);
+  }
+
+  let replacement = '`';
+  for (let i = 0; i < translatedParts.length; i++) {
+    const escapedPart = JSON.stringify(translatedParts[i])
+      .slice(1, -1)
+      .replace(/\\"/g, '"')
+      .replace(/`/g, '\\`')
+      .replace(/\$\{/g, '\\${');
+    replacement += escapedPart;
+
+    if (i < translatedSubstitutions.length) {
+      const originalIndex = translatedSubstitutions[i];
+      const expr = expressions[originalIndex];
+      const exprCode = magicString.slice(expr.start, expr.end);
+      replacement += '${' + exprCode + '}';
+    }
+  }
+  replacement += '`';
+
+  return replacement;
+}
+
 /**
  * Inlines translations into code using previously extracted localization metadata.
  *
@@ -370,6 +494,7 @@ async function inlineLocalize(
   locale: string,
   translation: Record<string, unknown> | undefined,
   filename: string,
+  missingTranslationOption: 'error' | 'warning' | 'ignore' = missingTranslation ?? 'ignore',
 ) {
   const magicString = new MagicString(code);
   const { Diagnostics, translate } = await loadLocalizeTools();
@@ -391,32 +516,15 @@ async function inlineLocalize(
       translation || {},
       callSite.messageParts,
       callSite.expressions.map((_, index) => index),
-      translation === undefined ? 'ignore' : missingTranslation,
+      translation === undefined ? 'ignore' : missingTranslationOption,
     );
 
-    // Reconstruct the new template/string literal replacement
-    let replacement: string;
-    if (translatedSubstitutions.length === 0) {
-      replacement = JSON.stringify(translatedParts[0]);
-    } else {
-      replacement = '`';
-      for (let i = 0; i < translatedParts.length; i++) {
-        const escapedPart = JSON.stringify(translatedParts[i])
-          .slice(1, -1)
-          .replace(/\\"/g, '"')
-          .replace(/`/g, '\\`')
-          .replace(/\$\{/g, '\\${');
-        replacement += escapedPart;
-
-        if (i < translatedSubstitutions.length) {
-          const originalIndex = translatedSubstitutions[i];
-          const expr = callSite.expressions[originalIndex];
-          const exprCode = magicString.slice(expr.start, expr.end);
-          replacement += '${' + exprCode + '}';
-        }
-      }
-      replacement += '`';
-    }
+    const replacement = formatReplacement(
+      translatedParts,
+      translatedSubstitutions,
+      callSite.expressions,
+      magicString,
+    );
 
     magicString.overwrite(callSite.start, callSite.end, replacement);
   }