@zohodesk/client_build_tool 0.0.11-exp.15.1 → 0.0.11-exp.15.4

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

@@ -1,186 +1,253 @@
 "use strict";
 
-const path = require('path');
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
 
-const {
-  sources,
-  Compilation,
-  util
-} = require('webpack');
+var _fs = _interopRequireDefault(require("fs"));
 
-const {
-  decodeUnicodeEscapes
-} = require('../../utils/propertiesParser');
+var _path = _interopRequireDefault(require("path"));
 
-const {
-  loadNumericMap,
-  loadI18nData
-} = require('./utils/i18nDataLoader');
+var _webpack = require("webpack");
+
+var _propertiesUtils = require("../I18nSplitPlugin/utils/propertiesUtils");
+
+var _I18nGroupRuntimeModule = require("./I18nGroupRuntimeModule");
+
+var _i18nDataLoader = require("./utils/i18nDataLoader");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const {
   RawSource
-} = sources;
+} = _webpack.sources;
 const pluginName = 'I18nNumericIndexPlugin';
 
 class I18nNumericIndexPlugin {
-  constructor(options = {}) {
-    this.options = { ...options,
-      singleFile: options.singleFile || false,
-      singleFileTemplate: options.singleFileTemplate,
-      includeContentHash: options.includeContentHash || false,
-      generateManifest: options.generateManifest || false,
-      manifestPath: options.manifestPath || 'i18n/manifest.json'
-    };
-    this.numericMap = null;
-    this.i18nData = null;
-    this.manifest = {};
+  constructor(options) {
+    this.options = options;
+    this.numericMap = {};
+    this.customGroups = {};
   }
 
-  getNumericMap(compilation) {
-    if (!this.numericMap) {
-      const mapPath = path.resolve(compilation.compiler.context, this.options.numericMapPath);
-      this.numericMap = loadNumericMap(mapPath, compilation);
-    }
+  apply(compiler) {
+    // Detect webpackI18nGroup comments in code
+    this.detectI18nGroupComments(compiler);
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      // Add runtime module for group-based loading
+      if (this.options.customGroups) {
+        compilation.hooks.runtimeRequirementInTree.for(_webpack.RuntimeGlobals.ensureChunk).tap(pluginName, chunk => {
+          compilation.addRuntimeModule(chunk, new _I18nGroupRuntimeModule.I18nGroupRuntimeModule({
+            customGroups: this.options.customGroups,
+            localeVarName: this.options.localeVarName,
+            jsonpFunc: this.options.jsonpFunc
+          }));
+        });
+      }
 
-    return this.numericMap;
+      compilation.hooks.processAssets.tap({
+        name: pluginName,
+        stage: compilation.PROCESS_ASSETS_STAGE_OPTIMIZE
+      }, () => {
+        this.processI18nFiles(compilation);
+      });
+    });
   }
 
-  getI18nData(compilation) {
-    if (!this.i18nData) {
-      this.i18nData = loadI18nData(this.options, compilation);
-    }
+  detectI18nGroupComments(compiler) {
+    compiler.hooks.normalModuleFactory.tap(pluginName, factory => {
+      factory.hooks.parser.for('javascript/auto').tap(pluginName, parser => {
+        parser.hooks.importCall.tap(pluginName, expr => {
+          // Check for webpackI18nGroup comment
+          const comments = expr.leadingComments || [];
+          comments.forEach(comment => {
+            if (comment.value && comment.value.includes('webpackI18nGroup')) {
+              const match = comment.value.match(/webpackI18nGroup:\s*["']([^"']+)["']/);
+
+              if (match) {
+                const groupName = match[1]; // Store this information for later use
+
+                if (!this.detectedGroups) {
+                  this.detectedGroups = {};
+                } // Extract chunk name from webpackChunkName comment
+
 
-    return this.i18nData;
+                const chunkNameMatch = comment.value.match(/webpackChunkName:\s*["']([^"']+)["']/);
+
+                if (chunkNameMatch) {
+                  const chunkName = chunkNameMatch[1];
+                  this.detectedGroups[chunkName] = groupName;
+                }
+              }
+            }
+          });
+        });
+      });
+    });
   }
 
-  generateContentHash(content, compilation) {
+  processI18nFiles(compilation) {
     const {
-      hashFunction,
-      hashDigest,
-      hashDigestLength
-    } = compilation.outputOptions;
-    const hash = util.createHash(hashFunction || 'xxhash64');
-    hash.update(content);
-    return hash.digest(hashDigest || 'hex').substring(0, hashDigestLength || 20);
-  }
+      jsResourcePath,
+      propertiesFolderPath,
+      numericMapPath,
+      customGroups,
+      jsonpFunc,
+      numericFilenameTemplate,
+      dynamicFilenameTemplate
+    } = this.options;
+
+    if (!jsResourcePath || !propertiesFolderPath) {
+      return;
+    } // Load existing numeric map if available
+
+
+    if (numericMapPath) {
+      const mapData = (0, _i18nDataLoader.loadNumericMap)(numericMapPath, compilation);
+
+      if (mapData && mapData.sortedKeys) {
+        // Initialize numericMap from existing data
+        mapData.sortedKeys.forEach((key, id) => {
+          if (key) {
+            this.numericMap[key] = id;
+          }
+        });
+      }
+    } // Read JSResources.properties
 
-  emitChunk(compilation, filename, locale, data, fileType = null) {
-    const content = decodeUnicodeEscapes(JSON.stringify(data));
-    const fileContent = `${this.options.jsonpFunc}(${content});`;
-    let outputPath = filename.replace(/\[locale\]/g, locale);
-    const hasContentHashPlaceholder = filename.includes('[contenthash]');
-    const shouldIncludeHash = hasContentHashPlaceholder || this.options.includeContentHash;
 
-    if (shouldIncludeHash) {
-      const contentHash = this.generateContentHash(fileContent, compilation);
+    const jsResourceKeys = (0, _propertiesUtils.getPropertiesAsJSON)(jsResourcePath); // Parse custom groups from banner markers
 
-      if (hasContentHashPlaceholder) {
-        outputPath = outputPath.replace(/\[contenthash\]/g, contentHash);
-      } else {
-        outputPath = outputPath.replace(/\.js$/, `.${contentHash}.js`);
-      }
-    }
+    if (customGroups) {
+      this.parseCustomGroups(jsResourcePath, customGroups);
+    } // Get all locale translations
 
-    if (this.options.generateManifest) {
-      const cleanName = filename.replace(/\[locale\]/g, locale).replace(/\.\[contenthash\]/g, '').replace(/\.js$/, '.js');
-      const cleanNameWithType = fileType ? cleanName.replace(/\.js$/, `.${fileType}.js`) : cleanName;
-      const manifestKey = cleanNameWithType.split('/').pop();
-      this.manifest[manifestKey] = outputPath.split('/').pop();
-    }
 
-    compilation.emitAsset(outputPath, new RawSource(fileContent));
-    return outputPath;
-  }
+    const allI18nObject = (0, _propertiesUtils.getAllI18n)({
+      folderPath: propertiesFolderPath,
+      disableDefault: false,
+      jsResourceI18nKeys: jsResourceKeys
+    }); // For en_US, use only JSResources (don't merge with ApplicationResources_en_US)
 
-  apply(compiler) {
-    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
-      compilation.hooks.processAssets.tapAsync({
-        name: pluginName,
-        stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
-      }, (assets, callback) => {
-        if (!this.options.enable) {
-          return callback();
-        }
+    if (allI18nObject['en_US']) {
+      allI18nObject['en_US'] = jsResourceKeys;
+    } else {
+      // If en_US doesn't exist in the folder, create it from JSResources
+      allI18nObject['en_US'] = jsResourceKeys;
+    }
 
-        const {
-          sortedKeys,
-          totalKeys,
-          originalKeyToNumericId
-        } = this.getNumericMap(compilation);
-        const {
-          jsResourceBase,
-          allI18n,
-          locales
-        } = this.getI18nData(compilation);
-        if (!locales.length) return callback();
-        const numericKeysSet = new Set(sortedKeys);
-        const englishData = allI18n.en_US || jsResourceBase;
-        const isDevMode = this.options.devMode || process.env.NODE_ENV === 'development';
-        locales.forEach(locale => {
-          const localeData = allI18n[locale] || {};
-          const numericData = {};
-          const unmappedData = {};
-          Object.keys(jsResourceBase).forEach(key => {
-            const translation = localeData[key] ?? englishData[key];
-
-            if (originalKeyToNumericId && originalKeyToNumericId.hasOwnProperty(key)) {
-              const numericId = originalKeyToNumericId[key];
-              numericData[numericId] = translation;
-            } else if (numericKeysSet.has(key)) {
-              const index = sortedKeys.indexOf(key);
-
-              if (index !== -1) {
-                numericData[index] = translation;
-              }
-            } else {
-              unmappedData[key] = translation;
-            }
-          });
+    const locales = Object.keys(allI18nObject); // Process each locale
 
-          if (this.options.singleFile) {
-            const combinedData = { ...numericData,
-              ...unmappedData
-            };
+    locales.forEach(locale => {
+      const localeData = allI18nObject[locale];
+      const numericData = {};
+      const dynamicData = {};
+      const groupData = {}; // Initialize custom groups
 
-            if (Object.keys(combinedData).length > 0) {
-              const filename = this.options.singleFileTemplate || this.options.numericFilenameTemplate || this.options.dynamicFilenameTemplate;
-              this.emitChunk(compilation, filename, locale, combinedData);
-            }
-          } else {
-            if (Object.keys(numericData).length > 0) {
-              this.emitChunk(compilation, this.options.numericFilenameTemplate, locale, numericData, 'numeric');
-            }
+      Object.keys(customGroups || {}).forEach(groupName => {
+        groupData[groupName] = {};
+      }); // Process each key
 
-            if (Object.keys(unmappedData).length > 0) {
-              this.emitChunk(compilation, this.options.dynamicFilenameTemplate, locale, unmappedData, 'dynamic');
-            }
-          }
-        });
+      Object.keys(localeData).forEach(key => {
+        const value = localeData[key]; // Simple logic: if has numeric ID use it, otherwise it's dynamic
+
+        if (this.numericMap[key]) {
+          const numericKey = String(this.numericMap[key]); // Check if belongs to a custom group
 
-        if (this.options.generateManifest && Object.keys(this.manifest).length > 0) {
-          // Determine manifest path
-          let manifestPath;
+          const belongsToGroup = this.getKeyGroup(key);
 
-          if (this.options.manifestPath) {
-            // Use explicitly configured path
-            manifestPath = this.options.manifestPath;
+          if (belongsToGroup) {
+            groupData[belongsToGroup][numericKey] = value;
           } else {
-            // Default to same directory as i18n files with manifest.json name
-            const template = this.options.singleFileTemplate || this.options.numericFilenameTemplate;
-            manifestPath = path.dirname(template) + '/manifest.json';
+            numericData[numericKey] = value;
           }
+        } else {
+          // No numeric ID = dynamic key (regardless of placeholders)
+          dynamicData[key] = value;
+        }
+      }); // Emit numeric chunk
+
+      this.emitChunk(compilation, numericFilenameTemplate, locale, numericData, jsonpFunc); // Emit dynamic chunk
 
-          const manifestContent = JSON.stringify(this.manifest, null, 2);
-          compilation.emitAsset(manifestPath, new RawSource(manifestContent));
+      this.emitChunk(compilation, dynamicFilenameTemplate, locale, dynamicData, jsonpFunc); // Emit custom group chunks
+
+      Object.entries(groupData).forEach(([groupName, data]) => {
+        const groupConfig = customGroups[groupName];
+
+        if (groupConfig && Object.keys(data).length > 0) {
+          this.emitChunk(compilation, groupConfig.filenameTemplate || `i18n-chunk/[locale]/${groupName}.i18n.js`, locale, data, jsonpFunc, groupName);
         }
+      });
+    }); // Don't save numeric map - it should only be generated by the external script
+  }
 
-        callback();
+  parseCustomGroups(jsResourcePath, customGroups) {
+    const content = _fs.default.readFileSync(jsResourcePath, 'utf-8');
+
+    const lines = content.split('\n');
+    Object.entries(customGroups).forEach(([groupName, config]) => {
+      const {
+        bannerStart,
+        bannerEnd
+      } = config;
+      let inGroup = false;
+      const groupKeys = [];
+      lines.forEach(line => {
+        if (line.includes(bannerStart)) {
+          inGroup = true;
+        } else if (line.includes(bannerEnd)) {
+          inGroup = false;
+        } else if (inGroup && line.includes('=')) {
+          const key = line.split('=')[0].trim();
+
+          if (key && !key.startsWith('#')) {
+            groupKeys.push(key);
+          }
+        }
       });
+      this.customGroups[groupName] = groupKeys;
     });
   }
 
+  getKeyGroup(key) {
+    for (const [groupName, keys] of Object.entries(this.customGroups)) {
+      if (keys.includes(key)) {
+        return groupName;
+      }
+    }
+
+    return null;
+  }
+
+  isDynamicKey(value) {
+    // Check if value contains placeholders like {0}, {1}, etc.
+    return /\{\d+\}/.test(value);
+  }
+
+  getNumericKey(key) {
+    // Return numeric ID if it exists, null otherwise
+    return this.numericMap[key] ? String(this.numericMap[key]) : null;
+  }
+
+  emitChunk(compilation, filenameTemplate, locale, data, jsonpFunc, groupName = null) {
+    const filename = filenameTemplate.replace('[locale]', locale);
+    const content = this.generateChunkContent(data, jsonpFunc, groupName);
+    compilation.emitAsset(filename, new RawSource(content));
+  }
+
+  generateChunkContent(data, jsonpFunc, groupName) {
+    // Decode Unicode escapes to convert \uXXXX to actual characters
+    const jsonString = (0, _propertiesUtils.decodeUnicodeEscapes)(JSON.stringify(data));
+
+    if (groupName) {
+      // Include group name for lazy loading identification
+      return `${jsonpFunc}(${jsonString}, "${groupName}");`;
+    }
+
+    return `${jsonpFunc}(${jsonString});`;
+  }
+
 }
 
-module.exports = {
-  I18nNumericIndexPlugin
-};
+exports.default = I18nNumericIndexPlugin;

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

@@ -5,13 +5,16 @@ const fs = require('fs');
 const path = require('path');
 
 const {
-  parseProperties
-} = require('../../../utils/propertiesParser');
+  getPropertiesAsJSON
+} = require('../../I18nSplitPlugin/utils/propertiesUtils');
+/**
+ * Load and parse a properties file
+ */
+
 
 function loadPropertiesFile(filePath, compilation, description) {
   try {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const parsed = parseProperties(content);
+    const parsed = getPropertiesAsJSON(filePath);
     return parsed;
   } catch (err) {
     if (compilation) {
@@ -21,18 +24,37 @@ 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);
-    const sortedKeys = new Array(parsedData.totalKeysInMap);
-    Object.entries(parsedData.originalKeyToNumericId).forEach(([key, id]) => {
+    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 maxId = Math.max(...Object.values(numericMap));
+    const sortedKeys = new Array(maxId + 1);
+    Object.entries(numericMap).forEach(([key, id]) => {
       sortedKeys[id] = key;
     });
     return {
       sortedKeys,
-      totalKeys: parsedData.totalKeysInMap
+      totalKeys
     };
   } catch (err) {
     if (compilation) {
@@ -45,23 +67,30 @@ function loadNumericMap(numericMapPath, compilation) {
     };
   }
 }
+/**
+ * Load all locale files from properties directory
+ */
+
 
 function loadAllLocaleFiles(propertiesPath, compilation, jsResourceBase) {
   const allI18n = {};
-  const locales = [];
+  const locales = []; // Start with English base
+
   allI18n['en_US'] = jsResourceBase;
   locales.push('en_US');
 
   try {
     const files = fs.readdirSync(propertiesPath);
     files.forEach(file => {
-      if (!file.endsWith('.properties')) return;
+      if (!file.endsWith('.properties')) return; // Match locale-specific property files
+
       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}`);
+        const localeData = loadPropertiesFile(filePath, compilation, `locale ${locale}`); // Merge with base resources
+
         allI18n[locale] = { ...jsResourceBase,
           ...localeData
         };
@@ -82,11 +111,17 @@ 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);
-  const jsResourceBase = loadPropertiesFile(jsResourcePath, compilation, 'JS resources');
+  const propertiesPath = path.resolve(compilation.compiler.context, options.propertiesFolderPath); // Load base JS resources
+
+  const jsResourceBase = loadPropertiesFile(jsResourcePath, compilation, 'JS resources'); // Load all locale files
+
   const {
     allI18n,
     locales

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

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.decodeUnicodeEscapes = decodeUnicodeEscapes;
 exports.getAllI18n = getAllI18n;
 exports.getPropertiesAsJSON = getPropertiesAsJSON;
 exports.jsonToString = jsonToString;
@@ -16,6 +17,21 @@ var _constants = require("../../../../../constants");
 function isComment(line) {
   return line[0] === '#';
 }
+/**
+ * Decode Unicode escape sequences in a string
+ * Converts \uXXXX to the actual character
+ */
+
+
+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));
+  });
+}
 
 function getPropertiesAsJSON(filePath) {
   try {
@@ -31,9 +47,11 @@ function getPropertiesAsJSON(filePath) {
 
       const ind = line.indexOf('=');
       const key = line.slice(0, ind).replace(/\\ /g, ' ');
-      const value = line.slice(ind + 1);
+      let value = line.slice(ind + 1);
 
       if (key && value) {
+        // Decode Unicode escapes in the value
+        value = decodeUnicodeEscapes(value);
         i18nObj[key] = value;
       }
     }, {});

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

@@ -12,8 +12,10 @@ const {
 } = require('./loaderConfigs/i18nIdReplaceLoaderConfig');
 
 function jsLoaders(options) {
-  const useLoaders = [];
-  useLoaders.push((0, _babelLoaderConfig.babelLoaderConfig)(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;
 
   if (shouldUseNumericIndexing) {
@@ -23,13 +25,16 @@ function jsLoaders(options) {
       if (loaderConfig) {
         useLoaders.push(loaderConfig);
       }
-    } catch (err) {// Silently skip if configuration fails
+    } catch (err) {
+      // Silently skip if configuration fails
+      console.warn('[jsLoaders] Failed to configure i18n ID replace loader:', err.message);
     }
   }
 
   return [{
     test: /\.js$/,
     exclude: /node_modules/,
-    use: useLoaders
+    use: useLoaders // include: path.join(appPath, folder)
+
   }];
 }

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

@@ -3,9 +3,13 @@
 const {
   getPropertiesAsJSON
 } = require('../custom_plugins/I18nSplitPlugin/utils/propertiesUtils');
+/**
+ * Load i18n data from JSResources file once for all chunks
+ */
+
 
 function loadJSResourcesOnce(options) {
-  let jsResourcePath;
+  let jsResourcePath; // Determine the JSResource path based on configuration
 
   if (options.i18nIndexing && options.i18nIndexing.enable) {
     jsResourcePath = options.i18nIndexing.jsResourcePath;
@@ -32,9 +36,13 @@ function loadJSResourcesOnce(options) {
     throw new Error(`Error reading JSResource file ${jsResourcePath}: ${err.message}`);
   }
 }
+/**
+ * Configure the i18n ID replace loader
+ */
+
 
 function i18nIdReplaceLoaderConfig(options, webpackContext) {
-  let numericMapPath;
+  let numericMapPath; // Determine the numeric map path based on configuration
 
   if (options.i18nIndexing && options.i18nIndexing.enable) {
     numericMapPath = options.i18nIndexing.numericMapPath;
@@ -46,7 +54,8 @@ function i18nIdReplaceLoaderConfig(options, webpackContext) {
 
   if (!numericMapPath) {
     throw new Error('numericMapPath is required in i18nIndexing or i18nChunkSplit config');
-  }
+  } // Load all i18n data for key detection
+
 
   const allI18nData = loadJSResourcesOnce(options);