@zohodesk/client_build_tool 0.0.1-0.exp.0.0.8 → 0.0.1-0.exp.1.0.3

package/lib/shared/bundler/webpack/custom_plugins/I18nNumericIndexPlugin/I18nNumericIndexPlugin.js

@@ -1,26 +1,22 @@
 "use strict";
 
-const fs = require('fs');
-
 const path = require('path');
 
 const {
   sources,
-  Compilation
+  Compilation,
+  util
 } = require('webpack');
 
 const {
-  parseProperties,
   decodeUnicodeEscapes
 } = require('../../utils/propertiesParser');
 
-let createHashFunction;
-
 const {
-  createHash
-} = require("../I18nSplitPlugin/createHash");
+  loadNumericMap,
+  loadI18nData
+} = require('./utils/i18nDataLoader');
 
-createHashFunction = createHash;
 const {
   RawSource
 } = sources;
@@ -28,463 +24,131 @@ const pluginName = 'I18nNumericIndexPlugin';
 
 class I18nNumericIndexPlugin {
   constructor(options = {}) {
-    this.options = options;
+    this.options = { ...options,
+      singleFile: options.singleFile || false,
+      includeContentHash: options.includeContentHash || false,
+      generateManifest: options.generateManifest || false
+    };
     this.numericMap = null;
-    this.stringPool = new Map(); // String interning for deduplication
-    // Default emitLiteralUnicode to true if not specified
-
-    if (typeof this.options.emitLiteralUnicode === 'undefined') {
-      this.options.emitLiteralUnicode = true;
-    } // Default to compact mode for memory optimization
-
-
-    if (typeof this.options.useCompactFormat === 'undefined') {
-      this.options.useCompactFormat = true;
-    }
-  } // String interning to reduce memory usage
-
-
-  intern(str) {
-    if (typeof str !== 'string') {
-      return str;
-    }
-
-    if (!this.stringPool.has(str)) {
-      this.stringPool.set(str, str);
-    }
-
-    return this.stringPool.get(str);
-  } // Generate compact numeric data structure - returns just an array of values
-
-
-  generateCompactNumericData(numericDataArray) {
-    if (!this.options.useCompactFormat) {
-      return numericDataArray;
-    } // Create a sparse array with only non-null values
-
-
-    const compactArray = [];
-
-    for (let i = 0; i < numericDataArray.length; i++) {
-      if (numericDataArray[i] !== null) {
-        compactArray[i] = this.intern(numericDataArray[i]);
-      }
-    }
-
-    return compactArray;
-  } // Compact serializer for JSON
-
-
-  compactSerialize(data) {
-    return JSON.stringify(data, null, 0).replace(/"(\d+)":/g, '$1:') // Remove quotes from numeric keys
-    .replace(/,null/g, ',0') // Replace null with 0 for smaller size
-    .replace(/null,/g, '0,'); // Replace null with 0 for smaller size
+    this.i18nData = null;
+    this.manifest = {};
   }
 
-  loadNumericMapOnce(compilation) {
-    if (this.numericMap) {
-      return this.numericMap;
-    }
-
-    const numericMapPathOpt = this.options.numericMapPath;
-    const numericMapPath = numericMapPathOpt ? path.resolve(compilation.compiler.context, numericMapPathOpt) : null;
-
-    try {
-      if (numericMapPath && fs.existsSync(numericMapPath)) {
-        const fileContent = fs.readFileSync(numericMapPath, 'utf-8');
-        const parsedData = JSON.parse(fileContent); // Handle both old format (sortedOriginalKeys) and new format (originalKeyToNumericId)
-
-        if (parsedData && parsedData.sortedOriginalKeys && parsedData.totalKeys !== undefined) {
-          // Old format
-          this.numericMap = {
-            sortedOriginalKeys: parsedData.sortedOriginalKeys,
-            totalKeys: parsedData.totalKeys
-          };
-          return this.numericMap;
-        } else if (parsedData && parsedData.originalKeyToNumericId && parsedData.totalKeysInMap !== undefined) {
-          // New format - convert originalKeyToNumericId to sortedOriginalKeys
-          const keyToIdMap = parsedData.originalKeyToNumericId;
-          const sortedOriginalKeys = new Array(parsedData.totalKeysInMap); // Fill the array with keys at their numeric positions
-
-          Object.keys(keyToIdMap).forEach(key => {
-            const numericId = keyToIdMap[key];
-
-            if (numericId >= 0 && numericId < parsedData.totalKeysInMap) {
-              sortedOriginalKeys[numericId] = key;
-            }
-          });
-          this.numericMap = {
-            sortedOriginalKeys: sortedOriginalKeys,
-            totalKeys: parsedData.totalKeysInMap
-          };
-          return this.numericMap;
-        } else {
-          compilation.warnings.push(new Error(`${pluginName}: numericMap file (${numericMapPath}) parsed but seems malformed. Expected 'sortedOriginalKeys' + 'totalKeys' or 'originalKeyToNumericId' + 'totalKeysInMap'. Using empty map.`));
-          this.numericMap = {
-            sortedOriginalKeys: [],
-            totalKeys: 0
-          };
-        }
-      } else {
-        if (numericMapPathOpt) {
-          // Only warn if a path was actually provided
-          compilation.warnings.push(new Error(`${pluginName}: numericMapPath (${numericMapPath}) not found. Using empty map.`));
-        }
-
-        this.numericMap = {
-          sortedOriginalKeys: [],
-          totalKeys: 0
-        };
-      }
-    } catch (err) {
-      compilation.errors.push(new Error(`${pluginName}: Error loading/parsing numericMapPath ${numericMapPath}: ${err.message}`));
-      this.numericMap = {
-        sortedOriginalKeys: [],
-        totalKeys: 0
-      };
+  getNumericMap(compilation) {
+    if (!this.numericMap) {
+      const mapPath = path.resolve(compilation.compiler.context, this.options.numericMapPath);
+      this.numericMap = loadNumericMap(mapPath, compilation);
     }
 
     return this.numericMap;
   }
 
-  loadJSResourceBaseFile(compilation) {
-    const compilerContext = compilation.compiler.context;
-    const jsResourcePathOpt = this.options.jsResourcePath;
-
-    if (!jsResourcePathOpt) {
-      return {};
+  getI18nData(compilation) {
+    if (!this.i18nData) {
+      this.i18nData = loadI18nData(this.options, compilation);
     }
 
-    const jsResourcePath = path.resolve(compilerContext, jsResourcePathOpt);
-
-    try {
-      if (fs.existsSync(jsResourcePath)) {
-        const fileContent = fs.readFileSync(jsResourcePath, 'utf-8');
-        return parseProperties(fileContent);
-      } else {
-        compilation.warnings.push(new Error(`${pluginName}: JS Resource base file not found: ${jsResourcePath}`));
-        return {};
-      }
-    } catch (err) {
-      compilation.errors.push(new Error(`${pluginName}: Error loading JS Resource base file ${jsResourcePath}: ${err.message}`));
-      return {};
-    }
+    return this.i18nData;
   }
 
-  loadAllI18nData(compilation) {
-    if (this.options.allI18nObject && this.options.locales) {
-      return {
-        allI18nObject: this.options.allI18nObject,
-        locales: this.options.locales,
-        jsResourceBase: this.loadJSResourceBaseFile(compilation)
-      };
-    }
+  generateContentHash(content, compilation) {
+    const {
+      hashFunction,
+      hashDigest,
+      hashDigestLength
+    } = compilation.outputOptions;
+    const hash = util.createHash(hashFunction || 'xxhash64');
+    hash.update(content);
+    return hash.digest(hashDigest || 'hex').substring(0, hashDigestLength || 20);
+  }
 
-    const allI18nObject = {};
-    const discoveredLocales = new Set();
-    const compilerContext = compilation.compiler.context;
-    const propertiesFolderPathOpt = this.options.propertiesFolderPath;
-    const jsResourcePathOpt = this.options.jsResourcePath;
+  emitChunk(compilation, filename, locale, data, fileType = null) {
+    const content = decodeUnicodeEscapes(JSON.stringify(data));
+    const fileContent = `${this.options.jsonpFunc}(${content});`;
+    let outputPath = filename.replace(/\[locale\]/g, locale);
 
-    if (!propertiesFolderPathOpt) {
-      compilation.errors.push(new Error(`${pluginName}: 'propertiesFolderPath' option is missing, cannot load translations.`));
-      return {
-        allI18nObject,
-        locales: [],
-        jsResourceBase: {}
-      };
+    if (this.options.includeContentHash) {
+      const contentHash = this.generateContentHash(fileContent, compilation);
+      outputPath = outputPath.replace(/\.js$/, `.${contentHash}.js`);
     }
 
-    const propertiesFolderPath = path.resolve(compilerContext, propertiesFolderPathOpt);
-    const baseJsResourcePath = jsResourcePathOpt ? path.resolve(compilerContext, jsResourcePathOpt) : null;
-
-    if (!fs.existsSync(propertiesFolderPath)) {
-      compilation.errors.push(new Error(`${pluginName}: propertiesFolderPath does not exist: ${propertiesFolderPath}`));
-      return {
-        allI18nObject,
-        locales: [],
-        jsResourceBase: {}
-      };
+    if (this.options.generateManifest) {
+      const cleanName = filename.replace(/\[locale\]/g, locale).replace(/\.js$/, '.js');
+      const cleanNameWithType = fileType ? cleanName.replace(/\.js$/, `.${fileType}.js`) : cleanName;
+      this.manifest[cleanNameWithType] = outputPath.split('/').pop();
     }
 
-    const baseFileName = baseJsResourcePath ? path.basename(baseJsResourcePath, path.extname(baseJsResourcePath)) : null;
-    const baseExtension = baseJsResourcePath ? path.extname(baseJsResourcePath) : '.properties';
-
-    try {
-      const files = fs.readdirSync(propertiesFolderPath);
-      files.forEach(file => {
-        const filePath = path.join(propertiesFolderPath, file);
-
-        if (fs.statSync(filePath).isFile()) {
-          let locale = null;
-          const ext = path.extname(file);
-          const nameWithoutExt = path.basename(file, ext);
-
-          if (baseFileName && nameWithoutExt.startsWith(baseFileName + '_')) {
-            locale = nameWithoutExt.substring((baseFileName + '_').length);
-          } else if (baseFileName && nameWithoutExt === baseFileName) {
-            locale = this.options.defaultLocaleForBaseFile || 'en';
-          } else if (!baseFileName && nameWithoutExt.includes('_')) {
-            // Generic pattern: messages_fr_CA.properties -> fr_CA
-            const parts = nameWithoutExt.split('_');
-
-            if (parts.length > 1) {
-              locale = parts.slice(1).join('_');
-            }
-          } else if (!baseFileName && !nameWithoutExt.includes('_') && ext.toLowerCase() === baseExtension.toLowerCase()) {
-            // Fallback for files like 'fr.properties' if no baseFileName is defined
-            locale = nameWithoutExt;
-          }
-
-          if (locale && ext.toLowerCase() === baseExtension.toLowerCase()) {
-            try {
-              const fileContent = fs.readFileSync(filePath, 'utf-8');
-              allI18nObject[locale] = parseProperties(fileContent);
-              discoveredLocales.add(locale);
-            } catch (readErr) {
-              compilation.errors.push(new Error(`${pluginName}: Error reading/parsing properties file ${filePath}: ${readErr.message}`));
-            }
-          }
-        }
-      });
-    } catch (err) {
-      compilation.errors.push(new Error(`${pluginName}: Error reading propertiesFolderPath ${propertiesFolderPath}: ${err.message}`));
-    } // Load JS Resource base file separately
-
-
-    const jsResourceBase = this.loadJSResourceBaseFile(compilation);
-    return {
-      allI18nObject,
-      locales: Array.from(discoveredLocales),
-      jsResourceBase
-    };
-  }
-
-  validateAndSanitizeData(data, chunkType, locale, compilation) {
-    // Placeholder for any future validation or sanitization logic
-    return data;
-  }
-
-  emitChunkFile(compilation, filenameTemplate, locale, fileContentData, jsonpFunc, chunkType) {
-    const dataToStringify = this.validateAndSanitizeData(fileContentData, chunkType, locale, compilation);
-    let stringifiedData;
-
-    try {
-      // Use compact serializer for smaller output
-      if (this.options.useCompactFormat) {
-        stringifiedData = this.compactSerialize(dataToStringify);
-      } else {
-        stringifiedData = JSON.stringify(dataToStringify, null, 0);
-      } // If emitLiteralUnicode is true (default), convert \uXXXX sequences back to actual Unicode characters
-      // This ensures the output file contains literal UTF-8 characters if desired.
-
-
-      if (this.options.emitLiteralUnicode) {
-        stringifiedData = decodeUnicodeEscapes(stringifiedData);
-      }
-    } catch (e) {
-      compilation.errors.push(new Error(`${pluginName}: Failed to stringify or post-process data for ${chunkType} chunk (${locale}): ${e.message}`));
-      return;
-    } // Create content in the format: window.loadI18nChunk({data})
-
-
-    const fileContent = `${jsonpFunc}(${stringifiedData});`;
-    const source = new RawSource(fileContent);
-    const actualContentHash = createHashFunction({
-      // Ensure createHashFunction is loaded
-      outputOptions: compilation.outputOptions,
-      content: fileContent // Hash is based on the final content
-
-    });
-    let processedFilenameTemplate = filenameTemplate.replace(/\[locale\]/g, locale).replace(/\[name\]/g, locale).replace(/\[id\]/g, locale);
-    const finalFileName = compilation.getAssetPath(processedFilenameTemplate, {
-      locale: locale,
-      contentHash: actualContentHash,
-      hash: compilation.hash,
-      // Webpack compilation hash
-      chunk: {
-        // Mock chunk object for placeholders
-        id: `i18n-${chunkType}-${locale}`,
-        name: `${chunkType}-${locale}`,
-        hash: actualContentHash,
-        // Chunk-specific hash
-        contentHash: {
-          [this.options.moduleType || 'i18n/data-extract']: actualContentHash
-        }
-      },
-      contentHashType: this.options.moduleType || 'i18n/data-extract'
-    });
-    compilation.emitAsset(finalFileName, source);
+    compilation.emitAsset(outputPath, new RawSource(fileContent));
+    return outputPath;
   }
 
   apply(compiler) {
     compiler.hooks.thisCompilation.tap(pluginName, compilation => {
       compilation.hooks.processAssets.tapAsync({
         name: pluginName,
-        stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE // Or a later stage if needed
-
-      }, (unusedAssets, callback) => {
+        stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+      }, (assets, callback) => {
         if (!this.options.enable) {
           return callback();
         }
 
         const {
-          allI18nObject,
-          locales,
-          jsResourceBase
-        } = this.loadAllI18nData(compilation);
-
-        if (!locales || locales.length === 0) {
-          if (this.options.propertiesFolderPath) {
-            // Only warn if path was given
-            compilation.warnings.push(new Error(`${pluginName}: No locales found or no translation data loaded from ${this.options.propertiesFolderPath}.`));
-          }
-
-          return callback();
-        }
-
-        const numericMapData = this.loadNumericMapOnce(compilation);
-        const sortedOriginalKeys = numericMapData.sortedOriginalKeys || [];
-        const totalKeys = numericMapData.totalKeys || 0;
-        const globallyUsedCommentKeys = new Set();
-
-        for (const module of compilation.modules) {
-          if (module.buildInfo && Array.isArray(module.buildInfo.loaderIdentifiedCommentI18nKeys)) {
-            module.buildInfo.loaderIdentifiedCommentI18nKeys.forEach(key => globallyUsedCommentKeys.add(key));
+          sortedKeys,
+          totalKeys
+        } = this.getNumericMap(compilation);
+        const {
+          jsResourceBase,
+          allI18n,
+          locales
+        } = this.getI18nData(compilation);
+        if (!locales.length) return callback();
+        const numericKeysSet = new Set(sortedKeys);
+        const englishData = allI18n.en_US || jsResourceBase;
+        locales.forEach(locale => {
+          const localeData = allI18n[locale] || {};
+          const numericData = {};
+
+          for (let i = 0; i < totalKeys; i++) {
+            const key = sortedKeys[i];
+
+            if (key && jsResourceBase[key] !== undefined) {
+              numericData[i] = localeData[key] ?? englishData[key];
+            }
           }
-        }
-
-        const numericFilenameTemplate = this.options.numericFilenameTemplate;
-        const dynamicFilenameTemplate = this.options.dynamicFilenameTemplate;
-        const jsonpFunction = this.options.jsonpFunc || 'window.loadI18nChunk';
-
-        if (!numericFilenameTemplate) {
-          compilation.errors.push(new Error(`${pluginName}: Missing required option 'numericFilenameTemplate' in plugin options.`)); // return callback(); // Allow processing other chunks if one template is missing
-        }
-
-        if (!dynamicFilenameTemplate) {
-          compilation.errors.push(new Error(`${pluginName}: Missing required option 'dynamicFilenameTemplate' in plugin options.`)); // return callback();
-        }
 
-        if (typeof numericFilenameTemplate === 'string' && !numericFilenameTemplate.includes('[locale]') && !numericFilenameTemplate.includes('[name]') && !numericFilenameTemplate.includes('[id]')) {
-          compilation.warnings.push(new Error( // Changed to warning as it might be intentional for a single combined file not per-locale
-          `${pluginName}: The 'numericFilenameTemplate' ("${numericFilenameTemplate}") ` + `does not include '[locale]', '[name]', or '[id]'. All locales will overwrite the same file if multiple locales exist.`));
-        }
-
-        if (typeof dynamicFilenameTemplate === 'string' && !dynamicFilenameTemplate.includes('[locale]') && !dynamicFilenameTemplate.includes('[name]') && !dynamicFilenameTemplate.includes('[id]')) {
-          compilation.warnings.push(new Error(`${pluginName}: The 'dynamicFilenameTemplate' ("${dynamicFilenameTemplate}") ` + `does not include '[locale]', '[name]', or '[id]'. All locales will overwrite the same file if multiple locales exist.`));
-        }
-
-        const numericKeysSet = new Set(sortedOriginalKeys); // Use JS resource base file as the master reference for keys
-
-        const jsResourceBaseTranslations = jsResourceBase || {}; // Get English translations for fallback 
-
-        const englishTranslations = allI18nObject.en || allI18nObject[this.options.defaultLocaleForBaseFile || 'en'] || jsResourceBaseTranslations; // Log base file and numeric map stats
-
-        console.log(`${pluginName}: === DEBUGGING STATS ===`);
-        console.log(`${pluginName}: JS Resource base file keys count: ${Object.keys(jsResourceBaseTranslations).length}`);
-        console.log(`${pluginName}: English fallback keys count: ${Object.keys(englishTranslations).length}`);
-        console.log(`${pluginName}: Numeric map total keys: ${totalKeys}`);
-        console.log(`${pluginName}: Numeric map actual keys: ${sortedOriginalKeys.filter(key => key !== undefined).length}`);
-        console.log(`${pluginName}: Global comment keys count: ${globallyUsedCommentKeys.size}`);
-
-        for (const locale of locales) {
-          const localeTranslations = allI18nObject[locale] || {};
-          const numericDataForLocale = []; // Fill numericDataForLocale based on sortedOriginalKeys
-
-          if (totalKeys > 0 && sortedOriginalKeys.length > 0) {
-            for (let i = 0; i < totalKeys; i++) {
-              // Iterate up to totalKeys (max expected length)
-              const originalKey = sortedOriginalKeys[i]; // Get key if available
-              // If originalKey is undefined (i < sortedOriginalKeys.length but originalKey is not there due to sparse array or shorter sortedKeys)
-              // or if the translation is missing, use English fallback if available, otherwise null.
-
-              let value = null;
-
-              if (originalKey !== undefined && jsResourceBaseTranslations[originalKey] !== undefined) {
-                if (localeTranslations[originalKey] !== undefined) {
-                  value = this.intern(localeTranslations[originalKey]);
-                } else if (englishTranslations[originalKey] !== undefined) {
-                  // Fallback to English value for missing key
-                  value = this.intern(englishTranslations[originalKey]);
-                }
-              }
-
-              numericDataForLocale.push(value);
+          const dynamicData = {};
+          Object.keys(jsResourceBase).forEach(key => {
+            if (!numericKeysSet.has(key)) {
+              dynamicData[key] = localeData[key] ?? englishData[key];
             }
-          } // Convert to compact format
-
-
-          const compactNumericData = this.generateCompactNumericData(numericDataForLocale);
-          const dynamicDataForLocale = Object.create(null); // Use null prototype for cleaner object
-          // Process globally used comment keys first (only if they exist in JS resource base)
-
-          globallyUsedCommentKeys.forEach(originalKey => {
-            if (!numericKeysSet.has(originalKey) && jsResourceBaseTranslations[originalKey] !== undefined) {
-              let value = null;
+          });
 
-              if (localeTranslations[originalKey] !== undefined) {
-                value = this.intern(localeTranslations[originalKey]);
-              } else if (englishTranslations[originalKey] !== undefined) {
-                // Fallback to English value for missing key
-                value = this.intern(englishTranslations[originalKey]);
-              }
+          if (this.options.singleFile) {
+            const combinedData = { ...numericData,
+              ...dynamicData
+            };
 
-              dynamicDataForLocale[originalKey] = value;
+            if (Object.keys(combinedData).length > 0) {
+              const filename = this.options.numericFilenameTemplate || this.options.dynamicFilenameTemplate;
+              this.emitChunk(compilation, filename, locale, combinedData);
             }
-          }); // Process remaining keys from JS resource base (keys in JS resource but not in numeric mapping)
-          // Only include keys that exist in the JS resource base file
-
-          Object.keys(jsResourceBaseTranslations).forEach(originalKey => {
-            // Add if not in numeric set AND not already added from globallyUsedCommentKeys
-            if (!numericKeysSet.has(originalKey) && !Object.prototype.hasOwnProperty.call(dynamicDataForLocale, originalKey)) {
-              let value = null;
-
-              if (localeTranslations[originalKey] !== undefined) {
-                value = this.intern(localeTranslations[originalKey]);
-              } else if (englishTranslations[originalKey] !== undefined) {
-                // Use English fallback for missing key
-                value = this.intern(englishTranslations[originalKey]);
-              }
-
-              dynamicDataForLocale[originalKey] = value;
+          } else {
+            if (Object.keys(numericData).length > 0) {
+              this.emitChunk(compilation, this.options.numericFilenameTemplate, locale, numericData, 'numeric');
             }
-          }); // Log per-locale stats
-
-          const numericKeysWithValues = numericDataForLocale.filter(v => v !== null).length;
-          const numericKeysWithFallbacks = numericDataForLocale.filter((v, i) => {
-            const originalKey = sortedOriginalKeys[i];
-            return v !== null && originalKey && localeTranslations[originalKey] === undefined && englishTranslations[originalKey] !== undefined;
-          }).length;
-          const dynamicKeysCount = Object.keys(dynamicDataForLocale).length;
-          const dynamicKeysWithFallbacks = Object.keys(dynamicDataForLocale).filter(key => localeTranslations[key] === undefined && englishTranslations[key] !== undefined).length; // Count how many locale keys are filtered out (not in JS resource base)
-
-          const localeKeysCount = Object.keys(localeTranslations).length;
-          const localeKeysInBase = Object.keys(localeTranslations).filter(key => jsResourceBaseTranslations[key] !== undefined).length;
-          const localeKeysFiltered = localeKeysCount - localeKeysInBase;
-          console.log(`${pluginName}: ${locale} - Total keys in locale file: ${localeKeysCount}`);
-          console.log(`${pluginName}: ${locale} - Keys from locale matching JS resource base: ${localeKeysInBase}`);
-          console.log(`${pluginName}: ${locale} - Keys filtered out (not in base): ${localeKeysFiltered}`);
-          console.log(`${pluginName}: ${locale} - Numeric: ${numericKeysWithValues}/${numericDataForLocale.length} (${numericKeysWithFallbacks} fallbacks)`);
-          console.log(`${pluginName}: ${locale} - Dynamic: ${dynamicKeysCount} (${dynamicKeysWithFallbacks} fallbacks)`);
-          console.log(`${pluginName}: ${locale} - Total emitted: ${numericKeysWithValues + dynamicKeysCount}`);
-          console.log(`${pluginName}: ---`); // Keep original debug logging for compatibility
 
-          if (this.options.logKeyCounts && this.options.isDevelopment && locale === (this.options.logKeyCountsForLocale || 'en_US')) {
-            console.log(`${pluginName}: ${locale} - Numeric: ${numericKeysWithValues}/${numericDataForLocale.length}, Dynamic: ${Object.keys(dynamicDataForLocale).length}`);
-          }
-
-          if (numericFilenameTemplate && (this.options.useCompactFormat ? compactNumericData.length > 0 : numericDataForLocale.length > 0)) {
-            this.emitChunkFile(compilation, numericFilenameTemplate, locale, this.options.useCompactFormat ? compactNumericData : numericDataForLocale, jsonpFunction, 'numeric');
-          }
-
-          if (dynamicFilenameTemplate && Object.keys(dynamicDataForLocale).length > 0) {
-            this.emitChunkFile(compilation, dynamicFilenameTemplate, locale, dynamicDataForLocale, jsonpFunction, 'dynamic');
+            if (Object.keys(dynamicData).length > 0) {
+              this.emitChunk(compilation, this.options.dynamicFilenameTemplate, locale, dynamicData, 'dynamic');
+            }
           }
-        } // Clear string pool after processing to free memory
+        });
 
+        if (this.options.generateManifest && Object.keys(this.manifest).length > 0) {
+          const manifestPath = path.dirname(this.options.numericFilenameTemplate) + '/manifest.json';
+          const manifestContent = JSON.stringify(this.manifest, null, 2);
+          compilation.emitAsset(manifestPath, new RawSource(manifestContent));
+        }
 
-        this.stringPool.clear();
         callback();
       });
     });