@zohodesk/client_build_tool 0.0.11-exp.16 → 0.0.11-exp.16.0

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

@@ -0,0 +1,328 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _webpack = require("webpack");
+var _propertiesUtils = require("../I18nSplitPlugin/utils/propertiesUtils");
+var _I18nGroupRuntimeModule = require("./I18nGroupRuntimeModule");
+var _i18nDataLoader = require("./utils/i18nDataLoader");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  RawSource
+} = _webpack.sources;
+const pluginName = 'I18nNumericIndexPlugin';
+class I18nNumericIndexPlugin {
+  constructor(options) {
+    this.options = {
+      ...options,
+      singleFile: options.singleFile || false,
+      singleFileTemplate: options.singleFileTemplate || '[locale].js',
+      includeContentHash: options.includeContentHash || false,
+      generateManifest: options.generateManifest || false,
+      outputFolder: options.outputFolder || 'i18n-chunk',
+      manifestPath: options.manifestPath || null
+    };
+    this.numericMap = {};
+    this.customGroups = {};
+    this.manifest = {};
+  }
+  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
+          }));
+        });
+      }
+      compilation.hooks.processAssets.tap({
+        name: pluginName,
+        stage: compilation.PROCESS_ASSETS_STAGE_OPTIMIZE
+      }, () => {
+        this.processI18nFiles(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
+                const chunkNameMatch = comment.value.match(/webpackChunkName:\s*["']([^"']+)["']/);
+                if (chunkNameMatch) {
+                  const chunkName = chunkNameMatch[1];
+                  this.detectedGroups[chunkName] = groupName;
+                }
+              }
+            }
+          });
+        });
+      });
+    });
+  }
+  processI18nFiles(compilation) {
+    const {
+      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
+    const jsResourceKeys = (0, _propertiesUtils.getPropertiesAsJSON)(jsResourcePath);
+
+    // Parse custom groups from banner markers
+    if (customGroups) {
+      this.parseCustomGroups(jsResourcePath, customGroups);
+    }
+
+    // Get all locale translations
+    const allI18nObject = (0, _propertiesUtils.getAllI18n)({
+      folderPath: propertiesFolderPath,
+      disableDefault: false,
+      jsResourceI18nKeys: jsResourceKeys
+    });
+
+    // For en_US, use only JSResources (don't merge with ApplicationResources_en_US)
+    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 locales = Object.keys(allI18nObject);
+
+    // Process each locale
+    locales.forEach(locale => {
+      const localeData = allI18nObject[locale];
+      const numericData = {};
+      const dynamicData = {};
+      const groupData = {};
+
+      // Initialize custom groups
+      Object.keys(customGroups || {}).forEach(groupName => {
+        groupData[groupName] = {};
+      });
+
+      // Process each key
+      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
+          const belongsToGroup = this.getKeyGroup(key);
+          if (belongsToGroup) {
+            groupData[belongsToGroup][numericKey] = value;
+          } else {
+            numericData[numericKey] = value;
+          }
+        } else {
+          // No numeric ID = dynamic key (regardless of placeholders)
+          dynamicData[key] = value;
+        }
+      });
+
+      // Handle single-file mode or separate files
+      if (this.options.singleFile) {
+        // Combine numeric and dynamic data into a single file
+        const combinedData = {
+          ...numericData,
+          ...dynamicData
+        };
+        if (Object.keys(combinedData).length > 0) {
+          // Use singleFileTemplate for combined file - no fileType suffix needed
+          const singleFileTemplate = this.options.singleFileTemplate || '[locale].js';
+          this.emitChunk(compilation, singleFileTemplate, locale, combinedData, jsonpFunc, null, null);
+        }
+      } else {
+        // Emit numeric chunk
+        if (Object.keys(numericData).length > 0) {
+          this.emitChunk(compilation, numericFilenameTemplate, locale, numericData, jsonpFunc, null, 'numeric');
+        }
+
+        // Emit dynamic chunk
+        if (Object.keys(dynamicData).length > 0) {
+          this.emitChunk(compilation, dynamicFilenameTemplate, locale, dynamicData, jsonpFunc, null, 'dynamic');
+        }
+      }
+
+      // Emit custom group chunks (always separate)
+      Object.entries(groupData).forEach(([groupName, data]) => {
+        const groupConfig = customGroups[groupName];
+        if (groupConfig && Object.keys(data).length > 0) {
+          const groupTemplate = groupConfig.filenameTemplate || `[locale]/${groupName}.i18n.js`;
+          this.emitChunk(compilation, groupTemplate, locale, data, jsonpFunc, groupName, `group-${groupName}`);
+        }
+      });
+    });
+
+    // Generate manifest file if enabled
+    if (this.options.generateManifest && Object.keys(this.manifest).length > 0) {
+      const manifestPath = this.options.manifestPath || _path.default.join(this.options.outputFolder, 'manifest.json');
+      const manifestContent = JSON.stringify(this.manifest, null, 2);
+      compilation.emitAsset(manifestPath, new RawSource(manifestContent));
+    }
+
+    // Don't save numeric map - it should only be generated by the external script
+  }
+  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;
+  }
+  generateContentHash(content, compilation) {
+    const {
+      hashFunction,
+      hashDigest,
+      hashDigestLength
+    } = compilation.outputOptions;
+    const hash = _webpack.util.createHash(hashFunction || 'xxhash64');
+    hash.update(content);
+    return hash.digest(hashDigest || 'hex').substring(0, hashDigestLength || 8);
+  }
+  constructFilePath(template, locale) {
+    const {
+      outputFolder,
+      singleFile
+    } = this.options;
+
+    // Replace locale placeholder
+    let filePath = template.replace(/\[locale\]/g, locale);
+
+    // If template already contains outputFolder or starts with a path separator, use as-is
+    if (filePath.includes(outputFolder) || filePath.startsWith('/')) {
+      return filePath.replace(/\\/g, '/');
+    }
+
+    // For single-file mode with a simple template like '[locale].js', 
+    // put it directly in outputFolder without subdirectories
+    if (singleFile && !filePath.includes('/')) {
+      return _path.default.join(outputFolder, filePath).replace(/\\/g, '/');
+    }
+
+    // For other cases, if template contains subdirectories, preserve them
+    return _path.default.join(outputFolder, filePath).replace(/\\/g, '/');
+  }
+  emitChunk(compilation, filenameTemplate, locale, data, jsonpFunc, groupName = null, fileType = null) {
+    if (!filenameTemplate || Object.keys(data).length === 0) {
+      return null;
+    }
+    const content = this.generateChunkContent(data, jsonpFunc, groupName);
+    let outputPath = this.constructFilePath(filenameTemplate, locale);
+
+    // Handle [contenthash] placeholder in template
+    if (outputPath.includes('[contenthash]')) {
+      const contentHash = this.generateContentHash(content, compilation);
+      outputPath = outputPath.replace(/\[contenthash\]/g, contentHash);
+    } else if (this.options.includeContentHash) {
+      // Legacy: Add content hash before .js extension if includeContentHash is true
+      const contentHash = this.generateContentHash(content, compilation);
+      outputPath = outputPath.replace(/\.js$/, `.${contentHash}.js`);
+    }
+
+    // Track in manifest if enabled
+    if (this.options.generateManifest) {
+      // For single-file mode, use clean locale.js format
+      let manifestKey;
+      if (this.options.singleFile) {
+        // Just use locale.js without path or type suffix
+        manifestKey = `${locale}.js`;
+      } else {
+        // For multi-file mode, include the full path
+        const cleanName = this.constructFilePath(filenameTemplate, locale);
+        manifestKey = fileType ? cleanName.replace(/\.js$/, `.${fileType}.js`) : cleanName;
+      }
+      this.manifest[manifestKey] = _path.default.basename(outputPath);
+    }
+    compilation.emitAsset(outputPath, new RawSource(content));
+    return outputPath;
+  }
+  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});`;
+  }
+}
+exports.default = I18nNumericIndexPlugin;

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

@@ -0,0 +1,135 @@
+"use strict";
+
+const fs = require('fs');
+const path = require('path');
+const {
+  getPropertiesAsJSON
+} = require('../../I18nSplitPlugin/utils/propertiesUtils');
+
+/**
+ * Load and parse a properties file
+ */
+function loadPropertiesFile(filePath, compilation, description) {
+  try {
+    const parsed = getPropertiesAsJSON(filePath);
+    return parsed;
+  } catch (err) {
+    if (compilation) {
+      compilation.errors.push(new Error(`I18nNumericIndexPlugin: Error loading ${description}: ${err.message}`));
+    }
+    return {};
+  }
+}
+
+/**
+ * Load numeric mapping from JSON file
+ */
+function loadNumericMap(numericMapPath, compilation) {
+  try {
+    const fileContent = fs.readFileSync(numericMapPath, 'utf-8');
+    const parsedData = JSON.parse(fileContent);
+    let numericMap;
+    let totalKeys;
+
+    // Handle both wrapped and flat formats
+    if (parsedData.originalKeyToNumericId) {
+      // New format with metadata
+      numericMap = parsedData.originalKeyToNumericId;
+      totalKeys = parsedData.totalKeysInMap || Object.keys(numericMap).length;
+    } else {
+      // Flat format - use directly
+      numericMap = parsedData;
+      totalKeys = Object.keys(numericMap).length;
+    }
+
+    // Create sorted array for numeric ID lookups
+    const maxId = Math.max(...Object.values(numericMap));
+    const sortedKeys = new Array(maxId + 1);
+    Object.entries(numericMap).forEach(([key, id]) => {
+      sortedKeys[id] = key;
+    });
+    return {
+      sortedKeys,
+      totalKeys
+    };
+  } catch (err) {
+    if (compilation) {
+      compilation.errors.push(new Error(`I18nNumericIndexPlugin: Error loading numeric map: ${err.message}`));
+    }
+    return {
+      sortedKeys: [],
+      totalKeys: 0
+    };
+  }
+}
+
+/**
+ * Load all locale files from properties directory
+ */
+function loadAllLocaleFiles(propertiesPath, compilation, jsResourceBase) {
+  const allI18n = {};
+  const locales = [];
+
+  // Start with English base
+  allI18n['en_US'] = jsResourceBase;
+  locales.push('en_US');
+  try {
+    const files = fs.readdirSync(propertiesPath);
+    files.forEach(file => {
+      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}`);
+
+        // Merge with base resources
+        allI18n[locale] = {
+          ...jsResourceBase,
+          ...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
+  };
+}
+
+/**
+ * Main loader function for i18n data
+ */
+function loadI18nData(options, compilation) {
+  const jsResourcePath = path.resolve(compilation.compiler.context, options.jsResourcePath);
+  const propertiesPath = path.resolve(compilation.compiler.context, options.propertiesFolderPath);
+
+  // Load base JS resources
+  const jsResourceBase = loadPropertiesFile(jsResourcePath, compilation, 'JS resources');
+
+  // Load all locale files
+  const {
+    allI18n,
+    locales
+  } = loadAllLocaleFiles(propertiesPath, compilation, jsResourceBase);
+  return {
+    jsResourceBase,
+    allI18n,
+    locales
+  };
+}
+module.exports = {
+  loadPropertiesFile,
+  loadNumericMap,
+  loadAllLocaleFiles,
+  loadI18nData
+};

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

