foy/lib/exec.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.shell = exports.ShellContext = exports.spawn = exports.exec = exports.execa = void 0;
const tslib_1 = require("tslib");
const execa_1 = tslib_1.__importDefault(require("execa"));
exports.execa = execa_1.default;
const path_1 = tslib_1.__importDefault(require("path"));
const logger_1 = require("./logger");
const utils_1 = require("./utils");
const fs_1 = require("./fs");
const shellParser = require('shell-parser');
function _exec(cmd, options) {
    let [file, ...args] = shellParser(cmd);
    return execa_1.default(file, args, options);
}
function exec(commands, options) {
    if (utils_1.Is.str(commands)) {
        return _exec(commands, options);
    }
    const rets = [];
    let retsP = Promise.resolve(null);
    for (const cmd of commands) {
        retsP = retsP.then(() => {
            return _exec(cmd, options).then((r) => {
                rets.push(r);
                return rets;
            });
        });
    }
    return retsP;
}
exports.exec = exec;
exports.spawn = execa_1.default;
class ShellContext {
    constructor() {
        this._cwdStack = [process.cwd()];
        this._env = {};
        this.logCommand = false;
        this.sleep = utils_1.sleep;
        this._logger = logger_1.logger;
        this._process = { current: null };
    }
    /**
     * get current word directory
     */
    get cwd() {
        return this._cwdStack[this._cwdStack.length - 1];
    }
    /**
     * change work directory
     * @param dir
     */
    cd(dir) {
        this._cwdStack[this._cwdStack.length - 1] = path_1.default.resolve(this._cwdStack[this._cwdStack.length - 1], dir);
        return this;
    }
    /**
     * like pushd in shell
     * @param dir
     */
    pushd(dir) {
        this._cwdStack.push(path_1.default.resolve(this._cwdStack[this._cwdStack.length - 1], dir));
        return this;
    }
    /**
     * like popd in shell
     */
    popd() {
        this._cwdStack.pop();
        return this;
    }
    exec(commands, options) {
        this._logCmd(commands);
        let p = exec(commands, Object.assign({ cwd: this.cwd, env: Object.assign(Object.assign({}, process.env), this._env), stdio: 'inherit' }, options));
        // tslint:disable-next-line:no-floating-promises
        p.catch((err) => {
            this._logger.error('Exec failed: ', commands);
            throw err;
        });
        this._process.current = p;
        p.finally(() => {
            this._process.current = null;
        });
        return p;
    }
    /**
     * spawn file
     * @param file
     * @param args
     * @param options
     */
    spawn(file, args = [], options) {
        const command = file + ' ' + args.map((a) => `"${a.replace(/"/g, '\\"')}"`).join(' ');
        this._logCmd(command);
        let p = exports.spawn(file, args, Object.assign({ cwd: this.cwd, env: Object.assign(Object.assign({}, process.env), this._env), stdio: 'inherit' }, options));
        // tslint:disable-next-line:no-floating-promises
        p.catch((err) => {
            this._logger.error('Exec failed: ', command);
            throw err;
        });
        this._process.current = p;
        p.finally(() => {
            this._process.current = null;
        });
        return p;
    }
    env(key, val) {
        if (arguments.length === 1) {
            return this._env[key];
        }
        if (utils_1.Is.defed(val)) {
            this._env[key] = val;
        }
        else {
            delete this._env[key];
        }
        return this;
    }
    /**
     * restart processes when file changes
     * @example
     *  ctx.monitor('./src', 'tsc')
     *  ctx.monitor('./src', 'webpack')
     *  ctx.monitor('./src', 'foy watch')
     *  ctx.monitor('./src', ['rm -rf dist', 'foy watch'])
     *  ctx.monitor('./src', async p => {
     *    await fs.rmrf('dist')
     *    p.current = ctx.exec('webpack serve')
     *  })
     */
    monitor(dir, run, options = {}) {
        let p = this._process;
        fs_1.fs.watchDir(dir, options, (event, file) => tslib_1.__awaiter(this, void 0, void 0, function* () {
            if (options.ignore && options.ignore(event, file)) {
                return;
            }
            while (p.current && !p.current.killed && p.current.exitCode === null) {
                p.current.kill();
                yield utils_1.sleep(1000);
            }
            if (typeof run === 'string') {
                let cmd = run;
                run = (p) => (p.current = this.exec(cmd));
            }
            if (Array.isArray(run)) {
                let cmds = run;
                run = (p) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                    for (const cmd of cmds.slice(0, -1)) {
                        yield this.exec(cmd);
                    }
                    p.current = this.exec(cmds.slice(-1)[0]);
                });
            }
            run(p);
        }));
    }
    /**
     * reset env to default
     */
    resetEnv() {
        this._env = {};
        return this;
    }
    _logCmd(cmd) {
        if (this.logCommand) {
            let env = Object.keys(this._env)
                .map((k) => `${k}=${this._env[k] || ''}`)
                .join(' ');
            if (env) {
                env += ' ';
            }
            cmd = Array.isArray(cmd) ? cmd : [cmd];
            cmd.forEach((cmd) => {
                this._logger.info(`$ ${env}${cmd}`);
            });
        }
    }
}
exports.ShellContext = ShellContext;
function shell(callback) {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        return callback(new ShellContext());
    });
}
exports.shell = shell;
//# sourceMappingURL=exec.js.map