@zohodesk/client_build_tool 0.0.18 → 0.0.19-i18n-exp.0

package/.claude/settings.local.json

@@ -0,0 +1,34 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(cat:*)",
+      "Bash(ls:*)",
+      "Bash(npm root:*)",
+      "Bash(grep:*)",
+      "Bash(source:*)",
+      "Bash(echo $CLAUDE_CODE_SUBAGENT_MODEL)",
+      "Bash(npm run devMode:*)",
+      "Bash(npm run start:*)",
+      "Bash(npm run build:*)",
+      "Bash(lsof:*)",
+      "Bash(xargs kill:*)",
+      "Bash(pkill:*)",
+      "Bash(node:*)",
+      "Bash(git -C /Users/ramaraj-14019/i18nIndexing_plugin/packages/client_build_tool status --short)",
+      "Bash(git -C /Users/ramaraj-14019/zoho_iM/zohoim_client/jsapps/imclient status --short)",
+      "Bash(git -C /Users/ramaraj-14019/zoho_iM/zohoim_client/jsapps/imclient diff --name-only)",
+      "Bash(git -C /Users/ramaraj-14019/zoho_iM/zohoim_client/jsapps/imclient status numericMap.json)",
+      "Bash(git -C /Users/ramaraj-14019/i18nIndexing_plugin/packages/client_build_tool status src/shared/bundler/webpack/utils/)",
+      "Bash(git -C /Users/ramaraj-14019/i18nIndexing_plugin/packages/client_build_tool show 3.0.0:src/shared/bundler/webpack/utils/)",
+      "Bash(git -C /Users/ramaraj-14019/i18nIndexing_plugin/packages/client_build_tool ls-tree:*)",
+      "Bash(git -C /Users/ramaraj-14019/i18nIndexing_plugin/packages/client_build_tool show 3.0.0:src/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/utils/propertiesUtils.js)",
+      "Bash(curl:*)",
+      "Skill(ralph-loop:ralph-loop)",
+      "Bash(kill:*)",
+      "Bash(npm install:*)",
+      "Bash(npm run createEfc:*)",
+      "Bash(npm run i18n-sync:*)",
+      "Bash(git push:*)"
+    ]
+  }
+}

package/lib/schemas/defaultConfigValues.js

@@ -179,6 +179,27 @@ var _default = {
     jsResource: null,
     propertiesFolder: null
   },
