@zohodesk/client_build_tool 0.0.1-0.exp.0.0.3 → 0.0.1-0.exp.0.0.8

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

@@ -40,6 +40,9 @@ function optionsHandler(options) {
     jsResourceI18nKeys,
     allI18nObject,
     locales,
+    // NEW OPTIONS FOR NUMERIC INDEXING
+    useNumericIndexing: options.useNumericIndexing,
+    numericMapPath: options.numericMapPath,
     // template: (object, locale) => `window.loadI18n(${JSON.stringify(object)}, ${JSON.stringify(locale)})`,
     runtime: true,
     runtimeOptions: {

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,91 +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();
   }
 
-  let resourcePathToLoad = '';
+}
+
+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 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 (options.i18nIndexing && options.i18nIndexing.enable && options.i18nIndexing.jsResourcePath) {
-    resourcePathToLoad = options.i18nIndexing.jsResourcePath;
-  } else if (options.i18nChunkSplit && options.i18nChunkSplit.jsResource) {
-    resourcePathToLoad = options.i18nChunkSplit.jsResource;
-  } else {
-    allI18nDataFromPropertiesCache = {};
-    return allI18nDataFromPropertiesCache;
+  if (cached) {
+    return cached;
   }
 
-  const propertiesFilePath = path.resolve(process.cwd(), resourcePathToLoad);
-  const i18nData = {};
+  if (!fs.existsSync(propertiesFilePath)) {
+    throw new Error(`JSResource file not found at: ${propertiesFilePath}`);
+  }
 
   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;
-        }
-      }
-    });
-  } catch (err) {// Silent error handling
-  }
+    const i18nData = parseProperties(data);
+
+    if (Object.keys(i18nData).length === 0) {
+      throw new Error(`No i18n data found in JSResource file: ${propertiesFilePath}`);
+    } // Cache the result
 
-  allI18nDataFromPropertiesCache = i18nData;
-  return allI18nDataFromPropertiesCache;
+
+    configCache.setI18nData(propertiesFilePath, i18nData);
+    return i18nData;
+  } catch (err) {
+    throw new Error(`Error reading JSResource file ${propertiesFilePath}: ${err.message}`);
+  }
 }
 
-function i18nIdReplaceLoaderConfig(options) {
-  const allI18nData = loadJSResourcesOnce(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, 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'
+    sourceMaps: !!(options.devtool && options.devtool.includes('source-map')),
+    isDebug: options.mode === 'development',
+    useNumericIndexing: true,
+    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
   };
-
-  if (options.i18nIndexing && options.i18nIndexing.enable) {
-    loaderOptions.useNumericIndexing = true;
-    loaderOptions.numericMapPath = options.i18nIndexing.numericMapPath;
-    loaderOptions.fallbackToHash = options.i18nIndexing.fallbackToHash !== undefined ? options.i18nIndexing.fallbackToHash : true;
-  } else {
-    loaderOptions.useNumericIndexing = false;
-    loaderOptions.fallbackToHash = true;
-  }
-
   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');
 
@@ -16,57 +18,80 @@ const {
   getOptions
 } = require('loader-utils');
 
-let collectAndCategorizeUsedI18nKeys, generateShortHash;
+let collectAndCategorizeUsedI18nKeys;
 
 try {
   collectAndCategorizeUsedI18nKeys = require('../custom_plugins/I18nSplitPlugin/utils/collectAstKeys').collectAndCategorizeUsedI18nKeys;
-  generateShortHash = require('../common/hashUtils').generateShortHash;
 } catch (e) {
-  collectAndCategorizeUsedI18nKeys = () => ({
-    literalKeys: new Set(),
-    commentKeys: new Set()
-  });
+  throw new Error('[i18nIdReplaceLoader] Required dependency not found: ' + e.message);
+}
+
+const LOADER_PREFIX = '[i18nIdReplaceLoader]'; // Improved caching with proper cleanup
+
+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();
+  }
 
-  generateShortHash = key => key;
 }
 
-const LOADER_PREFIX = '[i18nIdReplaceLoader]';
-let numericIdMapDataCache = null;
-let mapLoadAttemptedForPath = {};
+const loaderCache = new LoaderCache();
 
