@zohodesk/client_build_tool 0.0.9-exp.4 → 0.0.9-exp.8

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

@@ -0,0 +1,94 @@
+"use strict";
+
+const path = require('path');
+
+const fs = require('fs');
+
+let allI18nDataFromPropertiesCache = null;
+
+function loadJSResourcesOnce(options) {
+  if (allI18nDataFromPropertiesCache) {
+    return allI18nDataFromPropertiesCache;
+  }
+
+  let resourcePathToLoad = '';
+
+  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;
+  }
+
+  const propertiesFilePath = path.resolve(process.cwd(), resourcePathToLoad);
+  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;
+        }
+      }
+    });
+  } catch (err) {// Silent error handling
+  }
+
+  allI18nDataFromPropertiesCache = i18nData;
+  return allI18nDataFromPropertiesCache;
+}
+
+function i18nIdReplaceLoaderConfig(options) {
+  const allI18nData = loadJSResourcesOnce(options);
+
+  const i18nKeyReplaceLoaderPath = require.resolve('../loaders/i18nIdReplaceLoader.js');
+
+  const loaderOptions = {
+    allI18nData: allI18nData,
+    sourceMaps: !!options.devtool && options.devtool.includes('source-map'),
+    isDebug: options.mode === 'development'
+  };
+
+  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
+  };
+}
+
+module.exports = {
+  i18nIdReplaceLoaderConfig
+};

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

