@zohodesk/client_build_tool 0.0.11-exp.18 → 0.0.11-exp.18.0

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

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.I18nGroupRuntimeModule = void 0;
+
+var _webpack = require("webpack");
+
+class I18nGroupRuntimeModule extends _webpack.RuntimeModule {
+  constructor(options) {
+    super('i18n-group-loader');
+    this.options = options;
+  }
+
+  generate() {
+    const {
+      customGroups,
+      localeVarName,
+      jsonpFunc
+    } = this.options; // Build chunk-to-group mapping from config
+
+    const chunkToGroup = {};
+    Object.entries(customGroups || {}).forEach(([groupName, config]) => {
+      (config.chunks || []).forEach(chunkName => {
+        chunkToGroup[chunkName] = groupName;
+      });
+    });
+    return `
+    // I18n Group Loading Runtime
+    (function() {
+      var loadedGroups = {};
+      var chunkToGroup = ${JSON.stringify(chunkToGroup)};
+      
+      // Function to load i18n group
+      function loadI18nGroup(groupName) {
+        if (loadedGroups[groupName]) {
+          return Promise.resolve();
+        }
+        
+        var locale = ${localeVarName} || 'en_US';
+        var groupConfig = ${JSON.stringify(customGroups)};
+        var config = groupConfig[groupName];
+        
+        if (!config) {
+          return Promise.resolve();
+        }
+        
+        return new Promise(function(resolve, reject) {
+          var i18nUrl = config.filenameTemplate
+            .replace('[locale]', locale)
+            .replace('i18n-chunk/', __webpack_require__.p + 'i18n-chunk/');
+          
+          
+          var script = document.createElement('script');
+          script.src = i18nUrl;
+          script.async = true;
+          
+          script.onload = function() {
+            loadedGroups[groupName] = true;
+            resolve();
+          };
+          
+          script.onerror = function() {
+            reject(new Error('Failed to load i18n group: ' + groupName));
+          };
+          
+          document.head.appendChild(script);
+        });
+      }
+      
+      // Store original webpack chunk loading function
+      var originalEnsureChunk = __webpack_require__.e;
+      
+      // Override webpack's chunk loading if it exists
+      if (originalEnsureChunk) {
+        __webpack_require__.e = function(chunkId) {
+          var promise = originalEnsureChunk.apply(this, arguments);
+        
+        // Check if this chunk needs an i18n group
+        var groupName = chunkToGroup[chunkId];
+        if (groupName && !loadedGroups[groupName]) {
+          // Load the i18n group before the chunk
+          var i18nPromise = loadI18nGroup(groupName);
+          // Chain the promises so i18n loads first
+          promise = Promise.all([promise, i18nPromise]).then(function(results) {
+            return results[0]; // Return the original chunk promise result
+          });
+        }
+        
+          return promise;
+        };
+      }
+      
+      // Also check for webpackI18nGroup comments in dynamic imports
+      if (typeof __webpack_require__.l !== 'undefined') {
+        var originalLoadScript = __webpack_require__.l;
+        __webpack_require__.l = function(url, done, key, chunkId) {
+          // Check if chunk has i18n group
+          var groupName = chunkToGroup[chunkId];
+          if (groupName && !loadedGroups[groupName]) {
+            // Load i18n before main chunk
+            var locale = ${localeVarName} || 'en_US';
+            var groupConfig = ${JSON.stringify(customGroups)};
+            var config = groupConfig[groupName];
+            
+            if (config) {
+              var i18nUrl = config.filenameTemplate
+                .replace('[locale]', locale)
+                .replace('i18n-chunk/', __webpack_require__.p + 'i18n-chunk/');
+              
+              // Load i18n first, then the chunk
+              var i18nScript = document.createElement('script');
+              i18nScript.src = i18nUrl;
+              i18nScript.onload = function() {
+                loadedGroups[groupName] = true;
+                // Now load the original chunk
+                originalLoadScript.call(__webpack_require__, url, done, key, chunkId);
+              };
+              i18nScript.onerror = function() {
+                // Continue even if i18n fails
+                originalLoadScript.call(__webpack_require__, url, done, key, chunkId);
+              };
+              document.head.appendChild(i18nScript);
+              return;
+            }
+          }
+          
+          // Default behavior
+          return originalLoadScript.call(__webpack_require__, url, done, key, chunkId);
+        };
+      }
+    })();
+    `;
+  }
+
+}
+
+exports.I18nGroupRuntimeModule = I18nGroupRuntimeModule;

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

