balm-core 5.2.0 → 6.0.0-alpha.0

package/tslib/plugins/sass-legacy.js

@@ -1,95 +0,0 @@
-import { Transform } from 'node:stream';
-import * as sass from 'sass';
-import replaceExtension from 'replace-ext';
-import stripAnsi from 'strip-ansi';
-import applySourceMap from 'vinyl-sourcemaps-apply';
-import ansiColors from 'ansi-colors';
-const sassModule = node.getSassModule(sass);
-const PLUGIN_NAME = 'sass-legacy';
-const transformObj = (transform) => new Transform({ transform, objectMode: true });
-function filePush(file, sassObject, callback) {
-    if (sassObject.map) {
-        const sassMap = JSON.parse(sassObject.map.toString());
-        const sassMapFile = sassMap.file.replace(/^stdout$/, 'stdin');
-        const sassFileSrc = file.relative;
-        const sassFileSrcPath = node.path.dirname(sassFileSrc);
-        if (sassFileSrcPath) {
-            const sourceFileIndex = sassMap.sources.indexOf(sassMapFile);
-            sassMap.sources = sassMap.sources.map((source, index) => index === sourceFileIndex
-                ? source
-                : node.path.join(sassFileSrcPath, source));
-        }
-        sassMap.sources = sassMap.sources.filter((src) => src !== 'stdin' && src);
-        sassMap.file = replaceExtension(sassFileSrc, '.css');
-        applySourceMap(file, sassMap);
-    }
-    file.contents = sassObject.css;
-    file.path = replaceExtension(file.path, '.css');
-    if (file.stat) {
-        file.stat.atime = file.stat.mtime = file.stat.ctime = new Date();
-    }
-    callback(null, file);
-}
-function handleError(error, file, callback) {
-    const filePath = (error.file === 'stdin' ? file.path : error.file) || file.path;
-    const relativePath = node.path.relative(process.cwd(), filePath);
-    const message = `${ansiColors.underline(relativePath)}\n${error.formatted}`;
-    error.messageFormatted = message;
-    error.messageOriginal = error.message;
-    error.message = stripAnsi(message);
-    error.relativePath = relativePath;
-    return callback(new PluginError(PLUGIN_NAME, error));
-}
-const gulpSass = (options, sync = false) => transformObj((file, encoding, callback) => {
-    if (file.isNull()) {
-        return callback(null, file);
-    }
-    if (file.isStream()) {
-        return callback(new PluginError(PLUGIN_NAME, 'Streaming not supported'));
-    }
-    if (node.path.basename(file.path).startsWith('_')) {
-        return callback();
-    }
-    if (!file.contents.length) {
-        file.path = replaceExtension(file.path, '.css');
-        return callback(null, file);
-    }
-    const opts = (options || {});
-    opts.data = file.contents.toString();
-    opts.file = file.path;
-    if (node.path.extname(file.path) === '.sass') {
-        opts.indentedSyntax = true;
-    }
-    if (opts.includePaths) {
-        if (typeof opts.includePaths === 'string') {
-            opts.includePaths = [opts.includePaths];
-        }
-    }
-    else {
-        opts.includePaths = [];
-    }
-    opts.includePaths.unshift(node.path.dirname(file.path));
-    if (file.sourceMap) {
-        opts.sourceMap = file.path;
-        opts.omitSourceMapUrl = true;
-        opts.sourceMapContents = true;
-    }
-    if (sync !== true) {
-        sassModule.render(opts, (error, obj) => {
-            if (error) {
-                handleError(error, file, callback);
-                return;
-            }
-            filePush(file, obj, callback);
-        });
-    }
-    else {
-        try {
-            filePush(file, sassModule.renderSync(opts), callback);
-        }
-        catch (error) {
-            handleError(error, file, callback);
-        }
-    }
-});
-export default gulpSass;

package/tslib/plugins/sass.js

