balm-core 4.10.0 → 4.12.0

package/lib/hooks/index.js

@@ -1,111 +1,94 @@
 import Maker from './maker.js';
-
 class BaseHooks {
   get env() {
     return BalmJS.config.env;
-  } // HTML
-
+  }
 
+  // HTML
   html(input, output) {
     Maker.generate('html', [input, output]);
-  } // Stylesheets
-
+  }
 
+  // Stylesheets
   css(input, output) {
     Maker.generate('postcss', [input, output]);
   }
-
   sass(input, output, options) {
     Maker.generate('sass', [input, output, options]);
   }
-
   less(input, output, options) {
     Maker.generate('less', [input, output, options]);
   }
-
   url(input, output) {
     Maker.generate('url', [input, output]);
-  } // JavaScript
-
+  }
 
+  // JavaScript
   js() {
     BalmJS.logger.warn('balm api', '`mix.js` is deprecated, please use `mix.webpack`/`mix.rollup`/`mix.esbuild` instead.');
   }
-
   webpack(input, output, options, fn) {
     Maker.generate('webpack', [input, output, options, fn]);
   }
-
   esbuild(input, output, options) {
     Maker.generate('esbuild', [input, output, options]);
   }
-
   rollup(input, output) {
     Maker.generate('rollup', [input, output]);
   }
-
   jsmin(input, output, options) {
     Maker.generate('jsmin', [input, output, options]);
-  } // Files & Directories
-
+  }
 
+  // Files & Directories
   copy(input, output, options) {
     Maker.generate('copy', [input, output, options]);
   }
-
   remove(paths) {
     Maker.generate('remove', [paths]);
-  } // Cache
-
+  }
 
+  // Cache
   version(input, output, assetsOptions) {
     Maker.generate('version', [input, output, assetsOptions]);
-  } // Server
-
+  }
 
+  // Server
   serve(handler) {
     Maker.generate('serve', [handler]);
   }
-
 }
-
 class BalmHooks extends BaseHooks {
   // Stylesheets
   sprite(input, output, spriteOptions) {
     Maker.generate('sprite', [input, output, spriteOptions]);
-  } // Assets
-
+  }
 
+  // Assets
   replace(input, output, options) {
     Maker.generate('replace', [input, output, options]);
   }
-
   publish(input, output, renameOptions) {
     Maker.generate('publish', [input, output, renameOptions]);
   }
-
   zip(input = '', output = '', filename = 'archive.zip') {
     Maker.generate('zip', [input, output, filename]);
   }
-
   ftp(localFiles, options) {
     Maker.generate('ftp', [localFiles, options]);
-  } // PWA
-
+  }
 
+  // PWA
   generateSW(pwaOptions) {
     Maker.generate('pwa', ['generateSW', pwaOptions]);
   }
-
   injectManifest(pwaOptions) {
     Maker.generate('pwa', ['injectManifest', pwaOptions]);
-  } // Others
-
+  }
 
+  // Others
   modernizr() {
     Maker.generate('modernizr');
   }
-
 }
-
 export default BalmHooks;

package/lib/hooks/maker.js

@@ -1,58 +1,46 @@
 const BLOCKLIST_IN_PROD = ['serve'];
 let compiling = false;
-
 function ban(name) {
   const BLOCKLIST_IN_DEV = ['publish', ...(BalmJS.config.useDefaults ? BLOCKLIST_IN_PROD : [])];
   const banInProd = BalmJS.config.env.isProd && BLOCKLIST_IN_PROD.includes(name);
   const banInDev = BalmJS.config.env.isDev && BLOCKLIST_IN_DEV.includes(name);
   const isBan = banInProd || banInDev;
   const api = name === 'postcss' ? 'css' : name;
-
   if (isBan) {
     const message = BalmJS.config.useDefaults && BalmJS.config.env.isDev && BLOCKLIST_IN_PROD.includes(name) ? `'mix.${api}()' can only be used for 'balm.config.useDefaults = false;'` : `There is no 'mix.${api}()' hook in ${banInProd ? 'production' : 'development'} mode`;
     BalmJS.logger.warn('balm hook', message);
   }
-
   return isBan;
 }
