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

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

@@ -9,20 +9,76 @@ const {
   Compilation
 } = require('webpack');
 
+const {
+  parseProperties,
+  decodeUnicodeEscapes
+} = require('../../utils/propertiesParser');
+
+let createHashFunction;
+
 const {
   createHash
 } = require("../I18nSplitPlugin/createHash");
 
+createHashFunction = createHash;
 const {
   RawSource
 } = sources;
 const pluginName = 'I18nNumericIndexPlugin';
 
 class I18nNumericIndexPlugin {
-  constructor(options) {
+  constructor(options = {}) {
     this.options = options;
     this.numericMap = null;
-    this.numericMapPath = options.numericMapPath;
+    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
   }
 
   loadNumericMapOnce(compilation) {
@@ -30,34 +86,58 @@ class I18nNumericIndexPlugin {
       return this.numericMap;
     }
 
+    const numericMapPathOpt = this.options.numericMapPath;
+    const numericMapPath = numericMapPathOpt ? path.resolve(compilation.compiler.context, numericMapPathOpt) : null;
+
     try {
-      if (this.numericMapPath && fs.existsSync(this.numericMapPath)) {
-        const fileContent = fs.readFileSync(this.numericMapPath, 'utf-8');
-        const parsedData = JSON.parse(fileContent);
+      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
           };
-          compilation.logger.info(`${pluginName}: Loaded numeric map from ${this.numericMapPath}.`);
+          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.logger.error(`${pluginName}: Invalid format in numeric map file at ${this.numericMapPath}.`);
+          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 {
-        compilation.logger.warn(`${pluginName}: Numeric map path not provided or file not found at ${this.numericMapPath}.`);
+        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.logger.error(`${pluginName}: Error loading numeric map from ${this.numericMapPath}: ${err.message}`);
+      compilation.errors.push(new Error(`${pluginName}: Error loading/parsing numericMapPath ${numericMapPath}: ${err.message}`));
       this.numericMap = {
         sortedOriginalKeys: [],
         totalKeys: 0
@@ -67,117 +147,344 @@ class I18nNumericIndexPlugin {
     return this.numericMap;
   }
 
-  emitFile(compilation, baseFilenameTemplate, locale, fileContentData, jsonpFunc, typeSuffix = '') {
-    const fileContent = `${jsonpFunc}(${JSON.stringify(fileContentData)});`;
+  loadJSResourceBaseFile(compilation) {
+    const compilerContext = compilation.compiler.context;
+    const jsResourcePathOpt = this.options.jsResourcePath;
+
+    if (!jsResourcePathOpt) {
+      return {};
+    }
+
+    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 {};
+    }
+  }
+
+  loadAllI18nData(compilation) {
+    if (this.options.allI18nObject && this.options.locales) {
+      return {
+        allI18nObject: this.options.allI18nObject,
+        locales: this.options.locales,
+        jsResourceBase: this.loadJSResourceBaseFile(compilation)
+      };
+    }
+
+    const allI18nObject = {};
+    const discoveredLocales = new Set();
+    const compilerContext = compilation.compiler.context;
+    const propertiesFolderPathOpt = this.options.propertiesFolderPath;
+    const jsResourcePathOpt = this.options.jsResourcePath;
+
+    if (!propertiesFolderPathOpt) {
+      compilation.errors.push(new Error(`${pluginName}: 'propertiesFolderPath' option is missing, cannot load translations.`));
+      return {
+        allI18nObject,
+        locales: [],
+        jsResourceBase: {}
+      };
+    }
+
+    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: {}
+      };
+    }
+
+    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 = createHash({
-      //
+    const actualContentHash = createHashFunction({
+      // Ensure createHashFunction is loaded
       outputOptions: compilation.outputOptions,
-      content: fileContent
+      content: fileContent // Hash is based on the final content
+
     });
-    let processedFilenameTemplate = baseFilenameTemplate.replace(/\[locale\]/g, locale).replace(/\[name\]/g, locale).replace(/\[id\]/g, locale);
+    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: {
-        id: `i18n-${typeSuffix || 'data'}-${locale}`,
-        name: `${typeSuffix || 'data'}-${locale}`,
+        // Mock chunk object for placeholders
+        id: `i18n-${chunkType}-${locale}`,
+        name: `${chunkType}-${locale}`,
         hash: actualContentHash,
+        // Chunk-specific hash
         contentHash: {
-          [this.options.moduleType || 'i18n/mini-extract']: actualContentHash
+          [this.options.moduleType || 'i18n/data-extract']: actualContentHash
         }
       },
-      contentHashType: this.options.moduleType || 'i18n/mini-extract'
+      contentHashType: this.options.moduleType || 'i18n/data-extract'
     });
     compilation.emitAsset(finalFileName, source);
-    compilation.logger.info(`${pluginName}: Emitted ${typeSuffix} i18n file for locale ${locale} to ${finalFileName}`);
   }
 
   apply(compiler) {
     compiler.hooks.thisCompilation.tap(pluginName, compilation => {
       compilation.hooks.processAssets.tapAsync({
         name: pluginName,
-        stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
-      }, (assets, callback) => {
+        stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE // Or a later stage if needed
+
+      }, (unusedAssets, callback) => {
+        if (!this.options.enable) {
+          return callback();
+        }
+
         const {
-          sortedOriginalKeys,
-          totalKeys
-        } = this.loadNumericMapOnce(compilation);
+          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}.`));
+          }
 
-        if (totalKeys === 0 && (!sortedOriginalKeys || sortedOriginalKeys.length === 0)) {
-          compilation.logger.info(`${pluginName}: No numeric keys to process. Skipping numeric file emission.`);
+          return callback();
         }
 
-        const globallyUsedLiteralKeys = new Set();
+        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) {
-            if (Array.isArray(module.buildInfo.loaderIdentifiedLiteralI18nKeys)) {
-              module.buildInfo.loaderIdentifiedLiteralI18nKeys.forEach(key => globallyUsedLiteralKeys.add(key));
-            }
-
-            if (Array.isArray(module.buildInfo.loaderIdentifiedCommentI18nKeys)) {
-              module.buildInfo.loaderIdentifiedCommentI18nKeys.forEach(key => globallyUsedCommentKeys.add(key));
-            }
+          if (module.buildInfo && Array.isArray(module.buildInfo.loaderIdentifiedCommentI18nKeys)) {
+            module.buildInfo.loaderIdentifiedCommentI18nKeys.forEach(key => globallyUsedCommentKeys.add(key));
           }
         }
 
-        compilation.logger.info(`${pluginName}: Globally identified Literal Keys: ${globallyUsedLiteralKeys.size}, Comment Keys: ${globallyUsedCommentKeys.size}`);
-        const {
-          locales,
-          allI18nObject,
-          numericFilenameTemplate,
-          dynamicFilenameTemplate,
-          numericJsonpFunc,
-          dynamicJsonpFunc
-        } = this.options;
-
-        if (!locales || !allI18nObject || !numericFilenameTemplate || !dynamicFilenameTemplate || !numericJsonpFunc || !dynamicJsonpFunc) {
-          compilation.errors.push(new Error(`${pluginName}: Missing some required options (locales, allI18nObject, filename templates, jsonp funcs).`));
-          return callback();
+        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 (totalKeys > 0 && sortedOriginalKeys && sortedOriginalKeys.length > 0) {
-          for (const locale of locales) {
-            const localeTranslations = allI18nObject[locale] || {};
-            const orderedNumericTranslations = new Array(totalKeys);
+        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++) {
-              const originalKey = sortedOriginalKeys[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.
 
-              if (globallyUsedLiteralKeys.has(originalKey)) {
-                orderedNumericTranslations[i] = localeTranslations[originalKey] !== undefined ? localeTranslations[originalKey] : 0; // Use 0 or null as placeholder for missing keys
-              } else {
-                orderedNumericTranslations[i] = 0; // Placeholder for keys not identified as literals or not used
+              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);
             }
+          } // Convert to compact format
 
-            this.emitFile(compilation, numericFilenameTemplate, locale, orderedNumericTranslations, numericJsonpFunc, 'numeric');
-          }
-        }
 
-        if (globallyUsedCommentKeys.size > 0) {
-          for (const locale of locales) {
-            const localeTranslations = allI18nObject[locale] || {};
-            const dynamicKeyTranslations = {};
-            globallyUsedCommentKeys.forEach(originalKey => {
+          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) {
-                dynamicKeyTranslations[originalKey] = localeTranslations[originalKey];
-              } else {
-                dynamicKeyTranslations[originalKey] = null;
+                value = this.intern(localeTranslations[originalKey]);
+              } else if (englishTranslations[originalKey] !== undefined) {
+                // Fallback to English value for missing key
+                value = this.intern(englishTranslations[originalKey]);
               }
-            });
 
-            if (Object.keys(dynamicKeyTranslations).length > 0) {
-              this.emitFile(compilation, dynamicFilenameTemplate, locale, dynamicKeyTranslations, dynamicJsonpFunc, 'dynamic');
+              dynamicDataForLocale[originalKey] = value;
             }
+          }); // 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;
+            }
+          }); // 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}`);
           }
-        } else {
-          compilation.logger.info(`${pluginName}: No globally used comment keys found. Skipping dynamic file emission.`);
-        }
 
+          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');
+          }
+        } // Clear string pool after processing to free memory
+
+
+        this.stringPool.clear();
         callback();
       });
     });

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/I18nFilesEmitPlugin.js