@@ -1,109 +0,0 @@
-import { Transform } from 'node:stream';
-import * as sass from 'sass';
-import replaceExtension from 'replace-ext';
-import stripAnsi from 'strip-ansi';
-import applySourceMap from 'vinyl-sourcemaps-apply';
-import ansiColors from 'ansi-colors';
-const sassModule = node.getSassModule(sass);
-const PLUGIN_NAME = 'sass';
-const transformObj = (transform) => new Transform({ transform, objectMode: true });
-function filePush(file, result, callback) {
-    file.contents = Buffer.from(result.css);
-    file.path = replaceExtension(file.path, '.css');
-    if (result.sourceMap) {
-        const proto = /^file:\/\/?/;
-        const leadingSlash = /^\//;
-        const sassMap = result.sourceMap;
-        const base = node.path.resolve(file.cwd, file.base);
-        if (!sassMap.file) {
-            sassMap.file = file.history[0]
-                .replace(base + node.path.sep, '')
-                .replace(proto, '');
-        }
-        sassMap.sources = sassMap.sources.map((src) => {
-            const baseUri = base.replace(/\\/g, '/');
-            if (src.startsWith('data:')) {
-                return file.history[0]
-                    .replace(/\\/g, '/')
-                    .replace(`${baseUri}/`, '')
-                    .replace(proto, '')
-                    .replace(leadingSlash, '');
-            }
-            return src
-                .replace(proto, '')
-                .replace(`${baseUri}/`, '')
-                .replace(leadingSlash, '');
-        });
-        const sassFileSrc = file.relative;
-        sassMap.file = replaceExtension(sassFileSrc, '.css');
-        if (file.sourceMap &&
-            file.sourceMap.sourcesContent &&
-            !sassMap.sourcesContent) {
-            sassMap.sourcesContent = file.sourceMap.sourcesContent;
-        }
-        applySourceMap(file, sassMap);
-    }
-    if (file.stat) {
-        file.stat.atime = file.stat.mtime = file.stat.ctime = new Date();
-    }
-    callback(null, file);
-}
-function handleError(error, file, callback) {
-    const filePath = (error.file === 'stdin' ? file.path : error.file) || file.path;
-    const relativePath = node.path.relative(process.cwd(), filePath);
-    const message = `${ansiColors.underline(relativePath)}\n${error.message}`;
-    error.message = stripAnsi(message);
-    return callback(new PluginError(PLUGIN_NAME, error));
-}
-const gulpSass = (options, sync = false) => transformObj((file, encoding, callback) => {
-    if (file.isNull()) {
-        return callback(null, file);
-    }
-    if (file.isStream()) {
-        return callback(new PluginError(PLUGIN_NAME, 'Streaming not supported'));
-    }
-    if (node.path.basename(file.path).startsWith('_')) {
-        return callback();
-    }
-    if (!file.contents.length) {
-        file.path = replaceExtension(file.path, '.css');
-        return callback(null, file);
-    }
-    const opts = (options || {});
-    if (node.path.extname(file.path) === '.sass') {
-        opts.syntax = 'indented';
-    }
-    if (opts.loadPaths) {
-        if (typeof opts.loadPaths === 'string') {
-            opts.loadPaths = [opts.loadPaths];
-        }
-    }
-    else {
-        opts.loadPaths = [];
-    }
-    opts.loadPaths.unshift(node.path.dirname(file.path));
-    if (file.sourceMap) {
-        opts.sourceMap = true;
-        opts.sourceMapIncludeSources = true;
-    }
-    const fileContents = file.contents.toString();
-    if (sync !== true) {
-        sassModule
-            .compileStringAsync(fileContents, opts)
-            .then((compileResult) => {
-            filePush(file, compileResult, callback);
-        })
-            .catch((error) => {
-            handleError(error, file, callback);
-        });
-    }
-    else {
-        try {
-            filePush(file, sassModule.compileString(fileContents, opts), callback);
-        }
-        catch (error) {
-            handleError(error, file, callback);
-        }
-    }
-});
-export default gulpSass;

package/tslib/plugins/sftp.js

