@zohodesk/client_build_tool 0.0.1-0.exp.0.0.9 → 0.0.1-0.exp.1.0.3

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

@@ -0,0 +1,129 @@
+"use strict";
+
+const path = require('path');
+
+const {
+  sources,
+  Compilation
+} = require('webpack');
+
+const {
+  decodeUnicodeEscapes
+} = require('../../utils/propertiesParser');
+
+const {
+  loadNumericMap,
+  loadI18nData
+} = require('./utils/i18nDataLoader');
+
+const {
+  RawSource
+} = sources;
+const pluginName = 'I18nNumericIndexPlugin';
+
+class I18nNumericIndexPlugin {
+  constructor(options = {}) {
+    this.options = options;
+    this.numericMap = null;
+    this.i18nData = null;
+  }
+
+  getNumericMap(compilation) {
+    if (!this.numericMap) {
+      const mapPath = path.resolve(compilation.compiler.context, this.options.numericMapPath);
+      this.numericMap = loadNumericMap(mapPath, compilation);
+    }
+
+    return this.numericMap;
+  }
+
+  getI18nData(compilation) {
+    if (!this.i18nData) {
+      this.i18nData = loadI18nData(this.options, compilation);
+    }
+
+    return this.i18nData;
+  }
+
+  emitChunk(compilation, filename, locale, data) {
+    const content = decodeUnicodeEscapes(JSON.stringify(data));
+    const fileContent = `${this.options.jsonpFunc}(${content});`;
+    const outputPath = filename.replace(/\[locale\]/g, locale);
+    compilation.emitAsset(outputPath, new RawSource(fileContent));
+  }
+
+  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();
+        const {
+          sortedKeys,
+          totalKeys
+        } = this.getNumericMap(compilation);
+        const {
+          jsResourceBase,
+          allI18n,
+          locales
+        } = this.getI18nData(compilation);
+        if (!locales.length) return callback(); // Collect dynamic keys used in comments
+
+        const dynamicKeys = new Set();
+
+        for (const module of compilation.modules) {
+          if (module.buildInfo?.loaderIdentifiedCommentI18nKeys) {
+            module.buildInfo.loaderIdentifiedCommentI18nKeys.forEach(key => dynamicKeys.add(key));
+          }
+        }
+
+        const numericKeysSet = new Set(sortedKeys);
+        const englishData = allI18n.en || jsResourceBase; // Process each locale
+
+        locales.forEach(locale => {
+          const localeData = allI18n[locale] || {}; // Build numeric data
+
+          const numericData = {};
+
+          for (let i = 0; i < totalKeys; i++) {
+            const key = sortedKeys[i];
+
+            if (key && jsResourceBase[key] !== undefined) {
+              numericData[i] = localeData[key] ?? englishData[key];
+            }
+          } // Build dynamic data
+
+
+          const dynamicData = {}; // Add comment keys
+
+          dynamicKeys.forEach(key => {
+            if (!numericKeysSet.has(key) && jsResourceBase[key] !== undefined) {
+              dynamicData[key] = localeData[key] ?? englishData[key];
+            }
+          }); // Add remaining keys
+
+          Object.keys(jsResourceBase).forEach(key => {
+            if (!numericKeysSet.has(key) && !dynamicData[key]) {
+              dynamicData[key] = localeData[key] ?? englishData[key];
+            }
+          }); // Emit chunks
+
+          if (Object.keys(numericData).length > 0) {
+            this.emitChunk(compilation, this.options.numericFilenameTemplate, locale, numericData);
+          }
+
+          if (Object.keys(dynamicData).length > 0) {
+            this.emitChunk(compilation, this.options.dynamicFilenameTemplate, locale, dynamicData);
+          }
+        });
+        callback();
+      });
+    });
+  }
+
+}
+
+module.exports = {
+  I18nNumericIndexPlugin
+};

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

