balm-core 5.2.0 → 6.0.0-alpha.1

package/tslib/tasks/public/ftp.js

@@ -1,39 +0,0 @@
-class FtpTask extends BalmJS.BalmTask {
-    constructor() {
-        super('ftp');
-    }
-    get options() {
-        return Object.assign({}, BalmJS.config.ftp.options, this.customOptions);
-    }
-    recipe(localFiles, options = {}) {
-        const balmFtp = () => {
-            const taskName = `${this.name} task`;
-            const input = localFiles || BalmJS.watchFtpFile;
-            if (input) {
-                this.init(input, null, options);
-                if (!options.src) {
-                    this.gulpSrcOptions = {
-                        base: '.'
-                    };
-                }
-                let stream = this.src;
-                try {
-                    stream = stream.pipe(BalmJS.plugins.sftp(this.options));
-                }
-                catch (error) {
-                    const { message } = error;
-                    BalmJS.logger.error(taskName, message);
-                }
-                return stream;
-            }
-            else {
-                BalmJS.logger.warn(taskName, 'Invalid local files');
-            }
-        };
-        return balmFtp;
-    }
-    get fn() {
-        return this.recipe();
-    }
-}
-export default FtpTask;

package/tslib/tasks/public/html.js

@@ -1,75 +0,0 @@
-import { PUBLIC_URL } from '../../config/constants.js';
-class HtmlTask extends BalmJS.BalmTask {
-    constructor() {
-        super('html');
-        this.defaultInput = [
-            node.path.join(BalmJS.file.templateBasePath, '*.html'),
-            node.path.join(BalmJS.file.templateBasePath, BalmJS.config.pwa.manifest)
-        ];
-        this.defaultOutput = BalmJS.config.dest.base;
-    }
-    #updateAssetsPath = (type) => {
-        const isManifest = type === 'manifest';
-        const assetsType = isManifest ? 'img' : type;
-        const from = BalmJS.config.paths.source[assetsType];
-        const to = BalmJS.file.assetsPath(BalmJS.config.paths.target[assetsType]);
-        const assetsPathSrc = new RegExp(isManifest ? `/?${from}` : `${PUBLIC_URL}/${from}`, 'g');
-        const assetsPathDest = `${PUBLIC_URL}/${to}`;
-        BalmJS.logger.debug(`${this.name} task - assets path`, {
-            regex: assetsPathSrc,
-            replacement: assetsPathDest
-        }, {
-            pre: true
-        });
-        return BalmJS.plugins.replace(assetsPathSrc, assetsPathDest);
-    };
-    #hasSourcePath = (type) => {
-        return !!BalmJS.config.paths.source[type];
-    };
-    recipe(input, output) {
-        const balmHtml = () => {
-            this.init(input, output);
-            let stream = this.src;
-            if (BalmJS.config.env.isProd) {
-                stream = stream
-                    .pipe($.useref({
-                    base: BalmJS.config.workspace,
-                    searchPath: [
-                        BalmJS.config.roots.tmp,
-                        BalmJS.config.roots.source,
-                        '.'
-                    ]
-                }))
-                    .pipe($.if(/\.html$/, BalmJS.plugins.htmlmin(BalmJS.config.html.options)));
-                ['css', 'js', 'img', 'media', 'manifest'].forEach((type) => {
-                    const canUpdate = type === 'manifest'
-                        ? BalmJS.config.pwa.enabled
-                        : this.#hasSourcePath(type);
-                    if (canUpdate) {
-                        stream = stream.pipe(this.#updateAssetsPath(type));
-                    }
-                });
-                stream = BalmJS.config.assets.cache
-                    ? stream.pipe($.if(BalmJS.config.pwa.manifest, BalmJS.file.setPublicPath()))
-                    : stream.pipe(BalmJS.file.setPublicPath());
-            }
-            else {
-                ['css', 'js', 'img', 'media'].forEach((type, index) => {
-                    const canUpdate = index > 1
-                        ? this.#hasSourcePath(type) && !BalmJS.config.inFrontend
-                        : this.#hasSourcePath(type);
-                    if (canUpdate) {
-                        stream = stream.pipe(this.#updateAssetsPath(type));
-                    }
-                });
-                stream = stream.pipe(BalmJS.file.setPublicPath());
-            }
-            return stream.pipe(gulp.dest(this.output));
-        };
-        return balmHtml;
-    }
-    get fn() {
-        return this.recipe();
-    }
-}
-export default HtmlTask;

package/tslib/tasks/public/index.js

@@ -1,38 +0,0 @@
-import SassTask from './sass.js';
-import LessTask from './less.js';
-import PostcssTask from './postcss.js';
-import UrlTask from './url.js';
-import WebpackTask from './webpack.js';
-import EsbuildTask from './esbuild.js';
-import RollupTask from './rollup.js';
-import JsminTask from './jsmin.js';
-import HtmlTask from './html.js';
-import CopyTask from './copy.js';
-import RemoveTask from './remove.js';
-import ReplaceTask from './replace.js';
-import VersionTask from './version.js';
-import ServerTask from './server.js';
-import PublishTask from './publish.js';
-import ZipTask from './zip.js';
-import FtpTask from './ftp.js';
-import PwaTask from './pwa.js';
-export default {
-    SassTask,
-    LessTask,
-    PostcssTask,
-    UrlTask,
-    WebpackTask,
-    EsbuildTask,
-    RollupTask,
-    JsminTask,
-    HtmlTask,
-    CopyTask,
-    RemoveTask,
-    ReplaceTask,
-    VersionTask,
-    ServerTask,
-    PublishTask,
-    ZipTask,
-    FtpTask,
-    PwaTask
-};

package/tslib/tasks/public/jsmin.js

@@ -1,24 +0,0 @@
-class JsminTask extends BalmJS.BalmTask {
-    constructor() {
-        super('jsmin');
-    }
-    get options() {
-        const defaultOptions = Object.assign({}, BalmJS.config.scripts.minifyOptions);
-        return BalmJS.utils.deepMerge(defaultOptions, this.customOptions);
-    }
-    recipe(input, output, options = {}) {
-        const balmJsmin = () => {
-            this.init(input, output, options);
-            const renameOptions = options.rename || { suffix: '.min' };
-            return this.src
-                .pipe(BalmJS.plugins.jsmin(this.options))
-                .pipe(BalmJS.plugins.rename(renameOptions))
-                .pipe(gulp.dest(this.output));
-        };
-        return balmJsmin;
-    }
-    fn(callback) {
-        callback();
-    }
-}
-export default JsminTask;

package/tslib/tasks/public/less.js

@@ -1,21 +0,0 @@
-class LessTask extends BalmJS.BalmStyleTask {
-    constructor() {
-        super('less');
-    }
-    get options() {
-        return Object.assign({
-            paths: BalmJS.file.stylePaths
-        }, BalmJS.config.styles.lessOptions, this.customOptions);
-    }
-    recipe(input, output, options = {}) {
-        const balmLess = () => {
-            this.init(input, output, options);
-            return this.handleStyle(this.name, this.output, this.options);
-        };
-        return balmLess;
-    }
-    get fn() {
-        return this.recipe();
-    }
-}
-export default LessTask;

package/tslib/tasks/public/postcss.js

@@ -1,16 +0,0 @@
-class PostcssTask extends BalmJS.BalmStyleTask {
-    constructor() {
-        super('postcss');
-    }
-    recipe(input, output) {
-        const balmPostcss = () => {
-            this.init(input, output);
-            return this.handleStyle(this.name, this.output);
-        };
-        return balmPostcss;
-    }
-    get fn() {
-        return this.recipe();
-    }
-}
-export default PostcssTask;

package/tslib/tasks/public/publish.js

@@ -1,50 +0,0 @@
-import mergeStream from '../../utilities/merge-stream.js';
-class PublishTask extends BalmJS.BalmTask {
-    constructor() {
-        super('publish');
-        this.defaultInput = [
-            BalmJS.file.matchAllFiles(BalmJS.config.dest.static),
-            node.path.join(`!${BalmJS.config.dest.base}`, '*.*')
-        ];
-        this.defaultOutput = BalmJS.config.assets.static;
-    }
-    #release = (input, output, renameOptions = {}) => {
-        let srcPath;
-        let destPath;
-        if (input && output) {
-            srcPath = BalmJS.file.absPaths(node.path.join(BalmJS.config.dest.base, input));
-            destPath = BalmJS.file.absPath(node.path.join(BalmJS.config.assets.root, output));
-        }
-        else {
-            this.init();
-            srcPath = this.input;
-            destPath = this.output;
-        }
-        return gulp
-            .src(srcPath, { allowEmpty: true })
-            .pipe($.if(!BalmJS.utils.isArray(srcPath), BalmJS.plugins.rename(renameOptions)))
-            .pipe(gulp.dest(destPath));
-    };
-    recipe(input, output, renameOptions) {
-        const balmPublish = (callback) => {
-            if (BalmJS.config.env.isProd) {
-                if (BalmJS.utils.isArray(input)) {
-                    const tasks = input.map((template) => this.#release(template.input, template.output, template.renameOptions));
-                    return mergeStream(...tasks);
-                }
-                else {
-                    return this.#release(input, output, renameOptions);
-                }
-            }
-            else {
-                BalmJS.logger.warn(`${this.name} task`, '`mix.publish()` is only supported for production');
-                callback();
-            }
-        };
-        return balmPublish;
-    }
-    fn(callback) {
-        callback();
-    }
-}
-export default PublishTask;

package/tslib/tasks/public/pwa.js

@@ -1,87 +0,0 @@
-import { generateSW, injectManifest } from 'workbox-build';
-class PwaTask extends BalmJS.BalmTask {
-    constructor() {
-        super('pwa');
-    }
-    setIgnores(options) {
-        const defaultIgnores = [BalmJS.config.pwa.swSrcFilename];
-        if (options.globIgnores) {
-            options.globIgnores = options.globIgnores.concat(defaultIgnores);
-        }
-        else {
-            options.globIgnores = defaultIgnores;
-        }
-        return options;
-    }
-    recipe(customMode, customOptions = {}) {
-        const balmPwa = async (callback) => {
-            const mode = customMode || BalmJS.config.pwa.mode;
-            let options = {};
-            const globDirectory = BalmJS.config.dest.base;
-            const swDest = BalmJS.file.absPath(`${globDirectory}/${BalmJS.config.pwa.swDestFilename}`);
-            const swSrc = BalmJS.file.absPath(`${BalmJS.config.src.base}/${BalmJS.config.pwa.swSrcFilename}`);
-            let valid = true;
-            switch (mode) {
-                case 'generateSW':
-                    options = Object.assign({
-                        globDirectory,
-                        swDest
-                    }, BalmJS.config.pwa.options, customOptions);
-                    break;
-                case 'injectManifest':
-                    options = Object.assign({
-                        globDirectory,
-                        swDest,
-                        swSrc
-                    }, BalmJS.config.pwa.options, customOptions);
-                    break;
-                default:
-                    valid = false;
-            }
-            if (valid) {
-                options = this.setIgnores(options);
-                BalmJS.logger.debug(`pwa - ${mode}`, options, {
-                    pre: true
-                });
-                const workboxBuild = mode === 'generateSW'
-                    ? generateSW(options)
-                    : injectManifest(options);
-                try {
-                    const { count, size } = await workboxBuild;
-                    BalmJS.logger.info(`pwa - ${mode}`, `Generated '${swDest}', which will precache ${count} files, totaling ${size} bytes`);
-                    await new Promise((resolve) => {
-                        const pwaCacheTask = BalmJS.tasks.get('pwa-cache');
-                        if (pwaCacheTask) {
-                            const stream = pwaCacheTask.fn();
-                            if (stream && typeof stream.on === 'function') {
-                                stream.on('finish', resolve).on('error', () => resolve());
-                            }
-                            else if (stream && typeof stream.then === 'function') {
-                                stream.then(resolve, resolve);
-                            }
-                            else {
-                                resolve();
-                            }
-                        }
-                        else {
-                            resolve();
-                        }
-                    });
-                }
-                catch (err) {
-                    BalmJS.logger.warn(`pwa - ${mode}`, `Service worker generation failed: ${err}`);
-                }
-                callback();
-            }
-            else {
-                BalmJS.logger.warn('pwa task', 'Invalid PWA mode');
-                callback();
-            }
-        };
-        return balmPwa;
-    }
-    get fn() {
-        return this.recipe();
-    }
-}
-export default PwaTask;

package/tslib/tasks/public/remove.js

@@ -1,44 +0,0 @@
-import { deleteAsync } from 'del';
-class RemoveTask extends BalmJS.BalmTask {
-    constructor() {
-        super('remove');
-    }
-    #getFiles = (input) => {
-        let files = BalmJS.file.absPaths(input);
-        files = BalmJS.utils.isArray(input)
-            ? files.map((file) => file.replace(/\\/g, '/'))
-            : files.replace(/\\/g, '/');
-        return files;
-    };
-    recipe(input) {
-        const balmRemove = async (callback) => {
-            const canDel = !!((BalmJS.utils.isString(input) && input.trim()) ||
-                (BalmJS.utils.isArray(input) && input.length));
-            if (canDel) {
-                const files = this.#getFiles(input);
-                BalmJS.logger.debug(`${this.name} task`, {
-                    files
-                }, {
-                    pre: true
-                });
-                const deletedPaths = await deleteAsync(files, {
-                    force: true
-                });
-                BalmJS.logger.warn(`${this.name} task`, {
-                    deletedPaths
-                }, {
-                    pre: true
-                });
-            }
-            else {
-                BalmJS.logger.error(`${this.name} task`, 'Invalid input');
-            }
-            callback();
-        };
-        return balmRemove;
-    }
-    fn(callback) {
-        callback();
-    }
-}
-export default RemoveTask;

