@zohodesk/client_build_tool 0.0.11-exp.26.0 → 0.0.11-exp.28.0

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

@@ -15,15 +15,34 @@ var _propertiesUtils = require("../I18nSplitPlugin/utils/propertiesUtils");
 
 var _I18nGroupRuntimeModule = require("./I18nGroupRuntimeModule");
 
-var _i18nDataLoader = require("./utils/i18nDataLoader");
+var _i18nDataLoader = require("./utils/i18nDataLoader.js");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 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

@@ -1,21 +1,24 @@
 "use strict";
 
-const fs = require('fs');
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadAllLocaleFiles = loadAllLocaleFiles;
+exports.loadI18nData = loadI18nData;
+exports.loadNumericMap = loadNumericMap;
+exports.loadPropertiesFile = loadPropertiesFile;
 
-const path = require('path');
+var _fs = _interopRequireDefault(require("fs"));
 
-const {
-  getPropertiesAsJSON
-} = require('../../I18nSplitPlugin/utils/propertiesUtils');
-/**
- * Load and parse a properties file
- */
+var _path = _interopRequireDefault(require("path"));
 
+var _propertiesUtils = require("../../I18nSplitPlugin/utils/propertiesUtils.js");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function loadPropertiesFile(filePath, compilation, description) {
   try {
-    const parsed = getPropertiesAsJSON(filePath);
-    return parsed;
+    return (0, _propertiesUtils.getPropertiesAsJSON)(filePath);
   } catch (err) {
     if (compilation) {
       compilation.errors.push(new Error(`I18nNumericIndexPlugin: Error loading ${description}: ${err.message}`));
@@ -24,30 +27,16 @@ function loadPropertiesFile(filePath, compilation, description) {
     return {};
   }
 }
-/**
- * Load numeric mapping from JSON file
- */
-
 
 function loadNumericMap(numericMapPath, compilation) {
   try {
-    const fileContent = fs.readFileSync(numericMapPath, 'utf-8');
-    const parsedData = JSON.parse(fileContent);
-    let numericMap;
-    let totalKeys; // Handle both wrapped and flat formats
-
-    if (parsedData.originalKeyToNumericId) {
-      // New format with metadata
-      numericMap = parsedData.originalKeyToNumericId;
-      totalKeys = parsedData.totalKeysInMap || Object.keys(numericMap).length;
-    } else {
-      // Flat format - use directly
-      numericMap = parsedData;
-      totalKeys = Object.keys(numericMap).length;
-    } // Create sorted array for numeric ID lookups
+    const fileContent = _fs.default.readFileSync(numericMapPath, 'utf-8');
 
-
-    const maxId = Math.max(...Object.values(numericMap));
+    const parsedData = JSON.parse(fileContent);
+    const numericMap = parsedData.originalKeyToNumericId || parsedData;
+    const totalKeys = parsedData.totalKeysInMap || Object.keys(numericMap).length;
+    const values = Object.values(numericMap);
+    const maxId = Math.max(...values.map(id => typeof id === 'number' ? id : Number(id)));
     const sortedKeys = new Array(maxId + 1);
     Object.entries(numericMap).forEach(([key, id]) => {
       sortedKeys[id] = key;
@@ -67,30 +56,26 @@ function loadNumericMap(numericMapPath, compilation) {
     };
   }
 }
-/**
- * Load all locale files from properties directory
- */
-
 
 function loadAllLocaleFiles(propertiesPath, compilation, jsResourceBase) {
-  const allI18n = {};
-  const locales = []; // Start with English base
-
-  allI18n['en_US'] = jsResourceBase;
-  locales.push('en_US');
+  const allI18n = {
+    en_US: jsResourceBase
+  };
+  const locales = ['en_US'];
 
   try {
-    const files = fs.readdirSync(propertiesPath);
-    files.forEach(file => {
-      if (!file.endsWith('.properties')) return; // Match locale-specific property files
+    const files = _fs.default.readdirSync(propertiesPath);
 
+    files.forEach(file => {
+      if (!file.endsWith('.properties')) return;
       const match = file.match(/^ApplicationResources_([a-z]{2}_[A-Z]{2})\.properties$/);
 
       if (match) {
         const locale = match[1];
-        const filePath = path.join(propertiesPath, file);
-        const localeData = loadPropertiesFile(filePath, compilation, `locale ${locale}`); // Merge with base resources
 
+        const filePath = _path.default.join(propertiesPath, file);
+
+        const localeData = loadPropertiesFile(filePath, compilation, `locale ${locale}`);
         allI18n[locale] = { ...jsResourceBase,
           ...localeData
         };
@@ -111,17 +96,13 @@ function loadAllLocaleFiles(propertiesPath, compilation, jsResourceBase) {
     locales
   };
 }
-/**
- * Main loader function for i18n data
- */
-
 
 function loadI18nData(options, compilation) {
-  const jsResourcePath = path.resolve(compilation.compiler.context, options.jsResourcePath);
-  const propertiesPath = path.resolve(compilation.compiler.context, options.propertiesFolderPath); // Load base JS resources
+  const jsResourcePath = _path.default.resolve(compilation.compiler.context, options.jsResourcePath);
 
-  const jsResourceBase = loadPropertiesFile(jsResourcePath, compilation, 'JS resources'); // Load all locale files
+  const propertiesPath = _path.default.resolve(compilation.compiler.context, options.propertiesFolderPath);
 
+  const jsResourceBase = loadPropertiesFile(jsResourcePath, compilation, 'JS resources');
   const {
     allI18n,
     locales
@@ -131,11 +112,4 @@ function loadI18nData(options, compilation) {
     allI18n,
     locales
   };
-}
-
-module.exports = {
-  loadPropertiesFile,
-  loadNumericMap,
-  loadAllLocaleFiles,
-  loadI18nData
-};
+}