@@ -0,0 +1,98 @@
+"use strict";
+
+const HtmlWebpackPlugin = require('html-webpack-plugin');
+
+const path = require('path');
+
+const pluginName = 'I18nNumericIndexHtmlInjectorPlugin';
+
+class I18nNumericIndexHtmlInjectorPlugin {
+  constructor(options) {
+    this.options = { ...options,
+      injectI18nUrlInIndex: options.injectI18nUrlInIndex !== undefined ? options.injectI18nUrlInIndex : true // Default to true
+
+    };
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      HtmlWebpackPlugin.getHooks(compilation).beforeAssetTagGeneration.tapAsync(pluginName, (hookData, cb) => {
+        // Skip HTML injection if injectI18nUrlInIndex is false
+        if (!this.options.injectI18nUrlInIndex) {
+          return cb(null, hookData);
+        }
+
+        const {
+          assets
+        } = hookData;
+        const {
+          outputFolder,
+          numericFilenameTemplate,
+          dynamicFilenameTemplate,
+          singleFileTemplate,
+          htmlTemplateLabel,
+          singleFile,
+          i18nAssetsPublicPathPrefix = ''
+        } = this.options;
+        const newI18nAssetUrlsToAdd = []; // Construct full paths using outputFolder
+
+        const constructFullPath = (template, isSingleFile = false) => {
+          if (!template) return null; // Replace locale placeholder
+
+          let filePath = template.replace(/\[locale\]/g, htmlTemplateLabel); // Remove [contenthash] placeholder for HTML injection
+          // The actual hash will be determined at build time
+
+          filePath = filePath.replace(/\.\[contenthash\]/g, ''); // 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 (isSingleFile && !filePath.includes('/')) {
+            return path.join(outputFolder || 'i18n-chunk', filePath).replace(/\\/g, '/');
+          } // For other cases, preserve subdirectories
+
+
+          return path.join(outputFolder || 'i18n-chunk', filePath).replace(/\\/g, '/');
+        };
+
+        if (singleFile) {
+          // In single file mode, use singleFileTemplate
+          const singleTemplate = singleFileTemplate || '[locale].js';
+          const combinedFilename = constructFullPath(singleTemplate, true);
+
+          if (combinedFilename) {
+            newI18nAssetUrlsToAdd.push(combinedFilename);
+          }
+        } else {
+          // Add both numeric and dynamic files
+          const numericFilename = constructFullPath(numericFilenameTemplate);
+
+          if (numericFilename) {
+            newI18nAssetUrlsToAdd.push(numericFilename);
+          }
+
+          const dynamicFilename = constructFullPath(dynamicFilenameTemplate);
+
+          if (dynamicFilename) {
+            newI18nAssetUrlsToAdd.push(dynamicFilename);
+          }
+        }
+
+        if (newI18nAssetUrlsToAdd.length > 0) {
+          // Add i18n assets to the beginning of JS assets for early loading
+          assets.js = [...newI18nAssetUrlsToAdd, ...assets.js];
+        }
+
+        cb(null, hookData);
+      });
+    });
+  }
+
+}
+
+module.exports = {
+  I18nNumericIndexHtmlInjectorPlugin
+};

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

@@ -0,0 +1,399 @@
+"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(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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,
+      emitFiles: options.emitFiles !== undefined ? options.emitFiles : true
+    };
+    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.additionalTreeRuntimeRequirements.tap(pluginName, (chunk, set) => {
+          // Only add to the main/entry chunk to avoid duplication
+          if (chunk.name === 'main' || chunk.hasRuntime()) {
+            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
+
+
+    let jsResourceKeys = (0, _propertiesUtils.getPropertiesAsJSON)(jsResourcePath);
+    jsResourceKeys = this.normalizeObjectValues(jsResourceKeys); // 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
+    }); // Normalize locale values
+
+    Object.keys(allI18nObject).forEach(loc => {
+      allI18nObject[loc] = this.normalizeObjectValues(allI18nObject[loc]);
+    }); // 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;
+    } // If requested, restrict all locales to base (English) keys only
+
+
+    if (this.options.restrictToBaseKeys) {
+      const baseKeys = Object.keys(jsResourceKeys);
+      Object.keys(allI18nObject).forEach(locale => {
+        const merged = { ...jsResourceKeys,
+          ...allI18nObject[locale]
+        };
+        const filtered = {};
+        baseKeys.forEach(k => {
+          filtered[k] = merged[k];
+        });
+        allI18nObject[locale] = filtered;
+      });
+    }
+
+    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;
+    } // Generate content regardless of emitFiles flag (needed for runtime)
+
+
+    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);
+    } // Only emit the file if emitFiles is true
+
+
+    if (this.options.emitFiles) {
+      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});`;
+  }
+
+  normalizeValue(value) {
+    if (typeof value !== 'string') return value;
+    return value.replace(/\\t/g, '\t').replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\f/g, '\f').replace(/\\:/g, ':').replace(/\\=/g, '=').replace(/\\ /g, ' ');
+  }
+
+  normalizeObjectValues(obj) {
+    const out = {};
+    Object.keys(obj || {}).forEach(k => {
+      out[k] = this.normalizeValue(obj[k]);
+    });
+    return out;
+  }
+
+}
+
+exports.default = I18nNumericIndexPlugin;