@zohodesk/client_build_tool 0.0.11-exp.29.0 → 0.0.11-exp.31.0

package/lib/schemas/defaultConfigValues.js

@@ -200,7 +200,7 @@ var _default = {
     injectI18nUrlInIndex: true,
     customGroups: null,
     chunkToGroupMapping: {},
-    i18nPublicPathVar: null
+    groupPublicPathRuntimeExpression: 'window.__SMAP_PATH__'
   },
   publicFolders: {
     dev: ['...'],

package/lib/schemas/defaultConfigValuesOnly.js

@@ -117,7 +117,7 @@ var _default = {
     injectI18nUrlInIndex: true,
     customGroups: null,
     chunkToGroupMapping: {},
-    i18nPublicPathVar: null
+    groupPublicPathRuntimeExpression: 'window.__SMAP_PATH__'
   },
   publicFolders: {
     dev: ['...'],

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

@@ -6,23 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 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;
-  } // Allow relative paths within project structure (../assets, etc.)
-  // Block dangerous patterns like ../../etc/passwd
-
-
-  if (path.includes('../..') || path.startsWith('/') && path.includes('..')) {
-    throw new Error(`[I18nOptionsValidator] Invalid ${fieldName} contains suspicious path: ${path}`);
-  }
-}
+const REQUIRED_OPTIONS = ['jsResourcePath', 'propertiesFolderPath', 'numericMapPath'];
 
 function validateRequiredFields(options, requiredFields) {
   const missingOptions = requiredFields.filter(opt => {
@@ -43,8 +30,6 @@ function validateTemplateFormat(template, templateName) {
   if (!template.includes(LOCALE_PLACEHOLDER)) {
     throw new Error(`[I18nOptionsValidator] ${templateName} must include ${LOCALE_PLACEHOLDER} placeholder`);
   }
-
-  validatePathSecurity(template, templateName);
 }
 
 function validateI18nIndexingOptions(i18nOpts) {
@@ -59,9 +44,6 @@ function validateI18nIndexingOptions(i18nOpts) {
   }
 
   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');
@@ -71,11 +53,6 @@ function validateI18nIndexingOptions(i18nOpts) {
     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;
 
@@ -107,8 +84,6 @@ function validateI18nChunkSplitOptions(chunkSplitOpts) {
     throw new Error('[I18nOptionsValidator] Missing required numericMapPath in i18nChunkSplit options');
   }
 
-  validatePathSecurity(chunkSplitOpts.jsResource, 'jsResource');
-  validatePathSecurity(chunkSplitOpts.numericMapPath, 'numericMapPath');
   return {
     skipValidation: false
   };

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

@@ -10,8 +10,7 @@ var _webpack = require("webpack");
 class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
   constructor(options) {
     super('i18n-group-loader');
-    this.options = { ...options,
-      i18nPublicPathVar: options.i18nPublicPathVar || '(typeof window !== "undefined" && window.__I18N_CDN__)'
+    this.options = { ...options
     };
   }
 
@@ -20,82 +19,61 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
       customGroups,
       chunkIdToGroupMapping,
       localeVarName,
-      i18nPublicPathVar,
       groupAssetUrls,
-      includeContentHash,
-      mode
+      publicPathPrefix,
+      publicPathRuntimeExpression
     } = 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() {
       var loadedGroups = {};
       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;
+      var runtimePublicPathPrefixResolver = ${publicPathRuntimeExpression ? `function(){ try { return ${publicPathRuntimeExpression}; } catch (err) { return undefined; } }` : 'function(){ return undefined; }'};
+      var runtimePublicPathPrefix = runtimePublicPathPrefixResolver();
+      if (runtimePublicPathPrefix === undefined || runtimePublicPathPrefix === null || runtimePublicPathPrefix === '') {
+        runtimePublicPathPrefix = ${JSON.stringify(publicPathPrefix || '')};
+      }
+      if (typeof runtimePublicPathPrefix !== 'string') {
+        runtimePublicPathPrefix = runtimePublicPathPrefix != null ? String(runtimePublicPathPrefix) : '';
+      }
 
       function ensureTrailingSlash(path) {
         if (!path) return '';
         return path.charAt(path.length - 1) === '/' ? path : path + '/';
       }
 
-      function resolveConfiguredBase() {
-        try {
-          var candidate = (${i18nPublicPathVar});
-          if (typeof candidate === 'string' && candidate.length) {
-            return candidate;
-          }
-        } catch (err) {
-          // Fall back to DOM/publicPath detection
-        }
-        return '';
-      }
+      runtimePublicPathPrefix = ensureTrailingSlash(runtimePublicPathPrefix);
 
       function resolveI18nBase() {
         if (cachedI18nBase !== undefined) {
           return cachedI18nBase;
         }
 
-        var base = resolveConfiguredBase();
+        var base = __webpack_require__.p || '';
+        cachedI18nBase = ensureTrailingSlash(base);
+        return cachedI18nBase;
+      }
 
-        if (!base && typeof document !== 'undefined') {
-          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);
-              break;
-            }
-          }
+      function buildI18nUrl(relativePath) {
+        if (!relativePath) {
+          return runtimePublicPathPrefix || resolveI18nBase();
         }
 
-        if (!base) {
-          base = __webpack_require__.p || '';
-          if (base && base.indexOf('/smap/') !== -1 && base.slice(-6) === '/smap/') {
-            base = base.slice(0, -6) + '/';
-          }
+        var normalizedPath = relativePath;
+        if (normalizedPath.charAt(0) === '/') {
+          normalizedPath = normalizedPath.slice(1);
         }
 
-        cachedI18nBase = ensureTrailingSlash(base);
-        return cachedI18nBase;
-      }
+        if (runtimePublicPathPrefix) {
+          return runtimePublicPathPrefix + normalizedPath;
+        }
 
-      function buildI18nUrl(relativePath) {
         var base = resolveI18nBase();
-        if (!relativePath) return base;
-        if (relativePath.charAt(0) === '/') {
-          relativePath = relativePath.slice(1);
-        }
-        return base + relativePath;
+        return base + normalizedPath;
       }
 
       function loadI18nGroup(groupName, loadReason) {
@@ -111,19 +89,14 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
           return Promise.resolve();
         }
 
-        var shouldSkip =
-          (loadReason === 'prefetch' && config.prefetch === false) ||
-          (loadReason === 'preload' && config.preload === false);
-
-        if (shouldSkip) {
-          return Promise.resolve();
-        }
 
         return new Promise(function(resolve, reject) {
-          var relativePath = config.filenameTemplate.replace('[locale]', locale);
+          var relativePath;
 
-          if (hashAware && groupAssetUrls[groupName] && groupAssetUrls[groupName][locale]) {
+          if (groupAssetUrls[groupName] && groupAssetUrls[groupName][locale]) {
             relativePath = groupAssetUrls[groupName][locale];
+          } else {
+            relativePath = config.filenameTemplate.replace('[locale]', locale);
           }
 
           var i18nUrl = buildI18nUrl(relativePath);
@@ -140,17 +113,11 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
 
           script.onload = function() {
             loadedGroups[groupName] = true;
-            if (isDev) {
-              console.log('[i18n-group:loaded]', groupName, i18nUrl);
-            }
             cleanup();
             resolve();
           };
 
           script.onerror = function() {
-            if (isDev) {
-              console.error('[i18n-group:error]', groupName, i18nUrl);
-            }
             cleanup();
             loadedGroups[groupName] = true;
             resolve();
@@ -178,9 +145,6 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
             return i18nPromise.then(function() {
               return originalEnsureChunk.apply(self, args);
             }).catch(function(err) {
-              if (isDev) {
-                console.error('[i18n-group:critical] i18n failed, proceeding without:', err);
-              }
               return originalEnsureChunk.apply(self, args);
             });
           } else {
@@ -215,73 +179,17 @@ class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
         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);
-              }
+              // Silent error handling
             });
           }
         } catch (err) {
-          if (isDev) {
-            console.error('[i18n-group:url-detect] Error in URL detection:', err);
-          }
+          // Silent error handling
         }
       }
 
-      // Initialize preload and prefetch mechanisms
-      function initializeGroupLoading() {
-        if (typeof window === 'undefined') return;
-
-        var groupConfig = ${JSON.stringify(customGroups)};
-
-        // 1. Immediate preload for critical groups
-        for (var groupName in groupConfig) {
-          var config = groupConfig[groupName];
-          if (config.preload === true && !loadedGroups[groupName]) {
-            if (isDev) {
-              console.log('[i18n-group:preload]', groupName, 'loading immediately');
-            }
-            loadI18nGroup(groupName, 'preload').catch(function(err) {
-              if (isDev) {
-                console.error('[i18n-group:preload] Failed to preload', groupName, ':', err);
-              }
-            });
-          }
-        }
-
-        // 2. Schedule prefetch for background loading
-        function schedulePrefetch() {
-          for (var groupName in groupConfig) {
-            var config = groupConfig[groupName];
-            if (config.prefetch === true && !loadedGroups[groupName] && config.preload !== true) {
-              if (isDev) {
-                console.log('[i18n-group:prefetch]', groupName, 'scheduling background load');
-              }
-              loadI18nGroup(groupName, 'prefetch').catch(function(err) {
-                if (isDev) {
-                  console.error('[i18n-group:prefetch] Failed to prefetch', groupName, ':', err);
-                }
-              });
-            }
-          }
-        }
-
-        // Use requestIdleCallback for prefetch if available, otherwise setTimeout
-        if (window.requestIdleCallback) {
-          window.requestIdleCallback(schedulePrefetch, { timeout: 5000 });
-        } else {
-          setTimeout(schedulePrefetch, 100);
-        }
-
-        // 3. Check current URL for immediate loading
-        checkAndLoadGroupFromUrl();
-      }
-
-      // Initialize loading mechanisms
-      initializeGroupLoading();
+      // Check current URL for immediate loading
+      checkAndLoadGroupFromUrl();
     })();
     `;
   }

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

@@ -53,7 +53,9 @@ class I18nNumericIndexPlugin {
       outputFolder: options.outputFolder || 'i18n-chunk',
       manifestPath: options.manifestPath || null,
       emitFiles: options.emitFiles !== undefined ? options.emitFiles : true,
-      chunkToGroupMapping: options.chunkToGroupMapping || {}
+      chunkToGroupMapping: options.chunkToGroupMapping || {},
+      groupPublicPathPrefix: options.groupPublicPathPrefix || '',
+      groupPublicPathRuntimeExpression: options.groupPublicPathRuntimeExpression || ''
     };
     this.numericMap = {};
     this.customGroups = {};
@@ -66,20 +68,16 @@ class I18nNumericIndexPlugin {
   }
 
   apply(compiler) {
-    // Build-time validation for critical file paths
-    this.validateCriticalFilePaths(compiler); // Detect webpackI18nGroup comments in code
-
     this.detectI18nGroupComments(compiler);
     compiler.hooks.thisCompilation.tap(pluginName, compilation => {
       this.groupAssetUrls = {};
       this.detectedGroups = {};
       this.preparedAssets = [];
       this.assetsPrepared = false;
-      this.assetsEmitted = false; // Add runtime module for group-based loading
+      this.assetsEmitted = false;
 
       if (this.options.customGroups) {
         compilation.hooks.additionalTreeRuntimeRequirements.tap(pluginName, (chunk, set) => {
-          // Only add to the main/entry chunk to avoid duplication
           if (chunk.name === 'main' || chunk.hasRuntime()) {
             this.ensureAssetsPrepared(compilation);
             const chunkMapping = this.getChunkIdToGroupMapping(compilation);
@@ -88,9 +86,10 @@ class I18nNumericIndexPlugin {
               chunkIdToGroupMapping: chunkMapping,
               localeVarName: this.options.localeVarName,
               jsonpFunc: this.options.jsonpFunc,
-              i18nPublicPathVar: this.options.i18nPublicPathVar,
               groupAssetUrls: this.groupAssetUrls,
-              includeContentHash: this.options.includeContentHash
+              includeContentHash: this.options.includeContentHash,
+              publicPathPrefix: this.options.groupPublicPathPrefix,
+              publicPathRuntimeExpression: this.options.groupPublicPathRuntimeExpression
             }));
           }
         });
@@ -106,60 +105,6 @@ class I18nNumericIndexPlugin {
     });
   }
 
-  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);
-    }
-  }
-
   detectI18nGroupComments(compiler) {
     compiler.hooks.normalModuleFactory.tap(pluginName, factory => {
       factory.hooks.parser.for('javascript/auto').tap(pluginName, parser => {
@@ -197,11 +142,10 @@ class I18nNumericIndexPlugin {
     const chunkIdToGroup = {};
     const configuredMappings = { ...this.groupChunkMapping,
       ...(this.options.chunkToGroupMapping || {})
-    }; // Process chunks to get their actual IDs and map to groups
+    };
 
     for (const chunk of compilation.chunks) {
-      const chunkName = chunk.name; // First try detected groups, then fall back to configured mappings
-
+      const chunkName = chunk.name;
       let groupName = null;
 
       if (this.detectedGroups && this.detectedGroups[chunkName]) {
@@ -233,12 +177,12 @@ class I18nNumericIndexPlugin {
 
     if (!jsResourcePath || !propertiesFolderPath) {
       return;
-    } // Reset build-scoped caches so incremental builds don't carry stale data
+    } // Reset caches for incremental builds
 
 
     this.numericMap = {};
     this.manifest = {};
-    this.customGroups = {}; // Load existing numeric map if available
+    this.customGroups = {};
 
     if (numericMapPath) {
       const mapData = (0, _i18nDataLoader.loadNumericMap)(numericMapPath, compilation);
@@ -250,28 +194,24 @@ class I18nNumericIndexPlugin {
           }
         });
       }
-    } // Read JSResources.properties
-
+    }
 
     let jsResourceKeys = (0, _propertiesUtils.getPropertiesAsJSON)(jsResourcePath);
-    jsResourceKeys = this.normalizeObjectValues(jsResourceKeys); // Parse custom groups from banner markers
+    jsResourceKeys = this.normalizeObjectValues(jsResourceKeys);
 
     if (customGroups) {
       this.parseCustomGroups(jsResourcePath, customGroups);
-    } // Get all locale translations
-
+    }
 
     const allI18nObject = (0, _propertiesUtils.getAllI18n)({
       folderPath: propertiesFolderPath,
       disableDefault: false,
       jsResourceI18nKeys: jsResourceKeys
-    }); // Normalize locale values
-
+    });
     Object.keys(allI18nObject).forEach(loc => {
       allI18nObject[loc] = this.normalizeObjectValues(allI18nObject[loc]);
-    }); // For en_US, use only JSResources
-
-    allI18nObject['en_US'] = jsResourceKeys; // If requested, restrict all locales to base (English) keys only
+    });
+    allI18nObject['en_US'] = jsResourceKeys;
 
     if (this.options.restrictToBaseKeys) {
       const baseKeys = Object.keys(jsResourceKeys);
@@ -287,14 +227,12 @@ class I18nNumericIndexPlugin {
       });
     }
 
-    const locales = Object.keys(allI18nObject); // Process each locale
-
+    const locales = Object.keys(allI18nObject);
     locales.forEach(locale => {
       const localeData = allI18nObject[locale];
       const numericData = {};
       const dynamicData = {};
-      const groupData = {}; // Initialize custom groups
-
+      const groupData = {};
       Object.keys(customGroups || {}).forEach(groupName => {
         groupData[groupName] = {};
       }); // Process each key
@@ -442,12 +380,11 @@ class I18nNumericIndexPlugin {
     const {
       outputFolder
     } = this.options;
-    const filePath = template.replace(/\[locale\]/g, locale); // If template already contains outputFolder or starts with path separator, use as-is
+    const filePath = template.replace(/\[locale\]/g, locale);
 
     if (filePath.includes(outputFolder) || filePath.startsWith('/')) {
       return filePath;
-    } // Otherwise, join with outputFolder
-
+    }
 
     return _path.default.join(outputFolder, filePath).replace(/\\/g, '/');
   }

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/utils/propertiesUtils.js

@@ -59,8 +59,7 @@ function getPropertiesAsJSON(filePath) {
   } catch (err) {
     return {};
   }
-} // TODO: need to make it as custom option and  dynamic
-
+}
 
 function getLang(file) {
   const underScoreIndex = file.indexOf('_');
@@ -132,16 +131,4 @@ function jsonToString(json, keySeperator) {
   });
   str += '}';
   return str;
-}
-/**
- * not useable due to special charector
- * 
-      return `{${Object.keys(data).map(key =>  `"${key}": "${data[key]}"`).join(",")}}`
-      // return JSON.stringify(data);
-      let str = "{";
-      for (const key of Object.keys(data)) {
-        str+= `"${key}": "${data[key]}",`
-      }
-      str+="}";
-      return str;
- */
+}

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

@@ -12,11 +12,9 @@ const {
 } = require('./loaderConfigs/i18nIdReplaceLoaderConfig');
 
 function jsLoaders(options) {
-  const useLoaders = []; // Always add babel loader first
-
-  useLoaders.push((0, _babelLoaderConfig.babelLoaderConfig)(options)); // Add i18n ID replace loader if numeric indexing is enabled
-
-  const shouldUseNumericIndexing = options.i18nIndexing && options.i18nIndexing.enable || options.i18nChunkSplit && options.i18nChunkSplit.chunkSplitEnable && options.i18nChunkSplit.useNumericIndexing;
+  const useLoaders = [];
+  useLoaders.push((0, _babelLoaderConfig.babelLoaderConfig)(options));
+  const shouldUseNumericIndexing = options.i18nIndexing && options.i18nIndexing.enable;
 
   if (shouldUseNumericIndexing) {
     try {
@@ -26,7 +24,6 @@ function jsLoaders(options) {
         useLoaders.push(loaderConfig);
       }
     } catch (err) {
-      // Silently skip if configuration fails
       console.warn('[jsLoaders] Failed to configure i18n ID replace loader:', err.message);
     }
   }

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

@@ -14,13 +14,7 @@ var _fs = _interopRequireDefault(require("fs"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function loadJSResourcesOnce(options) {
-  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;
-  }
+  const jsResourcePath = options.i18nIndexing.jsResourcePath;
 
   try {
     const i18nData = (0, _propertiesUtils.getPropertiesAsJSON)(jsResourcePath);
@@ -45,14 +39,7 @@ function readNumericMapOnce(numericMapPath) {
 
 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;
-  }
-
+  const numericMapPath = options.i18nIndexing.numericMapPath;
   const allI18nData = loadJSResourcesOnce(options);
 
   const i18nKeyReplaceLoaderPath = require.resolve('../loaders/i18nIdReplaceLoader.js');
@@ -72,7 +59,8 @@ function i18nIdReplaceLoaderConfig(options) {
     numericIdMap: numericIdMap || undefined,
     devMode: options.i18nIndexing?.devMode || false,
     includePaths: options.i18nIndexing?.loaderOptions?.includePaths || [],
-    excludePaths: options.i18nIndexing?.loaderOptions?.excludePaths || ['node_modules', 'tests']
+    excludePaths: options.i18nIndexing?.loaderOptions?.excludePaths || ['node_modules', 'tests'],
+    i18nIndexingEnabled: true
   };
   return {
     loader: i18nKeyReplaceLoaderPath,

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

@@ -20,7 +20,11 @@ module.exports = function i18nIdReplaceLoader(source, map) {
   const resourcePath = this.resourcePath;
   this.cacheable && this.cacheable();
   const options = getOptions(this) || {};
-  const callback = this.async(); // Skip files in excluded paths
+  const callback = this.async(); // Early exit if i18n indexing is not enabled
+
+  if (!options.i18nIndexingEnabled) {
+    return callback(null, source, map);
+  }
 
   if (options.excludePaths && Array.isArray(options.excludePaths)) {
     const shouldExclude = options.excludePaths.some(excludePath => typeof excludePath === 'string' && resourcePath.includes(excludePath));
@@ -28,8 +32,7 @@ module.exports = function i18nIdReplaceLoader(source, map) {
     if (shouldExclude) {
       return callback(null, source, map);
     }
-  } // Only process files in included paths if specified
-
+  }
 
   if (options.includePaths && Array.isArray(options.includePaths) && options.includePaths.length > 0) {
     const shouldInclude = options.includePaths.some(includePath => typeof includePath === 'string' && resourcePath.includes(includePath));
@@ -37,13 +40,11 @@ module.exports = function i18nIdReplaceLoader(source, map) {
     if (!shouldInclude) {
       return callback(null, source, map);
     }
-  } // 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 - paths already validated by config
-
+  }
 
   let numericIdMap = options.numericIdMap;
 
@@ -60,28 +61,43 @@ module.exports = function i18nIdReplaceLoader(source, 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
-
+  }
 
   if (!numericIdMap) {
     return callback(null, source, map);
+  } // Pre-filter: Skip files without valid i18n keys from numericIdMap
+
+
+  function hasValidI18nKeys(source, numericIdMap) {
+    const keyPattern = /['"`]([\w-_]+(?:\.[\w-_]+){2,})['"`]/g;
+    let match;
+
+    while ((match = keyPattern.exec(source)) !== null) {
+      if (numericIdMap.hasOwnProperty(match[1])) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  if (!hasValidI18nKeys(source, numericIdMap)) {
+    return callback(null, source, map);
   }
 
   try {
-    // Parse the JavaScript/TypeScript source code
     const ast = parser.parse(source, {
       sourceType: 'module',
-      plugins: ['jsx', 'typescript', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator'],
+      plugins: ['jsx', 'typescript', 'nullishCoalescingOperator'],
       sourceFilename: resourcePath
     });
     let hasTransformations = false;
-    let transformationCount = 0; // Traverse AST and replace i18n keys with numeric IDs
-
+    let transformationCount = 0;
     traverse(ast, {
       StringLiteral(path) {
         const {
           node
-        } = path; // Check if this string is an i18n key and has numeric mapping
+        } = path;
 
         if (options.allI18nData.hasOwnProperty(node.value) && numericIdMap.hasOwnProperty(node.value)) {
           const numericId = String(numericIdMap[node.value]);
@@ -91,7 +107,7 @@ module.exports = function i18nIdReplaceLoader(source, map) {
         }
       }
 
-    }); // Generate code if transformations were made
+    });
 
     if (hasTransformations) {
       const output = generator(ast, {

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

@@ -18,7 +18,6 @@ class I18nNumericHtmlInjectorPlugin {
 
   apply(compiler) {
     compiler.hooks.thisCompilation.tap(pluginName, compilation => {
-      // Hook into HtmlWebpackPlugin to inject i18n script tags
       _htmlWebpackPlugin.default.getHooks(compilation).beforeAssetTagGeneration.tap(pluginName, hookData => {
         const {
           assets
@@ -27,36 +26,28 @@ class I18nNumericHtmlInjectorPlugin {
           numericFilenameTemplate,
           dynamicFilenameTemplate,
           htmlTemplateLabel,
-          i18nCdnTemplate,
           customGroups
         } = this.options;
-        const newI18nAssets = []; // Add numeric i18n chunk
+        const newI18nAssets = [];
 
         if (numericFilenameTemplate) {
-          const numericFilename = numericFilenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel).replace(/%5Blocale%5D/g, htmlTemplateLabel); // Don't add CDN template - HtmlWebpackPlugin handles it
-
+          const numericFilename = numericFilenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel).replace(/%5Blocale%5D/g, htmlTemplateLabel);
           newI18nAssets.push(numericFilename);
-        } // Add dynamic i18n chunk
-
+        }
 
         if (dynamicFilenameTemplate) {
-          const dynamicFilename = dynamicFilenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel).replace(/%5Blocale%5D/g, htmlTemplateLabel); // Don't add CDN template - HtmlWebpackPlugin handles it
-
+          const dynamicFilename = dynamicFilenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel).replace(/%5Blocale%5D/g, htmlTemplateLabel);
           newI18nAssets.push(dynamicFilename);
-        } // Add custom group chunks if they should be in initial HTML
-
+        }
 
         if (customGroups) {
           Object.entries(customGroups).forEach(([groupName, groupConfig]) => {
-            // Only add to initial HTML if preload is true
             if (groupConfig.preload && groupConfig.filenameTemplate) {
-              const groupFilename = groupConfig.filenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel).replace(/%5Blocale%5D/g, htmlTemplateLabel); // Don't add CDN template - HtmlWebpackPlugin handles it
-
+              const groupFilename = groupConfig.filenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel).replace(/%5Blocale%5D/g, htmlTemplateLabel);
               newI18nAssets.push(groupFilename);
             }
           });
-        } // Prepend i18n assets to ensure they load before main bundle
-
+        }
 
         if (newI18nAssets.length > 0) {
           assets.js = [...newI18nAssets, ...assets.js];
@@ -73,12 +64,11 @@ function configI18nNumericHtmlInjector(config) {
   const {
     i18nIndexing,
     cdnMapping
-  } = config; // Only create this plugin if i18nIndexing is enabled
+  } = config;
 
   if (!i18nIndexing || !i18nIndexing.enable) {
     return null;
-  } // Get the CDN template for i18n resources if CDN is enabled
-
+  }
 
   const i18nCdnTemplate = cdnMapping && cdnMapping.isCdnEnabled ? cdnMapping.i18nTemplate || cdnMapping.jsTemplate : '';
   const options = {

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

@@ -21,6 +21,8 @@ function configI18nNumericIndexPlugin(options) {
   }
 
   const i18nOpts = options.i18nIndexing;
+  const groupPublicPathPrefix = i18nOpts.groupPublicPathPrefix || '';
+  const groupPublicPathRuntimeExpression = i18nOpts.groupPublicPathRuntimeExpression !== undefined ? i18nOpts.groupPublicPathRuntimeExpression : 'window.__SMAP_PATH__';
 
   try {
     const result = (0, _i18nOptionsValidator.validateI18nIndexingOptions)(i18nOpts);
@@ -81,7 +83,8 @@ function configI18nNumericIndexPlugin(options) {
     customGroups: i18nOpts.customGroups || null,
     chunkToGroupMapping: i18nOpts.chunkToGroupMapping || {},
     emitFiles,
-    i18nPublicPathVar: i18nOpts.i18nPublicPathVar
+    groupPublicPathPrefix,
+    groupPublicPathRuntimeExpression
   };
   const htmlInjectorOptions = { ...sharedOptions,
     htmlTemplateLabel: i18nOpts.htmlTemplateLabel,

package/package.json

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