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

package/lib/schemas/defaultConfigValues.js

@@ -181,18 +181,6 @@ var _default = {
       value: false,
       cli: 'i18n_idx_enable'
     },
-    disableDefaultMerge: {
-      value: false,
-      cli: 'i18n_idx_disable_default_merge'
-    },
-    htmlTemplateLabel: {
-      value: '{{--user-locale}}',
-      cli: 'i18n_idx_html_template_label'
-    },
-    localeVarName: {
-      value: 'window.userLangCode',
-      cli: 'i18n_idx_locale_var_name'
-    },
     jsResourcePath: {
       value: './deskapp/properties/JSResources.properties',
       cli: 'i18n_idx_js_resource_path'
@@ -201,20 +189,29 @@ var _default = {
       value: './deskapp/properties',
       cli: 'i18n_idx_properties_folder_path'
     },
-    propertiesPattern: {
-      value: ''
-    },
     numericMapPath: {
       value: './deskapp/properties/i18n-numeric-map.json',
       cli: 'i18n_idx_numeric_map_path'
     },
+    numericFilenameTemplate: {
+      value: 'i18n-chunks/[locale]/numeric.[contenthash].js',
+      cli: 'i18n_idx_numeric_filename_template'
+    },
+    dynamicFilenameTemplate: {
+      value: 'i18n-chunks/[locale]/dynamic.[contenthash].js',
+      cli: 'i18n_idx_dynamic_filename_template'
+    },
     jsonpFunc: {
       value: 'window.loadI18nData',
       cli: 'i18n_idx_jsonp_func'
     },
-    fallbackToHash: {
-      value: true,
-      cli: 'i18n_idx_fallback_to_hash'
+    htmlTemplateLabel: {
+      value: '{{--user-locale}}',
+      cli: 'i18n_idx_html_template_label'
+    },
+    localeVarName: {
+      value: 'window.userLangCode',
+      cli: 'i18n_idx_locale_var_name'
     }
   },
   publicFolders: ['...'],

package/lib/schemas/defaultConfigValuesOnly.js

@@ -98,16 +98,14 @@ var _default = {
   },
   i18nIndexing: {
     enable: false,
-    disableDefaultMerge: false,
-    htmlTemplateLabel: '{{--user-locale}}',
-    localeVarName: 'window.userLangCode',
     jsResourcePath: './deskapp/properties/JSResources.properties',
     propertiesFolderPath: './deskapp/properties',
-    propertiesPattern: '',
     numericMapPath: './deskapp/properties/i18n-numeric-map.json',
-    numericJsonpFunc: 'window.loadI18nChunk',
-    dynamicJsonpFunc: 'window.loadI18nChunk',
-    fallbackToHash: true
+    numericFilenameTemplate: 'i18n-chunks/numeric/[locale]/numeric.[contenthash].js',
+    dynamicFilenameTemplate: 'i18n-chunks/dynamic/[locale]/dynamic.[contenthash].js',
+    jsonpFunc: 'window.loadI18nChunk',
+    htmlTemplateLabel: '{{--user-locale}}',
+    localeVarName: 'window.userLangCode'
   },
   publicFolders: ['...', {
     source: './deskapp/tp/',

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

@@ -9,20 +9,72 @@ 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 {
   createHash
 } = require("../I18nSplitPlugin/createHash");
 
+createHashFunction = createHash;
 const {
   RawSource
 } = sources;
 const pluginName = 'I18nNumericIndexPlugin';
 
+function parseProperties(content) {
+  const lines = content.split(/\r?\n/);
+  const data = {};
+
+  for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+    const line = lines[lineNum];
+    const trimmedLine = line.trim();
+
+    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 (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;
+        }
+      }
+    }
+  }
+
+  return {
+    data,
+    problematicLines: []
+  };
+} // This function converts strings like "Hello \\u00E9" to "Hello é"
+
+
+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));
+  });
+}
+
 class I18nNumericIndexPlugin {
-  constructor(options) {
+  constructor(options = {}) {
     this.options = options;
-    this.numericMap = null;
-    this.numericMapPath = options.numericMapPath;
+    this.numericMap = null; // Default emitLiteralUnicode to true if not specified
+
+    if (typeof this.options.emitLiteralUnicode === 'undefined') {
+      this.options.emitLiteralUnicode = true;
+    }
   }
 
   loadNumericMapOnce(compilation) {
@@ -30,9 +82,12 @@ class I18nNumericIndexPlugin {
       return this.numericMap;
     }
 
+    const numericMapPathOpt = this.options.numericMapPath;
+    const numericMapPath = numericMapPathOpt ? path.resolve(compilation.compiler.context, numericMapPathOpt) : null;
+
     try {
-      if (this.numericMapPath && fs.existsSync(this.numericMapPath)) {
-        const fileContent = fs.readFileSync(this.numericMapPath, 'utf-8');
+      if (numericMapPath && fs.existsSync(numericMapPath)) {
+        const fileContent = fs.readFileSync(numericMapPath, 'utf-8');
         const parsedData = JSON.parse(fileContent);
 
         if (parsedData && parsedData.sortedOriginalKeys && parsedData.totalKeys !== undefined) {
@@ -40,24 +95,27 @@ class I18nNumericIndexPlugin {
             sortedOriginalKeys: parsedData.sortedOriginalKeys,
             totalKeys: parsedData.totalKeys
           };
-          compilation.logger.info(`${pluginName}: Loaded numeric map from ${this.numericMapPath}.`);
           return this.numericMap;
         } else {
-          compilation.logger.error(`${pluginName}: Invalid format in numeric map file at ${this.numericMapPath}.`);
+          compilation.warnings.push(new Error(`${pluginName}: numericMap file (${numericMapPath}) parsed but seems malformed. Using empty map.`));
           this.numericMap = {
             sortedOriginalKeys: [],
             totalKeys: 0
           };
         }
       } else {
-        compilation.logger.warn(`${pluginName}: Numeric map path not provided or file not found at ${this.numericMapPath}.`);
+        if (numericMapPathOpt) {
+          // Only warn if a path was actually provided
+          compilation.warnings.push(new Error(`${pluginName}: numericMapPath (${numericMapPath}) not found. Using empty map.`));
+        }
+
         this.numericMap = {
           sortedOriginalKeys: [],
           totalKeys: 0
         };
       }
     } catch (err) {
-      compilation.logger.error(`${pluginName}: Error loading numeric map from ${this.numericMapPath}: ${err.message}`);
+      compilation.errors.push(new Error(`${pluginName}: Error loading/parsing numericMapPath ${numericMapPath}: ${err.message}`));
       this.numericMap = {
         sortedOriginalKeys: [],
         totalKeys: 0
@@ -67,115 +125,258 @@ class I18nNumericIndexPlugin {
     return this.numericMap;
   }
 
-  emitFile(compilation, baseFilenameTemplate, locale, fileContentData, jsonpFunc, typeSuffix = '') {
-    const fileContent = `${jsonpFunc}(${JSON.stringify(fileContentData)});`;
+  loadAllI18nData(compilation) {
+    if (this.options.allI18nObject && this.options.locales) {
+      return {
+        allI18nObject: this.options.allI18nObject,
+        locales: this.options.locales
+      };
+    }
+
+    const allI18nObject = {};
+    const discoveredLocales = new Set();
+    const compilerContext = compilation.compiler.context;
+    const propertiesFolderPathOpt = this.options.propertiesFolderPath;
+    const jsResourcePathOpt = this.options.jsResourcePath;
+
+    if (!propertiesFolderPathOpt) {
+      compilation.errors.push(new Error(`${pluginName}: 'propertiesFolderPath' option is missing, cannot load translations.`));
+      return {
+        allI18nObject,
+        locales: []
+      };
+    }
+
+    const propertiesFolderPath = path.resolve(compilerContext, propertiesFolderPathOpt);
+    const baseJsResourcePath = jsResourcePathOpt ? path.resolve(compilerContext, jsResourcePathOpt) : null;
+
+    if (!fs.existsSync(propertiesFolderPath)) {
+      compilation.errors.push(new Error(`${pluginName}: propertiesFolderPath does not exist: ${propertiesFolderPath}`));
+      return {
+        allI18nObject,
+        locales: []
+      };
+    }
+
+    const baseFileName = baseJsResourcePath ? path.basename(baseJsResourcePath, path.extname(baseJsResourcePath)) : null;
+    const baseExtension = baseJsResourcePath ? path.extname(baseJsResourcePath) : '.properties';
+
+    try {
+      const files = fs.readdirSync(propertiesFolderPath);
+      files.forEach(file => {
+        const filePath = path.join(propertiesFolderPath, file);
+
+        if (fs.statSync(filePath).isFile()) {
+          let locale = null;
+          const ext = path.extname(file);
+          const nameWithoutExt = path.basename(file, ext);
+
+          if (baseFileName && nameWithoutExt.startsWith(baseFileName + '_')) {
+            locale = nameWithoutExt.substring((baseFileName + '_').length);
+          } else if (baseFileName && nameWithoutExt === baseFileName) {
+            locale = this.options.defaultLocaleForBaseFile || 'en';
+          } else if (!baseFileName && nameWithoutExt.includes('_')) {
+            // Generic pattern: messages_fr_CA.properties -> fr_CA
+            const parts = nameWithoutExt.split('_');
+
+            if (parts.length > 1) {
+              locale = parts.slice(1).join('_');
+            }
+          } else if (!baseFileName && !nameWithoutExt.includes('_') && ext.toLowerCase() === baseExtension.toLowerCase()) {
+            // Fallback for files like 'fr.properties' if no baseFileName is defined
+            locale = nameWithoutExt;
+          }
+
+          if (locale && ext.toLowerCase() === baseExtension.toLowerCase()) {
+            try {
+              const fileContent = fs.readFileSync(filePath, 'utf-8');
+              const parseResult = parseProperties(fileContent);
+              allI18nObject[locale] = parseResult.data;
+              discoveredLocales.add(locale);
+            } catch (readErr) {
+              compilation.errors.push(new Error(`${pluginName}: Error reading/parsing properties file ${filePath}: ${readErr.message}`));
+            }
+          }
+        }
+      });
+    } catch (err) {
+      compilation.errors.push(new Error(`${pluginName}: Error reading propertiesFolderPath ${propertiesFolderPath}: ${err.message}`));
+    }
+
+    return {
+      allI18nObject,
+      locales: Array.from(discoveredLocales)
+    };
+  }
+
+  validateAndSanitizeData(data, chunkType, locale, compilation) {
+    // Placeholder for any future validation or sanitization logic
+    return data;
+  }
+
+  emitChunkFile(compilation, filenameTemplate, locale, fileContentData, jsonpFunc, chunkType) {
+    const dataToStringify = this.validateAndSanitizeData(fileContentData, chunkType, locale, compilation);
+    let stringifiedData;
+
+    try {
+      // 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
+      // 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;
+    }
+
+    const fileContent = `${jsonpFunc}(${stringifiedData});`; // RawSource expects a string. If stringifiedData contains literal Unicode,
+    // fileContent will also, and Webpack handles UTF-8 output correctly.
+
     const source = new RawSource(fileContent);
-    const actualContentHash = createHash({
-      //
+    const actualContentHash = createHashFunction({
+      // Ensure createHashFunction is loaded
       outputOptions: compilation.outputOptions,
-      content: fileContent
+      content: fileContent // Hash is based on the final content
+
     });
-    let processedFilenameTemplate = baseFilenameTemplate.replace(/\[locale\]/g, locale).replace(/\[name\]/g, locale).replace(/\[id\]/g, locale);
+    let processedFilenameTemplate = filenameTemplate.replace(/\[locale\]/g, locale).replace(/\[name\]/g, locale).replace(/\[id\]/g, locale);
     const finalFileName = compilation.getAssetPath(processedFilenameTemplate, {
       locale: locale,
       contentHash: actualContentHash,
       hash: compilation.hash,
+      // Webpack compilation hash
       chunk: {
-        id: `i18n-${typeSuffix || 'data'}-${locale}`,
-        name: `${typeSuffix || 'data'}-${locale}`,
+        // Mock chunk object for placeholders
+        id: `i18n-${chunkType}-${locale}`,
+        name: `${chunkType}-${locale}`,
         hash: actualContentHash,
+        // Chunk-specific hash
         contentHash: {
-          [this.options.moduleType || 'i18n/mini-extract']: actualContentHash
+          [this.options.moduleType || 'i18n/data-extract']: actualContentHash
         }
       },
-      contentHashType: this.options.moduleType || 'i18n/mini-extract'
+      contentHashType: this.options.moduleType || 'i18n/data-extract'
     });
     compilation.emitAsset(finalFileName, source);
-    compilation.logger.info(`${pluginName}: Emitted ${typeSuffix} i18n file for locale ${locale} to ${finalFileName}`);
   }
 
   apply(compiler) {
     compiler.hooks.thisCompilation.tap(pluginName, compilation => {
       compilation.hooks.processAssets.tapAsync({
         name: pluginName,
-        stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+        stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE // Or a later stage if needed
+
       }, (assets, callback) => {
+        if (!this.options.enable) {
+          return callback();
+        }
+
         const {
-          sortedOriginalKeys,
-          totalKeys
-        } = this.loadNumericMapOnce(compilation);
+          allI18nObject,
+          locales
+        } = this.loadAllI18nData(compilation);
 
-        if (totalKeys === 0 && (!sortedOriginalKeys || sortedOriginalKeys.length === 0)) {
-          compilation.logger.info(`${pluginName}: No numeric keys to process. Skipping numeric file emission.`);
+        if (!locales || locales.length === 0) {
+          if (this.options.propertiesFolderPath) {
+            // Only warn if path was given
+            compilation.warnings.push(new Error(`${pluginName}: No locales found or no translation data loaded from ${this.options.propertiesFolderPath}.`));
+          }
+
+          return callback();
         }
 
-        const globallyUsedLiteralKeys = new Set();
+        const numericMapData = this.loadNumericMapOnce(compilation);
+        const sortedOriginalKeys = numericMapData.sortedOriginalKeys || [];
+        const totalKeys = numericMapData.totalKeys || 0;
         const globallyUsedCommentKeys = new Set();
 
         for (const module of compilation.modules) {
-          if (module.buildInfo) {
-            if (Array.isArray(module.buildInfo.loaderIdentifiedLiteralI18nKeys)) {
-              module.buildInfo.loaderIdentifiedLiteralI18nKeys.forEach(key => globallyUsedLiteralKeys.add(key));
-            }
-
-            if (Array.isArray(module.buildInfo.loaderIdentifiedCommentI18nKeys)) {
-              module.buildInfo.loaderIdentifiedCommentI18nKeys.forEach(key => globallyUsedCommentKeys.add(key));
-            }
+          if (module.buildInfo && Array.isArray(module.buildInfo.loaderIdentifiedCommentI18nKeys)) {
+            module.buildInfo.loaderIdentifiedCommentI18nKeys.forEach(key => globallyUsedCommentKeys.add(key));
           }
         }
 
-        compilation.logger.info(`${pluginName}: Globally identified Literal Keys: ${globallyUsedLiteralKeys.size}, Comment Keys: ${globallyUsedCommentKeys.size}`);
-        const {
-          locales,
-          allI18nObject,
-          numericFilenameTemplate,
-          dynamicFilenameTemplate,
-          numericJsonpFunc,
-          dynamicJsonpFunc
-        } = this.options;
-
-        if (!locales || !allI18nObject || !numericFilenameTemplate || !dynamicFilenameTemplate || !numericJsonpFunc || !dynamicJsonpFunc) {
-          compilation.errors.push(new Error(`${pluginName}: Missing some required options (locales, allI18nObject, filename templates, jsonp funcs).`));
-          return callback();
+        const numericFilenameTemplate = this.options.numericFilenameTemplate;
+        const dynamicFilenameTemplate = this.options.dynamicFilenameTemplate;
+        const numericJsonpFunction = this.options.numericJsonpFunction || 'loadI18nNumericChunk';
+        const dynamicJsonpFunction = this.options.dynamicJsonpFunction || 'loadI18nDynamicChunk';
+
+        if (!numericFilenameTemplate) {
+          compilation.errors.push(new Error(`${pluginName}: Missing required option 'numericFilenameTemplate' in plugin options.`)); // return callback(); // Allow processing other chunks if one template is missing
+        }
+
+        if (!dynamicFilenameTemplate) {
+          compilation.errors.push(new Error(`${pluginName}: Missing required option 'dynamicFilenameTemplate' in plugin options.`)); // return callback();
+        }
+
+        if (typeof numericFilenameTemplate === 'string' && !numericFilenameTemplate.includes('[locale]') && !numericFilenameTemplate.includes('[name]') && !numericFilenameTemplate.includes('[id]')) {
+          compilation.warnings.push(new Error( // Changed to warning as it might be intentional for a single combined file not per-locale
+          `${pluginName}: The 'numericFilenameTemplate' ("${numericFilenameTemplate}") ` + `does not include '[locale]', '[name]', or '[id]'. All locales will overwrite the same file if multiple locales exist.`));
         }
 
-        if (totalKeys > 0 && sortedOriginalKeys && sortedOriginalKeys.length > 0) {
-          for (const locale of locales) {
-            const localeTranslations = allI18nObject[locale] || {};
-            const orderedNumericTranslations = new Array(totalKeys);
+        if (typeof dynamicFilenameTemplate === 'string' && !dynamicFilenameTemplate.includes('[locale]') && !dynamicFilenameTemplate.includes('[name]') && !dynamicFilenameTemplate.includes('[id]')) {
+          compilation.warnings.push(new Error(`${pluginName}: The 'dynamicFilenameTemplate' ("${dynamicFilenameTemplate}") ` + `does not include '[locale]', '[name]', or '[id]'. All locales will overwrite the same file if multiple locales exist.`));
+        }
+
+        const numericKeysSet = new Set(sortedOriginalKeys);
+
+        for (const locale of locales) {
+          const localeTranslations = allI18nObject[locale] || {};
+          const numericDataForLocale = []; // Fill numericDataForLocale based on sortedOriginalKeys
 
+          if (totalKeys > 0 && sortedOriginalKeys.length > 0) {
             for (let i = 0; i < totalKeys; i++) {
-              const originalKey = sortedOriginalKeys[i];
+              // Iterate up to totalKeys (max expected length)
+              const originalKey = sortedOriginalKeys[i]; // Get key if available
+              // If originalKey is undefined (i < sortedOriginalKeys.length but originalKey is not there due to sparse array or shorter sortedKeys)
+              // or if the translation is missing, push null.
 
-              if (globallyUsedLiteralKeys.has(originalKey)) {
-                orderedNumericTranslations[i] = localeTranslations[originalKey] !== undefined ? localeTranslations[originalKey] : 0; // Use 0 or null as placeholder for missing keys
-              } else {
-                orderedNumericTranslations[i] = 0; // Placeholder for keys not identified as literals or not used
-              }
+              const value = originalKey !== undefined && localeTranslations[originalKey] !== undefined ? localeTranslations[originalKey] : null;
+              numericDataForLocale.push(value);
             }
-
-            this.emitFile(compilation, numericFilenameTemplate, locale, orderedNumericTranslations, numericJsonpFunc, 'numeric');
           }
-        }
 
-        if (globallyUsedCommentKeys.size > 0) {
-          for (const locale of locales) {
-            const localeTranslations = allI18nObject[locale] || {};
-            const dynamicKeyTranslations = {};
-            globallyUsedCommentKeys.forEach(originalKey => {
-              if (localeTranslations[originalKey] !== undefined) {
-                dynamicKeyTranslations[originalKey] = localeTranslations[originalKey];
-              } else {
-                dynamicKeyTranslations[originalKey] = null;
-              }
-            });
-
-            if (Object.keys(dynamicKeyTranslations).length > 0) {
-              this.emitFile(compilation, dynamicFilenameTemplate, locale, dynamicKeyTranslations, dynamicJsonpFunc, 'dynamic');
+          const dynamicDataForLocale = {}; // Process globally used comment keys first
+
+          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
             }
+          }); // Process remaining keys from localeTranslations
+
+          Object.keys(localeTranslations).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 (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 (numericFilenameTemplate && numericDataForLocale.length > 0) {
+            this.emitChunkFile(compilation, numericFilenameTemplate, locale, numericDataForLocale, numericJsonpFunction, 'numeric');
+          }
+
+          if (dynamicFilenameTemplate && Object.keys(dynamicDataForLocale).length > 0) {
+            this.emitChunkFile(compilation, dynamicFilenameTemplate, locale, dynamicDataForLocale, dynamicJsonpFunction, 'dynamic');
           }
-        } else {
-          compilation.logger.info(`${pluginName}: No globally used comment keys found. Skipping dynamic file emission.`);
         }
 
         callback();

package/lib/shared/bundler/webpack/loaderConfigs/i18nIdReplaceLoaderConfig.js

@@ -11,18 +11,20 @@ function loadJSResourcesOnce(options) {
     return allI18nDataFromPropertiesCache;
   }
 
-  let resourcePathToLoad = '';
-
-  if (options.i18nIndexing && options.i18nIndexing.enable && options.i18nIndexing.jsResourcePath) {
-    resourcePathToLoad = options.i18nIndexing.jsResourcePath;
-  } else if (options.i18nChunkSplit && options.i18nChunkSplit.jsResource) {
-    resourcePathToLoad = options.i18nChunkSplit.jsResource;
-  } else {
-    allI18nDataFromPropertiesCache = {};
-    return allI18nDataFromPropertiesCache;
+  if (!options.i18nIndexing || !options.i18nIndexing.enable) {
+    throw new Error('i18nIdReplaceLoader requires i18nIndexing to be enabled');
+  }
+
+  if (!options.i18nIndexing.jsResourcePath) {
+    throw new Error('Missing required jsResourcePath in i18nIndexing options');
+  }
+
+  const propertiesFilePath = path.resolve(process.cwd(), options.i18nIndexing.jsResourcePath);
+
+  if (!fs.existsSync(propertiesFilePath)) {
+    throw new Error(`JSResource file not found at: ${propertiesFilePath}`);
   }
 
-  const propertiesFilePath = path.resolve(process.cwd(), resourcePathToLoad);
   const i18nData = {};
 
   try {
@@ -56,7 +58,12 @@ function loadJSResourcesOnce(options) {
         }
       }
     });
-  } catch (err) {// Silent error handling
+  } catch (err) {
+    throw new Error(`Error reading JSResource file ${propertiesFilePath}: ${err.message}`);
+  }
+
+  if (Object.keys(i18nData).length === 0) {
+    throw new Error(`No i18n data found in JSResource file: ${propertiesFilePath}`);
   }
 
   allI18nDataFromPropertiesCache = i18nData;
@@ -64,25 +71,25 @@ function loadJSResourcesOnce(options) {
 }
 
 function i18nIdReplaceLoaderConfig(options) {
+  if (!options.i18nIndexing || !options.i18nIndexing.enable) {
+    throw new Error('i18nIdReplaceLoader requires i18nIndexing to be enabled');
+  }
+
+  if (!options.i18nIndexing.numericMapPath) {
+    throw new Error('Missing required numericMapPath in i18nIndexing options');
+  }
+
   const allI18nData = loadJSResourcesOnce(options);
 
   const i18nKeyReplaceLoaderPath = require.resolve('../loaders/i18nIdReplaceLoader.js');
 
   const loaderOptions = {
     allI18nData: allI18nData,
-    sourceMaps: !!options.devtool && options.devtool.includes('source-map'),
-    isDebug: options.mode === 'development'
+    sourceMaps: !!(options.devtool && options.devtool.includes('source-map')),
+    isDebug: options.mode === 'development',
+    useNumericIndexing: true,
+    numericMapPath: options.i18nIndexing.numericMapPath
   };
-
-  if (options.i18nIndexing && options.i18nIndexing.enable) {
-    loaderOptions.useNumericIndexing = true;
-    loaderOptions.numericMapPath = options.i18nIndexing.numericMapPath;
-    loaderOptions.fallbackToHash = options.i18nIndexing.fallbackToHash !== undefined ? options.i18nIndexing.fallbackToHash : true;
-  } else {
-    loaderOptions.useNumericIndexing = false;
-    loaderOptions.fallbackToHash = true;
-  }
-
   return {
     loader: i18nKeyReplaceLoaderPath,
     options: loaderOptions

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

@@ -16,18 +16,12 @@ const {
   getOptions
 } = require('loader-utils');
 
-let collectAndCategorizeUsedI18nKeys, generateShortHash;
+let collectAndCategorizeUsedI18nKeys;
 
 try {
   collectAndCategorizeUsedI18nKeys = require('../custom_plugins/I18nSplitPlugin/utils/collectAstKeys').collectAndCategorizeUsedI18nKeys;
-  generateShortHash = require('../common/hashUtils').generateShortHash;
 } catch (e) {
-  collectAndCategorizeUsedI18nKeys = () => ({
-    literalKeys: new Set(),
-    commentKeys: new Set()
-  });
-
-  generateShortHash = key => key;
+  throw new Error('[i18nIdReplaceLoader] Required dependency not found: ' + e.message);
 }
 
 const LOADER_PREFIX = '[i18nIdReplaceLoader]';
@@ -36,34 +30,32 @@ let mapLoadAttemptedForPath = {};
 
 function loadNumericIdMap(loaderContext, mapPath) {
   if (!mapPath) {
-    loaderContext.emitWarning(new Error(`${LOADER_PREFIX} Numeric map path not provided in loader options.`));
-    return null;
+    throw new Error(`${LOADER_PREFIX} Numeric map path not provided in loader options.`);
   }
 
-  if (numericIdMapDataCache && mapLoadAttemptedForPath[mapPath]) {
+  const absoluteMapPath = path.isAbsolute(mapPath) ? mapPath : path.resolve(loaderContext.rootContext || process.cwd(), mapPath);
+
+  if (numericIdMapDataCache && mapLoadAttemptedForPath[absoluteMapPath]) {
     return numericIdMapDataCache;
   }
 
-  mapLoadAttemptedForPath[mapPath] = true;
+  mapLoadAttemptedForPath[absoluteMapPath] = true;
+
+  if (!fs.existsSync(absoluteMapPath)) {
+    throw new Error(`${LOADER_PREFIX} Pre-generated i18n numeric map file NOT FOUND at: ${absoluteMapPath}.`);
+  }
 
   try {
-    if (fs.existsSync(mapPath)) {
-      const fileContent = fs.readFileSync(mapPath, 'utf-8');
-      const parsedData = JSON.parse(fileContent);
-
-      if (parsedData && parsedData.originalKeyToNumericId && typeof parsedData.originalKeyToNumericId === 'object') {
-        numericIdMapDataCache = parsedData.originalKeyToNumericId;
-      } else {
-        loaderContext.emitError(new Error(`${LOADER_PREFIX} Pre-generated map file (${mapPath}) is invalid or does not contain 'originalKeyToNumericId'.`));
-        numericIdMapDataCache = null;
-      }
-    } else {
-      loaderContext.emitError(new Error(`${LOADER_PREFIX} Pre-generated i18n numeric map file NOT FOUND at: ${mapPath}.`));
-      numericIdMapDataCache = null;
+    const fileContent = fs.readFileSync(absoluteMapPath, 'utf-8');
+    const parsedData = JSON.parse(fileContent);
+
+    if (!parsedData || !parsedData.originalKeyToNumericId || typeof parsedData.originalKeyToNumericId !== 'object') {
+      throw new Error(`${LOADER_PREFIX} Pre-generated map file (${absoluteMapPath}) is invalid or does not contain 'originalKeyToNumericId'.`);
     }
+
+    numericIdMapDataCache = parsedData.originalKeyToNumericId;
   } catch (err) {
-    loaderContext.emitError(new Error(`${LOADER_PREFIX} Error loading or parsing pre-generated i18n map from ${mapPath}: ${err.message}`));
-    numericIdMapDataCache = null;
+    throw new Error(`${LOADER_PREFIX} Error loading or parsing pre-generated i18n map from ${absoluteMapPath}: ${err.message}`);
   }
 
   return numericIdMapDataCache;
@@ -77,23 +69,19 @@ module.exports = function i18nIdReplaceLoader(source, map, meta) {
   const loaderContext = this;
 
   if (!options.allI18nData || typeof options.allI18nData !== 'object' || Object.keys(options.allI18nData).length === 0) {
-    this.emitWarning(new Error(`${LOADER_PREFIX} [${resourcePath}] 'allI18nData' option is missing or empty. No replacements will be made.`));
-    return callback(null, source, map);
+    throw new Error(`${LOADER_PREFIX} [${resourcePath}] 'allI18nData' option is missing or empty.`);
   }
 
-  let useNumericIndexing = options.useNumericIndexing !== undefined ? options.useNumericIndexing : true;
-  let localOriginalKeyToNumericIdMap = null;
-
-  if (useNumericIndexing) {
-    localOriginalKeyToNumericIdMap = loadNumericIdMap(this, options.numericMapPath);
+  if (!options.useNumericIndexing) {
+    throw new Error(`${LOADER_PREFIX} [${resourcePath}] 'useNumericIndexing' must be enabled.`);
   }
 
-  const fallbackToHash = options.fallbackToHash !== undefined ? options.fallbackToHash : true;
+  const numericIdMap = loadNumericIdMap(this, options.numericMapPath);
 
   try {
     const parserOptions = {
       sourceType: 'module',
-      plugins: ['jsx', 'typescript', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator'],
+      plugins: ['jsx', 'typescript', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator', 'objectRestSpread', 'dynamicImport'],
       attachComment: true,
       sourceFilename: resourcePath
     };
@@ -119,9 +107,7 @@ module.exports = function i18nIdReplaceLoader(source, map, meta) {
       }
     }
 
-    const keysToReplaceInLiterals = literalKeys;
-
-    if (keysToReplaceInLiterals.size === 0) {
+    if (literalKeys.size === 0) {
       return callback(null, source, map);
     }
 
@@ -133,44 +119,25 @@ module.exports = function i18nIdReplaceLoader(source, map, meta) {
         if ((node.type === 'Literal' || node.type === 'StringLiteral') && typeof node.value === 'string') {
           const originalValue = node.value;
 
-          if (keysToReplaceInLiterals.has(originalValue)) {
-            let replaced = false;
+          if (literalKeys.has(originalValue)) {
+            const numericId = numericIdMap[originalValue];
 
-            if (useNumericIndexing && localOriginalKeyToNumericIdMap) {
-              const numericId = localOriginalKeyToNumericIdMap[originalValue];
+            if (numericId !== undefined) {
+              const numericLiteralNode = {
+                type: 'NumericLiteral',
+                value: numericId
+              };
+              let replacementNode = numericLiteralNode;
 
-              if (numericId !== undefined) {
-                const numericLiteralNode = {
-                  type: 'NumericLiteral',
-                  value: numericId
+              if (parent && parent.type === 'JSXAttribute' && parent.value === node) {
+                replacementNode = {
+                  type: 'JSXExpressionContainer',
+                  expression: numericLiteralNode
                 };
-                let replacementNode = numericLiteralNode;
-
-                if (parent && parent.type === 'JSXAttribute' && parent.value === node) {
-                  replacementNode = {
-                    type: 'JSXExpressionContainer',
-                    expression: numericLiteralNode
-                  };
-                }
-
-                walkerControl.replace(replacementNode);
-                replacementMade = true;
-                replaced = true;
               }
-            }
 
-            if (!replaced && fallbackToHash) {
-              try {
-                const hashValue = generateShortHash(originalValue);
-                const hashedStringLiteralNode = {
-                  type: 'StringLiteral',
-                  value: hashValue
-                };
-                walkerControl.replace(hashedStringLiteralNode);
-                replacementMade = true;
-              } catch (hashError) {
-                loaderContext.emitError(new Error(`${LOADER_PREFIX} [${resourcePath}] Error hashing key "${originalValue}": ${hashError.message}`));
-              }
+              walkerControl.replace(replacementNode);
+              replacementMade = true;
             }
           }
         }
@@ -179,7 +146,7 @@ module.exports = function i18nIdReplaceLoader(source, map, meta) {
 
     if (replacementMade) {
       const generateOptions = {
-        sourceMaps: options.sourceMaps,
+        sourceMaps: !!options.sourceMaps,
         sourceFileName: resourcePath,
         retainLines: false,
         comments: true
@@ -192,7 +159,7 @@ module.exports = function i18nIdReplaceLoader(source, map, meta) {
   } catch (err) {
     const detailedError = new Error(`${LOADER_PREFIX} [${resourcePath}] AST Processing Error: ${err.message} (Stack: ${err.stack})`);
 
-    if (err.loc) {
+    if (err.loc && err.loc.line) {
       detailedError.message += ` at line ${err.loc.line}, column ${err.loc.column}`;
     }
 

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

@@ -31,6 +31,18 @@ function urlJoin(...args) {
   return args.map(part => typeof part === 'string' ? part.replace(/(^\/+|\/+$)/g, '') : '').filter(part => part !== '').join('/');
 }
 
+function validateAndGetFilenameTemplate(template, chunkType) {
+  if (!template || typeof template !== 'string') {
+    throw new Error(`Missing required ${chunkType} filename template in i18nIndexing options`);
+  }
+
+  if (!template.includes('[locale]')) {
+    throw new Error(`${chunkType} filename template must include '[locale]' placeholder: ${template}`);
+  }
+
+  return template;
+}
+
 function configI18nNumericIndexPlugin(options) {
   if (!(options.i18nIndexing && options.i18nIndexing.enable)) {
     return null;
@@ -38,43 +50,52 @@ function configI18nNumericIndexPlugin(options) {
 
   const i18nOpts = options.i18nIndexing;
   const cdnConfig = options.cdnMapping || {};
+
+  if (!i18nOpts.jsResourcePath) {
+    throw new Error('Missing required jsResourcePath in i18nIndexing options');
+  }
+
+  if (!i18nOpts.propertiesFolderPath) {
+    throw new Error('Missing required propertiesFolderPath in i18nIndexing options');
+  }
+
+  if (!i18nOpts.numericMapPath) {
+    throw new Error('Missing required numericMapPath in i18nIndexing options');
+  }
+
+  if (!i18nOpts.jsonpFunc) {
+    throw new Error('Missing required jsonpFunc in i18nIndexing options');
+  }
+
+  if (!i18nOpts.htmlTemplateLabel) {
+    throw new Error('Missing required htmlTemplateLabel in i18nIndexing options');
+  }
+
+  if (!i18nOpts.localeVarName) {
+    throw new Error('Missing required localeVarName in i18nIndexing options');
+  }
+
+  console.log('I18n Indexing Options:', {
+    enable: i18nOpts.enable,
+    jsResourcePath: i18nOpts.jsResourcePath,
+    propertiesFolderPath: i18nOpts.propertiesFolderPath,
+    numericMapPath: i18nOpts.numericMapPath,
+    numericFilenameTemplate: i18nOpts.numericFilenameTemplate,
+    dynamicFilenameTemplate: i18nOpts.dynamicFilenameTemplate,
+    jsonpFunc: i18nOpts.jsonpFunc,
+    htmlTemplateLabel: i18nOpts.htmlTemplateLabel,
+    localeVarName: i18nOpts.localeVarName
+  });
   const {
     locales,
     allI18nObject
   } = readI18nValues({
     jsResource: i18nOpts.jsResourcePath,
     propertiesFolder: i18nOpts.propertiesFolderPath,
-    disableDefault: i18nOpts.disableDefaultMerge !== undefined ? i18nOpts.disableDefaultMerge : false
+    disableDefault: false
   });
-  const hardcodedDefaultNumericTemplate = 'i18n-chunks/[locale]/numeric.i18n.js';
-  const hardcodedDefaultDynamicTemplate = 'i18n-chunks/[locale]/dynamic.i18n.js';
-  let numericFilenameTemplate = i18nOpts.numericFilenameTemplate || hardcodedDefaultNumericTemplate;
-  let dynamicFilenameTemplate = i18nOpts.dynamicFilenameTemplate || hardcodedDefaultDynamicTemplate;
-
-  if (i18nOpts.numericFilenameTemplate === undefined) {
-    // Check if explicitly undefined or missing
-    const i18nSplitFilename = options.i18nChunkSplit && options.i18nChunkSplit.filename;
-
-    if (i18nSplitFilename && typeof i18nSplitFilename === 'string') {
-      // This adaptation logic might need to be more robust
-      numericFilenameTemplate = `i18n-chunks/[locale]/${path.basename(i18nSplitFilename).replace(/(\.i18n)?\.js$/, '.numeric.i18n.js')}`;
-    } else {
-      numericFilenameTemplate = hardcodedDefaultNumericTemplate;
-    }
-  }
-
-  if (i18nOpts.dynamicFilenameTemplate === undefined) {
-    const i18nSplitFilename = options.i18nChunkSplit && options.i18nChunkSplit.filename;
-
-    if (i18nSplitFilename && typeof i18nSplitFilename === 'string') {
-      dynamicFilenameTemplate = `i18n-chunks/[locale]/${path.basename(i18nSplitFilename).replace(/(\.i18n)?\.js$/, '.dynamic.i18n.js')}`;
-    } else {
-      dynamicFilenameTemplate = hardcodedDefaultDynamicTemplate;
-    }
-  }
-
-  const htmlTemplateLabel = i18nOpts.htmlTemplateLabel || '{{--user-locale}}';
-  const defaultJsonpFunc = options.i18nChunkSplit && options.i18nChunkSplit.jsonpFunc || 'window.loadI18nChunk';
+  const numericFilenameTemplate = validateAndGetFilenameTemplate(i18nOpts.numericFilenameTemplate, 'numericFilenameTemplate');
+  const dynamicFilenameTemplate = validateAndGetFilenameTemplate(i18nOpts.dynamicFilenameTemplate, 'dynamicFilenameTemplate');
   let i18nAssetsPublicPathPrefix = '';
 
   if (cdnConfig.isCdnEnabled) {
@@ -90,24 +111,32 @@ function configI18nNumericIndexPlugin(options) {
     i18nAssetsPublicPathPrefix = urlConcat(options.publicPath === undefined ? '' : options.publicPath);
   }
 
-  const pluginBaseOptions = {
+  const numericIndexPluginOptions = {
+    enable: i18nOpts.enable,
+    jsResourcePath: i18nOpts.jsResourcePath,
+    propertiesFolderPath: i18nOpts.propertiesFolderPath,
+    numericMapPath: i18nOpts.numericMapPath,
     locales,
     allI18nObject,
-    numericMapPath: i18nOpts.numericMapPath,
-    numericJsonpFunc: i18nOpts.numericJsonpFunc || defaultJsonpFunc,
-    dynamicJsonpFunc: i18nOpts.dynamicJsonpFunc || defaultJsonpFunc,
-    numericFilenameTemplate,
-    // This will now include "i18n-chunks/[locale]/"
-    dynamicFilenameTemplate,
-    // This will now include "i18n-chunks/[locale]/"
-    moduleType: 'i18n/mini-extract',
-    mainChunkName: options.i18nChunkSplit && options.i18nChunkSplit.mainChunkName || 'main',
-    htmlTemplateLabel,
-    localeVarName: i18nOpts.localeVarName
+    numericFilenameTemplate: numericFilenameTemplate,
+    dynamicFilenameTemplate: dynamicFilenameTemplate,
+    numericJsonpFunction: i18nOpts.jsonpFunc,
+    dynamicJsonpFunction: i18nOpts.jsonpFunc,
+    moduleType: 'i18n/mini-extract'
   };
-  const htmlInjectorOptions = { ...pluginBaseOptions,
+  const htmlInjectorOptions = {
+    locales,
+    numericFilenameTemplate: numericFilenameTemplate,
+    numericJsonpFunc: i18nOpts.jsonpFunc,
+    dynamicFilenameTemplate: dynamicFilenameTemplate,
+    dynamicJsonpFunc: i18nOpts.jsonpFunc,
+    mainChunkName: options.i18nChunkSplit && options.i18nChunkSplit.mainChunkName || 'main',
+    htmlTemplateLabel: i18nOpts.htmlTemplateLabel,
+    localeVarName: i18nOpts.localeVarName,
     i18nAssetsPublicPathPrefix: i18nAssetsPublicPathPrefix,
     cspNoncePlaceholder: i18nOpts.cspNoncePlaceholder || '{{--CSP-nonce}}'
   };
-  return [new I18nNumericIndexPlugin(pluginBaseOptions), new I18nNumericIndexHtmlInjectorPlugin(htmlInjectorOptions)];
+  const i18nNumericPluginInstance = new I18nNumericIndexPlugin(numericIndexPluginOptions);
+  const htmlInjectorPluginInstance = new I18nNumericIndexHtmlInjectorPlugin(htmlInjectorOptions);
+  return [i18nNumericPluginInstance, htmlInjectorPluginInstance];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/client_build_tool",
-  "version": "0.0.10.exp.0.0.3",
+  "version": "0.0.10.exp.0.0.4",
   "description": "A CLI tool to  build  web applications and client libraries",
   "main": "lib/index.js",
   "bin": {