@@ -0,0 +1,134 @@
+"use strict";
+
+const fs = require('fs');
+
+const path = require('path');
+
+const {
+  parseProperties
+} = require('../../utils/propertiesParser');
+/**
+ * Loads and parses a properties file
+ * @param {string} filePath - Path to the properties file
+ * @param {Object} compilation - Webpack compilation object for error reporting
+ * @param {string} description - Description for error messages
+ * @returns {Object} Parsed properties object
+ */
+
+
+function loadPropertiesFile(filePath, compilation, description) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return parseProperties(content);
+  } catch (err) {
+    if (compilation) {
+      compilation.errors.push(new Error(`I18nNumericIndexPlugin: Error loading ${description}: ${err.message}`));
+    }
+
+    return {};
+  }
+}
+/**
+ * Loads numeric mapping from JSON file
+ * @param {string} numericMapPath - Path to numeric map JSON file
+ * @param {Object} compilation - Webpack compilation object
+ * @returns {Object} Object with sortedKeys array and totalKeys count
+ */
+
+
+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]) => {
+      sortedKeys[id] = key;
+    });
+    return {
+      sortedKeys,
+      totalKeys: parsedData.totalKeysInMap
+    };
+  } catch (err) {
+    if (compilation) {
+      compilation.errors.push(new Error(`I18nNumericIndexPlugin: Error loading numeric map: ${err.message}`));
+    }
+
+    return {
+      sortedKeys: [],
+      totalKeys: 0
+    };
+  }
+}
+/**
+ * Loads all locale-specific properties files
+ * @param {string} propertiesPath - Path to properties folder
+ * @param {string} baseFileName - Base filename (e.g., 'JSResources')
+ * @param {Object} compilation - Webpack compilation object
+ * @returns {Object} Object with allI18n translations and locales array
+ */
+
+
+function loadAllLocaleFiles(propertiesPath, baseFileName, compilation) {
+  const allI18n = {};
+  const locales = [];
+
+  try {
+    const files = fs.readdirSync(propertiesPath);
+    files.forEach(file => {
+      if (!file.endsWith('.properties')) return;
+      const name = path.basename(file, '.properties');
+      let locale = null;
+
+      if (name === baseFileName) {
+        locale = 'en';
+      } else if (name.startsWith(baseFileName + '_')) {
+        locale = name.substring(baseFileName.length + 1);
+      }
+
+      if (locale) {
+        const filePath = path.join(propertiesPath, file);
+        allI18n[locale] = loadPropertiesFile(filePath, compilation, `locale ${locale}`);
+        locales.push(locale);
+      }
+    });
+  } catch (err) {
+    if (compilation) {
+      compilation.errors.push(new Error(`I18nNumericIndexPlugin: Error reading properties folder: ${err.message}`));
+    }
+  }
+
+  return {
+    allI18n,
+    locales
+  };
+}
+/**
+ * Loads all i18n data including base resources and locale-specific translations
+ * @param {Object} options - Plugin options
+ * @param {Object} compilation - Webpack compilation object
+ * @returns {Object} Object with jsResourceBase, allI18n, and locales
+ */
+
+
+function loadI18nData(options, compilation) {
+  const jsResourcePath = path.resolve(compilation.compiler.context, options.jsResourcePath);
+  const propertiesPath = path.resolve(compilation.compiler.context, options.propertiesFolderPath);
+  const baseFileName = path.basename(options.jsResourcePath, '.properties');
+  const jsResourceBase = loadPropertiesFile(jsResourcePath, compilation, 'JS resources');
+  const {
+    allI18n,
+    locales
+  } = loadAllLocaleFiles(propertiesPath, baseFileName, compilation);
+  return {
+    jsResourceBase,
+    allI18n,
+    locales
+  };
+}
+
+module.exports = {
+  loadPropertiesFile,
+  loadNumericMap,
+  loadAllLocaleFiles,
+  loadI18nData
+};

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

