balm-core 5.2.0 → 6.0.0-alpha.0

package/tslib/middlewares/webpack.js

@@ -1,29 +0,0 @@
-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: [
-                {
-                    key: 'balm-core',
-                    value: BalmJS.version
-                }
-            ],
-            publicPath: BalmJS.file.publicUrlOrPath,
-            stats: false
-        })));
-        if (BalmJS.config.server.useHMR) {
-            middleware.push(webpackHotMiddleware(BalmJS.webpackCompiler, {
-                log: false,
-                path: HMR_PATH
-            }));
-        }
-    }
-    else {
-        BalmJS.logger.warn('webpack middleware', 'Webpack compiler is not ready');
-    }
-    return middleware;
-}
-export default webpackMiddleware;

package/tslib/plugins/htmlmin.js

@@ -1,38 +0,0 @@
-import { minify } from 'html-minifier-terser';
-const PLUGIN_NAME = 'htmlmin';
-function gulpHtmlmin(options) {
-    options = BalmJS.utils.deepMerge({}, options);
-    function transform(file, encoding, callback) {
-        if (file.isNull()) {
-            callback(null, file);
-            return;
-        }
-        async function htmlMinify(buf, enc, cb) {
-            try {
-                const minified = await minify(buf.toString(), options);
-                const contents = Buffer.from(minified);
-                if (cb === callback) {
-                    file.contents = contents;
-                    cb(null, file);
-                }
-                else {
-                    cb(null, contents);
-                    callback(null, file);
-                }
-            }
-            catch (e) {
-                const opts = Object.assign(options, { fileName: file.path });
-                const error = new PluginError(PLUGIN_NAME, e, opts);
-                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/tslib/plugins/imagemin.js

@@ -1,97 +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) => {
-    return async (input) => {
-        try {
-            const m = await import(`imagemin-${plugin}`);
-            const pluginFn = m.default(...args);
-            return pluginFn(input);
-        }
-        catch (_) {
-            BalmJS.logger.error(PLUGIN_NAME, `Could not load default plugin \`${plugin}\``);
-            return input;
-        }
-    };
-};
-const exposePlugin = (plugin) => (...args) => loadPlugin(plugin, ...args);
-const getDefaultPlugins = () => defaultPlugins.flatMap((plugin) => loadPlugin(plugin));
-function gulpImagemin(customPlugins) {
-    if (typeof customPlugins === 'object' && !Array.isArray(customPlugins)) {
-        customPlugins = undefined;
-    }
-    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, {
-                    plugins: plugins
-                });
-                const originalSize = file.contents.length;
-                const optimizedSize = data.length;
-                const saved = originalSize - optimizedSize;
-                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 = Buffer.from(data);
-                callback(null, file);
-            }
-            catch (error) {
-                callback(new PluginError(PLUGIN_NAME, error, {
-                    fileName: file.path
-                }));
-            }
-        })();
-    }
-    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/tslib/plugins/index.js

@@ -1,27 +0,0 @@
-import htmlmin from './htmlmin.js';
-import imagemin from './imagemin.js';
-import jsmin from './jsmin.js';
-import less from './less.js';
-import plumber from './plumber.js';
-import postcss from './postcss.js';
-import postcssPlugins from './postcss-plugins.js';
-import rename from './rename.js';
-import replace from './replace.js';
-import sass from './sass.js';
-import legacySass from './sass-legacy.js';
-import sftp from './sftp.js';
-const plugins = {
-    htmlmin,
-    imagemin,
-    jsmin,
-    less,
-    plumber,
-    postcss,
-    postcssPlugins,
-    rename,
-    replace,
-    sass,
-    legacySass,
-    sftp
-};
-BalmJS.plugins = plugins;

package/tslib/plugins/jsmin.js

@@ -1,39 +0,0 @@
-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;
-            file.contents = Buffer.from(content);
-            cb(null, file);
-        }
-        catch (e) {
-            const error = new PluginError(PLUGIN_NAME, e);
-            cb(error);
-        }
-    }
-    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/tslib/plugins/less.js

