balm-core 4.11.0 → 4.13.0

package/lib/balm.js

@@ -1,57 +1,40 @@
 function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
-
 function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
-
 function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
-
 function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
-
 function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
-
 function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
-
 function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
-
 import './config/index.js';
 import './utilities/index.js';
 import './plugins/index.js';
 import registerTasks from './tasks/index.js';
 import { setConfig, setTask } from './bootstrap/index.js';
 import loading from './utilities/loading.js';
-
 var _config = /*#__PURE__*/new WeakMap();
-
 class Balm {
   constructor() {
     _classPrivateFieldInitSpec(this, _config, {
       writable: true,
       value: void 0
     });
-
     BalmJS.loading = false;
     loading.succeed();
-
     _classPrivateFieldSet(this, _config, setConfig({}));
   }
-
   get config() {
     return _classPrivateFieldGet(this, _config);
   }
-
   set config(value) {
     _classPrivateFieldSet(this, _config, setConfig(value));
-
     BalmJS.config = _classPrivateFieldGet(this, _config);
   }
-
   set beforeTask(name) {
     BalmJS.beforeTask = setTask(name);
   }
-
   set afterTask(name) {
     BalmJS.afterTask = setTask(name);
   }
-
   go(recipe = NOOP) {
     if (BalmJS.utils.isFunction(recipe)) {
       registerTasks(recipe);
@@ -59,7 +42,6 @@ class Balm {
       BalmJS.logger.error('initialization', 'BalmJS API: `balm.go(mix => {});`');
     }
   }
-
   reset() {
     BalmJS.tasks = new Map();
     BalmJS.recipes = [];
@@ -68,7 +50,5 @@ class Balm {
     BalmJS.afterTask = undefined;
     BalmJS.config.useDefaults = true;
   }
-
 }
-
 export default Balm;

package/lib/bootstrap/check_config.js

@@ -1,45 +1,42 @@
 import { DOMAIN } from '../config/constants.js';
 const docsBaseURL = `${DOMAIN}/docs/config`;
-
 function upgradeGuide(key, value, message) {
   const page = key === 'scripts' ? 'scripts-webpack' : key.toLowerCase();
   return `${message} See ${docsBaseURL}/${page}.html#${key}-${value.toLowerCase()}`;
 }
-
 function upgradeRenamed(version, configCategory, from, to) {
   if (BalmJS.config[configCategory][from]) {
     BalmJS.logger.warn(`balm@${version}+ config`, upgradeGuide(configCategory, to, `'${configCategory}.${from}' was renamed to '${configCategory}.${to}'.`));
   }
 }
-
 function upgradeMigrated(version, configName, from, to) {
   if (BalmJS.config[from][configName]) {
     BalmJS.logger.warn(`balm@${version}+ config`, upgradeGuide(to, configName, `'${from}.${configName}' was migrated to '${to}.${configName}'.`));
   }
 }
-
 function upgradeDeprecated(version, configCategory, configName) {
   if (BalmJS.config[configCategory][configName]) {
     BalmJS.logger.warn(`balm@${version}+ config`, `'${configCategory}.${configName}' was deprecated.`);
   }
-} // Compatibility for upgrade balm
-
+}
 
+// Compatibility for upgrade balm
 function checkConfig() {
   // For v2
   upgradeRenamed('2.5.0', 'scripts', 'disableDefaultLoaders', 'defaultLoaders');
   upgradeMigrated('2.11.0', 'postcssLoaderOptions', 'styles', 'scripts');
-  upgradeRenamed('2.22.0', 'images', 'defaultPlugins', 'plugins'); // For v3
+  upgradeRenamed('2.22.0', 'images', 'defaultPlugins', 'plugins');
 
+  // For v3
   upgradeRenamed('3.0.0', 'styles', 'minified', 'minify');
   upgradeRenamed('3.9.0', 'scripts', 'options', 'minifyOptions');
   upgradeRenamed('3.16.0', 'scripts', 'inject', 'useCache');
   upgradeDeprecated('3.17.0', 'styles', 'darkSass');
-  upgradeDeprecated('3.19.0', 'scripts', 'useCache'); // For v4
+  upgradeDeprecated('3.19.0', 'scripts', 'useCache');
 
+  // For v4
   upgradeDeprecated('4.0.0', 'scripts', 'libraryTarget');
   upgradeDeprecated('4.5.0', 'scripts', 'excludeUrlResource');
   upgradeDeprecated('4.5.0', 'scripts', 'urlLoaderOptions');
 }
-
 export default checkConfig;

package/lib/bootstrap/index.js

@@ -1,81 +1,77 @@
 import checkConfig from './check_config.js';
 import { ASSETS_TYPES } from '../config/constants.js';
-
 function createQuickPath(config, rootKey) {
   const result = {};
   const rootValue = config.roots[rootKey];
-
   for (const pathKey of Object.keys(config.paths[rootKey])) {
     const pathValue = config.paths[rootKey][pathKey];
     result[pathKey] = rootKey === 'target' && ASSETS_TYPES.includes(pathKey) ? node.path.join(rootValue, BalmJS.config.assets.virtualDir, BalmJS.file.assetsSuffixPath, pathValue) : node.path.join(rootValue, pathValue);
   }
-
   return rootKey === 'source' ? result : result;
 }
-
 function ready(config) {
   // Create local quick directories
   config.src = createQuickPath(config, 'source');
   config.dest = createQuickPath(config, config.env.isProd || !config.inFrontend ? 'target' : 'tmp');
-  config.dest.static = node.path.join(config.dest.base, BalmJS.config.assets.virtualDir, BalmJS.file.assetsSuffixPath); // Create remote quick directories
+  config.dest.static = node.path.join(config.dest.base, BalmJS.config.assets.virtualDir, BalmJS.file.assetsSuffixPath);
 
+  // Create remote quick directories
   config.assets.static = node.path.join(config.assets.root, config.assets.mainDir, BalmJS.file.assetsSuffixPath);
-
   for (const assetType of ASSETS_TYPES) {
     config.assets[assetType] = node.path.join(config.assets.static, config.paths.target[assetType]);
-  } // Set HMR flag
-
+  }
 
+  // Set HMR flag
   const HMR_ENV = config.useDefaults && config.env.isDev && !config.env.inSSR && !config.env.isMP;
   const HMR_Enabling = config.scripts.bundler === BalmJS.Bundler.webpack && !config.scripts.ie8;
-  config.server.useHMR = HMR_ENV && HMR_Enabling; // Set desktop app flag
+  config.server.useHMR = HMR_ENV && HMR_Enabling;
 
+  // Set desktop app flag
   if (/^electron-.*/.test(config.scripts.target)) {
     config.env.inDesktopApp = true;
-  } // Set use cache for webpack
-
+  }
 
