@zohodesk/client_build_tool 0.0.11-exp.25.0 → 0.0.11-exp.27.0

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

@@ -22,8 +22,27 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 const {
   RawSource
 } = _webpack.sources;
+const assetStoreKey = Symbol.for('I18nNumericIndexPluginAssets');
 const pluginName = 'I18nNumericIndexPlugin';
 
+function buildChunkMappingFromGroups(customGroups) {
+  if (!customGroups) {
+    return {};
+  }
+
+  const mapping = {};
+  Object.entries(customGroups).forEach(([groupName, config]) => {
+    if (config && Array.isArray(config.chunks)) {
+      config.chunks.forEach(chunkName => {
+        if (chunkName && typeof chunkName === 'string') {
+          mapping[chunkName] = groupName;
+        }
+      });
+    }
+  });
+  return mapping;
+}
+
 class I18nNumericIndexPlugin {
   constructor(options) {
     this.options = { ...options,
@@ -33,27 +52,45 @@ class I18nNumericIndexPlugin {
       generateManifest: options.generateManifest || false,
       outputFolder: options.outputFolder || 'i18n-chunk',
       manifestPath: options.manifestPath || null,
-      emitFiles: options.emitFiles !== undefined ? options.emitFiles : true
+      emitFiles: options.emitFiles !== undefined ? options.emitFiles : true,
+      chunkToGroupMapping: options.chunkToGroupMapping || {}
     };
     this.numericMap = {};
     this.customGroups = {};
     this.manifest = {};
+    this.groupAssetUrls = {};
+    this.preparedAssets = [];
+    this.assetsPrepared = false;
+    this.assetsEmitted = false;
+    this.groupChunkMapping = buildChunkMappingFromGroups(this.options.customGroups);
   }
 
   apply(compiler) {
-    // Detect webpackI18nGroup comments in code
+    // Build-time validation for critical file paths
+    this.validateCriticalFilePaths(compiler); // Detect webpackI18nGroup comments in code
+
     this.detectI18nGroupComments(compiler);
     compiler.hooks.thisCompilation.tap(pluginName, compilation => {
-      // Add runtime module for group-based loading
+      this.groupAssetUrls = {};
+      this.detectedGroups = {};
+      this.preparedAssets = [];
+      this.assetsPrepared = false;
+      this.assetsEmitted = false; // Add runtime module for group-based loading
+
       if (this.options.customGroups) {
         compilation.hooks.additionalTreeRuntimeRequirements.tap(pluginName, (chunk, set) => {
           // Only add to the main/entry chunk to avoid duplication
           if (chunk.name === 'main' || chunk.hasRuntime()) {
+            this.ensureAssetsPrepared(compilation);
+            const chunkMapping = this.getChunkIdToGroupMapping(compilation);
             compilation.addRuntimeModule(chunk, new _I18nGroupRuntimeModule.I18nGroupRuntimeModule({
               customGroups: this.options.customGroups,
+              chunkIdToGroupMapping: chunkMapping,
               localeVarName: this.options.localeVarName,
               jsonpFunc: this.options.jsonpFunc,
-              i18nPublicPathVar: this.options.i18nPublicPathVar
+              i18nPublicPathVar: this.options.i18nPublicPathVar,
+              groupAssetUrls: this.groupAssetUrls,
+              includeContentHash: this.options.includeContentHash
             }));
           }
         });
@@ -63,44 +100,133 @@ class I18nNumericIndexPlugin {
         name: pluginName,
         stage: compilation.PROCESS_ASSETS_STAGE_OPTIMIZE
       }, () => {
-        this.processI18nFiles(compilation);
+        this.ensureAssetsPrepared(compilation);
+        this.emitPreparedAssets(compilation);
       });
     });
   }
 
+  validateCriticalFilePaths(compiler) {
+    const {
+      jsResourcePath,
+      propertiesFolderPath,
+      numericMapPath
+    } = this.options;
+    const missingPaths = [];
+    const resolvedPaths = []; // Check jsResourcePath (must exist)
+
+    if (jsResourcePath) {
+      const resolvedJsPath = _path.default.resolve(compiler.context, jsResourcePath);
+
+      resolvedPaths.push(`jsResourcePath: ${resolvedJsPath}`);
+
+      if (!_fs.default.existsSync(resolvedJsPath)) {
+        missingPaths.push(`jsResourcePath: ${resolvedJsPath}`);
+      }
+    } else {
+      missingPaths.push('jsResourcePath: [not configured]');
+    } // Check propertiesFolderPath (must exist)
+
+
+    if (propertiesFolderPath) {
+      const resolvedPropsPath = _path.default.resolve(compiler.context, propertiesFolderPath);
+
+      resolvedPaths.push(`propertiesFolderPath: ${resolvedPropsPath}`);
+
+      if (!_fs.default.existsSync(resolvedPropsPath)) {
+        missingPaths.push(`propertiesFolderPath: ${resolvedPropsPath}`);
+      }
+    } else {
+      missingPaths.push('propertiesFolderPath: [not configured]');
+    } // Check numericMapPath (must exist)
+
+
+    if (numericMapPath) {
+      const resolvedMapPath = _path.default.resolve(compiler.context, numericMapPath);
+
+      resolvedPaths.push(`numericMapPath: ${resolvedMapPath}`);
+
+      if (!_fs.default.existsSync(resolvedMapPath)) {
+        missingPaths.push(`numericMapPath: ${resolvedMapPath}`);
+      }
+    } else {
+      missingPaths.push('numericMapPath: [not configured]');
+    } // If any critical files are missing, fail the build immediately
+
+
+    if (missingPaths.length > 0) {
+      const errorMessage = ['', '🚨 I18N BUILD FAILURE: Critical i18n files are missing!', '', 'The following required files could not be found:', ...missingPaths.map(path => `  ❌ ${path}`), '', 'These files are essential for i18n functionality. Please ensure they exist before building.', '', 'Resolved paths checked:', ...resolvedPaths.map(path => `  📁 ${path}`), ''].join('\n');
+      throw new Error(errorMessage);
+    } // Log successful validation in development mode
+
+
+    if (compiler.options.mode === 'development') {
+      console.log('✅ I18n critical file validation passed:');
+      resolvedPaths.forEach(path => console.log(`  📁 ${path}`));
+    }
+  }
+
   detectI18nGroupComments(compiler) {
     compiler.hooks.normalModuleFactory.tap(pluginName, factory => {
       factory.hooks.parser.for('javascript/auto').tap(pluginName, parser => {
         parser.hooks.importCall.tap(pluginName, expr => {
-          // Check for webpackI18nGroup comment
           const comments = expr.leadingComments || [];
-          comments.forEach(comment => {
-            if (comment.value && comment.value.includes('webpackI18nGroup')) {
-              const match = comment.value.match(/webpackI18nGroup:\s*["']([^"']+)["']/);
 
-              if (match) {
-                const groupName = match[1]; // Store this information for later use
+          if (comments.length > 0) {
+            comments.forEach(comment => {
+              if (comment.value && comment.value.includes('webpackI18nGroup')) {
+                const match = comment.value.match(/webpackI18nGroup:\s*["']([^"']+)["']/);
 
-                if (!this.detectedGroups) {
-                  this.detectedGroups = {};
-                } // Extract chunk name from webpackChunkName comment
+                if (match) {
+                  const groupName = match[1];
 
+                  if (!this.detectedGroups) {
+                    this.detectedGroups = {};
+                  }
 
-                const chunkNameMatch = comment.value.match(/webpackChunkName:\s*["']([^"']+)["']/);
+                  const chunkNameMatch = comment.value.match(/webpackChunkName:\s*["']([^"']+)["']/);
 
-                if (chunkNameMatch) {
-                  const chunkName = chunkNameMatch[1];
-                  this.detectedGroups[chunkName] = groupName;
+                  if (chunkNameMatch) {
+                    const chunkName = chunkNameMatch[1];
+                    this.detectedGroups[chunkName] = groupName;
+                  }
                 }
               }
-            }
-          });
+            });
+          }
         });
       });
     });
   }
 
+  getChunkIdToGroupMapping(compilation) {
+    const chunkIdToGroup = {};
+    const configuredMappings = { ...this.groupChunkMapping,
+      ...(this.options.chunkToGroupMapping || {})
+    }; // Process chunks to get their actual IDs and map to groups
+
+    for (const chunk of compilation.chunks) {
+      const chunkName = chunk.name; // First try detected groups, then fall back to configured mappings
+
+      let groupName = null;
+
+      if (this.detectedGroups && this.detectedGroups[chunkName]) {
+        groupName = this.detectedGroups[chunkName];
+      } else if (configuredMappings[chunkName]) {
+        groupName = configuredMappings[chunkName];
+      }
+
+      if (groupName) {
+        chunkIdToGroup[chunk.id] = groupName;
+      }
+    }
+
+    return chunkIdToGroup;
+  }
+
   processI18nFiles(compilation) {
+    this.preparedAssets = [];
+    this.groupAssetUrls = {};
     const {
       jsResourcePath,
       propertiesFolderPath,
@@ -113,14 +239,17 @@ class I18nNumericIndexPlugin {
 
     if (!jsResourcePath || !propertiesFolderPath) {
       return;
-    } // Load existing numeric map if available
+    } // Reset build-scoped caches so incremental builds don't carry stale data
+
 
+    this.numericMap = {};
+    this.manifest = {};
+    this.customGroups = {}; // Load existing numeric map if available
 
     if (numericMapPath) {
       const mapData = (0, _i18nDataLoader.loadNumericMap)(numericMapPath, compilation);
 
       if (mapData && mapData.sortedKeys) {
-        // Initialize numericMap from existing data
         mapData.sortedKeys.forEach((key, id) => {
           if (key) {
             this.numericMap[key] = id;
@@ -146,15 +275,9 @@ class I18nNumericIndexPlugin {
 
     Object.keys(allI18nObject).forEach(loc => {
       allI18nObject[loc] = this.normalizeObjectValues(allI18nObject[loc]);
-    }); // For en_US, use only JSResources (don't merge with ApplicationResources_en_US)
-
-    if (allI18nObject['en_US']) {
-      allI18nObject['en_US'] = jsResourceKeys;
-    } else {
-      // If en_US doesn't exist in the folder, create it from JSResources
-      allI18nObject['en_US'] = jsResourceKeys;
-    } // If requested, restrict all locales to base (English) keys only
+    }); // For en_US, use only JSResources
 
+    allI18nObject['en_US'] = jsResourceKeys; // If requested, restrict all locales to base (English) keys only
 
     if (this.options.restrictToBaseKeys) {
       const baseKeys = Object.keys(jsResourceKeys);
@@ -185,8 +308,11 @@ class I18nNumericIndexPlugin {
       Object.keys(localeData).forEach(key => {
         const value = localeData[key]; // Simple logic: if has numeric ID use it, otherwise it's dynamic
 
-        if (this.numericMap[key]) {
-          const numericKey = String(this.numericMap[key]); // Check if belongs to a custom group
+        const numericId = this.numericMap[key];
+        const hasNumericId = numericId !== undefined && numericId !== null;
+
+        if (hasNumericId) {
+          const numericKey = String(numericId); // Check if belongs to a custom group
 
           const belongsToGroup = this.getKeyGroup(key);
 
@@ -196,31 +322,29 @@ class I18nNumericIndexPlugin {
             numericData[numericKey] = value;
           }
         } else {
-          // No numeric ID = dynamic key (regardless of placeholders)
+          // No numeric ID = dynamic key
           dynamicData[key] = value;
         }
       }); // Handle single-file mode or separate files
 
       if (this.options.singleFile) {
-        // Combine numeric and dynamic data into a single file
         const combinedData = { ...numericData,
           ...dynamicData
         };
 
         if (Object.keys(combinedData).length > 0) {
-          // Use singleFileTemplate for combined file - no fileType suffix needed
           const singleFileTemplate = this.options.singleFileTemplate || '[locale].js';
-          this.emitChunk(compilation, singleFileTemplate, locale, combinedData, jsonpFunc, null, null);
+          this.prepareChunkAsset(compilation, singleFileTemplate, locale, combinedData, jsonpFunc, null, null);
         }
       } else {
         // Emit numeric chunk
         if (Object.keys(numericData).length > 0) {
-          this.emitChunk(compilation, numericFilenameTemplate, locale, numericData, jsonpFunc, null, 'numeric');
+          this.prepareChunkAsset(compilation, numericFilenameTemplate, locale, numericData, jsonpFunc, null, 'numeric');
         } // Emit dynamic chunk
 
 
         if (Object.keys(dynamicData).length > 0) {
-          this.emitChunk(compilation, dynamicFilenameTemplate, locale, dynamicData, jsonpFunc, null, 'dynamic');
+          this.prepareChunkAsset(compilation, dynamicFilenameTemplate, locale, dynamicData, jsonpFunc, null, 'dynamic');
         }
       } // Emit custom group chunks (always separate)
 
@@ -230,7 +354,7 @@ class I18nNumericIndexPlugin {
 
         if (groupConfig && Object.keys(data).length > 0) {
           const groupTemplate = groupConfig.filenameTemplate || `[locale]/${groupName}.i18n.js`;
-          this.emitChunk(compilation, groupTemplate, locale, data, jsonpFunc, groupName, `group-${groupName}`);
+          this.prepareChunkAsset(compilation, groupTemplate, locale, data, jsonpFunc, groupName, `group-${groupName}`);
         }
       });
     }); // Generate manifest file if enabled
@@ -239,9 +363,34 @@ class I18nNumericIndexPlugin {
       const manifestPath = this.options.manifestPath || _path.default.join(this.options.outputFolder, 'manifest.json');
 
       const manifestContent = JSON.stringify(this.manifest, null, 2);
-      compilation.emitAsset(manifestPath, new RawSource(manifestContent));
-    } // Don't save numeric map - it should only be generated by the external script
+      this.preparedAssets.push({
+        outputPath: manifestPath,
+        source: new RawSource(manifestContent),
+        shouldEmit: true
+      });
+    }
+  }
+
+  ensureAssetsPrepared(compilation) {
+    if (this.assetsPrepared) {
+      return;
+    }
+
+    this.processI18nFiles(compilation);
+    this.assetsPrepared = true;
+  }
+
+  emitPreparedAssets(compilation) {
+    if (this.assetsEmitted) {
+      return;
+    }
 
+    this.preparedAssets.forEach(asset => {
+      if (asset.shouldEmit !== false) {
+        compilation.emitAsset(asset.outputPath, asset.source);
+      }
+    });
+    this.assetsEmitted = true;
   }
 
   parseCustomGroups(jsResourcePath, customGroups) {
@@ -282,16 +431,6 @@ class I18nNumericIndexPlugin {
     return null;
   }
 
-  isDynamicKey(value) {
-    // Check if value contains placeholders like {0}, {1}, etc.
-    return /\{\d+\}/.test(value);
-  }
-
-  getNumericKey(key) {
-    // Return numeric ID if it exists, null otherwise
-    return this.numericMap[key] ? String(this.numericMap[key]) : null;
-  }
-
   generateContentHash(content, compilation) {
     const {
       hashFunction,
@@ -307,31 +446,22 @@ class I18nNumericIndexPlugin {
 
   constructFilePath(template, locale) {
     const {
-      outputFolder,
-      singleFile
-    } = this.options; // Replace locale placeholder
-
-    let filePath = template.replace(/\[locale\]/g, locale); // If template already contains outputFolder or starts with a path separator, use as-is
+      outputFolder
+    } = this.options;
+    const filePath = template.replace(/\[locale\]/g, locale); // If template already contains outputFolder or starts with path separator, use as-is
 
     if (filePath.includes(outputFolder) || filePath.startsWith('/')) {
-      return filePath.replace(/\\/g, '/');
-    } // For single-file mode with a simple template like '[locale].js', 
-    // put it directly in outputFolder without subdirectories
-
-
-    if (singleFile && !filePath.includes('/')) {
-      return _path.default.join(outputFolder, filePath).replace(/\\/g, '/');
-    } // For other cases, if template contains subdirectories, preserve them
+      return filePath;
+    } // Otherwise, join with outputFolder
 
 
     return _path.default.join(outputFolder, filePath).replace(/\\/g, '/');
   }
 
-  emitChunk(compilation, filenameTemplate, locale, data, jsonpFunc, groupName = null, fileType = null) {
+  prepareChunkAsset(compilation, filenameTemplate, locale, data, jsonpFunc, groupName = null, fileType = null) {
     if (!filenameTemplate || Object.keys(data).length === 0) {
       return null;
-    } // Generate content regardless of emitFiles flag (needed for runtime)
-
+    }
 
     const content = this.generateChunkContent(data, jsonpFunc, groupName);
     let outputPath = this.constructFilePath(filenameTemplate, locale); // Handle [contenthash] placeholder in template
@@ -340,42 +470,59 @@ class I18nNumericIndexPlugin {
       const contentHash = this.generateContentHash(content, compilation);
       outputPath = outputPath.replace(/\[contenthash\]/g, contentHash);
     } else if (this.options.includeContentHash) {
-      // Legacy: Add content hash before .js extension if includeContentHash is true
       const contentHash = this.generateContentHash(content, compilation);
       outputPath = outputPath.replace(/\.js$/, `.${contentHash}.js`);
     } // Track in manifest if enabled
 
 
     if (this.options.generateManifest) {
-      // For single-file mode, use clean locale.js format
-      let manifestKey;
-
-      if (this.options.singleFile) {
-        // Just use locale.js without path or type suffix
-        manifestKey = `${locale}.js`;
-      } else {
-        // For multi-file mode, include the full path
-        const cleanName = this.constructFilePath(filenameTemplate, locale);
-        manifestKey = fileType ? cleanName.replace(/\.js$/, `.${fileType}.js`) : cleanName;
-      }
-
+      const manifestKey = this.options.singleFile ? `${locale}.js` : outputPath;
       this.manifest[manifestKey] = _path.default.basename(outputPath);
-    } // Only emit the file if emitFiles is true
+    }
 
+    const source = new RawSource(content);
+    const assetInfo = {
+      locale,
+      fileType,
+      outputPath,
+      filenameTemplate
+    };
+    this.registerEmittedAsset(compilation, assetInfo);
+    this.preparedAssets.push({
+      outputPath,
+      source,
+      shouldEmit: this.options.emitFiles,
+      info: assetInfo
+    });
+    return outputPath;
+  }
 
-    if (this.options.emitFiles) {
-      compilation.emitAsset(outputPath, new RawSource(content));
+  registerEmittedAsset(compilation, assetInfo) {
+    if (!Object.prototype.hasOwnProperty.call(compilation, assetStoreKey)) {
+      Object.defineProperty(compilation, assetStoreKey, {
+        configurable: true,
+        enumerable: false,
+        value: []
+      });
     }
 
-    return outputPath;
+    compilation[assetStoreKey].push(assetInfo);
+
+    if (assetInfo.fileType && assetInfo.fileType.startsWith('group-')) {
+      const groupName = assetInfo.fileType.slice('group-'.length);
+
+      if (!this.groupAssetUrls[groupName]) {
+        this.groupAssetUrls[groupName] = {};
+      }
+
+      this.groupAssetUrls[groupName][assetInfo.locale] = assetInfo.outputPath;
+    }
   }
 
   generateChunkContent(data, jsonpFunc, groupName) {
-    // Decode Unicode escapes to convert \uXXXX to actual characters
     const jsonString = (0, _propertiesUtils.decodeUnicodeEscapes)(JSON.stringify(data));
 
     if (groupName) {
-      // Include group name for lazy loading identification
       return `${jsonpFunc}(${jsonString}, "${groupName}");`;
     }
 

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

@@ -47,7 +47,24 @@ function loadNumericMap(numericMapPath, compilation) {
     } // Create sorted array for numeric ID lookups
 
 
-    const maxId = Math.max(...Object.values(numericMap));
+    const values = Object.values(numericMap);
+
+    if (values.length === 0) {
+      throw new Error('numeric map is empty');
+    }
+
+    let maxId = 0;
+    values.forEach(id => {
+      const numericId = typeof id === 'number' ? id : Number(id);
+
+      if (Number.isNaN(numericId)) {
+        throw new Error(`invalid numeric map entry value: ${id}`);
+      }
+
+      if (numericId > maxId) {
+        maxId = numericId;
+      }
+    });
     const sortedKeys = new Array(maxId + 1);
     Object.entries(numericMap).forEach(([key, id]) => {
       sortedKeys[id] = key;

package/lib/shared/bundler/webpack/loaders/i18nIdReplaceLoader.js

@@ -20,16 +20,7 @@ module.exports = function i18nIdReplaceLoader(source, map) {
   const resourcePath = this.resourcePath;
   this.cacheable && this.cacheable();
   const options = getOptions(this) || {};
-  const callback = this.async();
-  let numericMapAbsPath = null;
-
-  if (options.numericMapPath) {
-    try {
-      numericMapAbsPath = path.isAbsolute(options.numericMapPath) ? options.numericMapPath : path.resolve(this.rootContext || this.context || process.cwd(), options.numericMapPath);
-      this.addDependency(numericMapAbsPath);
-    } catch (e) {}
-  } // Skip files in excluded paths
-
+  const callback = this.async(); // Skip files in excluded paths
 
   if (options.excludePaths) {
     const shouldExclude = options.excludePaths.some(excludePath => resourcePath.includes(excludePath));
@@ -51,46 +42,23 @@ module.exports = function i18nIdReplaceLoader(source, map) {
 
   if (!options.allI18nData || Object.keys(options.allI18nData).length === 0) {
     return callback(new Error(`i18nIdReplaceLoader: 'allI18nData' option is missing or empty`));
-  } // Load numeric ID mapping (use injected map if provided; fallback to memoized file read)
+  } // Load numeric ID mapping
 
 
-  let numericIdMap = options.numericIdMap || null;
+  let numericIdMap = options.numericIdMap;
 
-  try {
-    if (!numericIdMap && (numericMapAbsPath || options.numericMapPath)) {
-      // Module-level static cache
-      if (!global.__CBT_I18N_NUMERIC_MAP_CACHE__) {
-        global.__CBT_I18N_NUMERIC_MAP_CACHE__ = {};
-      }
+  if (!numericIdMap && options.numericMapPath) {
+    try {
+      const mapPath = path.isAbsolute(options.numericMapPath) ? options.numericMapPath : path.resolve(this.rootContext || this.context || process.cwd(), options.numericMapPath);
+      this.addDependency(mapPath);
 
-      const cache = global.__CBT_I18N_NUMERIC_MAP_CACHE__;
-      const p = numericMapAbsPath || options.numericMapPath;
-
-      try {
-        const stat = fs.statSync(p);
-        const key = `${p}`;
-        const mtime = stat && stat.mtimeMs ? stat.mtimeMs : 0;
-        const hit = cache[key];
-
-        if (hit && hit.mtime === mtime && hit.map) {
-          numericIdMap = hit.map;
-        } else if (fs.existsSync(p)) {
-          const txt = fs.readFileSync(p, 'utf-8');
-          const parsed = JSON.parse(txt);
-          const mapObj = parsed && parsed.originalKeyToNumericId ? parsed.originalKeyToNumericId : parsed;
-
-          if (mapObj && typeof mapObj === 'object') {
-            cache[key] = {
-              mtime,
-              map: mapObj
-            };
-            numericIdMap = mapObj;
-          }
-        }
-      } catch (e) {// ignore and proceed without map
+      if (fs.existsSync(mapPath)) {
+        const mapContent = fs.readFileSync(mapPath, 'utf-8');
+        const parsed = JSON.parse(mapContent);
+        numericIdMap = parsed.originalKeyToNumericId || parsed;
       }
+    } catch (e) {// Silently continue without numeric map
     }
-  } catch (e) {// ignore
   } // If no numeric map available, return source as-is
 
 
@@ -98,13 +66,11 @@ module.exports = function i18nIdReplaceLoader(source, map) {
     return callback(null, source, map);
   }
 
-  const isDevMode = options.devMode || process.env.NODE_ENV === 'development';
-
   try {
     // Parse the JavaScript/TypeScript source code
     const ast = parser.parse(source, {
       sourceType: 'module',
-      plugins: ['jsx', 'typescript', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator'],
+      plugins: ['jsx', 'typescript'],
       sourceFilename: resourcePath
     });
     let hasTransformations = false; // Traverse AST and replace i18n keys with numeric IDs
@@ -113,14 +79,9 @@ module.exports = function i18nIdReplaceLoader(source, map) {
       StringLiteral(path) {
         const {
           node
-        } = path; // Check if this string is an i18n key
-
-        if (!options.allI18nData.hasOwnProperty(node.value)) {
-          return;
-        } // Replace with numeric ID if available
-
+        } = path; // Check if this string is an i18n key and has numeric mapping
 
-        if (numericIdMap.hasOwnProperty(node.value)) {
+        if (options.allI18nData.hasOwnProperty(node.value) && numericIdMap.hasOwnProperty(node.value)) {
           const numericId = String(numericIdMap[node.value]);
           path.replaceWith(t.stringLiteral(numericId));
           hasTransformations = true;

package/lib/shared/bundler/webpack/optimizationConfig.js

@@ -23,10 +23,7 @@ function optimizationConfig(options) {
   } = options;
   const {
     chunkSplitEnable
-  } = options.i18nChunkSplit; // TEMP: Test console logs for minification verification
-
-  console.log('MINIFY_TEST: optimizationConfig called in mode:', options.mode);
-  console.log('MINIFY_TEST: TerserPlugin and CSS minification active');
+  } = options.i18nChunkSplit;
   const i18nChunkFilename = (0, _nameTemplates.nameTemplates)('i18njs', options);
   const chunkFilenameHasContentHash = (0, _hashUtils.hasContentHash)(i18nChunkFilename);
   /**

package/lib/shared/bundler/webpack/pluginConfigs/configI18nNumericIndexPlugin.js

@@ -90,6 +90,7 @@ function configI18nNumericIndexPlugin(options) {
     generateManifest: i18nOpts.generateManifest || false,
     manifestPath: i18nOpts.manifestPath || null,
     customGroups: i18nOpts.customGroups || null,
+    chunkToGroupMapping: i18nOpts.chunkToGroupMapping || {},
     emitFiles: i18nOpts.emitFiles !== undefined ? i18nOpts.emitFiles : true,
     isDevelopment: isDevelopment,
     i18nPublicPathVar: i18nOpts.i18nPublicPathVar
@@ -105,7 +106,8 @@ function configI18nNumericIndexPlugin(options) {
     i18nAssetsPublicPathPrefix: '',
     injectI18nUrlInIndex: i18nOpts.injectI18nUrlInIndex !== undefined ? i18nOpts.injectI18nUrlInIndex : true,
     // Control HTML injection
-    isDevelopment: isDevelopment
+    isDevelopment: isDevelopment,
+    includeContentHash: i18nOpts.includeContentHash || false
   };
   const i18nNumericPluginInstance = new _I18nNumericIndexPlugin.default(numericIndexPluginOptions);
   const htmlInjectorPluginInstance = new _I18nNumericIndexHtmlInjectorPlugin.I18nNumericIndexHtmlInjectorPlugin(htmlInjectorOptions);

package/lib/shared/bundler/webpack/plugins.js

@@ -55,9 +55,6 @@ var _configCustomScriptLoadingStrategyPlugin = require("./pluginConfigs/configCu
 function plugins(options) {
   const {
     webpackPlugins
-  } = options; // TEMP: Test console logs for minification verification
-
-  console.log('MINIFY_TEST: plugins function called with options:', options.mode);
-  console.log('MINIFY_TEST: This message should be visible if minification is disabled');
+  } = options;
   return [(0, _configEnvVariables.configEnvVariables)(options), (0, _configCustomAttributesPlugin.configCustomAttributesPlugin)(options), (0, _configTPHashMappingPlugin.configTPHashMappingPlugin)(options), (0, _configCopyPublicFolders.configCopyPublicFolders)(options), (0, _configIgnorePlugin.configIgnorePlugin)(options), (0, _configMiniCSSExtractPlugin.configMiniCSSExtractPlugin)(options), (0, _configSelectorWeightPlugin.configSelectorWeightPlugin)(options), (0, _configVariableConversionPlugin.configVariableConversionPlugin)(options), (0, _configI18nSplitPlugin.configI18nSplitPlugin)(options), ...((0, _configI18nNumericIndexPlugin.configI18nNumericIndexPlugin)(options) || []), (0, _configRtlCssPlugin.configRtlCssPlugin)(options), (0, _configHtmlWebpackPlugin.configHtmlWebpackPlugin)(options), (0, _configCustomScriptLoadingStrategyPlugin.configCustomScriptLoadingStrategyPlugin)(options), (0, _configCdnChangePlugin.configCdnChangePlugin)(options), (0, _configServiceWorkerPlugin.configServiceWorkerPlugin)(options), (0, _configEFCTemplatePlugin.configEFCTemplatePlugin)(options), (0, _configResourceHintsPlugin.configResourceHintsPlugin)(options), (0, _configBundleAnalyzer.configBundleAnalyzer)(options), (0, _configManifestJsonPlugin.configManifestJsonPlugin)(options), (0, _configSourceMapPlugin.configSourceMapPlugin)(options), (0, _configProgressPlugin.configProgressPlugin)(options), (0, _configBundleIntegrityReport.configBundleIntegrityReport)(options), (0, _configRuntimeResourceCleanup.configRuntimeResourceCleanup)(options), ...webpackPlugins].filter(Boolean);
 }