@@ -1,90 +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) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(data);
-                }
-            });
-        });
-    })).then((contents) => {
-        sourcemap.sourcesContent = contents;
-        return sourcemap;
-    }, () => sourcemap);
-}
-function renderLess(input, options) {
-    return new Promise((resolve, reject) => {
-        less.render(input, options, (error, output) => {
-            if (error) {
-                reject(error);
-            }
-            else {
-                const { css, imports } = output;
-                const result = {
-                    css,
-                    imports
-                };
-                if (options.sourceMap && output.map) {
-                    result.sourcemap = JSON.parse(output.map);
-                    inlineSources(result.sourcemap).then((map) => {
-                        result.sourcemap = map;
-                        resolve(result);
-                    });
-                }
-                else {
-                    resolve(result);
-                }
-            }
-        });
-    });
-}
-function gulpLess(customOptions) {
-    const options = Object.assign({}, {
-        compress: false,
-        paths: []
-    }, customOptions);
-    return through2.obj((file, enc, cb) => {
-        if (file.isNull()) {
-            return cb(null, file);
-        }
-        if (file.isStream()) {
-            return cb(new PluginError(PLUGIN_NAME, 'Streaming not supported'));
-        }
-        const input = file.contents.toString();
-        options.filename = file.path;
-        if (file.sourceMap || options.sourcemap) {
-            options.sourceMap = true;
-        }
-        renderLess(input, options)
-            .then((output) => {
-            file.contents = Buffer.from(output.css);
-            file.path = replaceExtension(file.path, '.css');
-            if (output.sourcemap) {
-                output.sourcemap.file = file.relative;
-                output.sourcemap.sources = output.sourcemap.sources.map((source) => node.path.relative(file.base, source));
-                applySourceMap(file, output.sourcemap);
-            }
-            return file;
-        })
-            .then((file) => {
-            cb(null, file);
-        })
-            .catch((err) => {
-            err.lineNumber = err.line;
-            err.fileName = err.filename;
-            err.message = `${err.message} in file ${err.fileName} line no.${err.lineNumber}`;
-            return cb(new PluginError(PLUGIN_NAME, err));
-        });
-    });
-}
-export default gulpLess;

package/tslib/plugins/plumber.js

@@ -1,81 +0,0 @@
-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) {
-        if (item.name === `on${event}`) {
-            found = item;
-            this.removeListener(event, item);
-        }
-    }, stream);
-    return found;
-}
-function wrapPanicOnErrorHandler(stream) {
-    const oldHandler = removeDefaultHandler(stream, 'error');
-    if (oldHandler) {
-        stream.on('error', function onerror2(error) {
-            if (emitter.listenerCount('error') === 1) {
-                this.removeListener('error', onerror2);
-                oldHandler.call(stream, error);
-            }
-        });
-    }
-}
-function defaultErrorHandler(error) {
-    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);
-            stream._pipe = stream._pipe || stream.pipe;
-            stream.pipe = stream.pipe2;
-            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;
-        if (opts.inherit !== false) {
-            patchPipe(dest);
-        }
-        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/tslib/plugins/postcss-plugins.js