+  i18nIndexing: {
+    enable: {
+      value: false,
+      cli: 'i18n_indexing'
+    },
+    jsResourcePath: null,
+    propertiesFolderPath: null,
+    numericMapPath: null,
+    outputFolder: 'i18n-chunk',
+    numericFilenameTemplate: 'i18n-chunk/[locale]/numeric.i18n.js',
+    dynamicFilenameTemplate: 'i18n-chunk/[locale]/dynamic.i18n.js',
+    singleFile: false,
+    singleFileTemplate: '[locale].js',
+    jsonpFunc: 'window.loadI18nChunk',
+    htmlTemplateLabel: '{{--user-locale}}',
+    localeVarName: 'window.userLangCode',
+    includeContentHash: false,
+    emitFiles: true,
+    generateManifest: false,
+    manifestPath: null
+  },
   publicFolders: {
     dev: ['...'],
     prod: ['...']

package/lib/schemas/defaultConfigValuesOnly.js

@@ -96,6 +96,24 @@ var _default = {
     jsResource: null,
     propertiesFolder: null
   },
+  i18nIndexing: {
+    enable: false,
+    jsResourcePath: null,
+    propertiesFolderPath: null,
+    numericMapPath: null,
+    outputFolder: 'i18n-chunk',
+    numericFilenameTemplate: 'i18n-chunk/[locale]/numeric.i18n.js',
+    dynamicFilenameTemplate: 'i18n-chunk/[locale]/dynamic.i18n.js',
+    singleFile: false,
+    singleFileTemplate: '[locale].js',
+    jsonpFunc: 'window.loadI18nChunk',
+    htmlTemplateLabel: '{{--user-locale}}',
+    localeVarName: 'window.userLangCode',
+    includeContentHash: false,
+    emitFiles: true,
+    generateManifest: false,
+    manifestPath: null
+  },
   publicFolders: {
     dev: ['...'],
     prod: ['...']

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

@@ -0,0 +1,195 @@
+"use strict";
+
+const path = require('path');
+
+const {
+  sources,
+  Compilation
+} = require('webpack');
+
+const {
+  decodeUnicodeEscapes
+} = require('../I18nSplitPlugin/utils/propertiesUtils');
+
+const {
+  loadNumericMap,
+  loadI18nData
+} = require('./utils/i18nDataLoader');
+
+const {
+  createHash
+} = require('../I18nSplitPlugin/createHash');
+
+const {
+  pathCreator
+} = require('../I18nSplitPlugin/pathCreator');
+
+const {
+  RawSource
+} = sources;
+const pluginName = 'I18nNumericIndexPlugin';
+
+class I18nNumericIndexPlugin {
+  constructor(options) {
+    if (!options) {
+      throw new Error('[I18nNumericIndexPlugin] options is required');
+    }
+
+    this.options = options;
+  }
+
+  emitChunk(compilation, filename, locale, data, manifest) {
+    const content = decodeUnicodeEscapes(JSON.stringify(data));
+    const fileContent = `${this.options.jsonpFunc}(${content});`;
+    const contentHash = createHash({
+      outputOptions: compilation.outputOptions,
+      content: fileContent
+    });
+    let outputPath = pathCreator(filename, compilation, {
+      hash: compilation.hash,
+      locale,
+      chunkName: null,
+      chunkId: locale,
+      chunkHash: null,
+      contentHash
+    });
+
+    if (this.options.includeContentHash && !filename.includes('[contenthash]')) {
+      outputPath = outputPath.replace(/\.js$/, `.${contentHash}.js`);
+    }
+
+    if (this.options.generateManifest) {
+      manifest[locale] = outputPath.split('/').pop();
+    }
+
+    if (this.options.emitFiles) {
+      compilation.emitAsset(outputPath, new RawSource(fileContent));
+    }
+
+    return outputPath;
+  }
+
+  buildNumericData(sortedKeys, totalKeys, jsResourceBase, localeData, englishData) {
+    const numericData = {};
+
+    for (let i = 0; i < totalKeys; i++) {
+      const key = sortedKeys[i];
+
+      if (key && jsResourceBase[key] !== undefined) {
+        numericData[i] = localeData[key] ?? englishData[key];
+      }
+    }
+
+    return numericData;
+  }
+
+  buildDynamicData(numericKeysSet, jsResourceBase, localeData, englishData) {
+    const dynamicData = {};
+
+    for (const key of Object.keys(jsResourceBase)) {
+      if (!numericKeysSet.has(key)) {
+        dynamicData[key] = localeData[key] ?? englishData[key];
+      }
+    }
+
+    return dynamicData;
+  }
+
+  processLocaleData(compilation, locale, {
+    sortedKeys,
+    totalKeys,
+    numericKeysSet,
+    jsResourceBase,
+    allI18n,
+    englishData,
+    manifest
+  }) {
+    const localeData = allI18n[locale] || {};
+    const numericData = this.buildNumericData(sortedKeys, totalKeys, jsResourceBase, localeData, englishData);
+    const dynamicData = this.buildDynamicData(numericKeysSet, jsResourceBase, localeData, englishData);
+
+    if (this.options.singleFile) {
+      const combinedData = { ...numericData,
+        ...dynamicData
+      };
+
+      if (Object.keys(combinedData).length > 0) {
+        const filename = `${this.options.outputFolder}/${this.options.singleFileTemplate}`;
+        this.emitChunk(compilation, filename, locale, combinedData, manifest);
+      }
+    } else {
+      if (Object.keys(numericData).length > 0) {
+        this.emitChunk(compilation, this.options.numericFilenameTemplate, locale, numericData, manifest);
+      }
+
+      if (Object.keys(dynamicData).length > 0) {
+        this.emitChunk(compilation, this.options.dynamicFilenameTemplate, locale, dynamicData, manifest);
+      }
+    }
+  }
+
+  emitManifest(compilation, manifest) {
+    if (!this.options.generateManifest || Object.keys(manifest).length === 0) {
+      return;
+    }
+
+    const manifestContent = JSON.stringify(manifest, null, 2);
+
+    if (this.options.emitFiles) {
+      compilation.emitAsset(this.options.manifestPath, new RawSource(manifestContent));
+    }
+  }
+
+  processI18nAssets(compilation) {
+    const mapPath = path.resolve(compilation.compiler.context, this.options.numericMapPath);
+    const {
+      sortedKeys,
+      totalKeys
+    } = loadNumericMap(mapPath, compilation);
+    const {
+      jsResourceBase,
+      allI18n,
+      locales
+    } = loadI18nData(this.options, compilation);
+    if (!locales.length) return;
+    const manifest = {};
+    const numericKeysSet = new Set(sortedKeys);
+    const englishData = allI18n.en_US || jsResourceBase;
+    const context = {
+      sortedKeys,
+      totalKeys,
+      numericKeysSet,
+      jsResourceBase,
+      allI18n,
+      englishData,
+      manifest
+    };
+
+    for (const locale of locales) {
+      this.processLocaleData(compilation, locale, context);
+    }
+
+    this.emitManifest(compilation, manifest);
+  }
+
+  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();
+        }
+
+        this.processI18nAssets(compilation);
+        callback();
+      });
+    });
+  }
+
+}
+
+module.exports = {
+  I18nNumericIndexPlugin
+};

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

