@zohodesk/client_build_tool 0.0.1-0.exp.0.0.4 → 0.0.1-0.exp.0.0.9

package/lib/schemas/defaultConfigValues.js

@@ -174,7 +174,17 @@ var _default = {
     localeVarName: 'document.documentElement.lang',
     jsonpFunc: 'console.log',
     jsResource: null,
-    propertiesFolder: null
+    propertiesFolder: null,
+    propertiesPattern: '',
+    // NEW OPTIONS FOR NUMERIC INDEXING IN CHUNK SPLIT
+    useNumericIndexing: {
+      value: false,
+      cli: 'i18n_split_use_numeric'
+    },
+    numericMapPath: {
+      value: './deskapp/properties/i18n-numeric-map.json',
+      cli: 'i18n_split_numeric_map_path'
+    }
   },
   i18nIndexing: {
     enable: {
@@ -202,7 +212,7 @@ var _default = {
       cli: 'i18n_idx_dynamic_filename_template'
     },
     jsonpFunc: {
-      value: 'window.loadI18nData',
+      value: 'window.loadI18nChunk',
       cli: 'i18n_idx_jsonp_func'
     },
     htmlTemplateLabel: {
@@ -212,6 +222,19 @@ var _default = {
     localeVarName: {
       value: 'window.userLangCode',
       cli: 'i18n_idx_locale_var_name'
+    },
+    // NEW LOADER CONFIGURATION OPTIONS
+    retainLines: {
+      value: false,
+      cli: 'i18n_idx_retain_lines'
+    },
+    preserveComments: {
+      value: true,
+      cli: 'i18n_idx_preserve_comments'
+    },
+    babelPlugins: {
+      value: null,
+      cli: 'i18n_idx_babel_plugins'
     }
   },
   publicFolders: ['...'],

package/lib/schemas/defaultConfigValuesOnly.js

@@ -94,18 +94,26 @@ var _default = {
     localeVarName: 'document.documentElement.lang',
     jsonpFunc: 'console.log',
     jsResource: null,
-    propertiesFolder: null
+    propertiesFolder: null,
+    propertiesPattern: '',
+    // NEW OPTIONS FOR NUMERIC INDEXING IN CHUNK SPLIT
+    useNumericIndexing: false,
+    numericMapPath: './deskapp/properties/i18n-numeric-map.json'
   },
   i18nIndexing: {
     enable: false,
     jsResourcePath: './deskapp/properties/JSResources.properties',
     propertiesFolderPath: './deskapp/properties',
     numericMapPath: './deskapp/properties/i18n-numeric-map.json',
-    numericFilenameTemplate: 'i18n-chunks/numeric/[locale]/numeric.[contenthash].js',
-    dynamicFilenameTemplate: 'i18n-chunks/dynamic/[locale]/dynamic.[contenthash].js',
+    numericFilenameTemplate: 'i18n-chunks/[locale]/numeric.[contenthash].js',
+    dynamicFilenameTemplate: 'i18n-chunks/[locale]/dynamic.[contenthash].js',
     jsonpFunc: 'window.loadI18nChunk',
     htmlTemplateLabel: '{{--user-locale}}',
-    localeVarName: 'window.userLangCode'
+    localeVarName: 'window.userLangCode',
+    // NEW LOADER CONFIGURATION OPTIONS
+    retainLines: false,
+    preserveComments: true,
+    babelPlugins: null
   },
   publicFolders: ['...', {
     source: './deskapp/tp/',

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

@@ -23,8 +23,8 @@ class I18nNumericIndexHtmlInjectorPlugin {
           i18nAssetsPublicPathPrefix = ''
         } = this.options;
         const DEFAULT_LOCALE = '{{--user-locale}}';
-        const NUMERIC_FILENAME = `i18n-chunks/${DEFAULT_LOCALE}/numeric.i18n.js`;
-        const DYNAMIC_FILENAME = `i18n-chunks/${DEFAULT_LOCALE}/dynamic.i18n.js`;
+        const NUMERIC_FILENAME = `i18n-chunk/${DEFAULT_LOCALE}/numeric.i18n.js`;
+        const DYNAMIC_FILENAME = `i18n-chunk/${DEFAULT_LOCALE}/dynamic.i18n.js`;
         const newI18nAssetUrlsToAdd = [];
         const numericAssetUrl = urlConcat('', NUMERIC_FILENAME);
         newI18nAssetUrlsToAdd.push(numericAssetUrl);

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

@@ -9,9 +9,12 @@ const {
   Compilation
 } = require('webpack');
 
-let createHashFunction; // Assuming "../I18nSplitPlugin/createHash" exists and exports createHash.
-// If it might not, the original try-catch with a fallback was more robust.
-// For this fix, I'm keeping your current simplified version.
+const {
+  parseProperties,
+  decodeUnicodeEscapes
+} = require('../../utils/propertiesParser');
+
+let createHashFunction;
 
 const {
   createHash
@@ -23,58 +26,59 @@ const {
 } = sources;
 const pluginName = 'I18nNumericIndexPlugin';
 
-function parseProperties(content) {
-  const lines = content.split(/\r?\n/);
-  const data = {};
+class I18nNumericIndexPlugin {
+  constructor(options = {}) {
+    this.options = options;
+    this.numericMap = null;
+    this.stringPool = new Map(); // String interning for deduplication
+    // Default emitLiteralUnicode to true if not specified
 
-  for (let lineNum = 0; lineNum < lines.length; lineNum++) {
-    const line = lines[lineNum];
-    const trimmedLine = line.trim();
+    if (typeof this.options.emitLiteralUnicode === 'undefined') {
+      this.options.emitLiteralUnicode = true;
+    } // Default to compact mode for memory optimization
 
-    if (trimmedLine && !trimmedLine.startsWith('#') && !trimmedLine.startsWith('!')) {
-      const separatorIndex = trimmedLine.indexOf('=');
 
-      if (separatorIndex !== -1) {
-        // Ensure key is trimmed before use, especially if spaces can exist before '='
-        let key = trimmedLine.substring(0, separatorIndex).trim();
-        let value = trimmedLine.substring(separatorIndex + 1).trim();
+    if (typeof this.options.useCompactFormat === 'undefined') {
+      this.options.useCompactFormat = true;
+    }
+  } // String interning to reduce memory usage
 
-        if (key) {
-          // Decode Unicode escape sequences in both key and value
-          // Assumes input like "\\uXXXX" from properties file for \uXXXX
-          key = decodeUnicodeEscapes(key);
-          value = decodeUnicodeEscapes(value);
-          data[key] = value;
-        }
-      }
+
+  intern(str) {
+    if (typeof str !== 'string') {
+      return str;
     }
-  }
 
-  return {
-    data,
-    problematicLines: []
-  };
-} // This function converts strings like "Hello \\u00E9" to "Hello é"
+    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
 
-function decodeUnicodeEscapes(str) {
-  if (typeof str !== 'string') {
-    return str;
-  }
 
-  return str.replace(/\\u([0-9a-fA-F]{4})/g, (match, hex) => {
-    return String.fromCharCode(parseInt(hex, 16));
-  });
-}
+  generateCompactNumericData(numericDataArray) {
+    if (!this.options.useCompactFormat) {
+      return numericDataArray;
+    } // Create a sparse array with only non-null values
 
-class I18nNumericIndexPlugin {
-  constructor(options = {}) {
-    this.options = options;
-    this.numericMap = null; // Default emitLiteralUnicode to true if not specified
 
-    if (typeof this.options.emitLiteralUnicode === 'undefined') {
-      this.options.emitLiteralUnicode = true;
+    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) {
@@ -88,16 +92,34 @@ class I18nNumericIndexPlugin {
     try {
       if (numericMapPath && fs.existsSync(numericMapPath)) {
         const fileContent = fs.readFileSync(numericMapPath, 'utf-8');
-        const parsedData = JSON.parse(fileContent);
+        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. Using empty map.`));
+          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
@@ -125,11 +147,36 @@ class I18nNumericIndexPlugin {
     return this.numericMap;
   }
 
+  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
+        locales: this.options.locales,
+        jsResourceBase: this.loadJSResourceBaseFile(compilation)
       };
     }
 
@@ -143,7 +190,8 @@ class I18nNumericIndexPlugin {
       compilation.errors.push(new Error(`${pluginName}: 'propertiesFolderPath' option is missing, cannot load translations.`));
       return {
         allI18nObject,
-        locales: []
+        locales: [],
+        jsResourceBase: {}
       };
     }
 
@@ -154,7 +202,8 @@ class I18nNumericIndexPlugin {
       compilation.errors.push(new Error(`${pluginName}: propertiesFolderPath does not exist: ${propertiesFolderPath}`));
       return {
         allI18nObject,
-        locales: []
+        locales: [],
+        jsResourceBase: {}
       };
     }
 
@@ -190,8 +239,7 @@ class I18nNumericIndexPlugin {
           if (locale && ext.toLowerCase() === baseExtension.toLowerCase()) {
             try {
               const fileContent = fs.readFileSync(filePath, 'utf-8');
-              const parseResult = parseProperties(fileContent);
-              allI18nObject[locale] = parseResult.data;
+              allI18nObject[locale] = parseProperties(fileContent);
               discoveredLocales.add(locale);
             } catch (readErr) {
               compilation.errors.push(new Error(`${pluginName}: Error reading/parsing properties file ${filePath}: ${readErr.message}`));
@@ -201,11 +249,14 @@ class I18nNumericIndexPlugin {
       });
     } 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)
+      locales: Array.from(discoveredLocales),
+      jsResourceBase
     };
   }
 
@@ -219,21 +270,25 @@ class I18nNumericIndexPlugin {
     let stringifiedData;
 
     try {
-      // JSON.stringify will escape non-ASCII characters to \uXXXX sequences
-      stringifiedData = JSON.stringify(dataToStringify, null, 0); // If emitLiteralUnicode is true (default), convert \uXXXX sequences back to actual Unicode characters
+      // 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});`; // RawSource expects a string. If stringifiedData contains literal Unicode,
-    // fileContent will also, and Webpack handles UTF-8 output correctly.
 
+    const fileContent = `${jsonpFunc}(${stringifiedData});`;
     const source = new RawSource(fileContent);
     const actualContentHash = createHashFunction({
       // Ensure createHashFunction is loaded
@@ -268,14 +323,15 @@ class I18nNumericIndexPlugin {
         name: pluginName,
         stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE // Or a later stage if needed
 
-      }, (assets, callback) => {
+      }, (unusedAssets, callback) => {
         if (!this.options.enable) {
           return callback();
         }
 
         const {
           allI18nObject,
-          locales
+          locales,
+          jsResourceBase
         } = this.loadAllI18nData(compilation);
 
         if (!locales || locales.length === 0) {
@@ -300,8 +356,7 @@ class I18nNumericIndexPlugin {
 
         const numericFilenameTemplate = this.options.numericFilenameTemplate;
         const dynamicFilenameTemplate = this.options.dynamicFilenameTemplate;
-        const numericJsonpFunction = this.options.numericJsonpFunction || 'loadI18nNumericChunk';
-        const dynamicJsonpFunction = this.options.dynamicJsonpFunction || 'loadI18nDynamicChunk';
+        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
@@ -320,7 +375,18 @@ class I18nNumericIndexPlugin {
           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);
+        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] || {};
@@ -331,54 +397,94 @@ class I18nNumericIndexPlugin {
               // 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, push null.
+              // 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]);
+                }
+              }
 
-              const value = originalKey !== undefined && localeTranslations[originalKey] !== undefined ? localeTranslations[originalKey] : null;
               numericDataForLocale.push(value);
             }
-          }
+          } // Convert to compact format
+
 
-          const dynamicDataForLocale = {}; // Process globally used comment keys first
+          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)) {
-              // Only if not already in numeric set
-              dynamicDataForLocale[originalKey] = localeTranslations[originalKey] !== undefined ? localeTranslations[originalKey] : null; // Explicitly null for missing keys referenced in comments
+            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]);
+              }
+
+              dynamicDataForLocale[originalKey] = value;
             }
-          }); // Process remaining keys from localeTranslations
+          }); // 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(localeTranslations).forEach(originalKey => {
+          Object.keys(jsResourceBaseTranslations).forEach(originalKey => {
             // Add if not in numeric set AND not already added from globallyUsedCommentKeys
-            if (!numericKeysSet.has(originalKey) && !dynamicDataForLocale.hasOwnProperty(originalKey)) {
-              dynamicDataForLocale[originalKey] = localeTranslations[originalKey];
-            }
-          });
+            if (!numericKeysSet.has(originalKey) && !Object.prototype.hasOwnProperty.call(dynamicDataForLocale, originalKey)) {
+              let value = null;
 
-          if (this.options.logKeyCounts && locale === (this.options.logKeyCountsForLocale || 'en_US')) {
-            const numericKeysWithValues = numericDataForLocale.filter(v => v !== null).length;
-            const numericKeysWithNullValues = numericDataForLocale.length - numericKeysWithValues;
-            const totalDynamicKeys = Object.keys(dynamicDataForLocale).length;
-            const dynamicKeysWithNullValues = Object.values(dynamicDataForLocale).filter(v => v === null).length;
-            const commentKeysInDynamic = Array.from(globallyUsedCommentKeys).filter(key => !numericKeysSet.has(key) && dynamicDataForLocale.hasOwnProperty(key)).length;
-            const jsResourceKeysInDynamic = totalDynamicKeys - commentKeysInDynamic;
-            console.log(`\n=== ${pluginName} KEY COUNTS FOR ${locale} ===`);
-            console.log(`📊 NUMERIC MAPPING: ${totalKeys} map size, ${sortedOriginalKeys.length} sorted keys provided`);
-            console.log(`📊 LOCALE TRANSLATIONS: ${Object.keys(localeTranslations).length} total keys for this locale`);
-            console.log(`📊 GLOBALLY USED COMMENT KEYS: ${globallyUsedCommentKeys.size} total, ${Array.from(globallyUsedCommentKeys).filter(k => numericKeysSet.has(k)).length} in numeric`);
-            console.log(`📊 NUMERIC CHUNK (${locale}): ${numericDataForLocale.length} items (${numericKeysWithValues} values, ${numericKeysWithNullValues} nulls)`);
-            console.log(`📊 DYNAMIC CHUNK (${locale}): ${totalDynamicKeys} items (${commentKeysInDynamic} from comments, ${jsResourceKeysInDynamic} from JS resources only, ${dynamicKeysWithNullValues} nulls)`);
-            console.log(`=== END KEY COUNTS ===\n`);
+              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}`);
           }
 
-          if (numericFilenameTemplate && numericDataForLocale.length > 0) {
-            this.emitChunkFile(compilation, numericFilenameTemplate, locale, numericDataForLocale, numericJsonpFunction, 'numeric');
+          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, dynamicJsonpFunction, 'dynamic');
+            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;

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

@@ -40,6 +40,9 @@ function optionsHandler(options) {
     jsResourceI18nKeys,
     allI18nObject,
     locales,
+    // NEW OPTIONS FOR NUMERIC INDEXING
+    useNumericIndexing: options.useNumericIndexing,
+    numericMapPath: options.numericMapPath,
     // template: (object, locale) => `window.loadI18n(${JSON.stringify(object)}, ${JSON.stringify(locale)})`,
     runtime: true,
     runtimeOptions: {