@@ -4,26 +4,21 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.I18nFilesEmitPlugin = void 0;
-
 var _webpack = require("webpack");
-
 var _createHash = require("./createHash");
-
 var _pathCreator = require("./pathCreator");
-
 var _propertiesUtils = require("./utils/propertiesUtils");
-
 var _LocaleChunkAssetsStore = require("./LocaleChunkAssetsStore");
-
 /* eslint-disable no-restricted-syntax */
+
 const pluginName = 'I18nFilesEmitPlugin';
 const {
   RawSource
 } = _webpack.sources;
-
 class I18nFilesEmitPlugin {
   constructor(options) {
-    this.options = options; // this.options = {
+    this.options = options;
+    // this.options = {
     //   locales: options.locales,
     //   chunkFilename: options.chunkFilename,
     //   filename: options.filename,
@@ -31,7 +26,6 @@ class I18nFilesEmitPlugin {
     //   jsonpFunc: options.jsonpFunc
     // };
   }
-
   apply(compiler) {
     compiler.hooks.thisCompilation.tap(pluginName, compilation => {
       // Get store for cache
@@ -48,12 +42,10 @@ class I18nFilesEmitPlugin {
         if (!i18nStore.isChunkHasI18n(chunk.id)) {
           return;
         }
-
         this.emitI18nFileForEveryLocale(chunk, compilation);
       });
     });
   }
-
   createAndStoreFileContentForEveryChunkAndLocale(compilation) {
     const {
       chunks
@@ -62,15 +54,12 @@ class I18nFilesEmitPlugin {
       locales
     } = this.options;
     const i18nStore = this.store;
-
     for (const chunk of chunks) {
       const i18nKeys = i18nStore.getI18nKeysForChunk(chunk);
-
       if (!i18nKeys.length) {
         // eslint-disable-next-line no-continue
         continue;
       }
-
       for (const locale of locales) {
         const content = this.getI18nChunkFileContent(i18nKeys, locale);
         i18nStore.storeData(chunk.id, locale, {
@@ -79,13 +68,11 @@ class I18nFilesEmitPlugin {
       }
     }
   }
-
   updateChunkHashForEveryLocale(chunk, hash) {
     const {
       locales
     } = this.options;
     const i18nStore = this.store;
-
     if (i18nStore.isChunkHasI18n(chunk.id)) {
       for (const loc of locales) {
         const content = i18nStore.getContent(chunk.id, loc);
@@ -93,7 +80,6 @@ class I18nFilesEmitPlugin {
       }
     }
   }
-
   emitI18nFileForEveryLocale(chunk, compilation) {
     const i18nStore = this.store;
     const {
@@ -101,8 +87,8 @@ class I18nFilesEmitPlugin {
       chunkFilename,
       filename
     } = this.options;
-    const fileNameTemplate = chunk.canBeInitial() ? filename : chunkFilename; // const { chunks } = compilation;
-
+    const fileNameTemplate = chunk.canBeInitial() ? filename : chunkFilename;
+    // const { chunks } = compilation;
     for (const locale of locales) {
       const content = i18nStore.getContent(chunk.id, locale);
       const contentHash = (0, _createHash.createHash)({
@@ -125,7 +111,6 @@ class I18nFilesEmitPlugin {
       compilation.emitAsset(filename, new RawSource(content));
     }
   }
-
   static createFilenameWithHash({
     compilation,
     fileNameTemplate,
@@ -147,20 +132,16 @@ class I18nFilesEmitPlugin {
       filename
     };
   }
-
   getI18nContentForkeys(i18nKeys, locale) {
     const {
       allI18nObject
     } = this.options;
     const data = {};
-
     for (const key of i18nKeys) {
       data[key] = allI18nObject[locale][key];
     }
-
     return data;
   }
-
   getI18nChunkFileContent(i18nKeys, loc) {
     const {
       jsonpFunc
@@ -168,7 +149,5 @@ class I18nFilesEmitPlugin {
     const data = this.getI18nContentForkeys(i18nKeys, loc);
     return `${jsonpFunc}(${(0, _propertiesUtils.jsonToString)(data)})`;
   }
-
 }
-
 exports.I18nFilesEmitPlugin = I18nFilesEmitPlugin;

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

@@ -4,13 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _utils = require("./utils");
-
 var _LocaleChunkAssetsStore = require("./LocaleChunkAssetsStore");
-
 /* eslint-disable max-classes-per-file */
+
 const pluginName = 'I18nKeysIdentifier';
+
 /**
  * this plugin search the i18 keys and make it as I18nDependency.
  * how it works?
@@ -20,7 +19,6 @@ const pluginName = 'I18nKeysIdentifier';
  *  after the walk of AST we get some I18n keys
  *  then we make it as I18nDependency.
  */
-
 class I18nKeysIdentifer {
   constructor({
     jsResourceI18nKeys
@@ -28,9 +26,9 @@ class I18nKeysIdentifer {
     this.jsResourceI18nKeys = jsResourceI18nKeys;
     this.store = new _LocaleChunkAssetsStore.LocaleChunkAssetsStore();
   }
-
   apply(compiler) {
     // const { splitChunks } = compiler.options.optimization;
+
     // if (splitChunks) {
     //   if (splitChunks.defaultSizeTypes.includes('...')) {
     //     splitChunks.defaultSizeTypes.push(MODULE_TYPE);
@@ -46,31 +44,30 @@ class I18nKeysIdentifer {
         parser.hooks.program.tap(pluginName, (ast, comments) => {
           const {
             module
-          } = parser.state; //
-
+          } = parser.state;
+          //
           if (!(module && /\.jsx?$/.test(module.resource))) {
             return;
-          } // i18n grep proper contract regex
-
-
+          }
+          // i18n grep proper contract regex
           let i18nKeys = (0, _utils.collectI18nKeysfromAST)(ast, this.jsResourceI18nKeys);
-          i18nKeys = i18nKeys.concat( // i18n grep proper contract regex
+          i18nKeys = i18nKeys.concat(
+          // i18n grep proper contract regex
           (0, _utils.collectI18nKeysfromComments)(comments, this.jsResourceI18nKeys));
-
           if (i18nKeys.length) {
             // console.log('i18nKeys.length', module.resource, i18nKeys);
             this.store.updateModuleI18nKeys(module.resource, i18nKeys);
           }
         });
-      }; // this below  hook was tapped for collect I18n Key from files and add as Dependency
-      // const factory = params.normalModuleFactory;
+      };
 
+      // this below  hook was tapped for collect I18n Key from files and add as Dependency
+
+      // const factory = params.normalModuleFactory;
 
       factory.hooks.parser.for('javascript/auto').tap(pluginName, handler);
       factory.hooks.parser.for('javascript/dynamic').tap(pluginName, handler);
     });
   }
-
 }
-
 exports.default = I18nKeysIdentifer;