@zohodesk/client_build_tool 0.0.1-0.exp.0.0.9 → 0.0.1-0.exp.1.0.3

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

@@ -5,121 +5,70 @@ const path = require('path');
 const fs = require('fs');
 
 const {
-  parseProperties
-} = require('../utils/propertiesParser'); // Improved caching with proper cleanup
-
-
-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();
-  }
-
-}
-
-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 (cached) {
-    return cached;
+  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 (!fs.existsSync(propertiesFilePath)) {
-    throw new Error(`JSResource file not found at: ${propertiesFilePath}`);
+  if (!jsResourcePath) {
+    throw new Error('Missing required jsResourcePath in i18n options');
   }
 
   try {
-    const data = fs.readFileSync(propertiesFilePath, {
-      encoding: 'utf-8'
-    });
-    const i18nData = parseProperties(data);
+    const i18nData = getPropertiesAsJSON(jsResourcePath);
 
     if (Object.keys(i18nData).length === 0) {
-      throw new Error(`No i18n data found in JSResource file: ${propertiesFilePath}`);
-    } // Cache the result
-
+      console.warn(`[i18nIdReplaceLoaderConfig] Warning: No i18n data found in JSResource file: ${jsResourcePath}`);
+      return {};
+    }
 
-    configCache.setI18nData(propertiesFilePath, i18nData);
     return i18nData;
   } catch (err) {
-    throw new Error(`Error reading JSResource file ${propertiesFilePath}: ${err.message}`);
+    throw new Error(`Error reading JSResource file ${jsResourcePath}: ${err.message}`);
   }
 }
 
 function i18nIdReplaceLoaderConfig(options, webpackContext) {
-  // Validate required options
-  if (!options.i18nIndexing || !options.i18nIndexing.enable) {
-    throw new Error('i18nIdReplaceLoader requires i18nIndexing to be enabled');
+  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 (!options.i18nIndexing.numericMapPath) {
-    throw new Error('Missing required numericMapPath in i18nIndexing options');
-  } // Load i18n data with proper context
-
-
-  const allI18nData = loadJSResourcesOnce(options, webpackContext);
+  if (!numericMapPath) {
+    throw new Error('numericMapPath is required in i18nIndexing or i18nChunkSplit config');
+  }
 
-  const i18nKeyReplaceLoaderPath = require.resolve('../loaders/i18nIdReplaceLoader.js'); // Enhanced loader options with better defaults
+  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',
-    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
+    sourceMaps: false,
+    numericMapPath: numericMapPath,
+    includePaths: options.i18nIndexing?.loaderOptions?.includePaths || [],
+    excludePaths: options.i18nIndexing?.loaderOptions?.excludePaths || ['node_modules', 'tests']
   };
   return {
     loader: i18nKeyReplaceLoaderPath,
     options: loaderOptions
   };
-} // Export cache for potential cleanup
-
-
-function clearCache() {
-  configCache.clear();
 }
 
 module.exports = {
-  i18nIdReplaceLoaderConfig,
-  clearCache
+  i18nIdReplaceLoaderConfig
 };

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

@@ -1,229 +1,105 @@
 "use strict";
 
-const fs = require('fs').promises;
-
-const fsSync = require('fs');
+const fs = require('fs');
 
 const path = require('path');
 
 const parser = require('@babel/parser');
 
+const traverse = require('@babel/traverse').default;
+
 const generator = require('@babel/generator').default;
 
-const {
-  walk
-} = require('estree-walker');
+const t = require('@babel/types');
 
 const {
   getOptions
 } = require('loader-utils');
 
