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

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

@@ -0,0 +1,141 @@
+"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/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

@@ -7,11 +7,34 @@ exports.jsLoaders = jsLoaders;
 
 var _babelLoaderConfig = require("./loaderConfigs/babelLoaderConfig");
 
+const {
+  i18nIdReplaceLoaderConfig
+} = require('./loaderConfigs/i18nIdReplaceLoaderConfig');
+
 function jsLoaders(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) {
+    try {
+      const loaderConfig = i18nIdReplaceLoaderConfig(options, options.context);
+
+      if (loaderConfig) {
+        useLoaders.push(loaderConfig);
+      }
+    } 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: [(0, _babelLoaderConfig.babelLoaderConfig)(options)] // include: path.join(appPath, folder)
+    use: useLoaders // include: path.join(appPath, folder)
 
   }];
 }

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

@@ -0,0 +1,90 @@
+"use strict";
+
+const {
+  getPropertiesAsJSON
+} = require('../custom_plugins/I18nSplitPlugin/utils/propertiesUtils');
+
+const fs = require('fs');
+
+function loadJSResourcesOnce(options) {
+  let jsResourcePath; // Determine the JSResource path based on configuration
+
+  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 readNumericMapOnce(numericMapPath) {
+  if (!numericMapPath) return null;
+
+  try {
+    if (!fs.existsSync(numericMapPath)) return null;
+    const fileContent = fs.readFileSync(numericMapPath, 'utf-8');
+    const parsed = JSON.parse(fileContent);
+    if (!parsed) return null;
+    return parsed.originalKeyToNumericId ? parsed.originalKeyToNumericId : parsed;
+  } catch (err) {
+    return null;
+  }
+}
+
+function i18nIdReplaceLoaderConfig(options, webpackContext) {
+  let numericMapPath; // Determine the numeric map path based on configuration
+
+  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');
+  } // Load all i18n data for key detection
+
+
+  const allI18nData = loadJSResourcesOnce(options);
+
+  const i18nKeyReplaceLoaderPath = require.resolve('../loaders/i18nIdReplaceLoader.js');
+
+  const numericIdMap = readNumericMapOnce(numericMapPath);
+  const loaderOptions = {
+    allI18nData: allI18nData,
+    sourceMaps: false,
+    numericMapPath: numericMapPath,
+    numericIdMap: numericIdMap || undefined,
+    devMode: options.i18nIndexing?.devMode || false,
+    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,146 @@
+"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();
+  let numericMapAbsPath = null;
+
+  if (options.numericMapPath) {
+    try {
+      numericMapAbsPath = path.isAbsolute(options.numericMapPath) ? options.numericMapPath : path.resolve(this.rootContext || this.context || process.cwd(), options.numericMapPath);
+      this.addDependency(numericMapAbsPath);
+    } catch (e) {}
+  } // Skip files in excluded paths
+
+
+  if (options.excludePaths) {
+    const shouldExclude = options.excludePaths.some(excludePath => resourcePath.includes(excludePath));
+
+    if (shouldExclude) {
+      return callback(null, source, map);
+    }
+  } // Only process files in included paths if specified
+
+
+  if (options.includePaths && options.includePaths.length > 0) {
+    const shouldInclude = options.includePaths.some(includePath => resourcePath.includes(includePath));
+
+    if (!shouldInclude) {
+      return callback(null, source, map);
+    }
+  } // Validate i18n data exists
+
+
+  if (!options.allI18nData || Object.keys(options.allI18nData).length === 0) {
+    return callback(new Error(`i18nIdReplaceLoader: 'allI18nData' option is missing or empty`));
+  } // Load numeric ID mapping (use injected map if provided; fallback to memoized file read)
+
+
+  let numericIdMap = options.numericIdMap || null;
+
+  try {
+    if (!numericIdMap && (numericMapAbsPath || options.numericMapPath)) {
+      // Module-level static cache
+      if (!global.__CBT_I18N_NUMERIC_MAP_CACHE__) {
+        global.__CBT_I18N_NUMERIC_MAP_CACHE__ = {};
+      }
+
+      const cache = global.__CBT_I18N_NUMERIC_MAP_CACHE__;
+      const p = numericMapAbsPath || options.numericMapPath;
+
+      try {
+        const stat = fs.statSync(p);
+        const key = `${p}`;
+        const mtime = stat && stat.mtimeMs ? stat.mtimeMs : 0;
+        const hit = cache[key];
+
+        if (hit && hit.mtime === mtime && hit.map) {
+          numericIdMap = hit.map;
+        } else if (fs.existsSync(p)) {
+          const txt = fs.readFileSync(p, 'utf-8');
+          const parsed = JSON.parse(txt);
+          const mapObj = parsed && parsed.originalKeyToNumericId ? parsed.originalKeyToNumericId : parsed;
+
+          if (mapObj && typeof mapObj === 'object') {
+            cache[key] = {
+              mtime,
+              map: mapObj
+            };
+            numericIdMap = mapObj;
+          }
+        }
+      } catch (e) {// ignore and proceed without map
+      }
+    }
+  } catch (e) {// ignore
+  } // If no numeric map available, return source as-is
+
+
+  if (!numericIdMap) {
+    return callback(null, source, map);
+  }
+
+  const isDevMode = options.devMode || process.env.NODE_ENV === 'development';
+
+  try {
+    // Parse the JavaScript/TypeScript source code
+    const ast = parser.parse(source, {
+      sourceType: 'module',
+      plugins: ['jsx', 'typescript', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator'],
+      sourceFilename: resourcePath
+    });
+    let hasTransformations = false; // Traverse AST and replace i18n keys with numeric IDs
+
+    traverse(ast, {
+      StringLiteral(path) {
+        const {
+          node
+        } = path; // Check if this string is an i18n key
+
+        if (!options.allI18nData.hasOwnProperty(node.value)) {
+          return;
+        } // Replace with numeric ID if available
+
+
+        if (numericIdMap.hasOwnProperty(node.value)) {
+          const numericId = String(numericIdMap[node.value]);
+          path.replaceWith(t.stringLiteral(numericId));
+          hasTransformations = true;
+        }
+      }
+
+    }); // Generate code if transformations were made
+
+    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);
+  }
+};

package/lib/shared/bundler/webpack/pluginConfigs/configI18nIndexingPlugin.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = configI18nIndexingPlugin;
+
+var _I18nNumericIndexPlugin = _interopRequireDefault(require("../custom_plugins/I18nNumericIndexPlugin/I18nNumericIndexPlugin"));
+
+var _resourceBasedPublicPath = require("../common/resourceBasedPublicPath");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function configI18nIndexingPlugin(config) {
+  const {
+    i18nIndexing,
+    cdnMapping
+  } = config;
+
+  if (!i18nIndexing || !i18nIndexing.enable) {
+    return null;
+  } // Get the public path for i18n resources
+
+
+  const i18nPublicPath = (0, _resourceBasedPublicPath.resourceBasedPublicPath)('i18n', config); // Get the CDN template for i18n resources if CDN is enabled
+
+  const i18nCdnTemplate = cdnMapping && cdnMapping.isCdnEnabled ? cdnMapping.i18nTemplate || cdnMapping.jsTemplate : '';
+  const options = {
+    jsResourcePath: i18nIndexing.jsResourcePath,
+    propertiesFolderPath: i18nIndexing.propertiesFolderPath,
+    numericMapPath: i18nIndexing.numericMapPath,
+    numericFilenameTemplate: i18nIndexing.numericFilenameTemplate || 'i18n-chunk/[locale]/numeric.i18n.js',
+    dynamicFilenameTemplate: i18nIndexing.dynamicFilenameTemplate || 'i18n-chunk/[locale]/dynamic.i18n.js',
+    jsonpFunc: i18nIndexing.jsonpFunc || 'window.loadI18nChunk',
+    htmlTemplateLabel: i18nIndexing.htmlTemplateLabel || '{{--user-locale}}',
+    localeVarName: i18nIndexing.localeVarName || 'window.userLangCode',
+    customGroups: i18nIndexing.customGroups || {},
+    publicPath: i18nPublicPath || '',
+    i18nCdnTemplate
+  };
+  return new _I18nNumericIndexPlugin.default(options);
+}

package/lib/shared/bundler/webpack/pluginConfigs/configI18nNumericHtmlInjector.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = configI18nNumericHtmlInjector;
+
+var _htmlWebpackPlugin = _interopRequireDefault(require("html-webpack-plugin"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const pluginName = 'I18nNumericHtmlInjectorPlugin';
+
+class I18nNumericHtmlInjectorPlugin {
+  constructor(options) {
+    this.options = options;
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      // Hook into HtmlWebpackPlugin to inject i18n script tags
+      _htmlWebpackPlugin.default.getHooks(compilation).beforeAssetTagGeneration.tap(pluginName, hookData => {
+        const {
+          assets
+        } = hookData;
+        const {
+          numericFilenameTemplate,
+          dynamicFilenameTemplate,
+          htmlTemplateLabel,
+          i18nCdnTemplate,
+          customGroups
+        } = this.options;
+        const newI18nAssets = []; // Add numeric i18n chunk
+
+        if (numericFilenameTemplate) {
+          const numericFilename = numericFilenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel).replace(/%5Blocale%5D/g, htmlTemplateLabel); // Don't add CDN template - HtmlWebpackPlugin handles it
+
+          newI18nAssets.push(numericFilename);
+        } // Add dynamic i18n chunk
+
+
+        if (dynamicFilenameTemplate) {
+          const dynamicFilename = dynamicFilenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel).replace(/%5Blocale%5D/g, htmlTemplateLabel); // Don't add CDN template - HtmlWebpackPlugin handles it
+
+          newI18nAssets.push(dynamicFilename);
+        } // Add custom group chunks if they should be in initial HTML
+
+
+        if (customGroups) {
+          Object.entries(customGroups).forEach(([groupName, groupConfig]) => {
+            // Only add to initial HTML if preload is true
+            if (groupConfig.preload && groupConfig.filenameTemplate) {
+              const groupFilename = groupConfig.filenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel).replace(/%5Blocale%5D/g, htmlTemplateLabel); // Don't add CDN template - HtmlWebpackPlugin handles it
+
+              newI18nAssets.push(groupFilename);
+            }
+          });
+        } // Prepend i18n assets to ensure they load before main bundle
+
+
+        if (newI18nAssets.length > 0) {
+          assets.js = [...newI18nAssets, ...assets.js];
+        }
+
+        return hookData;
+      });
+    });
+  }
+
+}
+
+function configI18nNumericHtmlInjector(config) {
+  const {
+    i18nIndexing,
+    cdnMapping
+  } = config; // Only create this plugin if i18nIndexing is enabled
+
+  if (!i18nIndexing || !i18nIndexing.enable) {
+    return null;
+  } // Get the CDN template for i18n resources if CDN is enabled
+
+
+  const i18nCdnTemplate = cdnMapping && cdnMapping.isCdnEnabled ? cdnMapping.i18nTemplate || cdnMapping.jsTemplate : '';
+  const options = {
+    numericFilenameTemplate: i18nIndexing.numericFilenameTemplate || 'i18n-chunk/[locale]/numeric.i18n.js',
+    dynamicFilenameTemplate: i18nIndexing.dynamicFilenameTemplate || 'i18n-chunk/[locale]/dynamic.i18n.js',
+    htmlTemplateLabel: i18nIndexing.htmlTemplateLabel || '{{--user-locale}}',
+    customGroups: i18nIndexing.customGroups || {},
+    i18nCdnTemplate
+  };
+  return new I18nNumericHtmlInjectorPlugin(options);
+}