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

package/lib/shared/bundler/webpack/common/i18nOptionsValidator.js

@@ -0,0 +1,144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateI18nChunkSplitOptions = validateI18nChunkSplitOptions;
+exports.validateI18nIndexingOptions = validateI18nIndexingOptions;
+exports.validateI18nOptions = validateI18nOptions;
+exports.validatePathSecurity = validatePathSecurity;
+exports.validateRequiredFields = validateRequiredFields;
+exports.validateTemplateFormat = validateTemplateFormat;
+const LOCALE_PLACEHOLDER = '[locale]';
+const REQUIRED_OPTIONS = ['jsResourcePath', 'propertiesFolderPath', 'numericMapPath', 'jsonpFunc', 'htmlTemplateLabel'];
+
+function validatePathSecurity(path, fieldName) {
+  if (!path || typeof path !== 'string') {
+    return;
+  }
+
+  if (path.includes('..')) {
+    throw new Error(`[I18nOptionsValidator] Invalid ${fieldName} contains '..': ${path}`);
+  }
+}
+
+function validateRequiredFields(options, requiredFields) {
+  const missingOptions = requiredFields.filter(opt => {
+    const value = options[opt];
+    return value === undefined || value === null || typeof value === 'string' && value.trim() === '';
+  });
+
+  if (missingOptions.length > 0) {
+    throw new Error(`[I18nOptionsValidator] Missing required i18n options: ${missingOptions.join(', ')}`);
+  }
+}
+
+function validateTemplateFormat(template, templateName) {
+  if (!template || typeof template !== 'string') {
+    throw new Error(`[I18nOptionsValidator] ${templateName} must be a non-empty string`);
+  }
+
+  if (!template.includes(LOCALE_PLACEHOLDER)) {
+    throw new Error(`[I18nOptionsValidator] ${templateName} must include ${LOCALE_PLACEHOLDER} placeholder`);
+  }
+
+  validatePathSecurity(template, templateName);
+}
+
+function validateI18nIndexingOptions(i18nOpts) {
+  if (!i18nOpts || typeof i18nOpts !== 'object') {
+    throw new Error('[I18nOptionsValidator] i18nIndexing configuration must be a valid object');
+  }
+
+  if (!i18nOpts.enable) {
+    return {
+      skipValidation: true
+    };
+  }
+
+  validateRequiredFields(i18nOpts, REQUIRED_OPTIONS);
+  validatePathSecurity(i18nOpts.jsResourcePath, 'jsResourcePath');
+  validatePathSecurity(i18nOpts.propertiesFolderPath, 'propertiesFolderPath');
+  validatePathSecurity(i18nOpts.numericMapPath, 'numericMapPath');
+  const numericTemplate = i18nOpts.numericFilenameTemplate || '[locale]/numeric.i18n.js';
+  const dynamicTemplate = i18nOpts.dynamicFilenameTemplate || '[locale]/dynamic.i18n.js';
+  validateTemplateFormat(numericTemplate, 'numericFilenameTemplate');
+  validateTemplateFormat(dynamicTemplate, 'dynamicFilenameTemplate');
+
+  if (i18nOpts.singleFileTemplate) {
+    validateTemplateFormat(i18nOpts.singleFileTemplate, 'singleFileTemplate');
+  }
+
+  if (i18nOpts.outputFolder) {
+    validatePathSecurity(i18nOpts.outputFolder, 'outputFolder');
+  } // Validate conflicting options
+
+
+  const includeContentHash = i18nOpts.includeContentHash;
+  const injectHtml = i18nOpts.injectI18nUrlInIndex !== undefined ? i18nOpts.injectI18nUrlInIndex : true;
+
+  if (includeContentHash && injectHtml) {
+    throw new Error('[I18nOptionsValidator] includeContentHash and injectI18nUrlInIndex cannot both be true - content hash changes filenames dynamically but HTML injection needs static filenames');
+  }
+
+  return {
+    skipValidation: false
+  };
+}
+
+function validateI18nChunkSplitOptions(chunkSplitOpts) {
+  if (!chunkSplitOpts || typeof chunkSplitOpts !== 'object') {
+    throw new Error('[I18nOptionsValidator] i18nChunkSplit configuration must be a valid object');
+  }
+
+  if (!chunkSplitOpts.chunkSplitEnable || !chunkSplitOpts.useNumericIndexing) {
+    return {
+      skipValidation: true
+    };
+  }
+
+  if (!chunkSplitOpts.jsResource) {
+    throw new Error('[I18nOptionsValidator] Missing required jsResource in i18nChunkSplit options');
+  }
+
+  if (!chunkSplitOpts.numericMapPath) {
+    throw new Error('[I18nOptionsValidator] Missing required numericMapPath in i18nChunkSplit options');
+  }
+
+  validatePathSecurity(chunkSplitOpts.jsResource, 'jsResource');
+  validatePathSecurity(chunkSplitOpts.numericMapPath, 'numericMapPath');
+  return {
+    skipValidation: false
+  };
+}
+
+function validateI18nOptions(options) {
+  if (!options || typeof options !== 'object') {
+    throw new Error('[I18nOptionsValidator] Options must be a valid object');
+  }
+
+  const hasIndexing = options.i18nIndexing && options.i18nIndexing.enable;
+  const hasChunkSplit = options.i18nChunkSplit && options.i18nChunkSplit.chunkSplitEnable && options.i18nChunkSplit.useNumericIndexing;
+
+  if (!hasIndexing && !hasChunkSplit) {
+    throw new Error('[I18nOptionsValidator] i18n validation requires either i18nIndexing to be enabled or i18nChunkSplit with useNumericIndexing');
+  }
+
+  if (hasIndexing) {
+    const result = validateI18nIndexingOptions(options.i18nIndexing);
+
+    if (result.skipValidation) {
+      throw new Error('[I18nOptionsValidator] i18nIndexing is not properly enabled');
+    }
+  }
+
+  if (hasChunkSplit) {
+    const result = validateI18nChunkSplitOptions(options.i18nChunkSplit);
+
+    if (result.skipValidation) {
+      throw new Error('[I18nOptionsValidator] i18nChunkSplit is not properly configured');
+    }
+  }
+
+  return true;
+}

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

