@zohodesk/client_build_tool 0.0.10 → 0.0.11-exp.6

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/utils/collectAstKeys.js

@@ -0,0 +1,96 @@
+"use strict";
+
+const {
+  walk
+} = require('estree-walker');
+
+const PREFIX_I18N_COMMENT = 'I18N';
+const PREFIX_I18N_COMMENT_DYNAMIC = 'dynamic-i18n-key';
+
+function getI18nKeysFromSingleComment(commentNode, validKeysSet) {
+  const foundKeysInComment = [];
+
+  if (!commentNode || typeof commentNode.value !== 'string') {
+    return foundKeysInComment;
+  }
+
+  const commentString = commentNode.value.trim();
+  let i18nKeyStr;
+
+  if (commentString.startsWith(PREFIX_I18N_COMMENT)) {
+    i18nKeyStr = commentString.slice(PREFIX_I18N_COMMENT.length).trim();
+  } else if (commentString.startsWith(PREFIX_I18N_COMMENT_DYNAMIC)) {
+    i18nKeyStr = commentString.slice(PREFIX_I18N_COMMENT_DYNAMIC.length).trim();
+  }
+
+  if (!i18nKeyStr) {
+    return foundKeysInComment;
+  }
+
+  const potentialKeys = i18nKeyStr.split(',').map(key => key.trim()).filter(key => key);
+  potentialKeys.forEach(key => {
+    if (validKeysSet.has(key)) {
+      foundKeysInComment.push(key);
+    }
+  });
+  return foundKeysInComment;
+}
+/**
+ * Traverses an AST and its comments to collect and categorize i18n keys.
+ *
+ * @param {object} astProgramNode - The Program node of the AST.
+ * @param {object[]} commentsArray - An array of comment nodes from the AST.
+ * @param {object} allI18nKeysMasterMap - Object map of all valid i18n keys (from JSResources).
+ * @param {boolean} [isDebug=false] - Flag for verbose logging.
+ * @returns {{literalKeys: Set<string>, commentKeys: Set<string>}}
+ * literalKeys: Set of valid i18n keys found as string literals.
+ * commentKeys: Set of valid i18n keys found in comments.
+ */
+
+
+function collectAndCategorizeUsedI18nKeys(astProgramNode, commentsArray, allI18nKeysMasterMap, isDebug = false) {
+  const foundLiteralKeys = new Set();
+  const foundCommentKeys = new Set();
+  const validKeysSet = new Set(Object.keys(allI18nKeysMasterMap || {}));
+
+  if (validKeysSet.size === 0 && isDebug) {
+    console.warn('[collectAndCategorizeUsedI18nKeys] allI18nKeysMasterMap is empty. No keys can be collected.');
+  } // 1. Collect keys from AST string literals
+
+
+  if (astProgramNode) {
+    try {
+      walk(astProgramNode, {
+        enter(node) {
+          if ((node.type === 'Literal' || node.type === 'StringLiteral') && typeof node.value === 'string') {
+            if (validKeysSet.has(node.value)) {
+              foundLiteralKeys.add(node.value);
+            }
+          }
+        }
+
+      });
+    } catch (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);
+      keysFromComment.forEach(key => {
+        foundCommentKeys.add(key);
+      });
+    });
+  }
+
+  return {
+    literalKeys: foundLiteralKeys,
+    commentKeys: foundCommentKeys
+  };
+}
+
+module.exports = {
+  collectAndCategorizeUsedI18nKeys: collectAndCategorizeUsedI18nKeys
+};

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

@@ -7,11 +7,29 @@ exports.jsLoaders = jsLoaders;
 
 var _babelLoaderConfig = require("./loaderConfigs/babelLoaderConfig");
 
+const {
+  i18nIdReplaceLoaderConfig
+} = require('./loaderConfigs/i18nIdReplaceLoaderConfig');
+
 function jsLoaders(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 (shouldUseNumericIndexing) {
+    try {
+      const loaderConfig = i18nIdReplaceLoaderConfig(options, options.context);
+
+      if (loaderConfig) {
+        useLoaders.push(loaderConfig);
+      }
+    } catch (err) {// Silently skip if configuration fails
+    }
+  }
+
   return [{
     test: /\.js$/,
     exclude: /node_modules/,
-    use: [(0, _babelLoaderConfig.babelLoaderConfig)(options)] // include: path.join(appPath, folder)
-
+    use: useLoaders
   }];
 }

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