@@ -0,0 +1,201 @@
+"use strict";
+
+const fs = require('fs');
+
+const path = require('path');
+
+const parser = require('@babel/parser');
+
+const generator = require('@babel/generator').default;
+
+const {
+  walk
+} = require('estree-walker');
+
+const {
+  getOptions
+} = require('loader-utils');
+
+let collectAndCategorizeUsedI18nKeys, generateShortHash;
+
+try {
+  collectAndCategorizeUsedI18nKeys = require('../custom_plugins/I18nSplitPlugin/utils/collectAstKeys').collectAndCategorizeUsedI18nKeys;
+  generateShortHash = require('../common/hashUtils').generateShortHash;
+} catch (e) {
+  collectAndCategorizeUsedI18nKeys = () => ({
+    literalKeys: new Set(),
+    commentKeys: new Set()
+  });
+
+  generateShortHash = key => key;
+}
+
+const LOADER_PREFIX = '[i18nIdReplaceLoader]';
+let numericIdMapDataCache = null;
+let mapLoadAttemptedForPath = {};
+
+function loadNumericIdMap(loaderContext, mapPath) {
+  if (!mapPath) {
+    loaderContext.emitWarning(new Error(`${LOADER_PREFIX} Numeric map path not provided in loader options.`));
+    return null;
+  }
+
+  if (numericIdMapDataCache && mapLoadAttemptedForPath[mapPath]) {
+    return numericIdMapDataCache;
+  }
+
+  mapLoadAttemptedForPath[mapPath] = true;
+
+  try {
+    if (fs.existsSync(mapPath)) {
+      const fileContent = fs.readFileSync(mapPath, 'utf-8');
+      const parsedData = JSON.parse(fileContent);
+
+      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;
+    }
+  } catch (err) {
+    loaderContext.emitError(new Error(`${LOADER_PREFIX} Error loading or parsing pre-generated i18n map from ${mapPath}: ${err.message}`));
+    numericIdMapDataCache = null;
+  }
+
+  return numericIdMapDataCache;
+}
+
+module.exports = function i18nIdReplaceLoader(source, map, meta) {
+  const resourcePath = this.resourcePath;
+  this.cacheable && this.cacheable();
+  const options = getOptions(this) || {};
+  const callback = this.async();
+  const loaderContext = this;
+
+  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);
+  }
+
+  let useNumericIndexing = options.useNumericIndexing !== undefined ? options.useNumericIndexing : true;
+  let localOriginalKeyToNumericIdMap = null;
+
+  if (useNumericIndexing) {
+    localOriginalKeyToNumericIdMap = loadNumericIdMap(this, options.numericMapPath);
+  }
+
+  const fallbackToHash = options.fallbackToHash !== undefined ? options.fallbackToHash : true;
+
+  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 (literalKeys.size > 0) {
+        this._module.buildInfo.loaderIdentifiedLiteralI18nKeys = Array.from(literalKeys);
+      }
+
+      if (commentKeys.size > 0) {
+        this._module.buildInfo.loaderIdentifiedCommentI18nKeys = Array.from(commentKeys);
+      }
+    }
+
+    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;
+
+        if ((node.type === 'Literal' || node.type === 'StringLiteral') && typeof node.value === 'string') {
+          const originalValue = node.value;
+
+          if (keysToReplaceInLiterals.has(originalValue)) {
+            let replaced = false;
+
+            if (useNumericIndexing && localOriginalKeyToNumericIdMap) {
+              const numericId = localOriginalKeyToNumericIdMap[originalValue];
+
+              if (numericId !== undefined) {
+                const numericLiteralNode = {
+                  type: 'NumericLiteral',
+                  value: numericId
+                };
+                let replacementNode = numericLiteralNode;
+
+                if (parent && parent.type === 'JSXAttribute' && parent.value === node) {
+                  replacementNode = {
+                    type: 'JSXExpressionContainer',
+                    expression: numericLiteralNode
+                  };
+                }
+
+                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}`));
+              }
+            }
+          }
+        }
+      }
+    });
+
+    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})`);
+
+    if (err.loc) {
+      detailedError.message += ` at line ${err.loc.line}, column ${err.loc.column}`;
+    }
+
+    callback(detailedError);
+  }
+};

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

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configI18nNumericIndexPlugin = configI18nNumericIndexPlugin;
+
+var {
+  I18nNumericIndexPlugin
+} = require("@zohodesk/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nNumericIndexPlugin/I18nNumericIndexPlugin");
+
+var {
+  I18nNumericIndexHtmlInjectorPlugin
+} = require("../custom_plugins/I18nNumericIndexPlugin/I18nNumericIndexHtmlInjectorPlugin");
+
+var {
+  readI18nValues
+} = require('../custom_plugins/I18nSplitPlugin/readI18nValues');
+
+const path = require('path');
+
+function urlConcat(strPath) {
+  if (strPath && typeof strPath === 'string' && !strPath.endsWith('/')) {
+    return strPath + '/';
+  }
+
+  return strPath;
+}
+
+function urlJoin(...args) {
+  return args.map(part => typeof part === 'string' ? part.replace(/(^\/+|\/+$)/g, '') : '').filter(part => part !== '').join('/');
+}
+
+function configI18nNumericIndexPlugin(options) {
+  if (!(options.i18nIndexing && options.i18nIndexing.enable)) {
+    return null;
+  }
+
+  const i18nOpts = options.i18nIndexing;
+  const cdnConfig = options.cdnMapping || {};
+  const {
+    locales,
+    allI18nObject
+  } = readI18nValues({
+    jsResource: i18nOpts.jsResourcePath,
+    propertiesFolder: i18nOpts.propertiesFolderPath,
+    disableDefault: i18nOpts.disableDefaultMerge !== undefined ? i18nOpts.disableDefaultMerge : 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';
+  let i18nAssetsPublicPathPrefix = '';
+
+  if (cdnConfig.isCdnEnabled) {
+    if (cdnConfig.i18nTemplate) {
+      i18nAssetsPublicPathPrefix = urlConcat(cdnConfig.i18nTemplate);
+    } else if (cdnConfig.jsTemplate) {
+      i18nAssetsPublicPathPrefix = urlConcat(cdnConfig.jsTemplate);
+    } else {
+      const defaultCdnDomainPlaceholder = '//{{--js-static-domain}}';
+      i18nAssetsPublicPathPrefix = urlConcat(urlJoin(defaultCdnDomainPlaceholder, options.publicPath === undefined ? '' : options.publicPath));
+    }
+  } else {
+    i18nAssetsPublicPathPrefix = urlConcat(options.publicPath === undefined ? '' : options.publicPath);
+  }
+
+  const pluginBaseOptions = {
+    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
+  };
+  const htmlInjectorOptions = { ...pluginBaseOptions,
+    i18nAssetsPublicPathPrefix: i18nAssetsPublicPathPrefix,
+    cspNoncePlaceholder: i18nOpts.cspNoncePlaceholder || '{{--CSP-nonce}}'
+  };
+  return [new I18nNumericIndexPlugin(pluginBaseOptions), new I18nNumericIndexHtmlInjectorPlugin(htmlInjectorOptions)];
+}

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

@@ -49,10 +49,29 @@ var _configRuntimeResourceCleanup = require("./pluginConfigs/configRuntimeResour
 
 var _configCustomScriptLoadingStrategyPlugin = require("./pluginConfigs/configCustomScriptLoadingStrategyPlugin");
 
-// 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), ...webpackPlugins].filter(Boolean);
+  const pluginConfigurations = [(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, _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)];
+
+  if (options.i18nIndexing && options.i18nIndexing.enable) {
+    const newI18nPlugins = configI18nNumericIndexPlugin(options);
+
+    if (newI18nPlugins) {
+      pluginConfigurations.push(...newI18nPlugins);
+    }
+  } else {
+    const configI18nSplitPlugin = (0, _configI18nSplitPlugin.configI18nSplitPlugin)(options);
+
+    if (configI18nSplitPlugin) {
+      pluginConfigurations.push(configI18nSplitPlugin);
+    }
+  }
+
+  return [...pluginConfigurations, ...webpackPlugins].filter(Boolean);
 }

package/lib/shared/server/mockApiHandler.js

@@ -44,13 +44,6 @@ function handleMockApi(mockEntryFile, app) {
   const entryFilePath = (0, _constants.joinWithAppPath)(mockEntryFile); // eslint-disable-next-line no-use-before-define
 
   const mockFunc = safeRequire(entryFilePath);
-
-  if (typeof mockFunc === 'function') {
-    // eslint-disable-next-line no-use-before-define
-    mockFunc(app);
-    return;
-  }
-
   mockFunc?.mockApi?.(app);
 } // function handleMockApi(params) {
 // }