-
 class Maker {
   // Register custom task
   static generate(name, args = []) {
     if (ban(name)) {
       return;
     }
-
     const customTask = BalmJS.tasks.get(name);
     const taskName = ['sprite', ...BLOCKLIST_IN_PROD].includes(customTask.name) ? customTask.name : `${customTask.name}:${BalmJS.recipeIndex}`;
-
     let balmTask = callback => {
       callback();
     }; // NOTE: `balmTask` function name for `gulp.parallel`
 
-
     switch (customTask.name) {
       // private
       case 'sprite':
         customTask.recipe(...args);
-
         if (customTask.deps.length) {
           balmTask = gulp.series(...BalmJS.toNamespace(customTask.deps));
         } else {
           BalmJS.logger.warn('balm hook', '`mix.sprite()` is missing `input` parameters');
         }
-
         break;
-
       case 'modernizr':
         balmTask = customTask.fn;
         break;
       // public
-
       default:
         balmTask = customTask.recipe(...args);
     }
-
     if (BalmJS.watching) {
       if (!compiling) {
         compiling = true;
@@ -67,7 +55,5 @@ class Maker {
       BalmJS.recipeIndex++;
     }
   }
-
 }
-
 export default Maker;

package/lib/middlewares/history.js

@@ -1,8 +1,6 @@
 import history from 'connect-history-api-fallback';
-
 function historyMiddleware() {
   const historyOptions = BalmJS.config.server.historyOptions;
   return historyOptions ? [BalmJS.utils.isObject(historyOptions) ? history(historyOptions) : history()] : [];
 }
-
 export default historyMiddleware;

package/lib/middlewares/index.js

@@ -1,15 +1,11 @@
 import webpackMiddleware from './webpack.js';
 import httpProxyMiddleware from './proxy.js';
 import historyMiddleware from './history.js';
-
 function getMiddlewares() {
   const canOverride = BalmJS.config.server.middlewares.every(middleware => BalmJS.utils.isFunction(middleware) || BalmJS.utils.isObject(middleware));
-
   if (!canOverride) {
     BalmJS.logger.error('server middleware', 'Server middleware must be a function (`function (req, res, next) {}`) or object (`{ route: "/api", handle: function (req, res, next) {} }`)');
   }
-
   return [...(BalmJS.config.scripts.bundler === BalmJS.Bundler.webpack ? webpackMiddleware() : []), ...httpProxyMiddleware(), ...historyMiddleware(), ...(canOverride ? BalmJS.config.server.middlewares : [])];
 }
-
 export default getMiddlewares;

package/lib/middlewares/proxy.js

@@ -1,20 +1,16 @@
 import { createProxyMiddleware } from 'http-proxy-middleware';
-
 function handleProxyConfigError() {
   const configuration = '{ context: string | array, options: object }';
   BalmJS.logger.error('proxy middleware', `Proxy config must be an object (${configuration}) or array ([${configuration}])`);
 }
-
 function httpProxyMiddleware() {
   const middleware = [];
   const proxyConfig = BalmJS.config.server.proxyConfig;
-
   if (proxyConfig) {
     try {
       if (BalmJS.utils.isObject(proxyConfig)) {
         // Single proxy
         const config = proxyConfig;
-
         if (config.context && config.options) {
           middleware.push(createProxyMiddleware(config.context, config.options));
         } else {
@@ -39,8 +35,6 @@ function httpProxyMiddleware() {
       BalmJS.logger.error('proxy middleware', message);
     }
   }
-
   return middleware;
 }
-
 export default httpProxyMiddleware;

package/lib/middlewares/webpack.js

@@ -1,10 +1,8 @@
 import webpackDevMiddleware from 'webpack-dev-middleware';
 import webpackHotMiddleware from 'webpack-hot-middleware';
 import { HMR_PATH } from '../config/constants.js';
-
 function webpackMiddleware() {
   const middleware = [];
-
   if (BalmJS.webpackCompiler) {
     middleware.push(webpackDevMiddleware(BalmJS.webpackCompiler, Object.assign({}, BalmJS.config.server.devOptions, {
       headers: [{
@@ -14,7 +12,6 @@ function webpackMiddleware() {
       publicPath: BalmJS.file.publicUrlOrPath,
       stats: false
     })));
-
     if (BalmJS.config.server.useHMR) {
       middleware.push(webpackHotMiddleware(BalmJS.webpackCompiler, {
         log: false,
@@ -24,8 +21,6 @@ function webpackMiddleware() {
   } else {
     BalmJS.logger.warn('webpack middleware', 'Webpack compiler is not ready');
   }
-
   return middleware;
 }
-
 export default webpackMiddleware;

package/lib/plugins/htmlmin.js

@@ -1,20 +1,17 @@
 // Reference `gulp-htmlmin@5.0.1`
+
 import { minify } from 'html-minifier';
 const PLUGIN_NAME = 'htmlmin';
-
 function gulpHtmlmin(options) {
   options = BalmJS.utils.deepMerge({}, options);
-
   function transform(file, encoding, callback) {
     if (file.isNull()) {
       callback(null, file);
       return;
     }
-
     function htmlMinify(buf, enc, cb) {
       try {
         const contents = Buffer.from(minify(buf.toString(), options));
-
         if (cb === callback) {
           file.contents = contents;
           cb(null, file);
@@ -30,15 +27,12 @@ function gulpHtmlmin(options) {
         cb === callback ? cb(error) : callback(error);
       }
     }
-
     if (file.isStream()) {
       file.contents = file.contents.pipe(through2(htmlMinify));
     } else {
       htmlMinify(file.contents, null, callback);
     }
   }
-
   return through2.obj(transform);
 }
-
 export default gulpHtmlmin;

package/lib/plugins/imagemin.js

@@ -1,10 +1,10 @@
 // Reference `gulp-imagemin@8.0.0`
+
 import imagemin from 'imagemin';
 import prettyBytes from 'pretty-bytes';
 import through2Concurrent from 'through2-concurrent';
 const PLUGIN_NAME = 'imagemin';
 const defaultPlugins = ['gifsicle', 'mozjpeg', 'optipng', 'svgo'];
-
 const loadPlugin = (plugin, ...args) => {
   try {
     return requireModule(`imagemin-${plugin}`)(...args);
@@ -12,36 +12,28 @@ const loadPlugin = (plugin, ...args) => {
     BalmJS.logger.error(PLUGIN_NAME, `Couldn't load default plugin "${plugin}"`);
   }
 };
-
 const exposePlugin = plugin => (...args) => loadPlugin(plugin, ...args);
-
 const getDefaultPlugins = () => defaultPlugins.flatMap(plugin => loadPlugin(plugin));
-
 const gulpImagemin = customPlugins => {
   const validExtensions = new Set(['.jpg', '.jpeg', '.png', '.gif', '.svg']);
   let totalBytes = 0;
   let totalSavedBytes = 0;
   let totalFiles = 0;
-
   function transform(file, encoding, callback) {
     if (file.isNull()) {
       callback(null, file);
       return;
     }
-
     if (file.isStream()) {
       callback(new PluginError(PLUGIN_NAME, 'Streaming not supported'));
       return;
     }
-
     if (!validExtensions.has(node.path.extname(file.path).toLowerCase())) {
       BalmJS.logger.info(PLUGIN_NAME, `Skipping unsupported image "${file.relative}"`);
       callback(null, file);
       return;
     }
-
     const plugins = customPlugins || getDefaultPlugins();
-
     (async () => {
       try {
         const data = await imagemin.buffer(file.contents, {
@@ -53,13 +45,11 @@ const gulpImagemin = customPlugins => {
         const percent = originalSize > 0 ? saved / originalSize * 100 : 0;
         const savedMessage = `saved ${prettyBytes(saved)} - ${percent.toFixed(1).replace(/\.0$/, '')}%`;
         const message = saved > 0 ? savedMessage : 'already optimized';
-
         if (saved > 0) {
           totalBytes += originalSize;
           totalSavedBytes += saved;
           totalFiles++;
         }
-
         BalmJS.logger.debug(PLUGIN_NAME, `${file.relative} (${message})`);
         file.contents = data;
         callback(null, file);
@@ -70,35 +60,28 @@ const gulpImagemin = customPlugins => {
       }
     })();
   }
-
   function flush(callback) {
     const percent = totalBytes > 0 ? totalSavedBytes / totalBytes * 100 : 0;
     let message = `Minified ${totalFiles} image${totalFiles > 1 ? 's' : ''}`;
-
     if (totalFiles > 0) {
       message += ` (saved ${prettyBytes(totalSavedBytes)} - ${percent.toFixed(1).replace(/\.0$/, '')}%)`;
     }
-
     BalmJS.logger.info(PLUGIN_NAME, message);
     callback();
   }
-
   return through2Concurrent.obj({
     maxConcurrency: 8
   }, transform, flush);
 };
-
 const gifsicle = exposePlugin('gifsicle');
 const mozjpeg = exposePlugin('mozjpeg');
 const optipng = exposePlugin('optipng');
 const svgo = exposePlugin('svgo');
-
 const getDefaultImagePlugins = () => ({
   gif: gifsicle(),
   jpeg: mozjpeg(),
   png: optipng(),
   svg: svgo()
 });
-
 export default gulpImagemin;
 export { getDefaultImagePlugins };

package/lib/plugins/jsmin.js

@@ -1,14 +1,11 @@
 import { minify } from 'terser';
 const PLUGIN_NAME = 'jsmin';
-
 async function jsMinify(file, opts, cb) {
   const extname = node.path.extname(file.path);
-
   if (extname === '.js') {
     const code = {};
     let content = file.contents.toString();
     code[node.path.basename(file.path)] = content;
-
     try {
       const result = await minify(code, opts);
       content = result.code;
@@ -21,27 +18,20 @@ async function jsMinify(file, opts, cb) {
   } else {
     BalmJS.logger.error(PLUGIN_NAME, 'Invalid JS file');
   }
-
   return file;
 }
-
 function gulpJsmin(options) {
   options = BalmJS.utils.deepMerge({}, options);
-
   function transform(chunk, encoding, callback) {
     if (chunk.isStream()) {
       return this.emit('error', new PluginError(PLUGIN_NAME, 'Streams not supported'));
     }
-
     if (chunk.isNull()) {
       callback(null, chunk);
       return;
     }
-
     jsMinify(chunk, options, callback);
   }
-
   return through2.obj(transform);
 }
-
 export default gulpJsmin;

package/lib/plugins/less.js

@@ -1,14 +1,13 @@
 // Reference `gulp-less@5.0.0`
+
 import less from 'less';
 import replaceExtension from 'replace-ext';
 import applySourceMap from 'vinyl-sourcemaps-apply';
 const PLUGIN_NAME = 'less';
-
 function inlineSources(sourcemap) {
   if (sourcemap.sourcesContent) {
     return Promise.resolve(sourcemap);
   }
-
   return Promise.all(sourcemap.sources.map(source => {
     return new Promise((resolve, reject) => {
       node.fs.readFile(source, 'utf8', (err, data) => {
@@ -24,7 +23,6 @@ function inlineSources(sourcemap) {
     return sourcemap;
   }, () => sourcemap);
 }
-
 function renderLess(str, opts) {
   return new Promise((resolve, reject) => {
     less.render(str, opts, (err, res) => {
@@ -35,7 +33,6 @@ function renderLess(str, opts) {
           result: res.css,
           imports: res.imports
         };
-
         if (opts.sourceMap && res.map) {
           obj.sourcemap = JSON.parse(res.map);
           inlineSources(obj.sourcemap).then(map => {
@@ -49,7 +46,6 @@ function renderLess(str, opts) {
     });
   });
 }
-
 function gulpLess(options) {
   // Mixes in default options.
   const opts = Object.assign({}, {
@@ -60,41 +56,38 @@ function gulpLess(options) {
     if (file.isNull()) {
       return cb(null, file);
     }
-
     if (file.isStream()) {
       return cb(new PluginError(PLUGIN_NAME, 'Streaming not supported'));
     }
+    const str = file.contents.toString();
 
-    const str = file.contents.toString(); // Injects the path of the current file
-
-    opts.filename = file.path; // Bootstrap source maps
+    // Injects the path of the current file
+    opts.filename = file.path;
 
+    // Bootstrap source maps
     if (file.sourceMap || opts.sourcemap) {
       opts.sourceMap = true;
     }
-
     renderLess(str, opts).then(res => {
       file.contents = Buffer.from(res.result);
       file.path = replaceExtension(file.path, '.css');
-
       if (res.sourcemap) {
         res.sourcemap.file = file.relative;
         res.sourcemap.sources = res.sourcemap.sources.map(source => node.path.relative(file.base, source));
         applySourceMap(file, res.sourcemap);
       }
-
       return file;
     }).then(file => {
       cb(null, file);
     }).catch(err => {
       // Convert the keys so PluginError can read them
       err.lineNumber = err.line;
-      err.fileName = err.filename; // Add a better error message
+      err.fileName = err.filename;
 
+      // Add a better error message
       err.message = `${err.message} in file ${err.fileName} line no.${err.lineNumber}`;
       return cb(new PluginError(PLUGIN_NAME, err));
     });
   });
 }
-
 export default gulpLess;

package/lib/plugins/plumber.js

@@ -2,7 +2,6 @@
 import { EventEmitter } from 'node:events';
 const PLUGIN_NAME = 'plumber';
 const emitter = new EventEmitter();
-
 function removeDefaultHandler(stream, event) {
   let found = false;
   stream.listeners(event).forEach(function (item) {
@@ -13,10 +12,8 @@ function removeDefaultHandler(stream, event) {
   }, stream);
   return found;
 }
-
 function wrapPanicOnErrorHandler(stream) {
   const oldHandler = removeDefaultHandler(stream, 'error');
-
   if (oldHandler) {
     stream.on('error', function onerror2(error) {
       if (emitter.listenerCount('error') === 1) {
@@ -26,28 +23,23 @@ function wrapPanicOnErrorHandler(stream) {
     });
   }
 }
-
 function defaultErrorHandler(error) {
   // onerror2 and this handler
   if (emitter.listenerCount('error') < 3) {
     BalmJS.logger.error(`${PLUGIN_NAME} - found unhandled error`, error.toString());
   }
 }
-
 function gulpPlumber(opts = {}) {
   if (BalmJS.utils.isFunction(opts)) {
     opts = {
       errorHandler: opts
     };
   }
-
   const through = through2.obj();
   through._plumber = true;
-
   if (opts.errorHandler !== false) {
     through.errorHandler = BalmJS.utils.isFunction(opts.errorHandler) ? opts.errorHandler : defaultErrorHandler;
   }
-
   function patchPipe(stream) {
     if (stream.pipe2) {
       wrapPanicOnErrorHandler(stream);
@@ -56,49 +48,40 @@ function gulpPlumber(opts = {}) {
       stream._plumbed = true;
     }
   }
-
   through.pipe2 = function pipe2(dest) {
     if (!dest) {
       throw new PluginError(PLUGIN_NAME, "Can't pipe to undefined");
     }
-
     this._pipe(dest);
-
     if (dest._unplumbed) {
       return dest;
     }
-
     removeDefaultHandler(this, 'error');
-
     if (dest._plumber) {
       return dest;
     }
+    dest.pipe2 = pipe2;
 
-    dest.pipe2 = pipe2; // Patching pipe method
-
+    // Patching pipe method
     if (opts.inherit !== false) {
       patchPipe(dest);
-    } // Placing custom on error handler
-
+    }
 
+    // Placing custom on error handler
     if (this.errorHandler) {
       dest.errorHandler = this.errorHandler;
       dest.on('error', this.errorHandler.bind(dest));
     }
-
     dest._plumbed = true;
     return dest;
   };
-
   patchPipe(through);
   return through;
 }
-
 function stop() {
   const through = through2.obj();
   through._unplumbed = true;
   return through;
 }
-
 export default gulpPlumber;
 export { stop };

package/lib/plugins/postcss-plugins.js

@@ -3,7 +3,6 @@ import postcssFlexbugsFixes from 'postcss-flexbugs-fixes';
 import postcssPresetEnv from 'postcss-preset-env';
 import autoprefixer from 'autoprefixer';
 import cssnano from 'cssnano';
-
 function getDefaultPostcssPlugins(isPostCSS = false) {
   const defaultPostcssPlugins = isPostCSS || BalmJS.config.styles.extname === 'css' ? [atImport({
     path: BalmJS.file.stylePaths
@@ -11,5 +10,4 @@ function getDefaultPostcssPlugins(isPostCSS = false) {
   const cssnanoPlugin = BalmJS.config.env.isProd || BalmJS.config.styles.minify ? [cssnano(BalmJS.config.styles.options)] : [];
   return defaultPostcssPlugins.concat([autoprefixer(), ...cssnanoPlugin, ...BalmJS.config.styles.postcssPlugins]);
 }
-
 export default getDefaultPostcssPlugins;