@@ -0,0 +1,74 @@
+"use strict";
+
+const path = require('path');
+
+const fs = require('fs');
+
+const {
+  getPropertiesAsJSON
+} = require('../custom_plugins/I18nSplitPlugin/utils/propertiesUtils');
+
+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;
+  } 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 {};
+    }
+
+    return i18nData;
+  } catch (err) {
+    throw new Error(`Error reading JSResource file ${jsResourcePath}: ${err.message}`);
+  }
+}
+
+function i18nIdReplaceLoaderConfig(options, webpackContext) {
+  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');
+  }
+
+  const allI18nData = loadJSResourcesOnce(options);
+
+  const i18nKeyReplaceLoaderPath = require.resolve('../loaders/i18nIdReplaceLoader.js');
+
+  const loaderOptions = {
+    allI18nData: allI18nData,
+    sourceMaps: false,
+    numericMapPath: numericMapPath,
+    includePaths: options.i18nIndexing?.loaderOptions?.includePaths || [],
+    excludePaths: options.i18nIndexing?.loaderOptions?.excludePaths || ['node_modules', 'tests']
+  };
+  return {
+    loader: i18nKeyReplaceLoaderPath,
+    options: loaderOptions
+  };
+}
+
+module.exports = {
+  i18nIdReplaceLoaderConfig
+};

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

@@ -0,0 +1,105 @@
+"use strict";
+
+const fs = require('fs');
+
+const path = require('path');
+
+const parser = require('@babel/parser');
+
+const traverse = require('@babel/traverse').default;
+
+const generator = require('@babel/generator').default;
+
+const t = require('@babel/types');
+
+const {
+  getOptions
+} = require('loader-utils');
+
+module.exports = function i18nIdReplaceLoader(source, map) {
+  const resourcePath = this.resourcePath;
+  this.cacheable && this.cacheable();
+  const options = getOptions(this) || {};
+  const callback = this.async();
+
+  if (options.excludePaths) {
+    const shouldExclude = options.excludePaths.some(excludePath => resourcePath.includes(excludePath));
+
+    if (shouldExclude) {
+      return callback(null, source, map);
+    }
+  }
+
+  if (options.includePaths && options.includePaths.length > 0) {
+    const shouldInclude = options.includePaths.some(includePath => resourcePath.includes(includePath));
+
+    if (!shouldInclude) {
+      return callback(null, source, map);
+    }
+  }
+
+  if (!options.allI18nData || Object.keys(options.allI18nData).length === 0) {
+    return callback(new Error(`i18nIdReplaceLoader: 'allI18nData' option is missing or empty`));
+  }
+
+  let numericIdMap = null;
+
+  if (options.numericMapPath) {
+    try {
+      if (fs.existsSync(options.numericMapPath)) {
+        const fileContent = fs.readFileSync(options.numericMapPath, 'utf-8');
+        const parsedData = JSON.parse(fileContent);
+
+        if (parsedData && parsedData.originalKeyToNumericId) {
+          numericIdMap = parsedData.originalKeyToNumericId;
+        }
+      }
+    } catch (err) {// ignore - optional file
+    }
+  }
+
+  if (!numericIdMap) {
+    return callback(null, source, map);
+  }
+
+  try {
+    const ast = parser.parse(source, {
+      sourceType: 'module',
+      plugins: ['jsx', 'typescript', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator'],
+      sourceFilename: resourcePath
+    });
+    let hasTransformations = false;
+    traverse(ast, {
+      StringLiteral(path) {
+        const {
+          node
+        } = path;
+
+        if (!options.allI18nData.hasOwnProperty(node.value)) {
+          return;
+        }
+
+        if (numericIdMap.hasOwnProperty(node.value)) {
+          const numericId = String(numericIdMap[node.value]);
+          path.replaceWith(t.stringLiteral(numericId));
+          hasTransformations = true;
+        }
+      }
+
+    });
+
+    if (hasTransformations) {
+      const output = generator(ast, {
+        sourceMaps: !!options.sourceMaps,
+        sourceFileName: resourcePath,
+        retainLines: false,
+        comments: true
+      }, source);
+      callback(null, output.code, output.map);
+    } else {
+      callback(null, source, map);
+    }
+  } catch (err) {
+    callback(err);
+  }
+};