@zohodesk/client_build_tool 0.0.11-exp.15 → 0.0.11-exp.15.2

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

@@ -1,186 +1,248 @@
 "use strict";
 
-const path = require('path');
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
 
-const {
-  sources,
-  Compilation,
-  util
-} = require('webpack');
+var _fs = _interopRequireDefault(require("fs"));
 
-const {
-  decodeUnicodeEscapes
-} = require('../../utils/propertiesParser');
+var _path = _interopRequireDefault(require("path"));
 
-const {
-  loadNumericMap,
-  loadI18nData
-} = require('./utils/i18nDataLoader');
+var _webpack = require("webpack");
+
+var _propertiesUtils = require("../I18nSplitPlugin/utils/propertiesUtils");
+
+var _I18nGroupRuntimeModule = require("./I18nGroupRuntimeModule");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const {
   RawSource
-} = sources;
+} = _webpack.sources;
 const pluginName = 'I18nNumericIndexPlugin';
 
 class I18nNumericIndexPlugin {
-  constructor(options = {}) {
-    this.options = { ...options,
-      singleFile: options.singleFile || false,
-      singleFileTemplate: options.singleFileTemplate,
-      includeContentHash: options.includeContentHash || false,
-      generateManifest: options.generateManifest || false,
-      manifestPath: options.manifestPath || 'i18n/manifest.json'
-    };
-    this.numericMap = null;
-    this.i18nData = null;
-    this.manifest = {};
+  constructor(options) {
+    this.options = options;
+    this.numericMap = {};
+    this.customGroups = {};
+    this.nextNumericId = 1;
   }
 
-  getNumericMap(compilation) {
-    if (!this.numericMap) {
-      const mapPath = path.resolve(compilation.compiler.context, this.options.numericMapPath);
-      this.numericMap = loadNumericMap(mapPath, compilation);
-    }
+  apply(compiler) {
+    // Detect webpackI18nGroup comments in code
+    this.detectI18nGroupComments(compiler);
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      // Add runtime module for group-based loading
+      if (this.options.customGroups) {
+        compilation.hooks.runtimeRequirementInTree.for(_webpack.RuntimeGlobals.ensureChunk).tap(pluginName, chunk => {
+          compilation.addRuntimeModule(chunk, new _I18nGroupRuntimeModule.I18nGroupRuntimeModule({
+            customGroups: this.options.customGroups,
+            localeVarName: this.options.localeVarName,
+            jsonpFunc: this.options.jsonpFunc
+          }));
+        });
+      }
 
-    return this.numericMap;
+      compilation.hooks.processAssets.tap({
+        name: pluginName,
+        stage: compilation.PROCESS_ASSETS_STAGE_OPTIMIZE
+      }, () => {
+        this.processI18nFiles(compilation);
+      });
+    });
   }
 
-  getI18nData(compilation) {
-    if (!this.i18nData) {
-      this.i18nData = loadI18nData(this.options, compilation);
-    }
+  detectI18nGroupComments(compiler) {
+    compiler.hooks.normalModuleFactory.tap(pluginName, factory => {
+      factory.hooks.parser.for('javascript/auto').tap(pluginName, parser => {
+        parser.hooks.importCall.tap(pluginName, expr => {
+          // Check for webpackI18nGroup comment
+          const comments = expr.leadingComments || [];
+          comments.forEach(comment => {
+            if (comment.value && comment.value.includes('webpackI18nGroup')) {
+              const match = comment.value.match(/webpackI18nGroup:\s*["']([^"']+)["']/);
+
+              if (match) {
+                const groupName = match[1]; // Store this information for later use
+
+                if (!this.detectedGroups) {
+                  this.detectedGroups = {};
+                } // Extract chunk name from webpackChunkName comment
+
 
-    return this.i18nData;
+                const chunkNameMatch = comment.value.match(/webpackChunkName:\s*["']([^"']+)["']/);
+
+                if (chunkNameMatch) {
+                  const chunkName = chunkNameMatch[1];
+                  this.detectedGroups[chunkName] = groupName;
+                }
+              }
+            }
+          });
+        });
+      });
+    });
   }
 
-  generateContentHash(content, compilation) {
+  processI18nFiles(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);
-  }
+      jsResourcePath,
+      propertiesFolderPath,
+      numericMapPath,
+      customGroups,
+      jsonpFunc,
+      numericFilenameTemplate,
+      dynamicFilenameTemplate
+    } = this.options;
 
-  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);
-    const hasContentHashPlaceholder = filename.includes('[contenthash]');
-    const shouldIncludeHash = hasContentHashPlaceholder || this.options.includeContentHash;
+    if (!jsResourcePath || !propertiesFolderPath) {
+      return;
+    } // Read JSResources.properties
 
