foy/lib/cli.js

#!/usr/bin/env node
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const cac_1 = tslib_1.__importDefault(require("cac"));
const fs_1 = require("./fs");
const path_1 = tslib_1.__importDefault(require("path"));
const logger_1 = require("./logger");
const utils_1 = require("./utils");
const task_manager_1 = require("./task-manager");
const defaultCli = cac_1.default();
let defaultArgv = [];
let taskArgv = [];
{
    const argv = process.argv.slice(2);
    const defaultOptions = new Map([
        ['--config', 1],
        ['-c', 1],
        ['--require', 1],
        ['-r', 1],
        ['--init', 1],
        ['-i', 1],
    ]);
    let i = 0;
    for (i = 0; i < argv.length; i++) {
        const arg = argv[i];
        let valLen = defaultOptions.get(arg);
        if (utils_1.Is.defed(valLen)) {
            let end = i + valLen;
            defaultArgv.push(...argv.slice(i, end + 1));
            i = end;
        }
        else {
            break;
        }
    }
    taskArgv = argv.slice(i);
}
defaultArgv = process.argv.slice(0, 2).concat(defaultArgv);
taskArgv = process.argv.slice(0, 2).concat(taskArgv);
function addDefaultOptions(cli) {
    return cli
        .option(`--config, -c <...files>`, 'The Foyfiles')
        .option(`--require, -r <...names>`, 'Require the given modules')
        .option(`--init, -i [ext]`, 'Generate the Foyfile, [ext] can be "ts" | "js", default is "js"');
}
addDefaultOptions(defaultCli).parse(defaultArgv);
if (defaultCli.options.init) {
    let ext = defaultCli.options.init;
    if (!utils_1.Is.str(ext)) {
        ext = 'js';
    }
    ext = ext.replace(/^\./, '');
    const file = `./Foyfile.${ext}`;
    if (fs_1.fs.existsSync(file)) {
        throw new Error(`Foyfile already exists: ${path_1.default.resolve(file)}`);
    }
    fs_1.fs.writeFileSync(file, `${ext === 'js'
        ? `const { task, desc, option, fs } = require('foy')`
        : `import { task, desc, option, fs } from 'foy'`}

task('build', async ctx => {
  // Your build tasks
  await ctx.exec('tsc')
})

`);
    process.exit();
}
let foyFiles = arrify(defaultCli.options.config);
let registers = arrify(defaultCli.options.require);
function arrify(arr) {
    if (!Array.isArray(arr)) {
        return arr == null ? [] : [arr];
    }
    return arr;
}
if (foyFiles.length) {
    foyFiles = foyFiles.map(c => path_1.default.resolve(process.cwd(), c));
}
else {
    let findFoyfiles = (baseDir) => {
        let cwdFoyfiles = fs_1.fs.readdirSync(baseDir).filter(f => f.startsWith('Foyfile.'));
        if (cwdFoyfiles.length) {
            if (cwdFoyfiles.length > 1) {
                logger_1.logger.warn(`Find more than 1 Foyfile in current directory, only first one will be used: \n${cwdFoyfiles.join('\n')}`);
            }
            foyFiles = [path_1.default.join(baseDir, cwdFoyfiles[0])];
        }
    };
    findFoyfiles(process.cwd());
    if (!foyFiles.length) {
        let maxDepth = 5;
        let dir = process.cwd();
        while (maxDepth-- && dir !== '/' && dir && !foyFiles.length) {
            dir = path_1.default.dirname(dir);
            findFoyfiles(dir);
        }
    }
}
for (const file of foyFiles) {
    if (!fs_1.fs.existsSync(file)) {
        throw new TypeError(`Cannot find Foyfile: ${file}`);
    }
}
if (registers.length) {
    for (let mod of registers) {
        try {
            require(mod);
        }
        catch (error) {
            require(path_1.default.resolve(process.cwd(), mod));
        }
    }
}
try {
    if (!require.extensions['.ts']) {
        require('ts-node').register({
            transpileOnly: true,
            compilerOptions: {
                module: 'commonjs',
            },
        });
    }
}
catch (error) {
    // ignore
}
{
    // Add global installed foy to module.paths
    const Module = require('module');
    const nodeModulePaths = Module._nodeModulePaths;
    const globalFoyPath = path_1.default.join(__dirname, '..', '..');
    if (nodeModulePaths) {
        Module._nodeModulePaths = (...args) => {
            let paths = nodeModulePaths.apply(Module, args);
            if (Array.isArray(paths)) {
                paths.push(globalFoyPath);
            }
            return paths;
        };
    }
}
for (const file of foyFiles) {
    require(file);
}
const taskCli = cac_1.default();
let taskManager = task_manager_1.getGlobalTaskManager();
taskManager.getTasks().forEach(t => {
    let strict = taskManager.globalOptions.strict || t.strict;
    let cmd = taskCli.command(t.name, t.desc, { allowUnknownOptions: !strict });
    if (t.optionDefs) {
        t.optionDefs.forEach(def => cmd.option(...def));
    }
    cmd.action((...args) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
        let options = args.pop();
        let { globalOptions } = taskManager;
        globalOptions.rawArgs = taskCli.rawArgs;
        globalOptions.options = options;
        yield taskManager.run(t.name, {
            options,
            rawArgs: taskCli.rawArgs.slice(3),
        }).catch(err => {
            logger_1.logger.error(err);
            throw err;
        });
    }));
});
taskCli.on('command:*', () => {
    console.error(`error: Unknown command \`${taskCli.args.join(' ')}\`\n\n`);
    process.exit(1);
});
taskCli.help(sections => {
    if (!taskCli.matchedCommand) {
        let last = sections[sections.length - 1];
        let lines = last.body.split('\n');
        lines.pop();
        last.body = lines
            .concat('  -h, --help                Display this message', '  --init, -i [ext]          Generate the Foyfile, <ext> can be "ts" | "js", default is "js"', '  --config, -c <...files>   The Foyfiles', '  --require, -r <...names>  Require the given modules')
            .join('\n');
    }
    console.log(sections
        .map(section => {
        return section.title ? `${section.title}:\n${section.body}` : section.body;
    })
        .join('\n\n'));
    process.exit(0);
});
taskCli.parse(taskArgv);
if (process.argv.length === 2) {
    taskCli.outputHelp();
}
//# sourceMappingURL=cli.js.map