@@ -1,258 +0,0 @@
-import { Client } from 'ssh2';
-import parents from 'parents';
-import async from 'async';
-const PLUGIN_NAME = 'sftp';
-const DefaultAlgorithms = {
-    kex: [
-        'curve25519-sha256',
-        'curve25519-sha256@libssh.org',
-        'ecdh-sha2-nistp256',
-        'ecdh-sha2-nistp384',
-        'ecdh-sha2-nistp521',
-        'diffie-hellman-group-exchange-sha256',
-        'diffie-hellman-group14-sha256',
-        'diffie-hellman-group15-sha512',
-        'diffie-hellman-group16-sha512',
-        'diffie-hellman-group17-sha512',
-        'diffie-hellman-group18-sha512',
-        'diffie-hellman-group-exchange-sha1',
-        'diffie-hellman-group14-sha1',
-        'diffie-hellman-group1-sha1'
-    ]
-};
-const normalizePath = (_path) => _path.replace(/\\/g, '/');
-function resolveHomePath(key) {
-    if (key.location) {
-        const HOME = process.env.HOME || process.env.USERPROFILE || '';
-        for (let i = 0, len = key.location.length; i < len; i++) {
-            if (key.location[i].substr(0, 2) === '~/') {
-                key.location[i] = node.path.resolve(HOME, key.location[i].replace(/^~\//, ''));
-            }
-        }
-        for (let i = 0, keyPath; (keyPath = key.location[i++]);) {
-            if (node.fs.existsSync(keyPath)) {
-                key.contents = node.fs.readFileSync(keyPath);
-                break;
-            }
-        }
-    }
-    else if (!key.contents) {
-        const rsaKey = key.location.join(', ');
-        throw new PluginError(PLUGIN_NAME, `Cannot find RSA key, searched: ${rsaKey}`);
-    }
-    return key;
-}
-function getKey(options) {
-    let key = options.key || options.keyLocation || null;
-    if (key && BalmJS.utils.isString(key)) {
-        key = {
-            location: key
-        };
-    }
-    if (!key &&
-        (options.passphrase || options.keyContents || !options.password)) {
-        key = {};
-    }
-    if (key) {
-        key.contents = key.contents || options.keyContents;
-        key.passphrase = key.passphrase || options.passphrase;
-        key.location = key.location || [
-            '~/.ssh/id_rsa',
-            '/.ssh/id_rsa',
-            '~/.ssh/id_dsa',
-            '/.ssh/id_dsa'
-        ];
-        if (!BalmJS.utils.isArray(key.location)) {
-            key.location = [key.location];
-        }
-        key = resolveHomePath(key);
-    }
-    return key;
-}
-function gulpSftp(options) {
-    options = Object.assign({}, options);
-    if (!options.host) {
-        throw new PluginError(PLUGIN_NAME, '`host` required');
-    }
-    let fileCount = 0;
-    const remotePath = options.remotePath || '/';
-    const remotePlatform = options.remotePlatform || options.platform || 'unix';
-    options.authKey = options.authKey || options.auth;
-    const authFilePath = options.authFile || '.ftppass';
-    const authFile = node.path.join('./', authFilePath);
-    if (options.authKey && node.fs.existsSync(authFile)) {
-        let auth = JSON.parse(node.fs.readFileSync(authFile, 'utf8'))[options.authKey];
-        if (!auth) {
-            throw new PluginError(PLUGIN_NAME, 'Could not find authkey in .ftppass');
-        }
-        if (BalmJS.utils.isString(auth) && auth.indexOf(':') !== -1) {
-            const authparts = auth.split(':');
-            auth = { user: authparts[0], pass: authparts[1] };
-        }
-        const authKeys = Object.keys(auth);
-        for (let i = 0, len = authKeys.length; i < len; i++) {
-            const attr = authKeys[i];
-            if (auth[attr]) {
-                options[attr] = auth[attr];
-            }
-        }
-    }
-    const password = options.password;
-    const username = options.username || 'anonymous';
-    const key = getKey(options);
-    const mkDirCache = {};
-    let finished = false;
-    let sftpCache = null;
-    let connCache = null;
-    function _pool(uploader) {
-        if (sftpCache) {
-            return uploader(sftpCache);
-        }
-        if (password) {
-            BalmJS.logger.debug(PLUGIN_NAME, 'Authenticating with password');
-        }
-        else if (key) {
-            BalmJS.logger.debug(PLUGIN_NAME, 'Authenticating with private key');
-        }
-        const connectionOptions = {
-            host: options.host,
-            port: options.port || 22,
-            username,
-            algorithms: options.algorithms || DefaultAlgorithms
-        };
-        if (password) {
-            connectionOptions.password = password;
-        }
-        else if (options.agent) {
-            connectionOptions.agent = options.agent;
-            connectionOptions.agentForward = options.agentForward || false;
-        }
-        else if (key) {
-            connectionOptions.privateKey = key.contents;
-            connectionOptions.passphrase = key.passphrase;
-        }
-        if (options.timeout) {
-            connectionOptions.readyTimeout = options.timeout;
-        }
-        const conn = new Client();
-        connCache = conn;
-        conn.on('ready', () => {
-            BalmJS.logger.debug(PLUGIN_NAME, 'Client :: ready');
-            conn.sftp((err, sftp) => {
-                if (err) {
-                    throw err;
-                }
-                sftp.on('end', function () {
-                    BalmJS.logger.debug(PLUGIN_NAME, 'SFTP session closed');
-                    sftpCache = null;
-                    if (!finished) {
-                        this.emit('error', new PluginError(PLUGIN_NAME, 'SFTP abrupt closure'));
-                    }
-                });
-                sftpCache = sftp;
-                uploader(sftpCache);
-            });
-        });
-        conn.on('error', (err) => {
-            const errorMsg = (err && (err.message || err.toString())) || 'SFTP connection error';
-            this.emit('error', new PluginError(PLUGIN_NAME, errorMsg));
-        });
-        conn.on('end', () => {
-            BalmJS.logger.debug(PLUGIN_NAME, 'Client :: end');
-        });
-        conn.on('close', () => {
-            if (!finished) {
-                this.emit('error', new PluginError(PLUGIN_NAME, 'SFTP abrupt closure'));
-            }
-            if (options.callback) {
-                options.callback();
-            }
-        });
-        conn.connect(connectionOptions);
-    }
-    function transform(file, encoding, callback) {
-        if (file.isNull()) {
-            return callback();
-        }
-        const finalRemotePath = normalizePath(node.path.join(remotePath, file.relative));
-        _pool.call(this, (sftp) => {
-            const dirname = node.path.dirname(finalRemotePath);
-            let fileDirs = parents(dirname)
-                .map((d) => d.replace(/^\/~/, '~'))
-                .map(normalizePath);
-            if (dirname.search(/^\//) === 0) {
-                fileDirs = fileDirs.map((dir) => dir.search(/^\//) === 0 ? dir : `/${dir}`);
-            }
-            fileDirs = fileDirs.filter((d) => d.length >= remotePath.length && !mkDirCache[d]);
-            async.whilst((cb) => cb(null, fileDirs && fileDirs.length), (cb) => {
-                let d = fileDirs.pop();
-                mkDirCache[d] = true;
-                if (remotePlatform &&
-                    remotePlatform.toLowerCase().indexOf('win') !== -1) {
-                    d = d.replace('/', '\\');
-                }
-                sftp.exists(d, (exist) => {
-                    if (exist) {
-                        cb();
-                    }
-                    else {
-                        const dirMode = options.dirMode || '0755';
-                        sftp.mkdir(d, { mode: dirMode }, (err) => {
-                            if (err) {
-                                BalmJS.logger.warn(PLUGIN_NAME, `Error or directory exists: ${err} ${d}`);
-                            }
-                            else {
-                                BalmJS.logger.debug(PLUGIN_NAME, `Created: ${d}`);
-                            }
-                            cb();
-                        });
-                    }
-                });
-            }, () => {
-                const fileMode = options.fileMode || '0666';
-                const stream = sftp.createWriteStream(finalRemotePath, {
-                    flags: 'w',
-                    encoding: null,
-                    mode: fileMode,
-                    autoClose: true
-                });
-                if (file.isStream()) {
-                    file.contents.pipe(stream);
-                }
-                else if (file.isBuffer()) {
-                    stream.end(file.contents);
-                }
-                stream.on('close', function (error) {
-                    if (error) {
-                        this.emit('error', new PluginError(PLUGIN_NAME, error));
-                    }
-                    else {
-                        const fileRelativePath = file.relative;
-                        BalmJS.logger.info(PLUGIN_NAME, `Uploaded: ${fileRelativePath} => ${finalRemotePath}`);
-                        fileCount++;
-                    }
-                    return callback(error);
-                });
-            });
-        });
-    }
-    function flush(callback) {
-        if (fileCount > 0) {
-            const unit = fileCount === 1 ? 'file' : 'files';
-            BalmJS.logger.info(PLUGIN_NAME, `${fileCount} ${unit} uploaded successfully`);
-        }
-        else {
-            BalmJS.logger.warn(PLUGIN_NAME, 'No files uploaded');
-        }
-        finished = true;
-        if (sftpCache) {
-            sftpCache.end();
-        }
-        if (connCache) {
-            connCache.end();
-        }
-        callback();
-    }
-    return through2.obj(transform, flush);
-}
-export default gulpSftp;

package/tslib/tasks/default.js

@@ -1,59 +0,0 @@
-class DefaultTask extends BalmJS.BalmTask {
-    constructor() {
-        super('default');
-    }
-    get startTask() {
-        const tasks = BalmJS.toNamespace(['start']);
-        if (BalmJS.utils.isString(BalmJS.beforeTask)) {
-            tasks.unshift(BalmJS.beforeTask);
-        }
-        return tasks;
-    }
-    get mainTasks() {
-        let tasks = [
-            'clean',
-            ...(BalmJS.config.styles.sprites.length ? ['sprite'] : []),
-            'style',
-            ...(BalmJS.config.scripts.lint ? ['lint'] : []),
-            'script',
-            'html',
-            ...(BalmJS.config.env.isProd || !BalmJS.config.inFrontend
-                ? ['image', 'font', 'media']
-                : [])
-        ];
-        if (BalmJS.config.env.isProd) {
-            tasks = [
-                ...tasks,
-                'extra',
-                'build',
-                ...(BalmJS.config.assets.cache ? ['cache'] : []),
-                ...(BalmJS.config.pwa.enabled ? ['workbox-sw', 'pwa'] : [])
-            ];
-        }
-        else {
-            tasks = [...tasks, 'modernizr', 'serve'];
-        }
-        let defaultMainTasks = BalmJS.config.useDefaults
-            ? BalmJS.toNamespace(tasks)
-            : [];
-        if (BalmJS.config.env.inSSR ||
-            BalmJS.config.env.isMP ||
-            BalmJS.config.env.inDesktopApp) {
-            defaultMainTasks = BalmJS.toNamespace(BalmJS.config.env.isMP ? ['style', 'script'] : ['script']);
-        }
-        return defaultMainTasks;
-    }
-    get subTasks() {
-        return BalmJS.recipes.length
-            ? BalmJS.toNamespace(BalmJS.recipes)
-            : [];
-    }
-    get endTask() {
-        const tasks = BalmJS.toNamespace(['end']);
-        if (BalmJS.utils.isString(BalmJS.afterTask)) {
-            tasks.push(BalmJS.afterTask);
-        }
-        return tasks;
-    }
-}
-export default DefaultTask;

package/tslib/tasks/foundation/balm.js

@@ -1,75 +0,0 @@
-class BalmTask {
-    name;
-    taskName;
-    defaultInput = '';
-    defaultOutput = '';
-    input = '';
-    output = '';
-    customOptions = {};
-    gulpSrcOptions = {};
-    constructor(name) {
-        this.name = name;
-        this.taskName = BalmJS.toNamespace(name);
-    }
-    get styleName() {
-        let name;
-        switch (BalmJS.config.styles.extname) {
-            case 'sass':
-            case 'scss':
-                name = 'sass';
-                break;
-            case 'less':
-                name = 'less';
-                break;
-            default:
-                name = 'postcss';
-        }
-        return name;
-    }
-    get src() {
-        return gulp
-            .src(this.input, Object.assign({
-            allowEmpty: true,
-            encoding: false
-        }, this.gulpSrcOptions))
-            .pipe(BalmJS.plugins.plumber((error) => {
-            BalmJS.logger.error(`${this.name} task`, error.message);
-        }));
-    }
-    init(input, output, options = {}) {
-        let key = this.name;
-        switch (key) {
-            case 'copy':
-                key = 'rename';
-                break;
-            case 'jsmin':
-                key = 'terser';
-                break;
-            default:
-        }
-        const useAbsPath = !['webpack', 'rollup', 'esbuild', 'sprite'].includes(key);
-        this.input = useAbsPath && (input || this.defaultInput)
-            ? BalmJS.file.absPaths(input || this.defaultInput)
-            : input || this.defaultInput;
-        this.output = useAbsPath && typeof (output || this.defaultOutput) === 'string'
-            ? BalmJS.file.absPath(output || this.defaultOutput)
-            : output || this.defaultOutput;
-        this.customOptions = options[key] || {};
-        const obj = {
-            input: this.input,
-            output: this.output
-        };
-        if (options[key]) {
-            obj.customOptions = this.customOptions;
-        }
-        if (useAbsPath) {
-            BalmJS.logger.debug(`${this.name} task`, obj, {
-                pre: true
-            });
-        }
-        if (options.src) {
-            this.gulpSrcOptions = options.src;
-        }
-    }
-}
-export default BalmTask;

package/tslib/tasks/foundation/balm_style.js

@@ -1,68 +0,0 @@
-import BalmTask from './balm.js';
-import { ASSET } from '../../config/constants.js';
-class BalmStyleTask extends BalmTask {
-    constructor(name) {
-        super(name);
-        let extname;
-        switch (name) {
-            case 'sass':
-                extname = '{scss,sass}';
-                break;
-            case 'less':
-                extname = 'less';
-                break;
-            default:
-                extname = 'css';
-        }
-        if (Array.isArray(BalmJS.config.styles.entry)) {
-            this.defaultInput = BalmJS.config.styles.entry.map((styleEntry) => node.path.join(BalmJS.config.src.css, styleEntry));
-        }
-        else {
-            if (BalmJS.config.styles.entry) {
-                this.defaultInput = node.path.join(BalmJS.config.src.css, BalmJS.config.styles.entry);
-            }
-            else {
-                this.defaultInput = node.path.join(BalmJS.config.src.css, '**', `!(_*).${extname}`);
-            }
-        }
-        this.defaultOutput = BalmJS.config.env.isMP
-            ? node.path.join(BalmJS.config.dest.base, ASSET.mpDir, BalmJS.config.paths.target.css)
-            : BalmJS.config.dest.css;
-    }
-    handleStyle(style, output, options) {
-        BalmJS.logger.debug(`${this.name} entry`, this.defaultInput, {
-            pre: true
-        });
-        const taskName = `${this.name} task`;
-        const shouldUseSourceMap = !(BalmJS.config.env.isProd || BalmJS.config.styles.minify);
-        let stream = gulp
-            .src(this.input, Object.assign({
-            sourcemaps: shouldUseSourceMap,
-            allowEmpty: true
-        }, this.gulpSrcOptions))
-            .pipe(BalmJS.plugins.plumber(function (error) {
-            BalmJS.logger.error(taskName, error.message);
-            this.emit('end');
-            this.destroy();
-        }));
-        switch (style) {
-            case 'sass':
-                stream = stream.pipe(node.isLegacySass
-                    ? BalmJS.plugins.legacySass(options)
-                    : BalmJS.plugins.sass(options));
-                break;
-            case 'less':
-                stream = stream.pipe(BalmJS.plugins.less(options));
-                break;
-            default:
-        }
-        return stream
-            .pipe(BalmJS.plugins.postcss(BalmJS.plugins.postcssPlugins(style === 'postcss')))
-            .pipe($.if(BalmJS.config.env.isMP, BalmJS.plugins.rename({ extname: '.wxss' })))
-            .pipe(gulp.dest(output, {
-            sourcemaps: shouldUseSourceMap
-        }))
-            .pipe(server.reload({ stream: true }));
-    }
-}
-export default BalmStyleTask;

package/tslib/tasks/foundation/index.js

@@ -1,10 +0,0 @@
-import BalmTask from './balm.js';
-import BalmStyleTask from './balm_style.js';
-BalmJS.BalmTask = BalmTask;
-BalmJS.BalmStyleTask = BalmStyleTask;
-BalmJS.tasks = new Map();
-BalmJS.recipes = [];
-BalmJS.recipeIndex = 0;
-BalmJS.server = null;
-BalmJS.watchFtpFile = '';
-BalmJS.watching = false;