@@ -7,6 +7,10 @@ exports.I18nFilesEmitPlugin = void 0;
 
 var _webpack = require("webpack");
 
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
 var _createHash = require("./createHash");
 
 var _pathCreator = require("./pathCreator");
@@ -15,6 +19,8 @@ var _propertiesUtils = require("./utils/propertiesUtils");
 
 var _LocaleChunkAssetsStore = require("./LocaleChunkAssetsStore");
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 /* eslint-disable no-restricted-syntax */
 const pluginName = 'I18nFilesEmitPlugin';
 const {
@@ -23,18 +29,57 @@ const {
 
 class I18nFilesEmitPlugin {
   constructor(options) {
-    this.options = options; // this.options = {
+    this.options = options;
+    this.numericIdMap = null; // this.options = {
     //   locales: options.locales,
     //   chunkFilename: options.chunkFilename,
     //   filename: options.filename,
     //   allI18nObject: options.allI18nObject,
-    //   jsonpFunc: options.jsonpFunc
+    //   jsonpFunc: options.jsonpFunc,
+    //   useNumericIndexing: options.useNumericIndexing, // NEW OPTION
+    //   numericMapPath: options.numericMapPath // NEW OPTION
     // };
   }
 
+  loadNumericIdMap(compilation) {
+    if (this.numericIdMap || !this.options.useNumericIndexing || !this.options.numericMapPath) {
+      return this.numericIdMap;
+    }
+
+    const absoluteMapPath = _path.default.isAbsolute(this.options.numericMapPath) ? this.options.numericMapPath : _path.default.resolve(compilation.compiler.context, this.options.numericMapPath);
+
+    try {
+      if (_fs.default.existsSync(absoluteMapPath)) {
+        const fileContent = _fs.default.readFileSync(absoluteMapPath, 'utf-8');
+
+        const parsedData = JSON.parse(fileContent);
+
+        if (parsedData && parsedData.originalKeyToNumericId && typeof parsedData.originalKeyToNumericId === 'object') {
+          this.numericIdMap = parsedData.originalKeyToNumericId;
+        } else {
+          compilation.warnings.push(new Error(`${pluginName}: Invalid numeric map format in ${absoluteMapPath}`));
+          this.numericIdMap = {};
+        }
+      } else {
+        compilation.warnings.push(new Error(`${pluginName}: Numeric map file not found: ${absoluteMapPath}`));
+        this.numericIdMap = {};
+      }
+    } catch (err) {
+      compilation.errors.push(new Error(`${pluginName}: Error loading numeric map from ${absoluteMapPath}: ${err.message}`));
+      this.numericIdMap = {};
+    }
+
+    return this.numericIdMap;
+  }
+
   apply(compiler) {
     compiler.hooks.thisCompilation.tap(pluginName, compilation => {
-      // Get store for cache
+      // Load numeric map if needed
+      if (this.options.useNumericIndexing) {
+        this.loadNumericIdMap(compilation);
+      } // Get store for cache
+
+
       this.store = (0, _LocaleChunkAssetsStore.getLocaleChunkAssetsStore)(compilation);
       const i18nStore = this.store;
       compilation.hooks.beforeHash.tap(pluginName, () => {
@@ -150,12 +195,28 @@ class I18nFilesEmitPlugin {
 
   getI18nContentForkeys(i18nKeys, locale) {
     const {
-      allI18nObject
+      allI18nObject,
+      useNumericIndexing
     } = this.options;
     const data = {};
 
     for (const key of i18nKeys) {
-      data[key] = allI18nObject[locale][key];
+      const value = allI18nObject[locale][key];
+
+      if (useNumericIndexing && this.numericIdMap) {
+        // Use numeric ID as key if available, otherwise keep original key
+        const numericId = this.numericIdMap[key];
+
+        if (numericId !== undefined) {
+          data[numericId] = value;
+        } else {
+          // Keep original key if no numeric mapping exists
+          data[key] = value;
+        }
+      } else {
+        // Default behavior: use original key
+        data[key] = value;
+      }
     }
 
     return data;