@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/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
@@ -31,6 +31,18 @@ function urlJoin(...args) {
   return args.map(part => typeof part === 'string' ? part.replace(/(^\/+|\/+$)/g, '') : '').filter(part => part !== '').join('/');
 }
 
+function validateAndGetFilenameTemplate(template, chunkType) {
+  if (!template || typeof template !== 'string') {
+    throw new Error(`Missing required ${chunkType} filename template in i18nIndexing options`);
+  }
+
+  if (!template.includes('[locale]')) {
+    throw new Error(`${chunkType} filename template must include '[locale]' placeholder: ${template}`);
+  }
+
+  return template;
+}
+
 function configI18nNumericIndexPlugin(options) {
   if (!(options.i18nIndexing && options.i18nIndexing.enable)) {
     return null;
@@ -38,43 +50,52 @@ function configI18nNumericIndexPlugin(options) {
 
   const i18nOpts = options.i18nIndexing;
   const cdnConfig = options.cdnMapping || {};
+
+  if (!i18nOpts.jsResourcePath) {
+    throw new Error('Missing required jsResourcePath in i18nIndexing options');
+  }
+
+  if (!i18nOpts.propertiesFolderPath) {
+    throw new Error('Missing required propertiesFolderPath in i18nIndexing options');
+  }
+
+  if (!i18nOpts.numericMapPath) {
+    throw new Error('Missing required numericMapPath in i18nIndexing options');
+  }
+
+  if (!i18nOpts.jsonpFunc) {
+    throw new Error('Missing required jsonpFunc in i18nIndexing options');
+  }
+
+  if (!i18nOpts.htmlTemplateLabel) {
+    throw new Error('Missing required htmlTemplateLabel in i18nIndexing options');
+  }
+
+  if (!i18nOpts.localeVarName) {
+    throw new Error('Missing required localeVarName in i18nIndexing options');
+  }
+
+  console.log('I18n Indexing Options:', {
+    enable: i18nOpts.enable,
+    jsResourcePath: i18nOpts.jsResourcePath,
+    propertiesFolderPath: i18nOpts.propertiesFolderPath,
+    numericMapPath: i18nOpts.numericMapPath,
+    numericFilenameTemplate: i18nOpts.numericFilenameTemplate,
+    dynamicFilenameTemplate: i18nOpts.dynamicFilenameTemplate,
+    jsonpFunc: i18nOpts.jsonpFunc,
+    htmlTemplateLabel: i18nOpts.htmlTemplateLabel,
+    localeVarName: i18nOpts.localeVarName
+  });
   const {
     locales,
     allI18nObject
   } = readI18nValues({
     jsResource: i18nOpts.jsResourcePath,
     propertiesFolder: i18nOpts.propertiesFolderPath,
-    disableDefault: i18nOpts.disableDefaultMerge !== undefined ? i18nOpts.disableDefaultMerge : false
+    disableDefault: false
   });
-  const hardcodedDefaultNumericTemplate = 'i18n-chunks/[locale]/numeric.i18n.js';
-  const hardcodedDefaultDynamicTemplate = 'i18n-chunks/[locale]/dynamic.i18n.js';
-  let numericFilenameTemplate = i18nOpts.numericFilenameTemplate || hardcodedDefaultNumericTemplate;
-  let dynamicFilenameTemplate = i18nOpts.dynamicFilenameTemplate || hardcodedDefaultDynamicTemplate;
-
-  if (i18nOpts.numericFilenameTemplate === undefined) {
-    // Check if explicitly undefined or missing
-    const i18nSplitFilename = options.i18nChunkSplit && options.i18nChunkSplit.filename;
-
-    if (i18nSplitFilename && typeof i18nSplitFilename === 'string') {
-      // This adaptation logic might need to be more robust
-      numericFilenameTemplate = `i18n-chunks/[locale]/${path.basename(i18nSplitFilename).replace(/(\.i18n)?\.js$/, '.numeric.i18n.js')}`;
-    } else {
-      numericFilenameTemplate = hardcodedDefaultNumericTemplate;
-    }
-  }
-
-  if (i18nOpts.dynamicFilenameTemplate === undefined) {
-    const i18nSplitFilename = options.i18nChunkSplit && options.i18nChunkSplit.filename;
-
-    if (i18nSplitFilename && typeof i18nSplitFilename === 'string') {
-      dynamicFilenameTemplate = `i18n-chunks/[locale]/${path.basename(i18nSplitFilename).replace(/(\.i18n)?\.js$/, '.dynamic.i18n.js')}`;
-    } else {
-      dynamicFilenameTemplate = hardcodedDefaultDynamicTemplate;
-    }
-  }
-
-  const htmlTemplateLabel = i18nOpts.htmlTemplateLabel || '{{--user-locale}}';
-  const defaultJsonpFunc = options.i18nChunkSplit && options.i18nChunkSplit.jsonpFunc || 'window.loadI18nChunk';
+  const numericFilenameTemplate = validateAndGetFilenameTemplate(i18nOpts.numericFilenameTemplate, 'numericFilenameTemplate');
+  const dynamicFilenameTemplate = validateAndGetFilenameTemplate(i18nOpts.dynamicFilenameTemplate, 'dynamicFilenameTemplate');
   let i18nAssetsPublicPathPrefix = '';
 
   if (cdnConfig.isCdnEnabled) {
@@ -90,24 +111,32 @@ function configI18nNumericIndexPlugin(options) {
     i18nAssetsPublicPathPrefix = urlConcat(options.publicPath === undefined ? '' : options.publicPath);
   }
 
-  const pluginBaseOptions = {
+  const numericIndexPluginOptions = {
+    enable: i18nOpts.enable,
+    jsResourcePath: i18nOpts.jsResourcePath,
+    propertiesFolderPath: i18nOpts.propertiesFolderPath,
+    numericMapPath: i18nOpts.numericMapPath,
     locales,
     allI18nObject,
-    numericMapPath: i18nOpts.numericMapPath,
-    numericJsonpFunc: i18nOpts.numericJsonpFunc || defaultJsonpFunc,
-    dynamicJsonpFunc: i18nOpts.dynamicJsonpFunc || defaultJsonpFunc,
-    numericFilenameTemplate,
-    // This will now include "i18n-chunks/[locale]/"
-    dynamicFilenameTemplate,
-    // This will now include "i18n-chunks/[locale]/"
-    moduleType: 'i18n/mini-extract',
-    mainChunkName: options.i18nChunkSplit && options.i18nChunkSplit.mainChunkName || 'main',
-    htmlTemplateLabel,
-    localeVarName: i18nOpts.localeVarName
+    numericFilenameTemplate: numericFilenameTemplate,
+    dynamicFilenameTemplate: dynamicFilenameTemplate,
+    numericJsonpFunction: i18nOpts.jsonpFunc,
+    dynamicJsonpFunction: i18nOpts.jsonpFunc,
+    moduleType: 'i18n/mini-extract'
   };
-  const htmlInjectorOptions = { ...pluginBaseOptions,
+  const htmlInjectorOptions = {
+    locales,
+    numericFilenameTemplate: numericFilenameTemplate,
+    numericJsonpFunc: i18nOpts.jsonpFunc,
+    dynamicFilenameTemplate: dynamicFilenameTemplate,
+    dynamicJsonpFunc: i18nOpts.jsonpFunc,
+    mainChunkName: options.i18nChunkSplit && options.i18nChunkSplit.mainChunkName || 'main',
+    htmlTemplateLabel: i18nOpts.htmlTemplateLabel,
+    localeVarName: i18nOpts.localeVarName,
     i18nAssetsPublicPathPrefix: i18nAssetsPublicPathPrefix,
     cspNoncePlaceholder: i18nOpts.cspNoncePlaceholder || '{{--CSP-nonce}}'
   };
-  return [new I18nNumericIndexPlugin(pluginBaseOptions), new I18nNumericIndexHtmlInjectorPlugin(htmlInjectorOptions)];
+  const i18nNumericPluginInstance = new I18nNumericIndexPlugin(numericIndexPluginOptions);
+  const htmlInjectorPluginInstance = new I18nNumericIndexHtmlInjectorPlugin(htmlInjectorOptions);
+  return [i18nNumericPluginInstance, htmlInjectorPluginInstance];
 }

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
+};