+  // Set use cache for webpack
   config.scripts.useCache = config.env.isProd && config.assets.cache && config.scripts.injectHtml;
   return config;
 }
-
 function resetConfig() {
   BalmJS.config.roots.target = 'dist';
   BalmJS.config.roots.tmp = '.tmp';
   return BalmJS.config;
 }
-
 function setConfig(customConfig) {
-  const defaultConfig = resetConfig(); // 1. Overwrite config
+  const defaultConfig = resetConfig();
 
+  // 1. Overwrite config
   const newConfig = BalmJS.utils.deepMerge(defaultConfig, customConfig);
-  checkConfig(); // 2. Copy `config.paths.target` to `config.paths.tmp`
+  checkConfig();
 
+  // 2. Copy `config.paths.target` to `config.paths.tmp`
   let config = BalmJS.utils.deepMerge(newConfig, {
     paths: {
       tmp: newConfig.paths.target
     }
-  }); // 3. For the dynamic project
+  });
 
+  // 3. For the dynamic project
   if (!config.inFrontend) {
     if (config.roots.target === 'dist') {
       config.roots.target = config.assets.mainDir; // NOTE: `BalmJS.config.roots.target = 'public'` for back-end project
     }
 
     config.roots.tmp = config.roots.target;
-  } // 4. Before created
-
+  }
 
+  // 4. Before created
   config = ready(config);
   BalmJS.logger.success('balm configuration', config, {
     pre: true
   });
   return config;
 }
