@zohodesk/client_build_tool 0.0.11-exp.26.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,40 +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
-      console.log('[I18nNumericIndexPlugin] customGroups:', this.options.customGroups);
+      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()) {
-            const chunkMapping = this.getChunkIdToGroupMapping(compilation); // Only log if we have actual mappings or it's the first time
-
-            const hasMapping = Object.keys(chunkMapping).length > 0;
-
-            if (hasMapping || !this._hasLoggedRuntime) {
-              console.log('[I18nNumericIndexPlugin] Adding runtime module to chunk:', chunk.name);
-              console.log('[I18nNumericIndexPlugin] Chunk mapping for runtime:', chunkMapping);
-              this._hasLoggedRuntime = true;
-            }
-
+            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
             }));
           }
         });
@@ -76,49 +100,96 @@ 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) {
-    console.log('[I18nNumericIndexPlugin] Setting up i18n group comment detection');
     compiler.hooks.normalModuleFactory.tap(pluginName, factory => {
       factory.hooks.parser.for('javascript/auto').tap(pluginName, parser => {
         parser.hooks.importCall.tap(pluginName, expr => {
-          // Only log if comments exist to reduce noise
           const comments = expr.leadingComments || [];
 
           if (comments.length > 0) {
-            console.log('[I18nNumericIndexPlugin] Import call with comments detected');
-            console.log('[I18nNumericIndexPlugin] Leading comments count:', comments.length);
-            comments.forEach((comment, index) => {
-              console.log(`[I18nNumericIndexPlugin] Comment ${index}:`, comment.value);
-
+            comments.forEach(comment => {
               if (comment.value && comment.value.includes('webpackI18nGroup')) {
-                console.log('[I18nNumericIndexPlugin] Found webpackI18nGroup comment:', comment.value);
                 const match = comment.value.match(/webpackI18nGroup:\s*["']([^"']+)["']/);
 
                 if (match) {
                   const groupName = match[1];
-                  console.log('[I18nNumericIndexPlugin] Extracted group name:', groupName); // Store this information for later use
 
                   if (!this.detectedGroups) {
                     this.detectedGroups = {};
-                  } // Extract chunk name from webpackChunkName comment
-
+                  }
 
                   const chunkNameMatch = comment.value.match(/webpackChunkName:\s*["']([^"']+)["']/);
 
                   if (chunkNameMatch) {
                     const chunkName = chunkNameMatch[1];
-                    console.log('[I18nNumericIndexPlugin] Mapping chunk:', chunkName, '→', groupName);
                     this.detectedGroups[chunkName] = groupName;
-                  } else {
-                    console.log('[I18nNumericIndexPlugin] No webpackChunkName found in comment');
                   }
-                } else {
-                  console.log('[I18nNumericIndexPlugin] webpackI18nGroup pattern did not match');
                 }
               }
             });
@@ -129,53 +200,33 @@ class I18nNumericIndexPlugin {
   }
 
   getChunkIdToGroupMapping(compilation) {
-    const chunkIdToGroup = {}; // Hardcoded chunk name to group mapping based on our setupAsync.js
-
-    const hardcodedMappings = {
-      'SetupHome': 'setup',
-      'preferencePopup': 'setup',
-      'auditloglist': 'setup'
-    };
-    let foundAnyMapping = false;
-    let hasRelevantChunks = false; // Process chunks to get their actual IDs and map to groups
+    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; // Check if this chunk is relevant to setup
-
-      if (chunkName && (chunkName.toLowerCase().includes('setup') || chunkName.toLowerCase().includes('preference') || chunkName.toLowerCase().includes('audit'))) {
-        hasRelevantChunks = true;
-      } // First try detected groups, then fallback to hardcoded mappings
-
+      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];
-        console.log(`[I18nNumericIndexPlugin] Found detected mapping: ${chunkName} → ${groupName} (ID: ${chunk.id})`);
-        foundAnyMapping = true;
-      } else if (hardcodedMappings[chunkName]) {
-        groupName = hardcodedMappings[chunkName];
-        console.log(`[I18nNumericIndexPlugin] Found hardcoded mapping: ${chunkName} → ${groupName} (ID: ${chunk.id})`);
-        foundAnyMapping = true;
+      } else if (configuredMappings[chunkName]) {
+        groupName = configuredMappings[chunkName];
       }
 
       if (groupName) {
         chunkIdToGroup[chunk.id] = groupName;
       }
-    } // Only log summary if we found mappings or relevant chunks
-
-
-    if (foundAnyMapping || hasRelevantChunks || compilation.chunks.size > 0) {
-      console.log('[I18nNumericIndexPlugin] Building chunk ID to group mapping');
-      console.log('[I18nNumericIndexPlugin] Detected groups:', this.detectedGroups);
-      console.log('[I18nNumericIndexPlugin] Total chunks in compilation:', compilation.chunks.size);
-      console.log('[I18nNumericIndexPlugin] Final chunk ID to group mapping:', chunkIdToGroup);
     }
 
     return chunkIdToGroup;
   }
 
   processI18nFiles(compilation) {
+    this.preparedAssets = [];
+    this.groupAssetUrls = {};
     const {
       jsResourcePath,
       propertiesFolderPath,
@@ -188,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;
@@ -221,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);
@@ -260,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);
 
@@ -271,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)
 
@@ -305,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
@@ -314,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) {
@@ -357,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,
@@ -382,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
@@ -415,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);
   /**