-    if (shouldIncludeHash) {
-      const contentHash = this.generateContentHash(fileContent, compilation);
 
-      if (hasContentHashPlaceholder) {
-        outputPath = outputPath.replace(/\[contenthash\]/g, contentHash);
-      } else {
-        outputPath = outputPath.replace(/\.js$/, `.${contentHash}.js`);
-      }
+    const jsResourceKeys = (0, _propertiesUtils.getPropertiesAsJSON)(jsResourcePath); // Parse custom groups from banner markers
+
+    if (customGroups) {
+      this.parseCustomGroups(jsResourcePath, customGroups);
+    } // Get all locale translations
+
+
+    const allI18nObject = (0, _propertiesUtils.getAllI18n)({
+      folderPath: propertiesFolderPath,
+      disableDefault: false,
+      jsResourceI18nKeys: jsResourceKeys
+    });
+    const locales = Object.keys(allI18nObject); // Process each locale
+
+    locales.forEach(locale => {
+      const localeData = allI18nObject[locale];
+      const numericData = {};
+      const dynamicData = {};
+      const groupData = {}; // Initialize custom groups
+
+      Object.keys(customGroups || {}).forEach(groupName => {
+        groupData[groupName] = {};
+      }); // Process each key
+
+      Object.keys(localeData).forEach(key => {
+        const value = localeData[key]; // Check if key belongs to a custom group
+
+        const belongsToGroup = this.getKeyGroup(key);
+
+        if (belongsToGroup) {
+          // Add to custom group
+          const numericKey = this.getNumericKey(key);
+          groupData[belongsToGroup][numericKey] = value;
+        } else if (this.isDynamicKey(value)) {
+          // Add to dynamic chunk (keep string keys for dynamic)
+          dynamicData[key] = value;
+        } else {
+          // Add to numeric chunk
+          const numericKey = this.getNumericKey(key);
+          numericData[numericKey] = value;
+        }
+      }); // Emit numeric chunk
+
+      this.emitChunk(compilation, numericFilenameTemplate, locale, numericData, jsonpFunc); // Emit dynamic chunk
+
+      this.emitChunk(compilation, dynamicFilenameTemplate, locale, dynamicData, jsonpFunc); // Emit custom group chunks
+
+      Object.entries(groupData).forEach(([groupName, data]) => {
+        const groupConfig = customGroups[groupName];
+
+        if (groupConfig && Object.keys(data).length > 0) {
+          this.emitChunk(compilation, groupConfig.filenameTemplate || `i18n-chunk/[locale]/${groupName}.i18n.js`, locale, data, jsonpFunc, groupName);
+        }
+      });
+    }); // Save numeric map
+
+    if (numericMapPath) {
+      this.saveNumericMap(numericMapPath);
     }
+  }
+
+  parseCustomGroups(jsResourcePath, customGroups) {
+    const content = _fs.default.readFileSync(jsResourcePath, 'utf-8');
+
+    const lines = content.split('\n');
+    Object.entries(customGroups).forEach(([groupName, config]) => {
+      const {
+        bannerStart,
+        bannerEnd
+      } = config;
+      let inGroup = false;
+      const groupKeys = [];
+      lines.forEach(line => {
+        if (line.includes(bannerStart)) {
+          inGroup = true;
+        } else if (line.includes(bannerEnd)) {
+          inGroup = false;
+        } else if (inGroup && line.includes('=')) {
+          const key = line.split('=')[0].trim();
+
+          if (key && !key.startsWith('#')) {
+            groupKeys.push(key);
+          }
+        }
+      });
+      this.customGroups[groupName] = groupKeys;
+    });
+  }
 