-let collectAndCategorizeUsedI18nKeys;
-
-try {
-  collectAndCategorizeUsedI18nKeys = require('../custom_plugins/I18nSplitPlugin/utils/collectAstKeys').collectAndCategorizeUsedI18nKeys;
-} catch (e) {
-  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
-  }
+module.exports = function i18nIdReplaceLoader(source, map) {
+  const resourcePath = this.resourcePath;
+  this.cacheable && this.cacheable();
+  const options = getOptions(this) || {};
+  const callback = this.async();
 
-  getNumericMap(mapPath) {
-    return this.numericMapCache.get(mapPath);
-  }
+  if (options.excludePaths) {
+    const shouldExclude = options.excludePaths.some(excludePath => resourcePath.includes(excludePath));
 
-  setNumericMap(mapPath, data) {
-    if (this.numericMapCache.size >= this.maxCacheSize) {
-      // Clear oldest entries
-      const firstKey = this.numericMapCache.keys().next().value;
-      this.numericMapCache.delete(firstKey);
+    if (shouldExclude) {
+      return callback(null, source, map);
     }
-
-    this.numericMapCache.set(mapPath, data);
   }
 
-  clear() {
-    this.numericMapCache.clear();
-    this.astCache.clear();
-  }
-
-}
+  if (options.includePaths && options.includePaths.length > 0) {
+    const shouldInclude = options.includePaths.some(includePath => resourcePath.includes(includePath));
 
-const loaderCache = new LoaderCache();
-
-async function loadNumericIdMap(loaderContext, mapPath) {
-  if (!mapPath) {
-    throw new Error(`${LOADER_PREFIX} Numeric map path not provided in loader options.`);
+    if (!shouldInclude) {
+      return callback(null, source, map);
+    }
   }
 
-  const absoluteMapPath = path.isAbsolute(mapPath) ? mapPath : path.resolve(loaderContext.rootContext || process.cwd(), mapPath); // Check cache first
-
-  const cached = loaderCache.getNumericMap(absoluteMapPath);
-
-  if (cached) {
-    return cached;
+  if (!options.allI18nData || Object.keys(options.allI18nData).length === 0) {
+    return callback(new Error(`i18nIdReplaceLoader: 'allI18nData' option is missing or empty`));
   }
 
-  try {
-    // 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
+  let numericIdMap = null;
 
+  if (options.numericMapPath) {
+    try {
+      if (fs.existsSync(options.numericMapPath)) {
+        const fileContent = fs.readFileSync(options.numericMapPath, 'utf-8');
+        const parsedData = JSON.parse(fileContent);
 
-    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'`);
+        if (parsedData && parsedData.originalKeyToNumericId) {
+          numericIdMap = parsedData.originalKeyToNumericId;
+        }
+      }
+    } catch (err) {// ignore - optional file
     }
-
-    const numericIdMap = parsedData.originalKeyToNumericId; // Cache the result
-
-    loaderCache.setNumericMap(absoluteMapPath, numericIdMap);
-    return numericIdMap;
-  } catch (err) {
-    throw new Error(`${LOADER_PREFIX} Error loading or parsing pre-generated i18n map from ${absoluteMapPath}: ${err.message}`);
   }
-}
 
-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; // Validate required options
-
-  if (!options.allI18nData || typeof options.allI18nData !== 'object' || Object.keys(options.allI18nData).length === 0) {
-    return callback(new Error(`${LOADER_PREFIX} [${resourcePath}] 'allI18nData' option is missing or empty.`));
+  if (!numericIdMap) {
+    return callback(null, source, map);
   }
 
-  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 = {};
-        }
-
-        if (literalKeys.size > 0) {
-          this._module.buildInfo.loaderIdentifiedLiteralI18nKeys = Array.from(literalKeys);
-        }
-
-        if (commentKeys.size > 0) {
-          this._module.buildInfo.loaderIdentifiedCommentI18nKeys = Array.from(commentKeys);
+  try {
+    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 (!options.allI18nData.hasOwnProperty(node.value)) {
+          return;
         }
-      } // Early return if no replacements needed
-
-
-      if (literalKeys.size === 0) {
-        return callback(null, source, map);
-      }
 
-      let replacementMade = false;
-      let replacementCount = 0; // Process AST and replace string literals with numeric IDs
-
-      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 (literalKeys.has(originalValue)) {
-              const numericId = numericIdMap[originalValue];
-
-              if (numericId !== undefined) {
-                const numericLiteralNode = {
-                  type: 'NumericLiteral',
-                  value: numericId,
-                  raw: String(numericId)
-                };
-                let replacementNode = numericLiteralNode; // Handle JSX attributes specially
-
-                if (parent && parent.type === 'JSXAttribute' && parent.value === node) {
-                  replacementNode = {
-                    type: 'JSXExpressionContainer',
-                    expression: numericLiteralNode
-                  };
-                }
-
-                walkerControl.replace(replacementNode);
-                replacementMade = true;
-                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`);
+        if (numericIdMap.hasOwnProperty(node.value)) {
+          const numericId = String(numericIdMap[node.value]);
+          path.replaceWith(t.stringLiteral(numericId));
+          hasTransformations = true;
         }
-
-        callback(null, output.code, options.sourceMaps && output.map ? output.map : map);
-      } else {
-        callback(null, source, map);
       }
-    } catch (err) {
-      // Enhanced error handling with better context
-      const detailedError = new Error(`${LOADER_PREFIX} [${resourcePath}] AST Processing Error: ${err.message}`);
 
-      if (err.loc && err.loc.line) {
-        detailedError.message += ` at line ${err.loc.line}, column ${err.loc.column}`;
-      } // Add stack trace in debug mode
-
-
-      if (options.isDebug && err.stack) {
-        detailedError.message += `\nStack: ${err.stack}`;
-      }
-
-      callback(detailedError);
+    });
+
+    if (hasTransformations) {
+      const output = generator(ast, {
+        sourceMaps: !!options.sourceMaps,
+        sourceFileName: resourcePath,
+        retainLines: false,
+        comments: true
+      }, source);
+      callback(null, output.code, output.map);
+    } else {
+      callback(null, source, map);
     }
-  }).catch(err => {
-    // Handle async errors from map loading
-    callback(new Error(`${LOADER_PREFIX} [${resourcePath}] Failed to load numeric map: ${err.message}`));
-  });
+  } catch (err) {
+    callback(err);
+  }
 };

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

@@ -5,43 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.configI18nNumericIndexPlugin = configI18nNumericIndexPlugin;
 
-var {
-  I18nNumericIndexPlugin
-} = require("../custom_plugins/I18nNumericIndexPlugin/I18nNumericIndexPlugin");
+var _I18nNumericIndexPlugin = require("../custom_plugins/I18nNumericIndexPlugin/I18nNumericIndexPlugin");
 
-var {
-  I18nNumericIndexHtmlInjectorPlugin
-} = require("../custom_plugins/I18nNumericIndexPlugin/I18nNumericIndexHtmlInjectorPlugin");
+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 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;
-}
+var _readI18nValues = require("../custom_plugins/I18nSplitPlugin/readI18nValues");
 
 function configI18nNumericIndexPlugin(options) {
   if (!(options.i18nIndexing && options.i18nIndexing.enable)) {
@@ -50,67 +18,32 @@ function configI18nNumericIndexPlugin(options) {
 
   const i18nOpts = options.i18nIndexing;
   const cdnConfig = options.cdnMapping || {};
+  const requiredOptions = ['jsResourcePath', 'propertiesFolderPath', 'numericMapPath', 'jsonpFunc', 'htmlTemplateLabel', 'localeVarName', 'numericFilenameTemplate', 'dynamicFilenameTemplate'];
+  const missingOptions = requiredOptions.filter(opt => !i18nOpts[opt]);
 
-  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');
+  if (missingOptions.length > 0) {
+    return null;
   }
 
-  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({
+  } = (0, _readI18nValues.readI18nValues)({
     jsResource: i18nOpts.jsResourcePath,
     propertiesFolder: i18nOpts.propertiesFolderPath,
     disableDefault: false
   });
-  const numericFilenameTemplate = validateAndGetFilenameTemplate(i18nOpts.numericFilenameTemplate, 'numericFilenameTemplate');
-  const dynamicFilenameTemplate = validateAndGetFilenameTemplate(i18nOpts.dynamicFilenameTemplate, 'dynamicFilenameTemplate');
-  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);
+  if (!i18nOpts.numericFilenameTemplate.includes('[locale]')) {
+    return null;
   }
 
+  if (!i18nOpts.dynamicFilenameTemplate.includes('[locale]')) {
+    return null;
+  } // Empty prefix - HtmlWebpackPlugin handles publicPath
+
+
+  const i18nAssetsPublicPathPrefix = '';
   const numericIndexPluginOptions = {
     enable: i18nOpts.enable,
     jsResourcePath: i18nOpts.jsResourcePath,
@@ -118,25 +51,20 @@ function configI18nNumericIndexPlugin(options) {
     numericMapPath: i18nOpts.numericMapPath,
     locales,
     allI18nObject,
-    numericFilenameTemplate: numericFilenameTemplate,
-    dynamicFilenameTemplate: dynamicFilenameTemplate,
-    numericJsonpFunction: i18nOpts.jsonpFunc,
-    dynamicJsonpFunction: i18nOpts.jsonpFunc,
-    moduleType: 'i18n/mini-extract'
+    numericFilenameTemplate: i18nOpts.numericFilenameTemplate,
+    dynamicFilenameTemplate: i18nOpts.dynamicFilenameTemplate,
+    jsonpFunc: i18nOpts.jsonpFunc,
+    singleFile: i18nOpts.singleFile || false,
+    includeContentHash: i18nOpts.includeContentHash || false,
+    generateManifest: i18nOpts.generateManifest || false
   };
   const htmlInjectorOptions = {
-    locales,
-    numericFilenameTemplate: numericFilenameTemplate,
-    numericJsonpFunc: i18nOpts.jsonpFunc,
-    dynamicFilenameTemplate: dynamicFilenameTemplate,
-    dynamicJsonpFunc: i18nOpts.jsonpFunc,
-    mainChunkName: options.i18nChunkSplit && options.i18nChunkSplit.mainChunkName || 'main',
+    numericFilenameTemplate: i18nOpts.numericFilenameTemplate,
+    dynamicFilenameTemplate: i18nOpts.dynamicFilenameTemplate,
     htmlTemplateLabel: i18nOpts.htmlTemplateLabel,
-    localeVarName: i18nOpts.localeVarName,
-    i18nAssetsPublicPathPrefix: i18nAssetsPublicPathPrefix,
-    cspNoncePlaceholder: i18nOpts.cspNoncePlaceholder || '{{--CSP-nonce}}'
+    i18nAssetsPublicPathPrefix
   };
-  const i18nNumericPluginInstance = new I18nNumericIndexPlugin(numericIndexPluginOptions);
-  const htmlInjectorPluginInstance = new I18nNumericIndexHtmlInjectorPlugin(htmlInjectorOptions);
+  const i18nNumericPluginInstance = new _I18nNumericIndexPlugin.I18nNumericIndexPlugin(numericIndexPluginOptions);
+  const htmlInjectorPluginInstance = new _I18nNumericIndexHtmlInjectorPlugin.I18nNumericIndexHtmlInjectorPlugin(htmlInjectorOptions);
   return [i18nNumericPluginInstance, htmlInjectorPluginInstance];
 }

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

@@ -36,9 +36,6 @@ 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,
-    // NEW OPTIONS FOR NUMERIC INDEXING
-    useNumericIndexing: i18nChunkSplit.useNumericIndexing,
-    numericMapPath: i18nChunkSplit.numericMapPath
+    propertiesFolder: i18nChunkSplit.propertiesFolder
   });
 }

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

@@ -49,29 +49,12 @@ var _configRuntimeResourceCleanup = require("./pluginConfigs/configRuntimeResour
 
 var _configCustomScriptLoadingStrategyPlugin = require("./pluginConfigs/configCustomScriptLoadingStrategyPlugin");
 
-var {
-  configI18nNumericIndexPlugin
-} = require("./pluginConfigs/configI18nNumericIndexPlugin");
+var _configI18nNumericIndexPlugin = require("./pluginConfigs/configI18nNumericIndexPlugin");
 
+// import { IgnorePlugin } from 'webpack';
 function plugins(options) {
   const {
     webpackPlugins
   } = options;
-  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);
+  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), ...webpackPlugins].filter(Boolean);
 }