refactor(@angular/build): pass code and sourcemap Blobs on demand per batch request in i18n inliner

Streamline WorkerPool initialization by removing global files Map from workerData.
Instead of storing all file Blobs in workerData for the worker pool lifetime,
pass code and sourcemap Blobs on demand per inlineFileBatch request.

On the worker thread, loadFileData consumes the passed code Blob on initial cache misses
and continues to cache pre-parsed OXC AST metadata in worker thread memory, preserving
100% of worker AST parsing speed while improving V8 Young Generation garbage collection.

Author: clydin

packages/angular/build/src/tools/esbuild/i18n-inliner-worker.ts

@@ -49,11 +49,20 @@ interface InlineCodeRequest {
  */
 interface InlineFileBatchRequest {
   /**
-   * The filename that should be processed. The data for the file is provided to the Worker
-   * during Worker initialization.
+   * The filename that should be processed.
    */
   filename: string;
 
+  /**
+   * The file content as a Blob.
+   */
+  code: Blob;
+
+  /**
+   * Optional sourcemap content as a Blob.
+   */
+  map?: Blob;
+
   /**
    * The locale specifiers and optional translations to use during the inlining process of the file.
    */
@@ -97,9 +106,8 @@ type InlineFileBatchResult =
       results: InlineLocaleResult[];
     };
 
-// Extract the application files and common options used for inline requests from the Worker context
-const { files, missingTranslation } = (workerData || {}) as {
-  files: ReadonlyMap<string, Blob>;
+// Extract common options used for inline requests from the Worker context
+const { missingTranslation } = (workerData || {}) as {
   missingTranslation: 'error' | 'warning' | 'ignore';
 };
 
@@ -128,20 +136,18 @@ const deserializedTranslations = new Map<string, Promise<Record<string, ɵParsed
  * to be garbage-collected once the batch request finishes.
  *
  * @param filename The name of the file to load.
+ * @param codeBlob The source code file as a Blob.
  * @param cache Whether to cache the loaded file data in the Worker's long-term cache.
  * @returns The cached or newly extracted code and localization metadata.
  */
-function loadFileData(filename: string, cache = true): Promise<CachedFileData> {
+function loadFileData(filename: string, codeBlob: Blob, cache = true): Promise<CachedFileData> {
   const existing = fileDataCache.get(filename);
   if (existing) {
     return existing;
   }
 
   const fileDataPromise = (async () => {
-    const data = files.get(filename);
-    assert(data !== undefined, `Invalid inline request for file '${filename}'.`);
-
-    const code = await data.text();
+    const code = await codeBlob.text();
     const metadata = extractLocalizeMetadata(filename, code);
 
     return { code, metadata };
@@ -209,7 +215,7 @@ export async function inlineFileBatch(
     }
   }
 
-  const { code, metadata } = await loadFileData(request.filename, !request.ephemeral);
+  const { code, metadata } = await loadFileData(request.filename, request.code, !request.ephemeral);
 
   // Fast path: file has no $localize call sites or locale insert sites
   if (metadata.callSites.length === 0 && metadata.localeInsertSites.length === 0) {
@@ -223,10 +229,13 @@ export async function inlineFileBatch(
     };
   }
 
-  // Parse the sourcemap once for the entire batch.
+  // Parse the sourcemap once for the entire batch if provided.
   // It will naturally be garbage-collected after this batch action returns.
-  const rawMap = await files.get(request.filename + '.map')?.text();
-  const map = rawMap ? (JSON.parse(rawMap) as SourceMapInput) : undefined;
+  let map: SourceMapInput | undefined;
+  if (request.map) {
+    const rawMap = await request.map.text();
+    map = rawMap ? (JSON.parse(rawMap) as SourceMapInput) : undefined;
+  }
 
   const results = await Promise.all(
     Array.from(request.locales, async ([locale, translation]) => {

packages/angular/build/src/tools/esbuild/i18n-inliner.ts

@@ -236,13 +236,6 @@ export class I18nInliner {
       // Extract options to ensure only the named options are serialized and sent to the worker
       workerData: {
         missingTranslation,
-        // 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: new Map<string, Blob>(
-          Array.from(files, ([name, file]) => [name, new Blob([file.contents])]),
-        ),
       },
     });
   }
@@ -463,13 +456,19 @@ export class I18nInliner {
     const workerTasks: Promise<void>[] = [];
 
     for (const [filename, entries] of uncachedByFile) {
+      const codeFile = this.#localizeFiles.get(filename);
+      assert(codeFile !== undefined, 'Localize file must exist: ' + filename);
+      const mapFile = this.#localizeFiles.get(filename + '.map');
+
       const ephemeral = isLastWindow && entries.length <= localesPerBatch;
       for (let i = 0; i < entries.length; i += localesPerBatch) {
         const batchEntries = entries.slice(i, i + localesPerBatch);
         const task = (async () => {
           const batchResult = (await this.#workerPool.run(
             {
               filename,
+              code: new Blob([codeFile.contents]),
+              map: mapFile ? new Blob([mapFile.contents]) : undefined,
               locales: new Map(batchEntries.map((e) => [e.locale, e.translation])),
               ephemeral,
               activeLocales,