@@ -22,11 +22,13 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
       localeVarName,
       i18nPublicPathVar,
       groupAssetUrls,
-      includeContentHash
+      includeContentHash,
+      mode
     } = this.options;
     const chunkIdToGroup = chunkIdToGroupMapping || {};
     const hasGroupAssetOverrides = !!groupAssetUrls && Object.values(groupAssetUrls).some(localeMap => localeMap && Object.keys(localeMap).length > 0);
     const hashAware = includeContentHash || hasGroupAssetOverrides;
+    const isDevelopment = mode === 'development';
     return `
     // I18n Group Loading Runtime
     (function() {
@@ -34,7 +36,9 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
       var chunkIdToGroup = ${JSON.stringify(chunkIdToGroup)};
       var groupAssetUrls = ${JSON.stringify(groupAssetUrls || {})};
       var hashAware = ${hashAware ? 'true' : 'false'};
+      var isDev = ${isDevelopment ? 'true' : 'false'};
       var cachedI18nBase;
+      var scriptCache = null;
 
       function ensureTrailingSlash(path) {
         if (!path) return '';
@@ -61,9 +65,11 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
         var base = resolveConfiguredBase();
 
         if (!base && typeof document !== 'undefined') {
-          var scripts = document.getElementsByTagName('script');
-          for (var i = 0; i < scripts.length; i++) {
-            var src = scripts[i].getAttribute('data-src') || scripts[i].getAttribute('src') || '';
+          if (!scriptCache) {
+            scriptCache = Array.from(document.getElementsByTagName('script'));
+          }
+          for (var i = 0; i < scriptCache.length; i++) {
+            var src = scriptCache[i].getAttribute('data-src') || scriptCache[i].getAttribute('src') || '';
             var markerIndex = src.indexOf('i18n-chunk/');
             if (markerIndex !== -1) {
               base = src.slice(0, markerIndex);
@@ -126,15 +132,28 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
           script.src = i18nUrl;
           script.async = true;
 
+          var cleanup = function() {
+            if (script.parentNode) {
+              script.parentNode.removeChild(script);
+            }
+          };
+
           script.onload = function() {
             loadedGroups[groupName] = true;
-            console.log('[i18n-group:loaded]', groupName, i18nUrl);
+            if (isDev) {
+              console.log('[i18n-group:loaded]', groupName, i18nUrl);
+            }
+            cleanup();
             resolve();
           };
 
           script.onerror = function() {
-            console.error('[i18n-group:error]', groupName, i18nUrl);
-            reject(new Error('Failed to load i18n group: ' + groupName));
+            if (isDev) {
+              console.error('[i18n-group:error]', groupName, i18nUrl);
+            }
+            cleanup();
+            loadedGroups[groupName] = true;
+            resolve();
           };
 
           document.head.appendChild(script);
@@ -159,8 +178,10 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
             return i18nPromise.then(function() {
               return originalEnsureChunk.apply(self, args);
             }).catch(function(err) {
-              console.error('[i18n-group:critical] i18n failed, blocking chunk loading:', err);
-              return Promise.reject(new Error('Cannot load setup without i18n: ' + err.message));
+              if (isDev) {
+                console.error('[i18n-group:critical] i18n failed, proceeding without:', err);
+              }
+              return originalEnsureChunk.apply(self, args);
             });
           } else {
             return originalEnsureChunk.apply(this, arguments);
@@ -180,7 +201,7 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
           if (config.urlPatterns && Array.isArray(config.urlPatterns)) {
             for (var i = 0; i < config.urlPatterns.length; i++) {
               var pattern = config.urlPatterns[i];
-              if (url.indexOf(pattern) !== -1) {
+              if (url.includes(pattern)) {
                 return groupName;
               }
             }
@@ -191,12 +212,22 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
       }
 
       function checkAndLoadGroupFromUrl() {
-        var detectedGroup = detectGroupFromUrl();
-        if (detectedGroup && !loadedGroups[detectedGroup]) {
-          console.log('[i18n-group:url-detect]', detectedGroup, 'loading for current URL');
-          loadI18nGroup(detectedGroup, 'url-detection').catch(function(err) {
-            console.error('[i18n-group:url-detect] Failed to load', detectedGroup, ':', err);
-          });
+        try {
+          var detectedGroup = detectGroupFromUrl();
+          if (detectedGroup && !loadedGroups[detectedGroup]) {
+            if (isDev) {
+              console.log('[i18n-group:url-detect]', detectedGroup, 'loading for current URL');
+            }
+            loadI18nGroup(detectedGroup, 'url-detection').catch(function(err) {
+              if (isDev) {
+                console.error('[i18n-group:url-detect] Failed to load', detectedGroup, ':', err);
+              }
+            });
+          }
+        } catch (err) {
+          if (isDev) {
+            console.error('[i18n-group:url-detect] Error in URL detection:', err);
+          }
         }
       }
 
@@ -210,9 +241,13 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
         for (var groupName in groupConfig) {
           var config = groupConfig[groupName];
           if (config.preload === true && !loadedGroups[groupName]) {
-            console.log('[i18n-group:preload]', groupName, 'loading immediately');
+            if (isDev) {
+              console.log('[i18n-group:preload]', groupName, 'loading immediately');
+            }
             loadI18nGroup(groupName, 'preload').catch(function(err) {
-              console.error('[i18n-group:preload] Failed to preload', groupName, ':', err);
+              if (isDev) {
+                console.error('[i18n-group:preload] Failed to preload', groupName, ':', err);
+              }
             });
           }
         }
@@ -222,9 +257,13 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
           for (var groupName in groupConfig) {
             var config = groupConfig[groupName];
             if (config.prefetch === true && !loadedGroups[groupName] && config.preload !== true) {
-              console.log('[i18n-group:prefetch]', groupName, 'scheduling background load');
+              if (isDev) {
+                console.log('[i18n-group:prefetch]', groupName, 'scheduling background load');
+              }
               loadI18nGroup(groupName, 'prefetch').catch(function(err) {
-                console.error('[i18n-group:prefetch] Failed to prefetch', groupName, ':', err);
+                if (isDev) {
+                  console.error('[i18n-group:prefetch] Failed to prefetch', groupName, ':', err);
+                }
               });
             }
           }

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

@@ -1,8 +1,15 @@
 "use strict";
 
-const HtmlWebpackPlugin = require('html-webpack-plugin');
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.I18nNumericIndexHtmlInjectorPlugin = void 0;
 
-const path = require('path');
+var _htmlWebpackPlugin = _interopRequireDefault(require("html-webpack-plugin"));
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const pluginName = 'I18nNumericIndexHtmlInjectorPlugin';
 const assetStoreKey = Symbol.for('I18nNumericIndexPluginAssets');
@@ -17,8 +24,7 @@ class I18nNumericIndexHtmlInjectorPlugin {
 
   apply(compiler) {
     compiler.hooks.thisCompilation.tap(pluginName, compilation => {
-      HtmlWebpackPlugin.getHooks(compilation).beforeAssetTagGeneration.tapAsync(pluginName, (hookData, cb) => {
-        // Skip HTML injection if disabled
+      _htmlWebpackPlugin.default.getHooks(compilation).beforeAssetTagGeneration.tapAsync(pluginName, (hookData, cb) => {
         if (!this.options.injectI18nUrlInIndex) {
           return cb(null, hookData);
         }
@@ -37,30 +43,26 @@ class I18nNumericIndexHtmlInjectorPlugin {
         } = this.options;
         const newI18nAssetUrlsToAdd = [];
         const emittedAssetNames = compilation.getAssets().map(asset => asset.name);
-        const recordedAssets = compilation[assetStoreKey] || []; // Simple asset resolution using recorded assets first, then fallback to template
+        const recordedAssets = compilation[assetStoreKey] || [];
 
         const resolveAssetPath = (template, fileType) => {
-          if (!template) return null; // Try to find from recorded assets first
-
+          if (!template) return null;
           const recorded = recordedAssets.find(asset => {
             if (fileType === 'single') return !asset.fileType;
             return asset.fileType === fileType;
           });
 
           if (recorded) {
-            // Use recorded asset with correct locale
             const assetPath = recorded.outputPath.replace(recorded.locale, htmlTemplateLabel);
             return i18nAssetsPublicPathPrefix + assetPath;
-          } // Fallback to template-based construction
-
+          }
 
           const filePath = template.replace(/\[locale\]/g, htmlTemplateLabel);
-          const fullPath = filePath.includes(outputFolder) || filePath.startsWith('/') ? filePath : path.join(outputFolder, filePath); // Check if the exact asset exists
+          const fullPath = filePath.includes(outputFolder) || filePath.startsWith('/') ? filePath : _path.default.join(outputFolder, filePath);
 
           if (emittedAssetNames.includes(fullPath)) {
             return i18nAssetsPublicPathPrefix + fullPath;
-          } // For content hash templates, find matching asset
-
+          }
 
           if (fullPath.includes('[contenthash]')) {
             const pattern = fullPath.replace('[contenthash]', '*');
@@ -69,15 +71,13 @@ class I18nNumericIndexHtmlInjectorPlugin {
             if (matchingAsset) {
               return i18nAssetsPublicPathPrefix + matchingAsset;
             }
-          } // Return as-is for basic cases
-
+          }
 
           return i18nAssetsPublicPathPrefix + fullPath;
         };
 
         if (singleFile) {
-          const singleTemplate = singleFileTemplate || '[locale].js';
-          const combinedFilename = resolveAssetPath(singleTemplate, 'single');
+          const combinedFilename = resolveAssetPath(singleFileTemplate, 'single');
 
           if (combinedFilename) {
             newI18nAssetUrlsToAdd.push(combinedFilename);
@@ -97,7 +97,6 @@ class I18nNumericIndexHtmlInjectorPlugin {
         }
 
         if (newI18nAssetUrlsToAdd.length > 0) {
-          // Add i18n assets to the beginning of JS assets for early loading
           assets.js = [...newI18nAssetUrlsToAdd, ...assets.js];
         }
 
@@ -108,6 +107,4 @@ class I18nNumericIndexHtmlInjectorPlugin {
 
 }
 
-module.exports = {
-  I18nNumericIndexHtmlInjectorPlugin
-};
+exports.I18nNumericIndexHtmlInjectorPlugin = I18nNumericIndexHtmlInjectorPlugin;

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

@@ -15,7 +15,7 @@ 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 }; }
 

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,47 +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 parsedData = JSON.parse(fileContent);
+    const numericMap = parsedData.originalKeyToNumericId || parsedData;
+    const totalKeys = parsedData.totalKeysInMap || Object.keys(numericMap).length;
     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 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;
@@ -84,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
         };
@@ -128,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
@@ -148,11 +112,4 @@ function loadI18nData(options, compilation) {
     allI18n,
     locales
   };
-}
-
-module.exports = {
-  loadPropertiesFile,
-  loadNumericMap,
-  loadAllLocaleFiles,
-  loadI18nData
-};
+}

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

@@ -1,37 +1,32 @@
 "use strict";
 
-const {
-  getPropertiesAsJSON
-} = require('../custom_plugins/I18nSplitPlugin/utils/propertiesUtils');
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.i18nIdReplaceLoaderConfig = i18nIdReplaceLoaderConfig;
 
-const fs = require('fs');
+var _propertiesUtils = require("../custom_plugins/I18nSplitPlugin/utils/propertiesUtils.js");
+
+var _i18nOptionsValidator = require("../common/i18nOptionsValidator.js");
+
+var _fs = _interopRequireDefault(require("fs"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function loadJSResourcesOnce(options) {
-  let jsResourcePath; // Determine the JSResource path based on configuration
+  let jsResourcePath;
 
   if (options.i18nIndexing && options.i18nIndexing.enable) {
     jsResourcePath = options.i18nIndexing.jsResourcePath;
   } else if (options.i18nChunkSplit && options.i18nChunkSplit.chunkSplitEnable && options.i18nChunkSplit.useNumericIndexing) {
     jsResourcePath = options.i18nChunkSplit.jsResource;
-  } else {
-    throw new Error('i18nIdReplaceLoader requires either i18nIndexing to be enabled or i18nChunkSplit with useNumericIndexing');
-  }
-
-  if (!jsResourcePath) {
-    throw new Error('Missing required jsResourcePath in i18n options');
   }
 
   try {
-    const i18nData = getPropertiesAsJSON(jsResourcePath);
-
-    if (Object.keys(i18nData).length === 0) {
-      console.warn(`[i18nIdReplaceLoaderConfig] Warning: No i18n data found in JSResource file: ${jsResourcePath}`);
-      return {};
-    }
-
+    const i18nData = (0, _propertiesUtils.getPropertiesAsJSON)(jsResourcePath);
     return i18nData;
   } catch (err) {
-    throw new Error(`Error reading JSResource file ${jsResourcePath}: ${err.message}`);
+    throw new Error(`[I18nIdReplaceLoaderConfig] Error reading JSResource file ${jsResourcePath}: ${err.message}`);
   }
 }
 
@@ -39,37 +34,35 @@ function readNumericMapOnce(numericMapPath) {
   if (!numericMapPath) return null;
 
   try {
-    if (!fs.existsSync(numericMapPath)) return null;
-    const fileContent = fs.readFileSync(numericMapPath, 'utf-8');
+    const fileContent = _fs.default.readFileSync(numericMapPath, 'utf-8');
+
     const parsed = JSON.parse(fileContent);
-    if (!parsed) return null;
     return parsed.originalKeyToNumericId ? parsed.originalKeyToNumericId : parsed;
   } catch (err) {
-    return null;
+    throw new Error(`[I18nIdReplaceLoaderConfig] Failed to read numeric map from ${numericMapPath}: ${err.message}`);
   }
 }
 
-function i18nIdReplaceLoaderConfig(options, webpackContext) {
-  let numericMapPath; // Determine the numeric map path based on configuration
+function i18nIdReplaceLoaderConfig(options) {
+  (0, _i18nOptionsValidator.validateI18nOptions)(options);
+  let numericMapPath;
 
   if (options.i18nIndexing && options.i18nIndexing.enable) {
     numericMapPath = options.i18nIndexing.numericMapPath;
   } else if (options.i18nChunkSplit && options.i18nChunkSplit.chunkSplitEnable && options.i18nChunkSplit.useNumericIndexing) {
     numericMapPath = options.i18nChunkSplit.numericMapPath;
-  } else {
-    throw new Error('i18nIdReplaceLoader requires either i18nIndexing to be enabled or i18nChunkSplit with useNumericIndexing');
   }
 
-  if (!numericMapPath) {
-    throw new Error('numericMapPath is required in i18nIndexing or i18nChunkSplit config');
-  } // Load all i18n data for key detection
-
-
   const allI18nData = loadJSResourcesOnce(options);
+  const i18nKeyReplaceLoaderPath = new URL('../loaders/i18nIdReplaceLoader.js', import.meta.url).pathname;
+  let numericIdMap;
 
-  const i18nKeyReplaceLoaderPath = require.resolve('../loaders/i18nIdReplaceLoader.js');
+  try {
+    numericIdMap = readNumericMapOnce(numericMapPath);
+  } catch (err) {
+    throw new Error(`[I18nIdReplaceLoaderConfig] Failed to load numeric map: ${err.message}`);
+  }
 
-  const numericIdMap = readNumericMapOnce(numericMapPath);
   const loaderOptions = {
     allI18nData: allI18nData,
     sourceMaps: false,
@@ -83,8 +76,4 @@ function i18nIdReplaceLoaderConfig(options, webpackContext) {
     loader: i18nKeyReplaceLoaderPath,
     options: loaderOptions
   };
-}
-
-module.exports = {
-  i18nIdReplaceLoaderConfig
-};
+}

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

@@ -22,8 +22,8 @@ module.exports = function i18nIdReplaceLoader(source, map) {
   const options = getOptions(this) || {};
   const callback = this.async(); // Skip files in excluded paths
 
-  if (options.excludePaths) {
-    const shouldExclude = options.excludePaths.some(excludePath => resourcePath.includes(excludePath));
+  if (options.excludePaths && Array.isArray(options.excludePaths)) {
+    const shouldExclude = options.excludePaths.some(excludePath => typeof excludePath === 'string' && resourcePath.includes(excludePath));
 
     if (shouldExclude) {
       return callback(null, source, map);
@@ -31,18 +31,18 @@ module.exports = function i18nIdReplaceLoader(source, map) {
   } // Only process files in included paths if specified
 
 
-  if (options.includePaths && options.includePaths.length > 0) {
-    const shouldInclude = options.includePaths.some(includePath => resourcePath.includes(includePath));
+  if (options.includePaths && Array.isArray(options.includePaths) && options.includePaths.length > 0) {
+    const shouldInclude = options.includePaths.some(includePath => typeof includePath === 'string' && resourcePath.includes(includePath));
 
     if (!shouldInclude) {
       return callback(null, source, map);
     }
-  } // Validate i18n data exists
+  } // Basic runtime validation - options should already be validated by config
 
 
   if (!options.allI18nData || Object.keys(options.allI18nData).length === 0) {
     return callback(new Error(`i18nIdReplaceLoader: 'allI18nData' option is missing or empty`));
-  } // Load numeric ID mapping
+  } // Load numeric ID mapping - paths already validated by config
 
 
   let numericIdMap = options.numericIdMap;
@@ -57,7 +57,8 @@ module.exports = function i18nIdReplaceLoader(source, map) {
         const parsed = JSON.parse(mapContent);
         numericIdMap = parsed.originalKeyToNumericId || parsed;
       }
-    } catch (e) {// Silently continue without numeric map
+    } catch (e) {
+      return callback(new Error(`i18nIdReplaceLoader: Failed to load numeric map from ${options.numericMapPath}: ${e.message}`));
     }
   } // If no numeric map available, return source as-is
 
@@ -70,10 +71,11 @@ module.exports = function i18nIdReplaceLoader(source, map) {
     // Parse the JavaScript/TypeScript source code
     const ast = parser.parse(source, {
       sourceType: 'module',
-      plugins: ['jsx', 'typescript'],
+      plugins: ['jsx', 'typescript', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator'],
       sourceFilename: resourcePath
     });
-    let hasTransformations = false; // Traverse AST and replace i18n keys with numeric IDs
+    let hasTransformations = false;
+    let transformationCount = 0; // Traverse AST and replace i18n keys with numeric IDs
 
     traverse(ast, {
       StringLiteral(path) {
@@ -85,6 +87,7 @@ module.exports = function i18nIdReplaceLoader(source, map) {
           const numericId = String(numericIdMap[node.value]);
           path.replaceWith(t.stringLiteral(numericId));
           hasTransformations = true;
+          transformationCount++;
         }
       }
 
@@ -102,6 +105,6 @@ module.exports = function i18nIdReplaceLoader(source, map) {
       callback(null, source, map);
     }
   } catch (err) {
-    callback(err);
+    callback(new Error(`i18nIdReplaceLoader: Failed to process ${resourcePath}: ${err.message}`));
   }
 };

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

@@ -11,17 +11,26 @@ var _I18nNumericIndexHtmlInjectorPlugin = require("../custom_plugins/I18nNumeric
 
 var _readI18nValues = require("../custom_plugins/I18nSplitPlugin/readI18nValues");
 
+var _i18nOptionsValidator = require("../common/i18nOptionsValidator.js");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function configI18nNumericIndexPlugin(options) {
-  if (!(options.i18nIndexing && options.i18nIndexing.enable)) {
+  if (!options.i18nIndexing) {
     return null;
   }
 
   const i18nOpts = options.i18nIndexing;
-  const isDevelopment = options.isDevelopment || false; // Get isDevelopment from options
-  // If we are only doing numeric ID replacement (no files to emit and no HTML injection, and no custom groups),
-  // we can skip creating plugin instances to save build time.
+
+  try {
+    const result = (0, _i18nOptionsValidator.validateI18nIndexingOptions)(i18nOpts);
+
+    if (result.skipValidation) {
+      return null;
+    }
+  } catch (error) {
+    throw new Error(`[I18nNumericIndexPlugin] ${error.message}`);
+  }
 
   const emitFiles = i18nOpts.emitFiles !== undefined ? i18nOpts.emitFiles : true;
   const injectHtml = i18nOpts.injectI18nUrlInIndex !== undefined ? i18nOpts.injectI18nUrlInIndex : true;
@@ -29,87 +38,55 @@ function configI18nNumericIndexPlugin(options) {
 
   if (!emitFiles && !injectHtml && !hasCustomGroups) {
     return [];
-  } // Validate required options
-
-
-  const requiredOptions = ['jsResourcePath', 'propertiesFolderPath', 'numericMapPath', 'jsonpFunc', 'htmlTemplateLabel', 'localeVarName'];
-  const missingOptions = requiredOptions.filter(opt => !i18nOpts[opt]);
+  }
 
-  if (missingOptions.length > 0) {
-    console.warn(`[I18nNumericIndexPlugin] Missing required options: ${missingOptions.join(', ')}`);
-    return null;
-  } // Read i18n values
+  let i18nData;
 
+  try {
+    i18nData = (0, _readI18nValues.readI18nValues)({
+      jsResource: i18nOpts.jsResourcePath,
+      propertiesFolder: i18nOpts.propertiesFolderPath,
+      disableDefault: false
+    });
+  } catch (error) {
+    throw new Error(`[I18nNumericIndexPlugin] Failed to read i18n data: ${error.message}`);
+  }
 
   const {
     locales,
     allI18nObject
-  } = (0, _readI18nValues.readI18nValues)({
-    jsResource: i18nOpts.jsResourcePath,
-    propertiesFolder: i18nOpts.propertiesFolderPath,
-    disableDefault: false
-  }); // Ensure templates have [locale] placeholder
-
+  } = i18nData;
   const numericTemplate = i18nOpts.numericFilenameTemplate || '[locale]/numeric.i18n.js';
   const dynamicTemplate = i18nOpts.dynamicFilenameTemplate || '[locale]/dynamic.i18n.js';
-
-  if (!numericTemplate.includes('[locale]')) {
-    console.warn('[I18nNumericIndexPlugin] numericFilenameTemplate must include [locale] placeholder');
-    return null;
-  }
-
-  if (!dynamicTemplate.includes('[locale]')) {
-    console.warn('[I18nNumericIndexPlugin] dynamicFilenameTemplate must include [locale] placeholder');
-    return null;
-  } // Resolve singleFileTemplate if it's a function
-
-
-  let resolvedSingleFileTemplate = i18nOpts.singleFileTemplate || '[locale].js';
-
-  if (typeof i18nOpts.singleFileTemplate === 'function') {
-    resolvedSingleFileTemplate = i18nOpts.singleFileTemplate(isDevelopment);
-  } // Plugin options
-
-
-  const numericIndexPluginOptions = {
-    enable: i18nOpts.enable,
+  const sharedOptions = {
     outputFolder: i18nOpts.outputFolder || 'i18n-chunk',
+    numericFilenameTemplate: numericTemplate,
+    dynamicFilenameTemplate: dynamicTemplate,
+    singleFileTemplate: i18nOpts.singleFileTemplate,
+    singleFile: i18nOpts.singleFile || false,
+    includeContentHash: i18nOpts.includeContentHash || false
+  };
+  const numericIndexPluginOptions = { ...sharedOptions,
+    enable: i18nOpts.enable,
     jsResourcePath: i18nOpts.jsResourcePath,
     propertiesFolderPath: i18nOpts.propertiesFolderPath,
     numericMapPath: i18nOpts.numericMapPath,
     locales,
     allI18nObject,
-    numericFilenameTemplate: numericTemplate,
-    dynamicFilenameTemplate: dynamicTemplate,
-    singleFileTemplate: resolvedSingleFileTemplate,
     jsonpFunc: i18nOpts.jsonpFunc,
     localeVarName: i18nOpts.localeVarName,
-    singleFile: i18nOpts.singleFile || false,
     restrictToBaseKeys: i18nOpts.restrictToBaseKeys || false,
-    includeContentHash: i18nOpts.includeContentHash || false,
     generateManifest: i18nOpts.generateManifest || false,
     manifestPath: i18nOpts.manifestPath || null,
     customGroups: i18nOpts.customGroups || null,
     chunkToGroupMapping: i18nOpts.chunkToGroupMapping || {},
-    emitFiles: i18nOpts.emitFiles !== undefined ? i18nOpts.emitFiles : true,
-    isDevelopment: isDevelopment,
+    emitFiles,
     i18nPublicPathVar: i18nOpts.i18nPublicPathVar
-  }; // HTML injector options
-
-  const htmlInjectorOptions = {
-    outputFolder: i18nOpts.outputFolder || 'i18n-chunk',
-    numericFilenameTemplate: numericTemplate,
-    dynamicFilenameTemplate: dynamicTemplate,
-    singleFileTemplate: resolvedSingleFileTemplate,
+  };
+  const htmlInjectorOptions = { ...sharedOptions,
     htmlTemplateLabel: i18nOpts.htmlTemplateLabel,
-    singleFile: i18nOpts.singleFile || false,
     i18nAssetsPublicPathPrefix: '',
-    injectI18nUrlInIndex: i18nOpts.injectI18nUrlInIndex !== undefined ? i18nOpts.injectI18nUrlInIndex : true,
-    // Control HTML injection
-    isDevelopment: isDevelopment,
-    includeContentHash: i18nOpts.includeContentHash || false
+    injectI18nUrlInIndex: injectHtml
   };
-  const i18nNumericPluginInstance = new _I18nNumericIndexPlugin.default(numericIndexPluginOptions);
-  const htmlInjectorPluginInstance = new _I18nNumericIndexHtmlInjectorPlugin.I18nNumericIndexHtmlInjectorPlugin(htmlInjectorOptions);
-  return [i18nNumericPluginInstance, htmlInjectorPluginInstance];
+  return [new _I18nNumericIndexPlugin.default(numericIndexPluginOptions), new _I18nNumericIndexHtmlInjectorPlugin.I18nNumericIndexHtmlInjectorPlugin(htmlInjectorOptions)];
 }

package/package.json

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