-    if (this.options.generateManifest) {
-      const cleanName = filename.replace(/\[locale\]/g, locale).replace(/\.\[contenthash\]/g, '').replace(/\.js$/, '.js');
-      const cleanNameWithType = fileType ? cleanName.replace(/\.js$/, `.${fileType}.js`) : cleanName;
-      const manifestKey = cleanNameWithType.split('/').pop();
-      this.manifest[manifestKey] = outputPath.split('/').pop();
+  getKeyGroup(key) {
+    for (const [groupName, keys] of Object.entries(this.customGroups)) {
+      if (keys.includes(key)) {
+        return groupName;
+      }
     }
 
-    compilation.emitAsset(outputPath, new RawSource(fileContent));
-    return outputPath;
+    return null;
   }
 
-  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();
-        }
+  isDynamicKey(value) {
+    // Check if value contains placeholders like {0}, {1}, etc.
+    return /\{\d+\}/.test(value);
+  }
 
-        const {
-          sortedKeys,
-          totalKeys,
-          originalKeyToNumericId
-        } = 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;
-        const isDevMode = this.options.devMode || process.env.NODE_ENV === 'development';
-        locales.forEach(locale => {
-          const localeData = allI18n[locale] || {};
-          const numericData = {};
-          const unmappedData = {};
-          Object.keys(jsResourceBase).forEach(key => {
-            const translation = localeData[key] ?? englishData[key];
-
-            if (originalKeyToNumericId && originalKeyToNumericId.hasOwnProperty(key)) {
-              const numericId = originalKeyToNumericId[key];
-              numericData[numericId] = translation;
-            } else if (numericKeysSet.has(key)) {
-              const index = sortedKeys.indexOf(key);
-
-              if (index !== -1) {
-                numericData[index] = translation;
-              }
-            } else {
-              unmappedData[key] = translation;
-            }
-          });
+  getNumericKey(key) {
+    if (!this.numericMap[key]) {
+      this.numericMap[key] = this.nextNumericId++;
+    }
 
-          if (this.options.singleFile) {
-            const combinedData = { ...numericData,
-              ...unmappedData
-            };
+    return String(this.numericMap[key]);
+  }
 
-            if (Object.keys(combinedData).length > 0) {
-              const filename = this.options.singleFileTemplate || 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');
-            }
+  emitChunk(compilation, filenameTemplate, locale, data, jsonpFunc, groupName = null) {
+    const filename = filenameTemplate.replace('[locale]', locale);
+    const content = this.generateChunkContent(data, jsonpFunc, groupName);
+    compilation.emitAsset(filename, new RawSource(content));
+  }
 
-            if (Object.keys(unmappedData).length > 0) {
-              this.emitChunk(compilation, this.options.dynamicFilenameTemplate, locale, unmappedData, 'dynamic');
-            }
-          }
-        });
+  generateChunkContent(data, jsonpFunc, groupName) {
+    const jsonString = JSON.stringify(data);
 
-        if (this.options.generateManifest && Object.keys(this.manifest).length > 0) {
-          // Determine manifest path
-          let manifestPath;
-
-          if (this.options.manifestPath) {
-            // Use explicitly configured path
-            manifestPath = this.options.manifestPath;
-          } else {
-            // Default to same directory as i18n files with manifest.json name
-            const template = this.options.singleFileTemplate || this.options.numericFilenameTemplate;
-            manifestPath = path.dirname(template) + '/manifest.json';
-          }
+    if (groupName) {
+      // Include group name for lazy loading identification
+      return `${jsonpFunc}(${jsonString}, "${groupName}");`;
+    }
 
-          const manifestContent = JSON.stringify(this.manifest, null, 2);
-          compilation.emitAsset(manifestPath, new RawSource(manifestContent));
-        }
+    return `${jsonpFunc}(${jsonString});`;
+  }
 
-        callback();
+  saveNumericMap(mapPath) {
+    const dir = _path.default.dirname(mapPath);
+
+    if (!_fs.default.existsSync(dir)) {
+      _fs.default.mkdirSync(dir, {
+        recursive: true
       });
-    });
+    }
+
+    _fs.default.writeFileSync(mapPath, JSON.stringify(this.numericMap, null, 2));
   }
 
 }
 
-module.exports = {
-  I18nNumericIndexPlugin
-};
+exports.default = I18nNumericIndexPlugin;

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

@@ -7,29 +7,11 @@ 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: useLoaders
+    use: [(0, _babelLoaderConfig.babelLoaderConfig)(options)] // include: path.join(appPath, folder)
+
   }];
 }

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