-
 function setTask(name) {
   let result = undefined;
-
   if (BalmJS.utils.isFunction(name)) {
     result = name;
   } else if (BalmJS.utils.isString(name)) {
@@ -87,8 +83,6 @@ function setTask(name) {
   } else {
     BalmJS.logger.error('before/end task', 'Task must be a string (gulp task name) or function');
   }
-
   return result;
 }
-
 export { setConfig, setTask };

package/lib/bundler/esbuild/build.js

@@ -1,6 +1,5 @@
 import { build } from 'esbuild';
 import { minifyOptions } from './options.js';
-
 const esBuild = (entryPoints, output, customBuildOptions, callback) => {
   const defaultBuildOptions = {
     entryPoints: BalmJS.file.absPaths(entryPoints),
@@ -24,5 +23,4 @@ const esBuild = (entryPoints, output, customBuildOptions, callback) => {
     callback();
   });
 };
-
 export default esBuild;

package/lib/bundler/esbuild/index.js

@@ -1,9 +1,7 @@
 import build from './build.js';
 import transform from './transform.js';
-
 const esbuild = (input, output, customOptions, callback) => {
   const entryPoints = BalmJS.utils.isString(input) ? [input] : input;
   BalmJS.config.scripts.useTransform ? transform(entryPoints, output, customOptions, callback) : build(entryPoints, output, customOptions, callback);
 };
-
 export default esbuild;

package/lib/bundler/esbuild/transform.js

@@ -1,13 +1,11 @@
 import { transform } from 'esbuild';
 import { minifyOptions } from './options.js';
-
 const esTransform = (entryPoints, output, customTransformOptions, callback) => {
   const build = {
     output: BalmJS.file.absPath(output)
   };
   const transformOptions = BalmJS.config.env.isProd ? Object.assign({}, minifyOptions) : {};
   const options = Object.assign(transformOptions, BalmJS.config.scripts.transformOptions, customTransformOptions);
-
   (async () => {
     try {
       for await (const entryPoint of entryPoints) {
@@ -19,7 +17,6 @@ const esTransform = (entryPoints, output, customTransformOptions, callback) => {
           pre: true
         });
         const filename = entryPoint.split('/').pop();
-
         if (filename && node.fs.existsSync(build.input)) {
           const inputCode = node.fs.readFileSync(build.input, 'utf8');
           const result = await transform(inputCode, options);
@@ -36,5 +33,4 @@ const esTransform = (entryPoints, output, customTransformOptions, callback) => {
     }
   })();
 };
-
 export default esTransform;

package/lib/bundler/rollup/build.js

@@ -2,7 +2,6 @@ const build = async (bundle, outputOptions) => {
   const {
     output
   } = await bundle.generate(outputOptions);
-
   for (const chunkOrAsset of output) {
     if (chunkOrAsset.type === 'asset') {
       // For assets, this contains
@@ -45,10 +44,9 @@ const build = async (bundle, outputOptions) => {
         pre: true
       });
     }
-  } // or write the bundle to disk
-
+  }
 
+  // or write the bundle to disk
   return await bundle.write(outputOptions);
 };
-
 export default build;

package/lib/bundler/rollup/entry.js

@@ -1,16 +1,15 @@
 import { getInputPlugins } from './plugins.js';
-
 function getEntry(inputOptions) {
   // Set plugins
   const inputPlugins = getInputPlugins(inputOptions);
   const options = Object.assign({}, BalmJS.config.scripts.inputOptions, inputOptions);
-  options.plugins = inputPlugins; // Set entry points
+  options.plugins = inputPlugins;
 
+  // Set entry points
   const {
     input
   } = options;
   let rollupEntries = input;
-
   if (BalmJS.utils.isObject(input)) {
     const entries = input;
     Object.keys(entries).forEach(entryAlias => {
@@ -20,12 +19,10 @@ function getEntry(inputOptions) {
   } else {
     rollupEntries = BalmJS.file.absPaths(input);
   }
-
   options.input = rollupEntries;
   BalmJS.logger.debug('rollup input options', options, {
     pre: true
   });
   return options;
 }
-
 export default getEntry;

package/lib/bundler/rollup/index.js

@@ -2,7 +2,6 @@ import { rollup } from 'rollup';
 import getEntry from './entry.js';
 import getOutput from './output.js';
 import build from './build.js';
-
 const buildLibrary = async (inputOptions, outputOptions) => {
   inputOptions = getEntry(inputOptions);
   outputOptions = getOutput(outputOptions);
@@ -10,7 +9,6 @@ const buildLibrary = async (inputOptions, outputOptions) => {
     output: outputOptions
   });
   const bundle = await rollup(rollupOptions);
-
   if (Array.isArray(outputOptions)) {
     for await (const outputOption of outputOptions) {
       await build(bundle, outputOption);
@@ -19,5 +17,4 @@ const buildLibrary = async (inputOptions, outputOptions) => {
     await build(bundle, outputOptions);
   }
 };
-
 export default buildLibrary;

package/lib/bundler/rollup/output.js

@@ -1,19 +1,15 @@
 import { getOutputPlugins } from './plugins.js';
-
 function setOutput(outputOptions) {
   const outputPlugins = getOutputPlugins(outputOptions);
   outputOptions = Object.assign({}, BalmJS.config.scripts.outputOptions, outputOptions);
   outputOptions.plugins = outputPlugins;
-
   if (outputOptions.dir) {
     outputOptions.dir = BalmJS.file.absPath(outputOptions.dir);
   } else {
     outputOptions.file = BalmJS.file.absPath(outputOptions.file);
   }
-
   return outputOptions;
 }
-
 function getOutput(outputOptions) {
   const options = Array.isArray(outputOptions) ? outputOptions.map(outputOption => setOutput(outputOption)) : setOutput(outputOptions);
   BalmJS.logger.debug('rollup output options', options, {
@@ -21,5 +17,4 @@ function getOutput(outputOptions) {
   });
   return options;
 }
-
 export default getOutput;

package/lib/bundler/rollup/plugins.js

@@ -1,41 +1,31 @@
 import { terser } from 'rollup-plugin-terser';
-
 function getInputPlugins(customInputOptions) {
   const {
     inputOptions
   } = BalmJS.config.scripts;
   const inputPlugins = [];
-
   if (inputOptions.plugins) {
     inputPlugins.push(...inputOptions.plugins);
   }
-
   if (customInputOptions.plugins) {
     inputPlugins.push(...customInputOptions.plugins);
   }
-
   return inputPlugins;
 }
-
 function getOutputPlugins(customOutputOptions) {
   const {
     outputOptions
   } = BalmJS.config.scripts;
   const outputPlugins = [];
-
   if (outputOptions.plugins) {
     outputPlugins.push(...outputOptions.plugins);
   }
-
   if (BalmJS.config.env.isProd) {
     outputPlugins.push(terser(BalmJS.config.scripts.minifyOptions));
   }
-
   if (customOutputOptions.plugins) {
     outputPlugins.push(...customOutputOptions.plugins);
   }
-
   return outputPlugins;
 }
-
 export { getInputPlugins, getOutputPlugins };

package/lib/bundler/webpack/config/common.js

@@ -2,19 +2,20 @@ import HtmlWebpackPlugin from 'html-webpack-plugin';
 import getLoaders from '../loaders.js';
 import { CHUNK } from '../../../config/constants.js';
 import getClientEnvironment from './env.js';
-
 function getDefaultPlugins(webpack, scripts) {
   // We will provide `BalmJS.file.publicUrlOrPath` to our app
   // as %PUBLIC_URL% in `index.html` and `process.env.PUBLIC_URL` in JavaScript.
   // Omit trailing slash as %PUBLIC_URL%/xyz looks better than %PUBLIC_URL%xyz.
   // Get environment variables to inject into our app.
   const env = getClientEnvironment(BalmJS.file.publicUrlOrPath.slice(0, -1));
-  const plugins = [// Makes some environment variables available to the JS code, for example:
+  const plugins = [
+  // Makes some environment variables available to the JS code, for example:
   // if (process.env.NODE_ENV === 'production') { ... }. See `./env.js`.
   // It is absolutely essential that NODE_ENV is set to production
   // during a production build.
   // Otherwise webapp will be compiled in the very slow development mode.
-  new webpack.DefinePlugin(env.stringified), // Moment.js is an extremely popular library that bundles large locale files
+  new webpack.DefinePlugin(env.stringified),
+  // Moment.js is an extremely popular library that bundles large locale files
   // by default due to how webpack interprets its code. This is a practical
   // solution that requires the user to opt into importing specific locales.
   // https://github.com/jmblog/how-to-optimize-momentjs-with-webpack
@@ -23,18 +24,15 @@ function getDefaultPlugins(webpack, scripts) {
     resourceRegExp: /^\.\/locale$/,
     contextRegExp: /moment$/
   })];
-
   if (scripts.injectHtml) {
     const isSPA = BalmJS.entries.length < 2;
     const titles = scripts.htmlPluginOptions.title || ['BalmJS App'];
-
     if (!BalmJS.entries.length) {
       BalmJS.entries.push({
         key: 'main',
         value: `./${BalmJS.file.defaultEntry}`
       });
     }
-
     BalmJS.entries.forEach((entry, index) => {
       const entryName = isSPA ? 'index' : entry.key;
       const chunks = isSPA ? 'all' : [entryName];
@@ -48,15 +46,12 @@ function getDefaultPlugins(webpack, scripts) {
       plugins.push(new HtmlWebpackPlugin(options));
     });
   }
-
   return plugins;
 }
-
 function getSplitChunks() {
   const scripts = BalmJS.config.scripts;
   const jsFolder = BalmJS.config.paths.target.js;
   let cacheGroups = {};
-
   if (scripts.extractAllVendors) {
     // All vendors
     const vendorsFilename = scripts.useCache ? `${scripts.vendorName}.${CHUNK.hash}.js` : `${scripts.vendorName}.js`;
@@ -66,13 +61,11 @@ function getSplitChunks() {
         chunks: 'initial',
         test: /[\\/](node_modules|bower_components)[\\/]/,
         filename: BalmJS.file.assetsPath(`${jsFolder}/${vendorsFilename}`) // Output: `js/vendors.js`
-
       }
     };
   } else if (BalmJS.vendors.length) {
     // Custom vendors
     cacheGroups = {};
-
     for (const vendor of BalmJS.vendors) {
       const name = vendor.key;
       const cacheGroupModules = vendor.value.join('|');
@@ -87,7 +80,6 @@ function getSplitChunks() {
       };
     }
   }
-
   if (BalmJS.config.env.isProd && BalmJS.config.scripts.extractCss) {
     // Custom styles in scripts
     for (const entry of BalmJS.entries) {
@@ -100,12 +92,10 @@ function getSplitChunks() {
       };
     }
   }
-
   return Object.keys(cacheGroups).length ? {
     cacheGroups
   } : false;
 }
-
 function getCommonConfig(webpack, scripts) {
   const splitChunks = getSplitChunks();
   const optimization = splitChunks ? BalmJS.utils.deepMerge({
@@ -142,5 +132,4 @@ function getCommonConfig(webpack, scripts) {
     stats: scripts.stats
   };
 }
-
 export default getCommonConfig;

package/lib/bundler/webpack/config/dev.js

@@ -1,13 +1,12 @@
 import { merge } from 'webpack-merge';
 import getCommonConfig from './common.js';
-
 function getDevConfig(webpack, scripts) {
   return merge(getCommonConfig(webpack, scripts), {
     mode: 'development',
-    plugins: [// This is necessary to emit hot updates
+    plugins: [
+    // This is necessary to emit hot updates
     new webpack.HotModuleReplacementPlugin()],
     devtool: scripts.sourceMap ? scripts.sourceMap : 'eval-cheap-module-source-map'
   });
 }
-
 export default getDevConfig;

package/lib/bundler/webpack/config/env.js

@@ -1,39 +1,37 @@
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 import dotenv from 'dotenv';
 import dotenvExpand from 'dotenv-expand';
 const NODE_ENV = process.env.NODE_ENV;
-
 if (!NODE_ENV) {
   throw new Error('The NODE_ENV environment variable is required but was not specified.');
 }
+const dotenvFile = BalmJS.file.resolveApp('.env');
 
-const dotenvFile = BalmJS.file.resolveApp('.env'); // https://github.com/bkeepers/dotenv#what-other-env-files-can-i-use
-
-const dotenvFiles = [`${dotenvFile}.${NODE_ENV}.local`, // Don't include `.env.local` for `test` environment
+// https://github.com/bkeepers/dotenv#what-other-env-files-can-i-use
+const dotenvFiles = [`${dotenvFile}.${NODE_ENV}.local`,
+// Don't include `.env.local` for `test` environment
 // since normally you expect tests to produce the same
 // results for everyone
-NODE_ENV !== 'test' && `${dotenvFile}.local`, `${dotenvFile}.${NODE_ENV}`, dotenvFile].filter(Boolean); // Load environment variables from .env* files. Suppress warnings using silent
+NODE_ENV !== 'test' && `${dotenvFile}.local`, `${dotenvFile}.${NODE_ENV}`, dotenvFile].filter(Boolean);
+
+// Load environment variables from .env* files. Suppress warnings using silent
 // if this file is missing. dotenv will never modify any environment variables
 // that have already been set.  Variable expansion is supported in .env files.
 // https://github.com/motdotla/dotenv
 // https://github.com/motdotla/dotenv-expand
-
 dotenvFiles.forEach(dotenvFile => {
   if (node.fs.existsSync(dotenvFile)) {
     dotenvExpand.expand(dotenv.config({
       path: dotenvFile
     }));
   }
-}); // Grab NODE_ENV and BALM_APP_* environment variables and prepare them to be
-// injected into the application via DefinePlugin in webpack configuration.
+});
 
+// Grab NODE_ENV and BALM_APP_* environment variables and prepare them to be
+// injected into the application via DefinePlugin in webpack configuration.
 const BALM_APP = /^BALM_APP_/i;
-
 function getClientEnvironment(publicUrl) {
   const raw = Object.keys(process.env).filter(key => BALM_APP.test(key)).reduce((env, key) => {
     env[key] = process.env[key];
@@ -47,8 +45,9 @@ function getClientEnvironment(publicUrl) {
     // This should only be used as an escape hatch. Normally you would put
     // images into the `src` and `import` them in code to get their paths.
     PUBLIC_URL: publicUrl
-  }, BalmJS.config.scripts.nodeEnv)); // Stringify all values so we can feed into webpack DefinePlugin
+  }, BalmJS.config.scripts.nodeEnv));
 
+  // Stringify all values so we can feed into webpack DefinePlugin
   const stringified = {
     'process.env': Object.keys(raw).reduce((env, key) => {
       env[key] = JSON.stringify(raw[key]);
@@ -63,5 +62,4 @@ function getClientEnvironment(publicUrl) {
     stringified
   };
 }
-
 export default getClientEnvironment;

package/lib/bundler/webpack/config/index.js

@@ -1,8 +1,6 @@
 import getDevConfig from './dev.js';
 import getProdConfig from './prod.js';
-
 function getDefaultConfig(webpack, scripts) {
   return BalmJS.config.env.isProd || scripts.minify || scripts.ie8 ? getProdConfig(webpack, scripts) : getDevConfig(webpack, scripts);
 }
-
 export default getDefaultConfig;

package/lib/bundler/webpack/config/prod.js

@@ -10,17 +10,13 @@ import { CHUNK } from '../../../config/constants.js';
 // `npm run prod --report`
 // Set to `true` or `false` to always turn it on or off
 const bundleAnalyzerReport = process.env.npm_config_report || false;
-
 const getCssFilename = () => `${BalmJS.config.paths.target.css}/${CHUNK.dir}/[name].${CHUNK.hash}.css`;
-
 function getProdConfig(webpack, scripts) {
   const shouldUseSourceMap = scripts.sourceMap;
   const terserOptions = scripts.minifyOptions;
-
   if (scripts.ie8) {
     terserOptions.ie8 = true;
   }
-
   return merge(getCommonConfig(webpack, scripts), {
     mode: 'production',
     optimization: {
@@ -29,14 +25,15 @@ function getProdConfig(webpack, scripts) {
         extractComments: false
       }), new CssMinimizerPlugin()]
     },
-    plugins: [// Extract css into its own file
+    plugins: [
+    // Extract css into its own file
     ...(scripts.extractCss ? [new MiniCssExtractPlugin({
       filename: BalmJS.file.assetsPath(getCssFilename()),
       chunkFilename: BalmJS.file.assetsPath(getCssFilename())
-    })] : []), // View the bundle analyzer report
+    })] : []),
+    // View the bundle analyzer report
     ...(bundleAnalyzerReport ? [new webpackBundleAnalyzer.BundleAnalyzerPlugin()] : [])],
     devtool: shouldUseSourceMap ? 'source-map' : false
   });
 }
-
 export default getProdConfig;