@zohodesk/client_build_tool 0.0.10 → 0.0.11-exp.7

package/CHANGELOG.md

@@ -1,16 +1,6 @@
 # Changelog and Release Notes
-# v0.0.10 (12-05-2025)
-**Feature:-**
-- `alias` support for `build:es` and `build:lib`
-    - Add babel-plugin-module-resolver dependencies
-    - Modify getBabelPlugin to include module resolver with aliases
 
-**Bug Fix:-**
-- Enhance runBabelForTSFile to handle both .tsx and .ts file extensions
-- Update mockApiHandler to ensure mock function is called correctly
 
-**Change:-**
-- Refactor defaultConfigValues.js to include cli options for enableRTLSplit
 
 **Feature:-**
 - externals was added to  Prevent bundling of certain imported packages and retrieve these external dependencies at runtime.

package/README.md

@@ -99,18 +99,8 @@ fixes :-
 - preload plc undefined url fixed 
 
 # Changelog and Release Notes
-# v0.0.10 (12-05-2025)
-**Feature:-**
-- `alias` support for `build:es` and `build:lib`
-    - Add babel-plugin-module-resolver dependencies
-    - Modify getBabelPlugin to include module resolver with aliases
 
-**Bug Fix:-**
-- Enhance runBabelForTSFile to handle both .tsx and .ts file extensions
-- Update mockApiHandler to ensure mock function is called correctly
 
-**Change:-**
-- Refactor defaultConfigValues.js to include cli options for enableRTLSplit
 
 **Feature:-**
 - externals was added to  Prevent bundling of certain imported packages and retrieve these external dependencies at runtime.

package/lib/schemas/defaultConfigValues.js