package/tslib/tasks/public/replace.js

@@ -1,27 +0,0 @@
-class ReplaceTask extends BalmJS.BalmTask {
-    constructor() {
-        super('replace');
-    }
-    recipe(input, output, options) {
-        const balmReplace = () => {
-            this.init(input, output);
-            let stream = this.src;
-            if (BalmJS.utils.isArray(options)) {
-                const replaceOptions = options;
-                replaceOptions.forEach((replaceOption) => {
-                    stream = stream.pipe(BalmJS.plugins.replace(replaceOption.substr, replaceOption.replacement));
-                });
-            }
-            else {
-                const replaceOption = options;
-                stream = stream.pipe(BalmJS.plugins.replace(replaceOption.substr, replaceOption.replacement));
-            }
-            return stream.pipe(gulp.dest(this.output));
-        };
-        return balmReplace;
-    }
-    fn(callback) {
-        callback();
-    }
-}
-export default ReplaceTask;

package/tslib/tasks/public/rollup.js

@@ -1,17 +0,0 @@
-import buildLibrary from '../../bundler/rollup/index.js';
-class RollupTask extends BalmJS.BalmTask {
-    constructor() {
-        super('rollup');
-    }
-    recipe(input, output) {
-        const balmBundler = async (callback) => {
-            await buildLibrary(input, output);
-            callback();
-        };
-        return balmBundler;
-    }
-    fn(callback) {
-        callback();
-    }
-}
-export default RollupTask;