@@ -0,0 +1,113 @@
+"use strict";
+
+const fs = require('fs');
+
+const path = require('path');
+
+const {
+  parseProperties
+} = require('../../../utils/propertiesParser');
+
+function loadPropertiesFile(filePath, compilation, description) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const parsed = parseProperties(content);
+    return parsed;
+  } catch (err) {
+    if (compilation) {
+      compilation.errors.push(new Error(`I18nNumericIndexPlugin: Error loading ${description}: ${err.message}`));
+    }
+
+    return {};
+  }
+}
+
+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]) => {
+      sortedKeys[id] = key;
+    });
+    return {
+      sortedKeys,
+      totalKeys: parsedData.totalKeysInMap
+    };
+  } catch (err) {
+    if (compilation) {
+      compilation.errors.push(new Error(`I18nNumericIndexPlugin: Error loading numeric map: ${err.message}`));
+    }
+
+    return {
+      sortedKeys: [],
+      totalKeys: 0
+    };
+  }
+}
+
+function loadAllLocaleFiles(propertiesPath, baseFileName, compilation) {
+  const allI18n = {};
+  const locales = [];
+
+  try {
+    const files = fs.readdirSync(propertiesPath);
+    files.forEach(file => {
+      if (file === baseFileName + '.properties') {
+        const filePath = path.join(propertiesPath, file);
+        const baseData = loadPropertiesFile(filePath, compilation, 'JSResources base');
+        allI18n['en_US'] = baseData;
+        locales.push('en_US');
+      }
+    });
+    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}`);
+        allI18n[locale] = { ...allI18n['en_US'],
+          ...localeData
+        };
+
+        if (!locales.includes(locale)) {
+          locales.push(locale);
+        }
+      }
+    });
+  } catch (err) {
+    if (compilation) {
+      compilation.errors.push(new Error(`I18nNumericIndexPlugin: Error reading properties folder: ${err.message}`));
+    }
+  }
+
+  return {
+    allI18n,
+    locales
+  };
+}
+
+function loadI18nData(options, compilation) {
+  const jsResourcePath = path.resolve(compilation.compiler.context, options.jsResourcePath);
+  const propertiesPath = path.resolve(compilation.compiler.context, options.propertiesFolderPath);
+  const baseFileName = path.basename(options.jsResourcePath, '.properties');
+  const jsResourceBase = loadPropertiesFile(jsResourcePath, compilation, 'JS resources');
+  const {
+    allI18n,
+    locales
+  } = loadAllLocaleFiles(propertiesPath, baseFileName, compilation);
+  return {
+    jsResourceBase,
+    allI18n,
+    locales
+  };
+}
+
+module.exports = {
+  loadPropertiesFile,
+  loadNumericMap,
+  loadAllLocaleFiles,
+  loadI18nData
+};

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/I18nFilesEmitPlugin.js

@@ -7,10 +7,6 @@ exports.I18nFilesEmitPlugin = void 0;
 
 var _webpack = require("webpack");
 
-var _fs = _interopRequireDefault(require("fs"));
-
-var _path = _interopRequireDefault(require("path"));
-
 var _createHash = require("./createHash");
 
 var _pathCreator = require("./pathCreator");
@@ -19,8 +15,6 @@ var _propertiesUtils = require("./utils/propertiesUtils");
 
 var _LocaleChunkAssetsStore = require("./LocaleChunkAssetsStore");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /* eslint-disable no-restricted-syntax */
 const pluginName = 'I18nFilesEmitPlugin';
 const {
@@ -29,57 +23,18 @@ const {
 
 class I18nFilesEmitPlugin {
   constructor(options) {
-    this.options = options;
-    this.numericIdMap = null; // this.options = {
+    this.options = options; // this.options = {
     //   locales: options.locales,
     //   chunkFilename: options.chunkFilename,
     //   filename: options.filename,
     //   allI18nObject: options.allI18nObject,
-    //   jsonpFunc: options.jsonpFunc,
-    //   useNumericIndexing: options.useNumericIndexing, // NEW OPTION
-    //   numericMapPath: options.numericMapPath // NEW OPTION
+    //   jsonpFunc: options.jsonpFunc
     // };
   }
 
-  loadNumericIdMap(compilation) {
-    if (this.numericIdMap || !this.options.useNumericIndexing || !this.options.numericMapPath) {
-      return this.numericIdMap;
-    }
-
-    const absoluteMapPath = _path.default.isAbsolute(this.options.numericMapPath) ? this.options.numericMapPath : _path.default.resolve(compilation.compiler.context, this.options.numericMapPath);
-
-    try {
-      if (_fs.default.existsSync(absoluteMapPath)) {
-        const fileContent = _fs.default.readFileSync(absoluteMapPath, 'utf-8');
-
-        const parsedData = JSON.parse(fileContent);
-
-        if (parsedData && parsedData.originalKeyToNumericId && typeof parsedData.originalKeyToNumericId === 'object') {
-          this.numericIdMap = parsedData.originalKeyToNumericId;
-        } else {
-          compilation.warnings.push(new Error(`${pluginName}: Invalid numeric map format in ${absoluteMapPath}`));
-          this.numericIdMap = {};
-        }
-      } else {
-        compilation.warnings.push(new Error(`${pluginName}: Numeric map file not found: ${absoluteMapPath}`));
-        this.numericIdMap = {};
-      }
-    } catch (err) {
-      compilation.errors.push(new Error(`${pluginName}: Error loading numeric map from ${absoluteMapPath}: ${err.message}`));
-      this.numericIdMap = {};
-    }
-
-    return this.numericIdMap;
-  }
-
   apply(compiler) {
     compiler.hooks.thisCompilation.tap(pluginName, compilation => {
-      // Load numeric map if needed
-      if (this.options.useNumericIndexing) {
-        this.loadNumericIdMap(compilation);
-      } // Get store for cache
-
-
+      // Get store for cache
       this.store = (0, _LocaleChunkAssetsStore.getLocaleChunkAssetsStore)(compilation);
       const i18nStore = this.store;
       compilation.hooks.beforeHash.tap(pluginName, () => {
@@ -195,28 +150,12 @@ class I18nFilesEmitPlugin {
 
   getI18nContentForkeys(i18nKeys, locale) {
     const {
-      allI18nObject,
-      useNumericIndexing
+      allI18nObject
     } = this.options;
     const data = {};
 
     for (const key of i18nKeys) {
-      const value = allI18nObject[locale][key];
-
-      if (useNumericIndexing && this.numericIdMap) {
-        // Use numeric ID as key if available, otherwise keep original key
-        const numericId = this.numericIdMap[key];
-
-        if (numericId !== undefined) {
-          data[numericId] = value;
-        } else {
-          // Keep original key if no numeric mapping exists
-          data[key] = value;
-        }
-      } else {
-        // Default behavior: use original key
-        data[key] = value;
-      }
+      data[key] = allI18nObject[locale][key];
     }
 
     return data;

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/optionsHandler.js

@@ -40,9 +40,6 @@ function optionsHandler(options) {
     jsResourceI18nKeys,
     allI18nObject,
     locales,
-    // NEW OPTIONS FOR NUMERIC INDEXING
-    useNumericIndexing: options.useNumericIndexing,
-    numericMapPath: options.numericMapPath,
     // template: (object, locale) => `window.loadI18n(${JSON.stringify(object)}, ${JSON.stringify(locale)})`,
     runtime: true,
     runtimeOptions: {

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

@@ -7,8 +7,7 @@ const {
 const PREFIX_I18N_COMMENT = 'I18N';
 const PREFIX_I18N_COMMENT_DYNAMIC = 'dynamic-i18n-key';
 
-function getI18nKeysFromSingleComment(commentNode, validKeysSet, isDebug = false) {
-  const functionName = '[getI18nKeysFromSingleComment]';
+function getI18nKeysFromSingleComment(commentNode, validKeysSet) {
   const foundKeysInComment = [];
 
   if (!commentNode || typeof commentNode.value !== 'string') {
@@ -50,13 +49,12 @@ function getI18nKeysFromSingleComment(commentNode, validKeysSet, isDebug = false
 
 
 function collectAndCategorizeUsedI18nKeys(astProgramNode, commentsArray, allI18nKeysMasterMap, isDebug = false) {
-  const functionName = '[collectAndCategorizeUsedI18nKeys]';
   const foundLiteralKeys = new Set();
   const foundCommentKeys = new Set();
   const validKeysSet = new Set(Object.keys(allI18nKeysMasterMap || {}));
 
   if (validKeysSet.size === 0 && isDebug) {
-    console.warn(`${functionName} allI18nKeysMasterMap is empty. No keys can be collected.`);
+    console.warn('[collectAndCategorizeUsedI18nKeys] allI18nKeysMasterMap is empty. No keys can be collected.');
   } // 1. Collect keys from AST string literals
 
 
@@ -73,14 +71,14 @@ function collectAndCategorizeUsedI18nKeys(astProgramNode, commentsArray, allI18n
 
       });
     } catch (error) {
-      console.error(`${functionName} Error during AST walk:`, error);
+      console.error('[collectAndCategorizeUsedI18nKeys] Error during AST walk:', error);
     }
   } // 2. Collect keys from comments
 
 
   if (commentsArray && Array.isArray(commentsArray)) {
     commentsArray.forEach(commentNode => {
-      const keysFromComment = getI18nKeysFromSingleComment(commentNode, validKeysSet, isDebug);
+      const keysFromComment = getI18nKeysFromSingleComment(commentNode, validKeysSet);
       keysFromComment.forEach(key => {
         foundCommentKeys.add(key);
       });

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

@@ -36,7 +36,7 @@ function getI18nAssetsForChunkAsArrayStr({
   chunkSplitEnable,
   i18nFileNameTemplate
 }) {
-  if (!chunkSplitEnable || !i18nStore) {
+  if (!chunkSplitEnable) {
     // NOTE: we have used lang variable inside
     // NOTE: below code for full i18n for now it is not implemented
     // if (!chunkSplitEnable) {
@@ -71,11 +71,6 @@ function getI18nAssetForChunkAsStr({
   i18nStore,
   i18nFileNameTemplate
 }) {
-  // Handle case where i18nStore is undefined (when i18nChunkSplit is disabled or not initialized)
-  if (!i18nStore || !i18nStore.isChunkHasI18n) {
-    return '';
-  }
-
   if (!i18nStore.isChunkHasI18n(chunk)) {
     return '';
   }

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

@@ -7,18 +7,23 @@ exports.jsLoaders = jsLoaders;
 
 var _babelLoaderConfig = require("./loaderConfigs/babelLoaderConfig");
 
-var {
+const {
   i18nIdReplaceLoaderConfig
-} = require("./loaderConfigs/i18nIdReplaceLoaderConfig");
+} = require('./loaderConfigs/i18nIdReplaceLoaderConfig');
 
 function jsLoaders(options) {
-  const useLoaders = [(0, _babelLoaderConfig.babelLoaderConfig)(options)];
+  const useLoaders = [];
+  useLoaders.push((0, _babelLoaderConfig.babelLoaderConfig)(options));
+  const shouldUseNumericIndexing = options.i18nIndexing && options.i18nIndexing.enable || options.i18nChunkSplit && options.i18nChunkSplit.chunkSplitEnable && options.i18nChunkSplit.useNumericIndexing;
 
-  if (options.i18nIndexing && options.i18nIndexing.enable) {
-    const i18nLoader = i18nIdReplaceLoaderConfig(options);
+  if (shouldUseNumericIndexing) {
+    try {
+      const loaderConfig = i18nIdReplaceLoaderConfig(options, options.context);
 
-    if (i18nLoader) {
-      useLoaders.push(i18nLoader);
+      if (loaderConfig) {
+        useLoaders.push(loaderConfig);
+      }
+    } catch (err) {// Silently skip if configuration fails
     }
   }