@@ -115,10 +115,7 @@ var _default = {
     // Name Suggestions  `customizations` this will be easier then `plugin` to understand for developers
     plugins: {
       rtlSplit: {
-        enableRTLSplit: {
-          value: false,
-          cli: 'enable_rtl_split'
-        },
+        enableRTLSplit: false,
         templateLabel: '{{--dir}}',
         disableMinifySelector: false,
         dirVarName: 'document.dir'
@@ -174,7 +171,22 @@ var _default = {
     localeVarName: 'document.documentElement.lang',
     jsonpFunc: 'console.log',
     jsResource: null,
-    propertiesFolder: null
+    propertiesFolder: null,
+    useNumericIndexing: false
+  },
+  i18nIndexing: {
+    enable: false,
+    jsResourcePath: './deskapp/properties/JSResources.properties',
+    propertiesFolderPath: './deskapp/properties',
+    numericMapPath: './deskapp/properties/i18n-numeric-map.json',
+    numericFilenameTemplate: 'i18n-chunk/[locale]/numeric.i18n.js',
+    dynamicFilenameTemplate: 'i18n-chunk/[locale]/dynamic.i18n.js',
+    jsonpFunc: 'window.loadI18nChunk',
+    htmlTemplateLabel: '{{--user-locale}}',
+    localeVarName: 'window.userLangCode',
+    singleFile: false,
+    includeContentHash: false,
+    generateManifest: false
   },
   publicFolders: ['...'],
   app: {

package/lib/schemas/defaultConfigValuesOnly.js

@@ -94,7 +94,22 @@ var _default = {
     localeVarName: 'document.documentElement.lang',
     jsonpFunc: 'console.log',
     jsResource: null,
-    propertiesFolder: null
+    propertiesFolder: null,
+    useNumericIndexing: false
+  },
+  i18nIndexing: {
+    enable: false,
+    jsResourcePath: './deskapp/properties/JSResources.properties',
+    propertiesFolderPath: './deskapp/properties',
+    numericMapPath: './deskapp/properties/i18n-numeric-map.json',
+    numericFilenameTemplate: 'i18n-chunk/[locale]/numeric.i18n.js',
+    dynamicFilenameTemplate: 'i18n-chunk/[locale]/dynamic.i18n.js',
+    jsonpFunc: 'window.loadI18nChunk',
+    htmlTemplateLabel: '{{--user-locale}}',
+    localeVarName: 'window.userLangCode',
+    singleFile: false,
+    includeContentHash: false,
+    generateManifest: false
   },
   publicFolders: ['...', {
     source: './deskapp/tp/',

package/lib/shared/babel/getBabelPlugin.js

@@ -20,14 +20,7 @@ function getBabelPlugin(options) {
   const {
     mode
   } = options;
-  const {
-    alias
-  } = options.resolve; // let customPlugins = [];
-
-  let customPlugins = [[require.resolve('babel-plugin-module-resolver'), {
-    root: ['./'],
-    alias
-  }]];
+  let customPlugins = [];
   const {
     babelCustomizations
   } = options;
@@ -39,4 +32,6 @@ function getBabelPlugin(options) {
   }
 
   return customPlugins.filter(Boolean);
-}
+}
+
+;

package/lib/shared/babel/runBabelForTsFile.js

@@ -25,6 +25,6 @@ function runBabelForTSFile({
     // const jsSourceCode = readFileSync(filename).toString();
     const babelConfig = (0, _babelWebConfig.babelWebConfig)(options, mode);
     const result = (0, _core.transformFileSync)(filename, babelConfig);
-    (0, _copyFile.writeFile)(outputFile.replace('.tsx', '.js').replace('.ts', '.js'), result.code);
+    (0, _copyFile.writeFile)(outputFile.replace('.tsx', '.js'), result.code);
   }
 }

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

@@ -0,0 +1,49 @@
+"use strict";
+
+const HtmlWebpackPlugin = require('html-webpack-plugin');
+
+const pluginName = 'I18nNumericIndexHtmlInjectorPlugin';
+
+class I18nNumericIndexHtmlInjectorPlugin {
+  constructor(options) {
+    this.options = options;
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      HtmlWebpackPlugin.getHooks(compilation).beforeAssetTagGeneration.tapAsync(pluginName, (hookData, cb) => {
+        const {
+          assets
+        } = hookData;
+        const {
+          numericFilenameTemplate,
+          dynamicFilenameTemplate,
+          htmlTemplateLabel,
+          i18nAssetsPublicPathPrefix = ''
+        } = this.options;
+        const newI18nAssetUrlsToAdd = [];
+
+        if (numericFilenameTemplate) {
+          const numericFilename = numericFilenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel);
+          newI18nAssetUrlsToAdd.push(numericFilename);
+        }
+
+        if (dynamicFilenameTemplate) {
+          const dynamicFilename = dynamicFilenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel);
+          newI18nAssetUrlsToAdd.push(dynamicFilename);
+        }
+
+        if (newI18nAssetUrlsToAdd.length > 0) {
+          assets.js = [...assets.js, ...newI18nAssetUrlsToAdd];
+        }
+
+        cb(null, hookData);
+      });
+    });
+  }
+
+}
+
+module.exports = {
+  I18nNumericIndexHtmlInjectorPlugin
+};

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

@@ -0,0 +1,163 @@
+"use strict";
+
+const path = require('path');
+
+const {
+  sources,
+  Compilation,
+  util
+} = require('webpack');
+
+const {
+  decodeUnicodeEscapes
+} = require('../../utils/propertiesParser');
+
+const {
+  loadNumericMap,
+  loadI18nData
+} = require('./utils/i18nDataLoader');
+
+const {
+  RawSource
+} = sources;
+const pluginName = 'I18nNumericIndexPlugin';
+
+class I18nNumericIndexPlugin {
+  constructor(options = {}) {
+    this.options = { ...options,
+      singleFile: options.singleFile || false,
+      includeContentHash: options.includeContentHash || false,
+      generateManifest: options.generateManifest || false
+    };
+    this.numericMap = null;
+    this.i18nData = null;
+    this.manifest = {};
+  }
+
+  getNumericMap(compilation) {
+    if (!this.numericMap) {
+      const mapPath = path.resolve(compilation.compiler.context, this.options.numericMapPath);
+      this.numericMap = loadNumericMap(mapPath, compilation);
+    }
+
+    return this.numericMap;
+  }
+
+  getI18nData(compilation) {
+    if (!this.i18nData) {
+      this.i18nData = loadI18nData(this.options, compilation);
+    }
+
+    return this.i18nData;
+  }
+
+  generateContentHash(content, compilation) {
+    const {
+      hashFunction,
+      hashDigest,
+      hashDigestLength
+    } = compilation.outputOptions;
+    const hash = util.createHash(hashFunction || 'xxhash64');
+    hash.update(content);
+    return hash.digest(hashDigest || 'hex').substring(0, hashDigestLength || 20);
+  }
+
+  emitChunk(compilation, filename, locale, data, fileType = null) {
+    const content = decodeUnicodeEscapes(JSON.stringify(data));
+    const fileContent = `${this.options.jsonpFunc}(${content});`;
+    let outputPath = filename.replace(/\[locale\]/g, locale);
+
+    if (this.options.includeContentHash) {
+      const contentHash = this.generateContentHash(fileContent, compilation);
+      outputPath = outputPath.replace(/\.js$/, `.${contentHash}.js`);
+    }
+
+    if (this.options.generateManifest) {
+      const cleanName = filename.replace(/\[locale\]/g, locale).replace(/\.js$/, '.js');
+      const cleanNameWithType = fileType ? cleanName.replace(/\.js$/, `.${fileType}.js`) : cleanName;
+      const manifestKey = cleanNameWithType.split('/').pop(); // Extract just the filename for the key
+
+      this.manifest[manifestKey] = outputPath.split('/').pop();
+    }
+
+    compilation.emitAsset(outputPath, new RawSource(fileContent));
+    return outputPath;
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      compilation.hooks.processAssets.tapAsync({
+        name: pluginName,
+        stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+      }, (assets, callback) => {
+        if (!this.options.enable) {
+          return callback();
+        }
+
+        const {
+          sortedKeys,
+          totalKeys
+        } = this.getNumericMap(compilation);
+        const {
+          jsResourceBase,
+          allI18n,
+          locales
+        } = this.getI18nData(compilation);
+        if (!locales.length) return callback();
+        const numericKeysSet = new Set(sortedKeys);
+        const englishData = allI18n.en_US || jsResourceBase;
+        locales.forEach(locale => {
+          const localeData = allI18n[locale] || {};
+          const numericData = {};
+
+          for (let i = 0; i < totalKeys; i++) {
+            const key = sortedKeys[i];
+
+            if (key && jsResourceBase[key] !== undefined) {
+              numericData[i] = localeData[key] ?? englishData[key];
+            }
+          }
+
+          const dynamicData = {};
+          Object.keys(jsResourceBase).forEach(key => {
+            if (!numericKeysSet.has(key)) {
+              dynamicData[key] = localeData[key] ?? englishData[key];
+            }
+          });
+
+          if (this.options.singleFile) {
+            const combinedData = { ...numericData,
+              ...dynamicData
+            };
+
+            if (Object.keys(combinedData).length > 0) {
+              const filename = this.options.numericFilenameTemplate || this.options.dynamicFilenameTemplate;
+              this.emitChunk(compilation, filename, locale, combinedData);
+            }
+          } else {
+            if (Object.keys(numericData).length > 0) {
+              this.emitChunk(compilation, this.options.numericFilenameTemplate, locale, numericData, 'numeric');
+            }
+
+            if (Object.keys(dynamicData).length > 0) {
+              this.emitChunk(compilation, this.options.dynamicFilenameTemplate, locale, dynamicData, 'dynamic');
+            }
+          }
+        });
+
+        if (this.options.generateManifest && Object.keys(this.manifest).length > 0) {
+          const manifestPath = path.dirname(this.options.numericFilenameTemplate) + '/manifest.json';
+          const manifestContent = JSON.stringify(this.manifest, null, 2);
+          compilation.emitAsset(manifestPath, new RawSource(manifestContent));
+        }
+
+        callback();
+      });
+    });
+  }
+
+}
+
+module.exports = {
+  I18nNumericIndexPlugin
+};

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