@@ -1,24 +0,0 @@
-import atImport from 'postcss-import';
-import postcssFlexbugsFixes from 'postcss-flexbugs-fixes';
-import postcssPresetEnv from 'postcss-preset-env';
-import autoprefixer from 'autoprefixer';
-import cssnano from 'cssnano';
-function getDefaultPostcssPlugins(isPostCSS = false, useTailwind = false) {
-    const defaultPostcssPlugins = isPostCSS || BalmJS.config.styles.extname === 'css'
-        ? [
-            ...(useTailwind ? ['tailwindcss'] : []),
-            atImport({ path: BalmJS.file.stylePaths }),
-            postcssFlexbugsFixes(),
-            postcssPresetEnv(BalmJS.config.styles.postcssEnvOptions)
-        ]
-        : [];
-    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;

package/tslib/plugins/postcss.js

@@ -1,111 +0,0 @@
-import { Transform } from 'node:stream';
-import postcss from 'postcss';
-import postcssLoadConfig from 'postcss-load-config';
-import applySourceMap from 'vinyl-sourcemaps-apply';
-const PLUGIN_NAME = 'postcss';
-function gulpPostcss(cb) {
-    return function (plugins, options) {
-        if (Array.isArray(plugins)) {
-            return cb(() => Promise.resolve({
-                plugins: plugins,
-                options: options
-            }));
-        }
-        else if (typeof plugins === 'function') {
-            return cb((file) => Promise.resolve(plugins(file)));
-        }
-        else {
-            const contextOptions = plugins || {};
-            return cb((file) => {
-                let configPath;
-                if (contextOptions.config) {
-                    if (node.path.isAbsolute(contextOptions.config)) {
-                        configPath = contextOptions.config;
-                    }
-                    else {
-                        configPath = node.path.join(file.base, contextOptions.config);
-                    }
-                }
-                else {
-                    configPath = file.dirname;
-                }
-                const ctx = {
-                    file,
-                    options: contextOptions
-                };
-                return postcssLoadConfig(ctx, configPath);
-            });
-        }
-    };
-}
-export default gulpPostcss((loadConfig) => {
-    const stream = new Transform({ objectMode: true });
-    stream._transform = function (file, encoding, cb) {
-        if (file.isNull()) {
-            return cb(null, file);
-        }
-        if (file.isStream()) {
-            return handleError('Streams are not supported!');
-        }
-        const isProtected = file.sourceMap
-            ? { from: true, map: true }
-            : {};
-        const options = {
-            from: file.path,
-            to: file.path,
-            map: file.sourceMap ? { annotation: false } : false
-        };
-        loadConfig(file)
-            .then(function (config) {
-            const configOpts = config.options || {};
-            for (const opt in configOpts) {
-                if (Object.prototype.hasOwnProperty.call(configOpts, opt) &&
-                    !isProtected[opt]) {
-                    options[opt] = configOpts[opt];
-                }
-                else {
-                    BalmJS.logger.info(PLUGIN_NAME, `${file.relative}\nCannot override ${opt} option, because it is required by gulp-sourcemaps`);
-                }
-            }
-            return postcss(config.plugins || []).process(file.contents, options);
-        })
-            .then(handleResult, handleError);
-        function handleResult(result) {
-            let map;
-            const warnings = result.warnings().join('\n');
-            file.contents = Buffer.from(result.css);
-            if (file.sourceMap) {
-                map = result.map.toJSON();
-                map.file = file.relative;
-                map.sources = [].map.call(map.sources, function (source) {
-                    return node.path.join(node.path.dirname(file.relative), source);
-                });
-                applySourceMap(file, map);
-            }
-            if (warnings) {
-                BalmJS.logger.info(PLUGIN_NAME, `${file.relative}\nwarnings`);
-            }
-            setImmediate(function () {
-                cb(null, file);
-            });
-        }
-        function handleError(error) {
-            const errorOptions = {
-                fileName: file.path,
-                showStack: true
-            };
-            if (error.name === 'CssSyntaxError') {
-                errorOptions.error = error;
-                errorOptions.fileName = error.file || file.path;
-                errorOptions.lineNumber = error.line;
-                errorOptions.showProperties = false;
-                errorOptions.showStack = false;
-                error = `${error.message}\n\n${error.showSourceCode()}\n`;
-            }
-            setImmediate(function () {
-                cb(new PluginError(PLUGIN_NAME, error, errorOptions));
-            });
-        }
-    };
-    return stream;
-});

package/tslib/plugins/rename.js

@@ -1,51 +0,0 @@
-import { Transform } from 'node:stream';
-function gulpRename(obj, options = {}) {
-    const stream = new Transform({ objectMode: true });
-    const parsePath = (_path) => {
-        const extname = options.multiExt
-            ? node.path.basename(_path).slice(node.path.basename(_path).indexOf('.'))
-            : node.path.extname(_path);
-        return {
-            dirname: node.path.dirname(_path),
-            basename: node.path.basename(_path, extname),
-            extname: extname
-        };
-    };
-    stream._transform = (chunk, unused, callback) => {
-        const file = chunk.clone();
-        let parsedPath = parsePath(file.relative);
-        let _path;
-        const type = typeof obj;
-        if (type === 'string' && obj !== '') {
-            _path = obj;
-        }
-        else if (type === 'function') {
-            const newParsedPath = obj(parsedPath, file);
-            if (typeof newParsedPath === 'object' && newParsedPath !== null) {
-                parsedPath = newParsedPath;
-            }
-            _path = node.path.join(parsedPath.dirname, parsedPath.basename + parsedPath.extname);
-        }
-        else if (type === 'object' && obj !== undefined && obj !== null) {
-            const _obj = obj;
-            const dirname = _obj.dirname || parsedPath.dirname;
-            const prefix = _obj.prefix || '';
-            const suffix = _obj.suffix || '';
-            const basename = _obj.basename || parsedPath.basename;
-            const extname = _obj.extname || parsedPath.extname;
-            const filename = prefix + basename + suffix + extname;
-            _path = node.path.join(dirname, filename);
-        }
-        else {
-            callback(new Error('Unsupported renaming parameter type supplied'), undefined);
-            return;
-        }
-        file.path = node.path.join(file.base, _path);
-        if (file.sourceMap) {
-            file.sourceMap.file = file.relative;
-        }
-        callback(null, file);
-    };
-    return stream;
-}
-export default gulpRename;

package/tslib/plugins/replace.js

@@ -1,72 +0,0 @@
-import { Transform } from 'node:stream';
-import * as isTextModule from 'istextorbinary';
-import rs from '../utilities/replacestream.js';
-const isText = isTextModule.isText || isTextModule;
-const defaultOptions = {
-    skipBinary: true
-};
-function gulpReplace(search, _replacement, options = {}) {
-    options = {
-        ...defaultOptions,
-        ...options
-    };
-    return new Transform({
-        objectMode: true,
-        transform: (file, encoding, callback) => {
-            if (file.isNull()) {
-                return callback(null, file);
-            }
-            let replacement = _replacement;
-            if (typeof _replacement === 'function') {
-                replacement = _replacement.bind({ file: file });
-            }
-            function doReplace() {
-                if (file.isStream()) {
-                    file.contents = file.contents.pipe(rs(search, replacement));
-                    return callback(null, file);
-                }
-                if (file.isBuffer()) {
-                    const content = file.contents.toString();
-                    if (search instanceof RegExp) {
-                        file.contents = Buffer.from(content.replace(search, replacement));
-                    }
-                    else {
-                        const chunks = content.split(search);
-                        let result;
-                        if (typeof replacement === 'function') {
-                            result = [chunks[0]];
-                            for (let i = 1; i < chunks.length; i++) {
-                                result.push(replacement(search));
-                                result.push(chunks[i]);
-                            }
-                            result = result.join('');
-                        }
-                        else {
-                            result = chunks.join(replacement);
-                        }
-                        file.contents = Buffer.from(result);
-                    }
-                    return callback(null, file);
-                }
-                callback(null, file);
-            }
-            if (options.skipBinary) {
-                const isNode16 = process.version.split('.')[0] === 'v16';
-                if (isNode16) {
-                    doReplace();
-                }
-                else {
-                    if (isText(file.path, file.contents)) {
-                        doReplace();
-                    }
-                    else {
-                        callback(null, file);
-                    }
-                }
-                return;
-            }
-            doReplace();
-        }
-    });
-}
-export default gulpReplace;