@@ -43,9 +43,10 @@ function folderPatterns(publicFolders) {
 
 function configCopyPublicFolders(options) {
   let {
-    publicFolders
+    publicFolders,
+    mode = 'dev'
   } = options;
-  publicFolders = (0, _updateArrayWithDefault.updateArrayWithDefault)(publicFolders, defaultPublicFolders);
+  publicFolders = (0, _updateArrayWithDefault.updateArrayWithDefault)(publicFolders[mode], defaultPublicFolders);
 
   if (publicFolders.length === 0) {
     return null;

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

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = configI18nIndexingPlugin;
+
+var _I18nNumericIndexPlugin = _interopRequireDefault(require("../custom_plugins/I18nNumericIndexPlugin/I18nNumericIndexPlugin"));
+
+var _resourceBasedPublicPath = require("../common/resourceBasedPublicPath");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function configI18nIndexingPlugin(config) {
+  const {
+    i18nIndexing,
+    cdnMapping
+  } = config;
+
+  if (!i18nIndexing || !i18nIndexing.enable) {
+    return null;
+  } // Get the public path for i18n resources
+
+
+  const i18nPublicPath = (0, _resourceBasedPublicPath.resourceBasedPublicPath)('i18n', config); // Get the CDN template for i18n resources if CDN is enabled
+
+  const i18nCdnTemplate = cdnMapping && cdnMapping.isCdnEnabled ? cdnMapping.i18nTemplate || cdnMapping.jsTemplate : '';
+  const options = {
+    jsResourcePath: i18nIndexing.jsResourcePath,
+    propertiesFolderPath: i18nIndexing.propertiesFolderPath,
+    numericMapPath: i18nIndexing.numericMapPath,
+    numericFilenameTemplate: i18nIndexing.numericFilenameTemplate || 'i18n-chunk/[locale]/numeric.i18n.js',
+    dynamicFilenameTemplate: i18nIndexing.dynamicFilenameTemplate || 'i18n-chunk/[locale]/dynamic.i18n.js',
+    jsonpFunc: i18nIndexing.jsonpFunc || 'window.loadI18nChunk',
+    htmlTemplateLabel: i18nIndexing.htmlTemplateLabel || '{{--user-locale}}',
+    localeVarName: i18nIndexing.localeVarName || 'window.userLangCode',
+    customGroups: i18nIndexing.customGroups || {},
+    publicPath: i18nPublicPath || '',
+    i18nCdnTemplate
+  };
+  return new _I18nNumericIndexPlugin.default(options);
+}

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

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = configI18nNumericHtmlInjector;
+
+var _htmlWebpackPlugin = _interopRequireDefault(require("html-webpack-plugin"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const pluginName = 'I18nNumericHtmlInjectorPlugin';
+
+class I18nNumericHtmlInjectorPlugin {
+  constructor(options) {
+    this.options = options;
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      // Hook into HtmlWebpackPlugin to inject i18n script tags
+      _htmlWebpackPlugin.default.getHooks(compilation).beforeAssetTagGeneration.tap(pluginName, hookData => {
+        const {
+          assets
+        } = hookData;
+        const {
+          numericFilenameTemplate,
+          dynamicFilenameTemplate,
+          htmlTemplateLabel,
+          i18nCdnTemplate,
+          customGroups
+        } = this.options;
+        const newI18nAssets = []; // Add numeric i18n chunk
+
+        if (numericFilenameTemplate) {
+          const numericFilename = numericFilenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel).replace(/%5Blocale%5D/g, htmlTemplateLabel); // Don't add CDN template - HtmlWebpackPlugin handles it
+
+          newI18nAssets.push(numericFilename);
+        } // Add dynamic i18n chunk
+
+
+        if (dynamicFilenameTemplate) {
+          const dynamicFilename = dynamicFilenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel).replace(/%5Blocale%5D/g, htmlTemplateLabel); // Don't add CDN template - HtmlWebpackPlugin handles it
+
+          newI18nAssets.push(dynamicFilename);
+        } // Add custom group chunks if they should be in initial HTML
+
+
+        if (customGroups) {
+          Object.entries(customGroups).forEach(([groupName, groupConfig]) => {
+            // Only add to initial HTML if preload is true
+            if (groupConfig.preload && groupConfig.filenameTemplate) {
+              const groupFilename = groupConfig.filenameTemplate.replace(/\[locale\]/g, htmlTemplateLabel).replace(/%5Blocale%5D/g, htmlTemplateLabel); // Don't add CDN template - HtmlWebpackPlugin handles it
+
+              newI18nAssets.push(groupFilename);
+            }
+          });
+        } // Prepend i18n assets to ensure they load before main bundle
+
+
+        if (newI18nAssets.length > 0) {
+          assets.js = [...newI18nAssets, ...assets.js];
+        }
+
+        return hookData;
+      });
+    });
+  }
+
+}
+
+function configI18nNumericHtmlInjector(config) {
+  const {
+    i18nIndexing,
+    cdnMapping
+  } = config; // Only create this plugin if i18nIndexing is enabled
+
+  if (!i18nIndexing || !i18nIndexing.enable) {
+    return null;
+  } // Get the CDN template for i18n resources if CDN is enabled
+
+
+  const i18nCdnTemplate = cdnMapping && cdnMapping.isCdnEnabled ? cdnMapping.i18nTemplate || cdnMapping.jsTemplate : '';
+  const options = {
+    numericFilenameTemplate: i18nIndexing.numericFilenameTemplate || 'i18n-chunk/[locale]/numeric.i18n.js',
+    dynamicFilenameTemplate: i18nIndexing.dynamicFilenameTemplate || 'i18n-chunk/[locale]/dynamic.i18n.js',
+    htmlTemplateLabel: i18nIndexing.htmlTemplateLabel || '{{--user-locale}}',
+    customGroups: i18nIndexing.customGroups || {},
+    i18nCdnTemplate
+  };
+  return new I18nNumericHtmlInjectorPlugin(options);
+}

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

@@ -11,6 +11,10 @@ var _configEnvVariables = require("./pluginConfigs/configEnvVariables");
 
 var _configI18nSplitPlugin = require("./pluginConfigs/configI18nSplitPlugin");
 
+var _configI18nIndexingPlugin = _interopRequireDefault(require("./pluginConfigs/configI18nIndexingPlugin"));
+
+var _configI18nNumericHtmlInjector = _interopRequireDefault(require("./pluginConfigs/configI18nNumericHtmlInjector"));
+
 var _configMiniCSSExtractPlugin = require("./pluginConfigs/configMiniCSSExtractPlugin");
 
 var _configRtlCssPlugin = require("./pluginConfigs/configRtlCssPlugin");
@@ -49,12 +53,12 @@ var _configRuntimeResourceCleanup = require("./pluginConfigs/configRuntimeResour
 
 var _configCustomScriptLoadingStrategyPlugin = require("./pluginConfigs/configCustomScriptLoadingStrategyPlugin");
 
-var _configI18nNumericIndexPlugin = require("./pluginConfigs/configI18nNumericIndexPlugin");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // import { IgnorePlugin } from 'webpack';
 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, _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);
+  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, _configI18nIndexingPlugin.default)(options), (0, _configRtlCssPlugin.configRtlCssPlugin)(options), (0, _configHtmlWebpackPlugin.configHtmlWebpackPlugin)(options), (0, _configI18nNumericHtmlInjector.default)(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);
 }

package/lib/shared/postcss/custom_postcss_plugins/VariableModificationPlugin/index.js

@@ -259,7 +259,7 @@ var _default = ({
               if (range) {
                 // console.log('multiple :', decl.value)
                 let newVal = '';
-                decl.value.split(' ').forEach(singleVal => {
+                decl.value.split(' ').filter(Boolean).forEach(singleVal => {
                   newVal += `${singleConvertor(singleVal, settings.replacements.px, {
                     decl,
                     filename,

package/lib/shared/server/mockApiHandler.js

@@ -44,6 +44,13 @@ 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) {
 // }

package/lib/shared/server/urlConcat.js

@@ -17,10 +17,11 @@ function urlConcat(url, path) {
   const slashRemovedPath = removeFrontSlash(path);
 
   if (slashRemovedUrl === '') {
-    return path;
-  }
+    return `${path}/`;
+  } //return  `${slashRemovedUrl}/${slashRemovedPath}`;
 
-  return `${slashRemovedUrl}/${slashRemovedPath}/`;
+
+  return `${[slashRemovedUrl, slashRemovedPath].filter(a => a).join('/')}/`;
 }
 
 function removeLastSlash(url) {