@@ -0,0 +1,113 @@
+"use strict";
+
+const fs = require('fs');
+
+const path = require('path');
+
+const {
+  parseProperties
+} = require('../../../utils/propertiesParser');
+
+function loadPropertiesFile(filePath, compilation, description) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const parsed = parseProperties(content);
+    return parsed;
+  } catch (err) {
+    if (compilation) {
+      compilation.errors.push(new Error(`I18nNumericIndexPlugin: Error loading ${description}: ${err.message}`));
+    }
+
+    return {};
+  }
+}
+
+function loadNumericMap(numericMapPath, compilation) {
+  try {
+    const fileContent = fs.readFileSync(numericMapPath, 'utf-8');
+    const parsedData = JSON.parse(fileContent);
+    const sortedKeys = new Array(parsedData.totalKeysInMap);
+    Object.entries(parsedData.originalKeyToNumericId).forEach(([key, id]) => {
+      sortedKeys[id] = key;
+    });
+    return {
+      sortedKeys,
+      totalKeys: parsedData.totalKeysInMap
+    };
+  } catch (err) {
+    if (compilation) {
+      compilation.errors.push(new Error(`I18nNumericIndexPlugin: Error loading numeric map: ${err.message}`));
+    }
+
+    return {
+      sortedKeys: [],
+      totalKeys: 0
+    };
+  }
+}
+
+function loadAllLocaleFiles(propertiesPath, baseFileName, compilation) {
+  const allI18n = {};
+  const locales = [];
+
+  try {
+    const files = fs.readdirSync(propertiesPath);
+    files.forEach(file => {
+      if (file === baseFileName + '.properties') {
+        const filePath = path.join(propertiesPath, file);
+        const baseData = loadPropertiesFile(filePath, compilation, 'JSResources base');
+        allI18n['en_US'] = baseData;
+        locales.push('en_US');
+      }
+    });
+    files.forEach(file => {
+      if (!file.endsWith('.properties')) return;
+      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}`);
+        allI18n[locale] = { ...allI18n['en_US'],
+          ...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
+  };
+}
+
+function loadI18nData(options, compilation) {
+  const jsResourcePath = path.resolve(compilation.compiler.context, options.jsResourcePath);
+  const propertiesPath = path.resolve(compilation.compiler.context, options.propertiesFolderPath);
+  const baseFileName = path.basename(options.jsResourcePath, '.properties');
+  const jsResourceBase = loadPropertiesFile(jsResourcePath, compilation, 'JS resources');
+  const {
+    allI18n,
+    locales
+  } = loadAllLocaleFiles(propertiesPath, baseFileName, compilation);
+  return {
+    jsResourceBase,
+    allI18n,
+    locales
+  };
+}
+
+module.exports = {
+  loadPropertiesFile,
+  loadNumericMap,
+  loadAllLocaleFiles,
+  loadI18nData
+};

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/utils/collectAstKeys.js

@@ -0,0 +1,96 @@
+"use strict";
+
+const {
+  walk
+} = require('estree-walker');
+
+const PREFIX_I18N_COMMENT = 'I18N';
+const PREFIX_I18N_COMMENT_DYNAMIC = 'dynamic-i18n-key';
+
+function getI18nKeysFromSingleComment(commentNode, validKeysSet) {
+  const foundKeysInComment = [];
+
+  if (!commentNode || typeof commentNode.value !== 'string') {
+    return foundKeysInComment;
+  }
+
+  const commentString = commentNode.value.trim();
+  let i18nKeyStr;
+
+  if (commentString.startsWith(PREFIX_I18N_COMMENT)) {
+    i18nKeyStr = commentString.slice(PREFIX_I18N_COMMENT.length).trim();
+  } else if (commentString.startsWith(PREFIX_I18N_COMMENT_DYNAMIC)) {
+    i18nKeyStr = commentString.slice(PREFIX_I18N_COMMENT_DYNAMIC.length).trim();
+  }
+
+  if (!i18nKeyStr) {
+    return foundKeysInComment;
+  }
+
+  const potentialKeys = i18nKeyStr.split(',').map(key => key.trim()).filter(key => key);
+  potentialKeys.forEach(key => {
+    if (validKeysSet.has(key)) {
+      foundKeysInComment.push(key);
+    }
+  });
+  return foundKeysInComment;
+}
+/**
+ * Traverses an AST and its comments to collect and categorize i18n keys.
+ *
+ * @param {object} astProgramNode - The Program node of the AST.
+ * @param {object[]} commentsArray - An array of comment nodes from the AST.
+ * @param {object} allI18nKeysMasterMap - Object map of all valid i18n keys (from JSResources).
+ * @param {boolean} [isDebug=false] - Flag for verbose logging.
+ * @returns {{literalKeys: Set<string>, commentKeys: Set<string>}}
+ * literalKeys: Set of valid i18n keys found as string literals.
+ * commentKeys: Set of valid i18n keys found in comments.
+ */
+
+
+function collectAndCategorizeUsedI18nKeys(astProgramNode, commentsArray, allI18nKeysMasterMap, isDebug = false) {
+  const foundLiteralKeys = new Set();
+  const foundCommentKeys = new Set();
+  const validKeysSet = new Set(Object.keys(allI18nKeysMasterMap || {}));
+
+  if (validKeysSet.size === 0 && isDebug) {
+    console.warn('[collectAndCategorizeUsedI18nKeys] allI18nKeysMasterMap is empty. No keys can be collected.');
+  } // 1. Collect keys from AST string literals
+
+
+  if (astProgramNode) {
+    try {
+      walk(astProgramNode, {
+        enter(node) {
+          if ((node.type === 'Literal' || node.type === 'StringLiteral') && typeof node.value === 'string') {
+            if (validKeysSet.has(node.value)) {
+              foundLiteralKeys.add(node.value);
+            }
+          }
+        }
+
+      });
+    } catch (error) {
+      console.error('[collectAndCategorizeUsedI18nKeys] Error during AST walk:', error);
+    }
+  } // 2. Collect keys from comments
+
+
+  if (commentsArray && Array.isArray(commentsArray)) {
+    commentsArray.forEach(commentNode => {
+      const keysFromComment = getI18nKeysFromSingleComment(commentNode, validKeysSet);
+      keysFromComment.forEach(key => {
+        foundCommentKeys.add(key);
+      });
+    });
+  }
+
+  return {
+    literalKeys: foundLiteralKeys,
+    commentKeys: foundCommentKeys
+  };
+}
+
+module.exports = {
+  collectAndCategorizeUsedI18nKeys: collectAndCategorizeUsedI18nKeys
+};

package/lib/shared/bundler/webpack/jsLoaders.js

@@ -7,11 +7,29 @@ exports.jsLoaders = jsLoaders;
 
 var _babelLoaderConfig = require("./loaderConfigs/babelLoaderConfig");
 
+const {
+  i18nIdReplaceLoaderConfig
+} = require('./loaderConfigs/i18nIdReplaceLoaderConfig');
+
 function jsLoaders(options) {
+  const useLoaders = [];
+  useLoaders.push((0, _babelLoaderConfig.babelLoaderConfig)(options));
+  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
+    }
+  }
+
   return [{
     test: /\.js$/,
     exclude: /node_modules/,
-    use: [(0, _babelLoaderConfig.babelLoaderConfig)(options)] // include: path.join(appPath, folder)
-
+    use: useLoaders
   }];
 }

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

@@ -0,0 +1,74 @@
+"use strict";
+
+const path = require('path');
+
+const fs = require('fs');
+
+const {
+  getPropertiesAsJSON
+} = require('../custom_plugins/I18nSplitPlugin/utils/propertiesUtils');
+
+function loadJSResourcesOnce(options) {
+  let jsResourcePath;
+
+  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 i18nIdReplaceLoaderConfig(options, webpackContext) {
+  let numericMapPath;
+
+  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');
+  }
+
+  const allI18nData = loadJSResourcesOnce(options);
+
+  const i18nKeyReplaceLoaderPath = require.resolve('../loaders/i18nIdReplaceLoader.js');
+
+  const loaderOptions = {
+    allI18nData: allI18nData,
+    sourceMaps: false,
+    numericMapPath: numericMapPath,
+    includePaths: options.i18nIndexing?.loaderOptions?.includePaths || [],
+    excludePaths: options.i18nIndexing?.loaderOptions?.excludePaths || ['node_modules', 'tests']
+  };
+  return {
+    loader: i18nKeyReplaceLoaderPath,
+    options: loaderOptions
+  };
+}
+
+module.exports = {
+  i18nIdReplaceLoaderConfig
+};