package/tslib/tasks/public/sass.js

@@ -1,27 +0,0 @@
-class SassTask extends BalmJS.BalmStyleTask {
-    constructor() {
-        super('sass');
-    }
-    get options() {
-        return Object.assign(node.isLegacySass
-            ? {
-                includePaths: BalmJS.file.stylePaths,
-                outputStyle: 'expanded'
-            }
-            : {
-                loadPaths: BalmJS.file.stylePaths,
-                sourceMap: true
-            }, { quietDeps: BalmJS.config.logs.level < BalmJS.LogLevel.Warn }, BalmJS.config.styles.sassOptions, this.customOptions);
-    }
-    recipe(input, output, options = {}) {
-        const balmSass = () => {
-            this.init(input, output, options);
-            return this.handleStyle(this.name, this.output, this.options);
-        };
-        return balmSass;
-    }
-    get fn() {
-        return this.recipe();
-    }
-}
-export default SassTask;

package/tslib/tasks/public/server.js

@@ -1,129 +0,0 @@
-import detectPort from '../../utilities/detect-port.js';
-import getMiddlewares from '../../middlewares/index.js';
-class ServerTask extends BalmJS.BalmTask {
-    constructor() {
-        super('serve');
-        if (BalmJS.config.env.isDev) {
-            detectPort(BalmJS.config.server.port, BalmJS.config.server.host).then((port) => {
-                if (BalmJS.config.server.port !== port) {
-                    BalmJS.logger.warn('server task', `port: ${BalmJS.config.server.port} was occupied, try port: ${port}`);
-                    BalmJS.config.server.port = port;
-                }
-            }, () => { });
-        }
-    }
-    #watchTask = (taskName, serverReload = false) => {
-        const balmTask = BalmJS.tasks.get(taskName).fn;
-        const reload = (done) => {
-            server.reload();
-            done();
-        };
-        return serverReload ? gulp.series(balmTask, reload) : balmTask;
-    };
-    #onWatch = () => {
-        const { watch } = gulp;
-        const watchOptions = {
-            cwd: BalmJS.config.workspace
-        };
-        watch([
-            `${BalmJS.config.src.img}/**/*`,
-            `${BalmJS.config.dest.font}/**/*`,
-            ...BalmJS.config.server.extraWatchFiles
-        ], watchOptions).on('change', server.reload);
-        watch(`${BalmJS.file.templateBasePath}/*.html`, watchOptions, this.#watchTask('html', true));
-        watch(`${BalmJS.config.src.css}/**/*.${BalmJS.config.styles.extname}`, watchOptions, this.#watchTask(BalmJS.config.inFrontend ? this.styleName : 'style'));
-        if (!BalmJS.config.server.useHMR) {
-            watch(`${BalmJS.config.src.js}/**/*`, watchOptions, this.#watchTask(BalmJS.config.scripts.bundler, true));
-        }
-        watch(`${BalmJS.config.src.base}/modernizr.json`, watchOptions, this.#watchTask('modernizr'));
-        watch(`${BalmJS.config.src.font}/**/*`, watchOptions, this.#watchTask('font'));
-        if (BalmJS.config.ftp.watchFiles.length) {
-            watch(BalmJS.config.ftp.watchFiles, watchOptions).on('change', (path) => {
-                BalmJS.logger.debug(`${this.name} task`, `File ${path} was changed`);
-                BalmJS.watchFtpFile = path;
-                this.#watchTask('ftp', true)();
-            });
-        }
-    };
-    recipe(customHandler) {
-        const balmServe = (callback) => {
-            if (BalmJS.server) {
-                BalmJS.logger.warn('server task', 'Server has started');
-            }
-            else {
-                const serverConfig = BalmJS.config.server;
-                let bsOptions = {
-                    logPrefix: 'BalmJS',
-                    notify: false,
-                    port: serverConfig.port,
-                    host: serverConfig.host,
-                    https: serverConfig.https,
-                    callbacks: {
-                        ready() {
-                            if (BalmJS.config.env.isMP) {
-                                BalmJS.logger.info('提示', `请使用微信开发者工具打开 ${BalmJS.config.roots.tmp} 预览小程序`, { logLevel: BalmJS.LogLevel.Error });
-                            }
-                            serverConfig.next();
-                        }
-                    },
-                    open: serverConfig.open,
-                    localOnly: BalmJS.config.env.inDesktopApp,
-                    scriptPath: BalmJS.config.scripts.ie8 ? () => '' : undefined
-                };
-                if (serverConfig.proxy) {
-                    if (BalmJS.utils.isString(serverConfig.proxy)) {
-                        bsOptions.proxy = {
-                            target: serverConfig.proxy
-                        };
-                    }
-                    else if (BalmJS.utils.isObject(serverConfig.proxy)) {
-                        bsOptions.proxy = serverConfig.proxy;
-                    }
-                    else {
-                        BalmJS.logger.error(`${this.name} task`, '`server.proxy` must be a string or object');
-                    }
-                    bsOptions.serveStatic = serverConfig.serveStatic;
-                }
-                else {
-                    bsOptions.server = {
-                        baseDir: [BalmJS.config.dest.base, BalmJS.config.src.base],
-                        routes: {
-                            '/bower_components': BalmJS.file.absPath('bower_components'),
-                            '/node_modules': BalmJS.file.absPath('node_modules')
-                        }
-                    };
-                }
-                bsOptions.middleware = BalmJS.config.env.isDev
-                    ? getMiddlewares()
-                    : false;
-                bsOptions = BalmJS.utils.deepMerge(bsOptions, serverConfig.options);
-                if (BalmJS.config.env.isDev) {
-                    BalmJS.server = server.init(bsOptions);
-                    if (BalmJS.config.useDefaults) {
-                        this.#onWatch();
-                    }
-                    else {
-                        BalmJS.watching = true;
-                        const watcher = gulp.watch([
-                            `${BalmJS.config.src.base}/**/*`,
-                            ...serverConfig.extraWatchFiles
-                        ]);
-                        try {
-                            customHandler && customHandler(watcher, server.reload);
-                        }
-                        catch (error) {
-                            const { message } = error;
-                            BalmJS.logger.error('balm hook', message);
-                        }
-                    }
-                }
-            }
-            callback();
-        };
-        return balmServe;
-    }
-    get fn() {
-        return this.recipe();
-    }
-}
-export default ServerTask;

package/tslib/tasks/public/url.js

@@ -1,35 +0,0 @@
-class UrlTask extends BalmJS.BalmTask {
-    constructor() {
-        super('url');
-        this.defaultOutput = BalmJS.config.dest.css;
-        this.defaultInput = BalmJS.file.matchAllFiles(this.defaultOutput, '*.css');
-    }
-    #urlProcessing = (type) => {
-        const pattern = BalmJS.config.paths.source[type]
-            .split('/')
-            .pop();
-        const pathSrc = new RegExp(`\\.{2}/${pattern}/`, 'g');
-        const pathDest = `../${BalmJS.config.paths.target[type]}/`;
-        BalmJS.logger.debug(`${this.name} task`, {
-            regex: pathSrc,
-            replacement: pathDest
-        }, {
-            pre: true
-        });
-        return BalmJS.plugins.replace(pathSrc, pathDest);
-    };
-    recipe(input, output) {
-        const balmUrl = () => {
-            this.init(input, output);
-            return this.src
-                .pipe(this.#urlProcessing('img'))
-                .pipe(this.#urlProcessing('font'))
-                .pipe(gulp.dest(this.output));
-        };
-        return balmUrl;
-    }
-    get fn() {
-        return this.recipe();
-    }
-}
-export default UrlTask;

package/tslib/tasks/public/version.js

@@ -1,27 +0,0 @@
-import revAll from 'gulp-rev-all';
-class VersionTask extends BalmJS.BalmTask {
-    constructor() {
-        super('version');
-        this.defaultOutput = BalmJS.config.dest.base;
-    }
-    get options() {
-        return Object.assign({}, BalmJS.config.assets.options, this.customOptions);
-    }
-    recipe(input, output, assetsOptions) {
-        const balmVersion = () => {
-            this.init(input, output, {
-                version: assetsOptions
-            });
-            return this.src
-                .pipe(revAll.revision(this.options))
-                .pipe(gulp.dest(this.output))
-                .pipe(revAll.versionFile())
-                .pipe(gulp.dest(this.output));
-        };
-        return balmVersion;
-    }
-    fn(callback) {
-        callback();
-    }
-}
-export default VersionTask;