-function loadNumericIdMap(loaderContext, mapPath) {
+async function loadNumericIdMap(loaderContext, mapPath) {
   if (!mapPath) {
-    loaderContext.emitWarning(new Error(`${LOADER_PREFIX} Numeric map path not provided in loader options.`));
-    return null;
+    throw new Error(`${LOADER_PREFIX} Numeric map path not provided in loader options.`);
   }
 
-  if (numericIdMapDataCache && mapLoadAttemptedForPath[mapPath]) {
-    return numericIdMapDataCache;
-  }
+  const absoluteMapPath = path.isAbsolute(mapPath) ? mapPath : path.resolve(loaderContext.rootContext || process.cwd(), mapPath); // Check cache first
+
+  const cached = loaderCache.getNumericMap(absoluteMapPath);
 
-  mapLoadAttemptedForPath[mapPath] = true;
+  if (cached) {
+    return cached;
+  }
 
   try {
-    if (fs.existsSync(mapPath)) {
-      const fileContent = fs.readFileSync(mapPath, '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
 
-      if (parsedData && parsedData.originalKeyToNumericId && typeof parsedData.originalKeyToNumericId === 'object') {
-        numericIdMapDataCache = parsedData.originalKeyToNumericId;
-      } else {
-        loaderContext.emitError(new Error(`${LOADER_PREFIX} Pre-generated map file (${mapPath}) is invalid or does not contain 'originalKeyToNumericId'.`));
-        numericIdMapDataCache = null;
-      }
-    } else {
-      loaderContext.emitError(new Error(`${LOADER_PREFIX} Pre-generated i18n numeric map file NOT FOUND at: ${mapPath}.`));
-      numericIdMapDataCache = null;
+
+    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(`Pre-generated map file (${absoluteMapPath}) is invalid or does not contain 'originalKeyToNumericId'`);
     }
+
+    const numericIdMap = parsedData.originalKeyToNumericId; // Cache the result
+
+    loaderCache.setNumericMap(absoluteMapPath, numericIdMap);
+    return numericIdMap;
   } catch (err) {
-    loaderContext.emitError(new Error(`${LOADER_PREFIX} Error loading or parsing pre-generated i18n map from ${mapPath}: ${err.message}`));
-    numericIdMapDataCache = null;
+    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) {
@@ -74,77 +99,78 @@ 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) {
-    this.emitWarning(new Error(`${LOADER_PREFIX} [${resourcePath}] 'allI18nData' option is missing or empty. No replacements will be made.`));
-    return callback(null, source, map);
+    return callback(new Error(`${LOADER_PREFIX} [${resourcePath}] 'allI18nData' option is missing or empty.`));
   }
 
-  let useNumericIndexing = options.useNumericIndexing !== undefined ? options.useNumericIndexing : true;
-  let localOriginalKeyToNumericIdMap = null;
-
-  if (useNumericIndexing) {
-    localOriginalKeyToNumericIdMap = loadNumericIdMap(this, options.numericMapPath);
-  }
+  if (!options.useNumericIndexing) {
+    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 fallbackToHash = options.fallbackToHash !== undefined ? options.fallbackToHash : true;
+        if (literalKeys.size > 0) {
+          this._module.buildInfo.loaderIdentifiedLiteralI18nKeys = Array.from(literalKeys);
+        }
 
-  try {
-    const parserOptions = {
-      sourceType: 'module',
-      plugins: ['jsx', 'typescript', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator'],
-      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);
       }
-    }
-
-    const keysToReplaceInLiterals = literalKeys;
 
-    if (keysToReplaceInLiterals.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 (keysToReplaceInLiterals.has(originalValue)) {
-            let replaced = false;
+          if ((node.type === 'Literal' || node.type === 'StringLiteral') && typeof node.value === 'string') {
+            const originalValue = node.value;
 
-            if (useNumericIndexing && localOriginalKeyToNumericIdMap) {
-              const numericId = localOriginalKeyToNumericIdMap[originalValue];
+            if (literalKeys.has(originalValue)) {
+              const numericId = numericIdMap[originalValue];
 
               if (numericId !== undefined) {
                 const numericLiteralNode = {
                   type: 'NumericLiteral',
-                  value: numericId
+                  value: numericId,
+                  raw: String(numericId)
                 };
-                let replacementNode = numericLiteralNode;
+                let replacementNode = numericLiteralNode; // Handle JSX attributes specially
 
                 if (parent && parent.type === 'JSXAttribute' && parent.value === node) {
                   replacementNode = {
@@ -155,47 +181,49 @@ module.exports = function i18nIdReplaceLoader(source, map, meta) {
 
                 walkerControl.replace(replacementNode);
                 replacementMade = true;
-                replaced = true;
-              }
-            }
-
-            if (!replaced && fallbackToHash) {
-              try {
-                const hashValue = generateShortHash(originalValue);
-                const hashedStringLiteralNode = {
-                  type: 'StringLiteral',
-                  value: hashValue
-                };
-                walkerControl.replace(hashedStringLiteralNode);
-                replacementMade = true;
-              } catch (hashError) {
-                loaderContext.emitError(new Error(`${LOADER_PREFIX} [${resourcePath}] Error hashing key "${originalValue}": ${hashError.message}`));
+                replacementCount++;
               }
             }
           }
         }
+      }); // 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) {
-      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}`));
+  });
 };