@@ -0,0 +1,115 @@
+"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');
+    return parseProperties(content);
+  } 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 numericIds = Object.values(parsedData.originalKeyToNumericId);
+    const maxId = numericIds.length > 0 ? Math.max(...numericIds) : -1;
+    const totalKeys = maxId + 1;
+    const sortedKeys = new Array(totalKeys);
+    Object.entries(parsedData.originalKeyToNumericId).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
+    };
+  }
+}
+
+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/propertiesUtils.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.decodeUnicodeEscapes = decodeUnicodeEscapes;
 exports.getAllI18n = getAllI18n;
 exports.getPropertiesAsJSON = getPropertiesAsJSON;
 exports.jsonToString = jsonToString;
@@ -13,6 +14,10 @@ var _path = require("path");
 
 var _constants = require("../../../../../constants");
 
+function decodeUnicodeEscapes(str) {
+  return str.replace(/\\u([0-9A-Fa-f]{4})/g, (_, code) => String.fromCharCode(parseInt(code, 16)));
+}
+
 function isComment(line) {
   return line[0] === '#';
 }

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

@@ -5,13 +5,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.jsLoaders = jsLoaders;
 
-var _babelLoaderConfig = require("./loaderConfigs/babelLoaderConfig");
+var _babelLoaderConfig = require("./loaderConfigs/babelLoaderConfig.js");
+
+var _i18nIdReplaceLoaderConfig = require("./loaderConfigs/i18nIdReplaceLoaderConfig.js");
 
 function jsLoaders(options) {
+  const useLoaders = [(0, _babelLoaderConfig.babelLoaderConfig)(options)];
+  const shouldUseNumericIndexing = options.i18nIndexing?.enable || options.i18nChunkSplit?.chunkSplitEnable && options.i18nChunkSplit.useNumericIndexing;
+
+  if (shouldUseNumericIndexing) {
+    useLoaders.push((0, _i18nIdReplaceLoaderConfig.i18nIdReplaceLoaderConfig)(options));
+  }
+
   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,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.i18nIdReplaceLoaderConfig = i18nIdReplaceLoaderConfig;
+
+var _propertiesUtils = require("../custom_plugins/I18nSplitPlugin/utils/propertiesUtils.js");
+
+function getI18nConfig(options) {
+  if (options.i18nIndexing?.enable) {
+    return {
+      jsResourcePath: options.i18nIndexing.jsResourcePath,
+      numericMapPath: options.i18nIndexing.numericMapPath
+    };
+  }
+
+  if (options.i18nChunkSplit?.chunkSplitEnable && options.i18nChunkSplit.useNumericIndexing) {
+    return {
+      jsResourcePath: options.i18nChunkSplit.jsResource,
+      numericMapPath: options.i18nChunkSplit.numericMapPath
+    };
+  }
+
+  return null;
+}
+
+function loadJSResources(jsResourcePath) {
+  const i18nData = (0, _propertiesUtils.getPropertiesAsJSON)(jsResourcePath);
+
+  if (Object.keys(i18nData).length === 0) {
+    console.warn(`[i18nIdReplaceLoaderConfig] Warning: No i18n data found in JSResource file: ${jsResourcePath}`);
+    return {};
+  }
+
+  return i18nData;
+}
+
+function i18nIdReplaceLoaderConfig(options) {
+  const config = getI18nConfig(options);
+
+  if (!config) {
+    throw new Error('i18nIdReplaceLoader requires either i18nIndexing to be enabled or i18nChunkSplit with useNumericIndexing');
+  }
+
+  if (!config.jsResourcePath) {
+    throw new Error('Missing required jsResourcePath in i18n options');
+  }
+
+  if (!config.numericMapPath) {
+    throw new Error('numericMapPath is required in i18nIndexing or i18nChunkSplit config');
+  }
+
+  return {
+    loader: require.resolve('../loaders/i18nIdReplaceLoader.js'),
+    options: {
+      allI18nData: loadJSResources(config.jsResourcePath),
+      numericMapPath: config.numericMapPath,
+      sourceMaps: false
+    }
+  };
+}

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

@@ -0,0 +1,116 @@
+"use strict";
+
+const fs = require('fs');
+
+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');
+
+function loadNumericMap(numericMapPath) {
+  if (!numericMapPath) {
+    console.warn('[i18nIdReplaceLoader] numericMapPath option is missing');
+    return null;
+  }
+
+  if (!fs.existsSync(numericMapPath)) {
+    console.warn(`[i18nIdReplaceLoader] Numeric map file not found: ${numericMapPath}`);
+    return null;
+  }
+
+  try {
+    const fileContent = fs.readFileSync(numericMapPath, 'utf-8');
+    const parsedData = JSON.parse(fileContent);
+
+    if (!parsedData?.originalKeyToNumericId) {
+      console.warn(`[i18nIdReplaceLoader] Invalid numeric map format: missing 'originalKeyToNumericId'`);
+      return null;
+    }
+
+    return parsedData.originalKeyToNumericId;
+  } catch (err) {
+    console.warn(`[i18nIdReplaceLoader] Error reading numeric map: ${err.message}`);
+    return null;
+  }
+}
+
+function transformSource(source, resourcePath, numericIdMap, allI18nData, options) {
+  const ast = parser.parse(source, {
+    sourceType: 'module',
+    plugins: ['jsx', 'typescript', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator'],
+    sourceFilename: resourcePath
+  });
+  let hasTransformations = false;
+  traverse(ast, {
+    StringLiteral(path) {
+      const {
+        node
+      } = path;
+
+      if (!(node.value in allI18nData)) {
+        return;
+      }
+
+      if (node.value in numericIdMap) {
+        path.replaceWith(t.stringLiteral(String(numericIdMap[node.value])));
+        hasTransformations = true;
+      }
+    }
+
+  });
+
+  if (!hasTransformations) {
+    return null;
+  }
+
+  return generator(ast, {
+    sourceMaps: !!options.sourceMaps,
+    sourceFileName: resourcePath,
+    retainLines: false,
+    comments: true
+  }, source);
+}
+
+module.exports = function i18nIdReplaceLoader(source, map) {
+  const resourcePath = this.resourcePath;
+  if (this.cacheable) this.cacheable();
+  const options = getOptions(this) || {};
+  const callback = this.async();
+
+  if (resourcePath.includes('node_modules') || !resourcePath.includes('src')) {
+    return callback(null, source, map);
+  }
+
+  if (!options.allI18nData) {
+    return callback(null, source, map);
+  }
+
+  if (options.numericMapPath) {
+    this.addDependency(options.numericMapPath);
+  }
+
+  const numericIdMap = loadNumericMap(options.numericMapPath);
+
+  if (!numericIdMap) {
+    return callback(null, source, map);
+  }
+
+  try {
+    const output = transformSource(source, resourcePath, numericIdMap, options.allI18nData, options);
+
+    if (output) {
+      callback(null, output.code, output.map);
+    } else {
+      callback(null, source, map);
+    }
+  } catch (err) {
+    callback(err);
+  }
+};

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

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configI18nNumericIndexPlugin = configI18nNumericIndexPlugin;
+
+var _I18nNumericIndexPlugin = require("../custom_plugins/I18nNumericIndexPlugin/I18nNumericIndexPlugin.js");
+
+var _readI18nValues = require("../custom_plugins/I18nSplitPlugin/readI18nValues.js");
+
+function configI18nNumericIndexPlugin(options) {
+  if (!options.i18nIndexing?.enable) {
+    return null;
+  }
+
+  const i18nOpts = options.i18nIndexing;
+  const requiredOptions = ['jsResourcePath', 'propertiesFolderPath', 'numericMapPath', 'jsonpFunc', 'localeVarName'];
+  const missingOptions = requiredOptions.filter(opt => !i18nOpts[opt]);
+
+  if (missingOptions.length > 0) {
+    console.warn(`[configI18nNumericIndexPlugin] Missing required options: ${missingOptions.join(', ')}`);
+    return null;
+  }
+
+  if (i18nOpts.singleFile) {
+    if (!i18nOpts.singleFileTemplate) {
+      console.warn('[configI18nNumericIndexPlugin] singleFileTemplate is required when singleFile is true');
+      return null;
+    }
+  } else {
+    if (!i18nOpts.numericFilenameTemplate || !i18nOpts.numericFilenameTemplate.includes('[locale]')) {
+      console.warn('[configI18nNumericIndexPlugin] numericFilenameTemplate must include [locale] placeholder');
+      return null;
+    }
+
+    if (!i18nOpts.dynamicFilenameTemplate || !i18nOpts.dynamicFilenameTemplate.includes('[locale]')) {
+      console.warn('[configI18nNumericIndexPlugin] dynamicFilenameTemplate must include [locale] placeholder');
+      return null;
+    }
+  }
+
+  if (i18nOpts.generateManifest && !i18nOpts.manifestPath) {
+    console.warn('[configI18nNumericIndexPlugin] manifestPath is required when generateManifest is true');
+    return null;
+  }
+
+  const {
+    locales,
+    allI18nObject
+  } = (0, _readI18nValues.readI18nValues)({
+    jsResource: i18nOpts.jsResourcePath,
+    propertiesFolder: i18nOpts.propertiesFolderPath,
+    disableDefault: false
+  });
+  const numericIndexPluginOptions = {
+    enable: i18nOpts.enable,
+    jsResourcePath: i18nOpts.jsResourcePath,
+    propertiesFolderPath: i18nOpts.propertiesFolderPath,
+    numericMapPath: i18nOpts.numericMapPath,
+    locales,
+    allI18nObject,
+    outputFolder: i18nOpts.outputFolder,
+    numericFilenameTemplate: i18nOpts.numericFilenameTemplate,
+    dynamicFilenameTemplate: i18nOpts.dynamicFilenameTemplate,
+    singleFile: i18nOpts.singleFile,
+    singleFileTemplate: i18nOpts.singleFileTemplate,
+    jsonpFunc: i18nOpts.jsonpFunc,
+    includeContentHash: i18nOpts.includeContentHash,
+    emitFiles: i18nOpts.emitFiles,
+    generateManifest: i18nOpts.generateManifest,
+    manifestPath: i18nOpts.manifestPath
+  };
+  return new _I18nNumericIndexPlugin.I18nNumericIndexPlugin(numericIndexPluginOptions);
+}

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

@@ -57,10 +57,11 @@ var _configInjectChunkGraphPlugin = require("./pluginConfigs/configInjectChunkGr
 
 var _configCssCustomOrderPlugin = require("./pluginConfigs/configCssCustomOrderPlugin");
 
-// import { IgnorePlugin } from 'webpack';
+var _configI18nNumericIndexPlugin = require("./pluginConfigs/configI18nNumericIndexPlugin");
+
 function plugins(options) {
   const {
     webpackPlugins
   } = options;
-  return [(0, _configEnvVariables.configEnvVariables)(options), (0, _configCustomAttributesPlugin.configCustomAttributesPlugin)(options), (0, _configTPHashMappingPlugin.configTPHashMappingPlugin)(options), (0, _configCopyPublicFolders.configCopyPublicFolders)(options), (0, _configIgnorePlugin.configIgnorePlugin)(options), (0, _configMiniCSSExtractPlugin.configMiniCSSExtractPlugin)(options), (0, _configSelectorWeightPlugin.configSelectorWeightPlugin)(options), (0, _configVariableConversionPlugin.configVariableConversionPlugin)(options), (0, _configI18nSplitPlugin.configI18nSplitPlugin)(options), (0, _configRtlCssPlugin.configRtlCssPlugin)(options), (0, _configHtmlWebpackPlugin.configHtmlWebpackPlugin)(options), (0, _configCustomScriptLoadingStrategyPlugin.configCustomScriptLoadingStrategyPlugin)(options), (0, _configCdnChangePlugin.configCdnChangePlugin)(options), (0, _configServiceWorkerPlugin.configServiceWorkerPlugin)(options), (0, _configEFCTemplatePlugin.configEFCTemplatePlugin)(options), (0, _configResourceHintsPlugin.configResourceHintsPlugin)(options), (0, _configBundleAnalyzer.configBundleAnalyzer)(options), (0, _configManifestJsonPlugin.configManifestJsonPlugin)(options), (0, _configSourceMapPlugin.configSourceMapPlugin)(options), (0, _configProgressPlugin.configProgressPlugin)(options), (0, _configBundleIntegrityReport.configBundleIntegrityReport)(options), (0, _configRuntimeResourceCleanup.configRuntimeResourceCleanup)(options), (0, _configMurphyInjectorPlugin.configMurphyInjectorPlugin)(options), (0, _configCssCustomOrderPlugin.configCssCustomOrderPlugin)(options), (0, _configChunkHierarchyPlugin.configChunkHierarchyPlugin)(options), ...webpackPlugins].filter(Boolean);
+  return [(0, _configEnvVariables.configEnvVariables)(options), (0, _configCustomAttributesPlugin.configCustomAttributesPlugin)(options), (0, _configTPHashMappingPlugin.configTPHashMappingPlugin)(options), (0, _configCopyPublicFolders.configCopyPublicFolders)(options), (0, _configIgnorePlugin.configIgnorePlugin)(options), (0, _configMiniCSSExtractPlugin.configMiniCSSExtractPlugin)(options), (0, _configSelectorWeightPlugin.configSelectorWeightPlugin)(options), (0, _configVariableConversionPlugin.configVariableConversionPlugin)(options), (0, _configI18nSplitPlugin.configI18nSplitPlugin)(options), (0, _configRtlCssPlugin.configRtlCssPlugin)(options), (0, _configHtmlWebpackPlugin.configHtmlWebpackPlugin)(options), (0, _configI18nNumericIndexPlugin.configI18nNumericIndexPlugin)(options), (0, _configCustomScriptLoadingStrategyPlugin.configCustomScriptLoadingStrategyPlugin)(options), (0, _configCdnChangePlugin.configCdnChangePlugin)(options), (0, _configServiceWorkerPlugin.configServiceWorkerPlugin)(options), (0, _configEFCTemplatePlugin.configEFCTemplatePlugin)(options), (0, _configResourceHintsPlugin.configResourceHintsPlugin)(options), (0, _configBundleAnalyzer.configBundleAnalyzer)(options), (0, _configManifestJsonPlugin.configManifestJsonPlugin)(options), (0, _configSourceMapPlugin.configSourceMapPlugin)(options), (0, _configProgressPlugin.configProgressPlugin)(options), (0, _configBundleIntegrityReport.configBundleIntegrityReport)(options), (0, _configRuntimeResourceCleanup.configRuntimeResourceCleanup)(options), (0, _configMurphyInjectorPlugin.configMurphyInjectorPlugin)(options), (0, _configCssCustomOrderPlugin.configCssCustomOrderPlugin)(options), (0, _configChunkHierarchyPlugin.configChunkHierarchyPlugin)(options), ...webpackPlugins].filter(Boolean);
 }

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

@@ -0,0 +1,36 @@
+"use strict";
+
+const fs = require('fs');
+
+function decodeUnicodeEscapes(str) {
+  return str.replace(/\\u([0-9A-Fa-f]{4})/g, (_, code) => String.fromCharCode(parseInt(code, 16)));
+}
+
+function parseProperties(content) {
+  const result = {};
+  const lines = content.split(/\r?\n/);
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('!')) {
+      continue;
+    }
+
+    const separatorIndex = trimmed.search(/[=:]/);
+    if (separatorIndex === -1) continue;
+    const key = trimmed.slice(0, separatorIndex).trim().replace(/\\ /g, ' ');
+    const value = trimmed.slice(separatorIndex + 1).trim();
+
+    if (key) {
+      result[key] = decodeUnicodeEscapes(value);
+    }
+  }
+
+  return result;
+}
+
+module.exports = {
+  decodeUnicodeEscapes,
+  parseProperties
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/client_build_tool",
-  "version": "0.0.18",
+  "version": "0.0.19-i18n-exp.0",
   "description": "A CLI tool to  build  web applications and client libraries",
   "main": "lib/index.js",
   "bin": {