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

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

@@ -36,7 +36,7 @@ function getI18nAssetsForChunkAsArrayStr({
   chunkSplitEnable,
   i18nFileNameTemplate
 }) {
-  if (!chunkSplitEnable) {
+  if (!chunkSplitEnable || !i18nStore) {
     // NOTE: we have used lang variable inside
     // NOTE: below code for full i18n for now it is not implemented
     // if (!chunkSplitEnable) {
@@ -71,6 +71,11 @@ 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/loaderConfigs/i18nIdReplaceLoaderConfig.js

@@ -4,98 +4,122 @@ const path = require('path');
 
 const fs = require('fs');
 
-let allI18nDataFromPropertiesCache = null;
+const {
+  parseProperties
+} = require('../utils/propertiesParser'); // Improved caching with proper cleanup
 
-function loadJSResourcesOnce(options) {
-  if (allI18nDataFromPropertiesCache) {
-    return allI18nDataFromPropertiesCache;
+
+class ConfigCache {
+  constructor() {
+    this.i18nDataCache = new Map();
+    this.maxCacheSize = 10; // Limit cache size
+  }
+
+  getI18nData(filePath) {
+    return this.i18nDataCache.get(filePath);
+  }
+
+  setI18nData(filePath, data) {
+    if (this.i18nDataCache.size >= this.maxCacheSize) {
+      // Clear oldest entries
+      const firstKey = this.i18nDataCache.keys().next().value;
+      this.i18nDataCache.delete(firstKey);
+    }
+
+    this.i18nDataCache.set(filePath, data);
+  }
+
+  clear() {
+    this.i18nDataCache.clear();
   }
 
+}
+
+const configCache = new ConfigCache();
+
+function loadJSResourcesOnce(options, webpackContext) {
   if (!options.i18nIndexing || !options.i18nIndexing.enable) {
     throw new Error('i18nIdReplaceLoader requires i18nIndexing to be enabled');
   }
 
   if (!options.i18nIndexing.jsResourcePath) {
     throw new Error('Missing required jsResourcePath in i18nIndexing options');
-  }
+  } // Use webpack context instead of process.cwd() for better reliability
 
-  const propertiesFilePath = path.resolve(process.cwd(), options.i18nIndexing.jsResourcePath);
+
+  const contextPath = webpackContext || process.cwd();
+  const propertiesFilePath = path.isAbsolute(options.i18nIndexing.jsResourcePath) ? options.i18nIndexing.jsResourcePath : path.resolve(contextPath, options.i18nIndexing.jsResourcePath); // Check cache first
+
+  const cached = configCache.getI18nData(propertiesFilePath);
+
+  if (cached) {
+    return cached;
+  }
 
   if (!fs.existsSync(propertiesFilePath)) {
     throw new Error(`JSResource file not found at: ${propertiesFilePath}`);
   }
 
-  const i18nData = {};
-
   try {
     const data = fs.readFileSync(propertiesFilePath, {
       encoding: 'utf-8'
     });
-    const lines = data.split(/\r?\n/);
-    lines.forEach(line => {
-      const trimmedLine = line.trim();
-
-      if (trimmedLine.startsWith('#') || trimmedLine.startsWith('!') || trimmedLine === '') {
-        return;
-      }
-
-      let separatorIndex = -1;
-
-      for (let i = 0; i < trimmedLine.length; i++) {
-        if ((trimmedLine[i] === '=' || trimmedLine[i] === ':') && (i === 0 || trimmedLine[i - 1] !== '\\')) {
-          separatorIndex = i;
-          break;
-        }
-      }
-
-      if (separatorIndex > 0) {
-        let key = trimmedLine.substring(0, separatorIndex).trim();
-        const value = trimmedLine.substring(separatorIndex + 1).trim();
-        key = key.replace(/\\ /g, ' ');
-
-        if (key) {
-          i18nData[key] = value;
-        }
-      }
-    });
+    const i18nData = parseProperties(data);
+
+    if (Object.keys(i18nData).length === 0) {
+      throw new Error(`No i18n data found in JSResource file: ${propertiesFilePath}`);
+    } // Cache the result
+
+
+    configCache.setI18nData(propertiesFilePath, i18nData);
+    return i18nData;
   } catch (err) {
     throw new Error(`Error reading JSResource file ${propertiesFilePath}: ${err.message}`);
   }
-
-  if (Object.keys(i18nData).length === 0) {
-    throw new Error(`No i18n data found in JSResource file: ${propertiesFilePath}`);
-  }
-
-  allI18nDataFromPropertiesCache = i18nData;
-  return allI18nDataFromPropertiesCache;
 }
 
-function i18nIdReplaceLoaderConfig(options) {
+function i18nIdReplaceLoaderConfig(options, webpackContext) {
+  // Validate required options
   if (!options.i18nIndexing || !options.i18nIndexing.enable) {
     throw new Error('i18nIdReplaceLoader requires i18nIndexing to be enabled');
   }
 
   if (!options.i18nIndexing.numericMapPath) {
     throw new Error('Missing required numericMapPath in i18nIndexing options');
-  }
+  } // Load i18n data with proper context
+
 
-  const allI18nData = loadJSResourcesOnce(options);
+  const allI18nData = loadJSResourcesOnce(options, webpackContext);
+
+  const i18nKeyReplaceLoaderPath = require.resolve('../loaders/i18nIdReplaceLoader.js'); // Enhanced loader options with better defaults
 
-  const i18nKeyReplaceLoaderPath = require.resolve('../loaders/i18nIdReplaceLoader.js');
 
   const loaderOptions = {
     allI18nData: allI18nData,
     sourceMaps: !!(options.devtool && options.devtool.includes('source-map')),
     isDebug: options.mode === 'development',
     useNumericIndexing: true,
-    numericMapPath: options.i18nIndexing.numericMapPath
+    numericMapPath: options.i18nIndexing.numericMapPath,
+    // Additional configurable options
+    retainLines: options.i18nIndexing.retainLines || false,
+    preserveComments: options.i18nIndexing.preserveComments !== false,
+    compact: options.mode === 'production',
+    minified: options.mode === 'production',
+    // Allow custom babel plugins
+    babelPlugins: options.i18nIndexing.babelPlugins || undefined
   };
   return {
     loader: i18nKeyReplaceLoaderPath,
     options: loaderOptions
   };
+} // Export cache for potential cleanup
+
+
+function clearCache() {
+  configCache.clear();
 }
 
 module.exports = {
-  i18nIdReplaceLoaderConfig
+  i18nIdReplaceLoaderConfig,
+  clearCache
 };

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

@@ -1,6 +1,8 @@
 "use strict";
 
-const fs = require('fs');
+const fs = require('fs').promises;
+
+const fsSync = require('fs');
 
 const path = require('path');
 
@@ -24,41 +26,72 @@ try {
   throw new Error('[i18nIdReplaceLoader] Required dependency not found: ' + e.message);
 }
 
-const LOADER_PREFIX = '[i18nIdReplaceLoader]';
-let numericIdMapDataCache = null;
-let mapLoadAttemptedForPath = {};
+const LOADER_PREFIX = '[i18nIdReplaceLoader]'; // Improved caching with proper cleanup
 
-function loadNumericIdMap(loaderContext, mapPath) {
-  if (!mapPath) {
-    throw new Error(`${LOADER_PREFIX} Numeric map path not provided in loader options.`);
+class LoaderCache {
+  constructor() {
+    this.numericMapCache = new Map();
+    this.astCache = new Map();
+    this.maxCacheSize = 100; // Prevent memory leaks
+  }
+
+  getNumericMap(mapPath) {
+    return this.numericMapCache.get(mapPath);
+  }
+
+  setNumericMap(mapPath, data) {
+    if (this.numericMapCache.size >= this.maxCacheSize) {
+      // Clear oldest entries
+      const firstKey = this.numericMapCache.keys().next().value;
+      this.numericMapCache.delete(firstKey);
+    }
+
+    this.numericMapCache.set(mapPath, data);
+  }
+
+  clear() {
+    this.numericMapCache.clear();
+    this.astCache.clear();
   }
 
-  const absoluteMapPath = path.isAbsolute(mapPath) ? mapPath : path.resolve(loaderContext.rootContext || process.cwd(), mapPath);
+}
+
+const loaderCache = new LoaderCache();
 
-  if (numericIdMapDataCache && mapLoadAttemptedForPath[absoluteMapPath]) {
-    return numericIdMapDataCache;
+async function loadNumericIdMap(loaderContext, mapPath) {
+  if (!mapPath) {
+    throw new Error(`${LOADER_PREFIX} Numeric map path not provided in loader options.`);
   }
 
-  mapLoadAttemptedForPath[absoluteMapPath] = true;
+  const absoluteMapPath = path.isAbsolute(mapPath) ? mapPath : path.resolve(loaderContext.rootContext || process.cwd(), mapPath); // Check cache first
+
+  const cached = loaderCache.getNumericMap(absoluteMapPath);
 
-  if (!fs.existsSync(absoluteMapPath)) {
-    throw new Error(`${LOADER_PREFIX} Pre-generated i18n numeric map file NOT FOUND at: ${absoluteMapPath}.`);
+  if (cached) {
+    return cached;
   }
 
   try {
-    const fileContent = fs.readFileSync(absoluteMapPath, 'utf-8');
-    const parsedData = JSON.parse(fileContent);
+    // Check if file exists
+    if (!fsSync.existsSync(absoluteMapPath)) {
+      throw new Error(`Pre-generated i18n numeric map file NOT FOUND at: ${absoluteMapPath}`);
+    } // Read file asynchronously for better performance
+
+
+    const fileContent = await fs.readFile(absoluteMapPath, 'utf-8');
+    const parsedData = JSON.parse(fileContent); // Validate map structure
 
     if (!parsedData || !parsedData.originalKeyToNumericId || typeof parsedData.originalKeyToNumericId !== 'object') {
-      throw new Error(`${LOADER_PREFIX} Pre-generated map file (${absoluteMapPath}) is invalid or does not contain 'originalKeyToNumericId'.`);
+      throw new Error(`Pre-generated map file (${absoluteMapPath}) is invalid or does not contain 'originalKeyToNumericId'`);
     }
 
-    numericIdMapDataCache = parsedData.originalKeyToNumericId;
+    const numericIdMap = parsedData.originalKeyToNumericId; // Cache the result
+
+    loaderCache.setNumericMap(absoluteMapPath, numericIdMap);
+    return numericIdMap;
   } catch (err) {
     throw new Error(`${LOADER_PREFIX} Error loading or parsing pre-generated i18n map from ${absoluteMapPath}: ${err.message}`);
   }
-
-  return numericIdMapDataCache;
 }
 
 module.exports = function i18nIdReplaceLoader(source, map, meta) {
@@ -66,103 +99,131 @@ module.exports = function i18nIdReplaceLoader(source, map, meta) {
   this.cacheable && this.cacheable();
   const options = getOptions(this) || {};
   const callback = this.async();
-  const loaderContext = this;
+  const loaderContext = this; // Validate required options
 
   if (!options.allI18nData || typeof options.allI18nData !== 'object' || Object.keys(options.allI18nData).length === 0) {
-    throw new Error(`${LOADER_PREFIX} [${resourcePath}] 'allI18nData' option is missing or empty.`);
+    return callback(new Error(`${LOADER_PREFIX} [${resourcePath}] 'allI18nData' option is missing or empty.`));
   }
 
   if (!options.useNumericIndexing) {
-    throw new Error(`${LOADER_PREFIX} [${resourcePath}] 'useNumericIndexing' must be enabled.`);
-  }
+    return callback(new Error(`${LOADER_PREFIX} [${resourcePath}] 'useNumericIndexing' must be enabled.`));
+  } // Load numeric map asynchronously
+
+
+  loadNumericIdMap(this, options.numericMapPath).then(numericIdMap => {
+    try {
+      // Configure parser with better defaults and configurability
+      const parserOptions = {
+        sourceType: 'module',
+        plugins: options.babelPlugins || ['jsx', 'typescript', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator', 'objectRestSpread', 'dynamicImport', 'decorators-legacy', 'asyncGenerators', 'bigInt', 'dynamicImport', 'exportDefaultFrom', 'exportNamespaceFrom', 'functionBind', 'importMeta', 'numericSeparator', 'optionalCatchBinding', 'throwExpressions', 'topLevelAwait'],
+        attachComment: true,
+        sourceFilename: resourcePath,
+        allowImportExportEverywhere: true,
+        allowAwaitOutsideFunction: true,
+        allowReturnOutsideFunction: true,
+        ranges: false,
+        tokens: false
+      };
+      const astFile = parser.parse(source, parserOptions);
+      const astProgram = astFile.program;
+      const comments = astFile.comments || [];
+      const {
+        literalKeys,
+        commentKeys
+      } = collectAndCategorizeUsedI18nKeys(astProgram, comments, options.allI18nData, options.isDebug); // Store keys in module build info for plugin consumption
+
+      if (this._module) {
+        if (!this._module.buildInfo) {
+          this._module.buildInfo = {};
+        }
 
-  const numericIdMap = loadNumericIdMap(this, options.numericMapPath);
+        if (literalKeys.size > 0) {
+          this._module.buildInfo.loaderIdentifiedLiteralI18nKeys = Array.from(literalKeys);
+        }
 
-  try {
-    const parserOptions = {
-      sourceType: 'module',
-      plugins: ['jsx', 'typescript', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator', 'objectRestSpread', 'dynamicImport'],
-      attachComment: true,
-      sourceFilename: resourcePath
-    };
-    const astFile = parser.parse(source, parserOptions);
-    const astProgram = astFile.program;
-    const comments = astFile.comments || [];
-    const {
-      literalKeys,
-      commentKeys
-    } = collectAndCategorizeUsedI18nKeys(astProgram, comments, options.allI18nData, options.isDebug);
-
-    if (this._module) {
-      if (!this._module.buildInfo) {
-        this._module.buildInfo = {};
-      }
+        if (commentKeys.size > 0) {
+          this._module.buildInfo.loaderIdentifiedCommentI18nKeys = Array.from(commentKeys);
+        }
+      } // Early return if no replacements needed
 
-      if (literalKeys.size > 0) {
-        this._module.buildInfo.loaderIdentifiedLiteralI18nKeys = Array.from(literalKeys);
-      }
 
-      if (commentKeys.size > 0) {
-        this._module.buildInfo.loaderIdentifiedCommentI18nKeys = Array.from(commentKeys);
+      if (literalKeys.size === 0) {
+        return callback(null, source, map);
       }
-    }
-
-    if (literalKeys.size === 0) {
-      return callback(null, source, map);
-    }
 
-    let replacementMade = false;
-    walk(astProgram, {
-      enter: function (node, parent, prop, index) {
-        const walkerControl = this;
+      let replacementMade = false;
+      let replacementCount = 0; // Process AST and replace string literals with numeric IDs
 
-        if ((node.type === 'Literal' || node.type === 'StringLiteral') && typeof node.value === 'string') {
-          const originalValue = node.value;
+      walk(astProgram, {
+        enter: function (node, parent, prop, index) {
+          const walkerControl = this;
 
-          if (literalKeys.has(originalValue)) {
-            const numericId = numericIdMap[originalValue];
+          if ((node.type === 'Literal' || node.type === 'StringLiteral') && typeof node.value === 'string') {
+            const originalValue = node.value;
 
-            if (numericId !== undefined) {
-              const numericLiteralNode = {
-                type: 'NumericLiteral',
-                value: numericId
-              };
-              let replacementNode = numericLiteralNode;
+            if (literalKeys.has(originalValue)) {
+              const numericId = numericIdMap[originalValue];
 
-              if (parent && parent.type === 'JSXAttribute' && parent.value === node) {
-                replacementNode = {
-                  type: 'JSXExpressionContainer',
-                  expression: numericLiteralNode
+              if (numericId !== undefined) {
+                const numericLiteralNode = {
+                  type: 'NumericLiteral',
+                  value: numericId,
+                  raw: String(numericId)
                 };
+                let replacementNode = numericLiteralNode; // Handle JSX attributes specially
+
+                if (parent && parent.type === 'JSXAttribute' && parent.value === node) {
+                  replacementNode = {
+                    type: 'JSXExpressionContainer',
+                    expression: numericLiteralNode
+                  };
+                }
+
+                walkerControl.replace(replacementNode);
+                replacementMade = true;
+                replacementCount++;
               }
-
-              walkerControl.replace(replacementNode);
-              replacementMade = true;
             }
           }
         }
+      }); // Generate output only if replacements were made
+
+      if (replacementMade) {
+        const generateOptions = {
+          sourceMaps: !!options.sourceMaps,
+          sourceFileName: resourcePath,
+          retainLines: options.retainLines || false,
+          comments: options.preserveComments !== false,
+          compact: options.compact || false,
+          minified: options.minified || false
+        };
+        const output = generator(astFile, generateOptions, source); // Debug logging if enabled
+
+        if (options.isDebug) {
+          console.log(`${LOADER_PREFIX} [${resourcePath}] Replaced ${replacementCount} i18n keys with numeric IDs`);
+        }
+
+        callback(null, output.code, options.sourceMaps && output.map ? output.map : map);
+      } else {
+        callback(null, source, map);
       }
-    });
-
-    if (replacementMade) {
-      const generateOptions = {
-        sourceMaps: !!options.sourceMaps,
-        sourceFileName: resourcePath,
-        retainLines: false,
-        comments: true
-      };
-      const output = generator(astFile, generateOptions, source);
-      callback(null, output.code, options.sourceMaps && output.map ? output.map : map);
-    } else {
-      callback(null, source, map);
-    }
-  } catch (err) {
-    const detailedError = new Error(`${LOADER_PREFIX} [${resourcePath}] AST Processing Error: ${err.message} (Stack: ${err.stack})`);
+    } catch (err) {
+      // Enhanced error handling with better context
+      const detailedError = new Error(`${LOADER_PREFIX} [${resourcePath}] AST Processing Error: ${err.message}`);
 
-    if (err.loc && err.loc.line) {
-      detailedError.message += ` at line ${err.loc.line}, column ${err.loc.column}`;
-    }
+      if (err.loc && err.loc.line) {
+        detailedError.message += ` at line ${err.loc.line}, column ${err.loc.column}`;
+      } // Add stack trace in debug mode
 
-    callback(detailedError);
-  }
+
+      if (options.isDebug && err.stack) {
+        detailedError.message += `\nStack: ${err.stack}`;
+      }
+
+      callback(detailedError);
+    }
+  }).catch(err => {
+    // Handle async errors from map loading
+    callback(new Error(`${LOADER_PREFIX} [${resourcePath}] Failed to load numeric map: ${err.message}`));
+  });
 };

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

@@ -7,7 +7,7 @@ exports.configI18nNumericIndexPlugin = configI18nNumericIndexPlugin;
 
 var {
   I18nNumericIndexPlugin
-} = require("@zohodesk/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nNumericIndexPlugin/I18nNumericIndexPlugin");
+} = require("../custom_plugins/I18nNumericIndexPlugin/I18nNumericIndexPlugin");
 
 var {
   I18nNumericIndexHtmlInjectorPlugin

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

@@ -36,6 +36,9 @@ function configI18nSplitPlugin(options) {
     publicPath: i18nPublicPath,
     i18nManifestFileName: (0, _nameTemplates.nameTemplates)('i18nmanifest', options),
     // template: (object, locale) => `window.loadI18n(${JSON.stringify(object)}, ${JSON.stringify(locale)})`,
-    propertiesFolder: i18nChunkSplit.propertiesFolder
+    propertiesFolder: i18nChunkSplit.propertiesFolder,
+    // NEW OPTIONS FOR NUMERIC INDEXING
+    useNumericIndexing: i18nChunkSplit.useNumericIndexing,
+    numericMapPath: i18nChunkSplit.numericMapPath
   });
 }

package/lib/shared/bundler/webpack/utils/propertiesParser.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Shared properties file parsing utility
+ * Handles consistent parsing across all i18n tools
+ */
+// Decode Unicode escape sequences (for values only)
+
+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));
+  });
+}
+/**
+ * Parse properties file content into key-value pairs
+ * @param {string} content - Properties file content
+ * @returns {Object} Parsed key-value pairs
+ */
+
+
+function parseProperties(content) {
+  const lines = content.split(/\r?\n/);
+  const data = {};
+  lines.forEach(line => {
+    const trimmedLine = line.trim();
+
+    if (trimmedLine.startsWith('#') || trimmedLine.startsWith('!') || trimmedLine === '') {
+      return;
+    } // Find unescaped separator (= or :)
+
+
+    let separatorIndex = -1;
+
+    for (let i = 0; i < trimmedLine.length; i++) {
+      if ((trimmedLine[i] === '=' || trimmedLine[i] === ':') && (i === 0 || trimmedLine[i - 1] !== '\\')) {
+        separatorIndex = i;
+        break;
+      }
+    }
+
+    if (separatorIndex > 0) {
+      let key = trimmedLine.substring(0, separatorIndex).trim();
+      let value = trimmedLine.substring(separatorIndex + 1).trim();
+
+      if (key) {
+        // Handle escaped spaces in keys only
+        key = key.replace(/\\ /g, ' '); // Decode Unicode escape sequences ONLY in values, not keys
+
+        value = decodeUnicodeEscapes(value);
+        data[key] = value;
+      }
+    }
+  });
+  return data;
+}
+/**
+ * Parse properties file content into a Set of keys only
+ * @param {string} content - Properties file content
+ * @returns {Set<string>} Set of keys
+ */
+
+
+function parsePropertiesToKeySet(content) {
+  const lines = content.split(/\r?\n/);
+  const keys = new Set();
+  lines.forEach(line => {
+    const trimmedLine = line.trim();
+
+    if (trimmedLine.startsWith('#') || trimmedLine.startsWith('!') || trimmedLine === '') {
+      return;
+    } // Find unescaped separator (= or :)
+
+
+    let separatorIndex = -1;
+
+    for (let i = 0; i < trimmedLine.length; i++) {
+      if ((trimmedLine[i] === '=' || trimmedLine[i] === ':') && (i === 0 || trimmedLine[i - 1] !== '\\')) {
+        separatorIndex = i;
+        break;
+      }
+    }
+
+    if (separatorIndex > 0) {
+      let key = trimmedLine.substring(0, separatorIndex).trim();
+
+      if (key) {
+        // Handle escaped spaces in keys only
+        key = key.replace(/\\ /g, ' ');
+        keys.add(key);
+      }
+    }
+  });
+  return keys;
+}
+
+module.exports = {
+  parseProperties,
+  parsePropertiesToKeySet,
+  decodeUnicodeEscapes
+};