@backtrace/javascript-cli/lib/commands/Command.js

Backtrace CLI for working with Javascript files.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Command = void 0;
const sourcemap_tools_1 = require("@backtrace/sourcemap-tools");
const command_line_args_1 = __importDefault(require("command-line-args"));
const command_line_usage_1 = __importDefault(require("command-line-usage"));
const logger_1 = require("../logger");
const CLI_COMMAND = 'backtrace-js';
class Command {
    constructor(definition) {
        this.definition = definition;
        this.subcommands = [];
        this.options = [];
        this.helpSections = [];
    }
    subcommand(command) {
        this.subcommands.push(command);
        return this;
    }
    option(option) {
        this.options.push(option);
        return this;
    }
    help(...sections) {
        this.helpSections.push(...sections);
        return this;
    }
    execute(fn) {
        this._execute = fn;
        return this;
    }
    async run(argv, stack) {
        const stackOptions = stack?.flatMap((s) => s.options.filter((o) => o.global)) ?? [];
        const localOptions = [...this.options, ...stackOptions];
        const subcommandOption = {
            name: '_subcommand',
            defaultOption: true,
        };
        const subCommandMode = !!this.subcommands.length;
        if (subCommandMode) {
            localOptions.push(subcommandOption);
        }
        const valuesResult = this.safeCommandLineArgs(localOptions, {
            argv,
            stopAtFirstUnknown: subCommandMode,
        });
        if (valuesResult.isErr()) {
            const logger = (0, logger_1.createLogger)();
            logger.info(Command.getHelpMessage(this, stack));
            return valuesResult.mapErr((error) => ({ command: this, error, stack }));
        }
        const values = valuesResult.data;
        if (subCommandMode && values._subcommand) {
            const subcommand = this.subcommands.find((s) => s.definition.name === values._subcommand);
            if (subcommand) {
                const subcommandValues = (0, command_line_args_1.default)([subcommandOption], { argv, stopAtFirstUnknown: true });
                return await subcommand.run(subcommandValues._unknown ?? [], [...(stack ?? []), this]);
            }
        }
        const logger = (0, logger_1.createLogger)(values);
        if (values.help) {
            logger.output(Command.getHelpMessage(this, stack));
            return (0, sourcemap_tools_1.Ok)(0);
        }
        if (this._execute) {
            const context = {
                opts: values,
                logger,
                getHelpMessage: () => Command.getHelpMessage(this, stack),
            };
            return (await this._execute(context))
                .map((data) => (typeof data === 'number' ? data : 0))
                .mapErr((error) => ({
                command: this,
                error,
                stack,
            }));
        }
        logger.info(Command.getHelpMessage(this, stack));
        if (subCommandMode) {
            return (0, sourcemap_tools_1.Err)({ command: this, stack, error: 'Unknown command.' });
        }
        return (0, sourcemap_tools_1.Err)({ command: this, stack, error: 'Unknown option.' });
    }
    static getHelpMessage(command, stack) {
        const globalOptions = [
            ...command.options.filter((o) => o.global),
            ...(stack?.flatMap((o) => o.options.filter((o) => o.global)) ?? []),
        ];
        const nonGlobalOptions = command.options.filter((o) => !o.global);
        let cmd = CLI_COMMAND;
        const stackCmd = `${[...(stack ?? []), command]
            .map((s) => s.definition.name)
            .filter((s) => !!s)
            .join(' ') ?? ''}`;
        if (stackCmd) {
            cmd += ` ${stackCmd}`;
        }
        let usage = cmd;
        if (command.subcommands.length) {
            usage += ' <command>';
        }
        const defaultOption = nonGlobalOptions.find((s) => s.defaultOption) ?? globalOptions.find((s) => s.defaultOption);
        if (defaultOption) {
            usage += ` <${defaultOption.name}>`;
        }
        if (globalOptions.length + nonGlobalOptions.length) {
            usage += ' [options]';
        }
        const sections = [
            {
                header: cmd,
                content: 'Backtrace utility for managing Javascript files.',
            },
        ];
        if (command.helpSections.length) {
            sections.push(...command.helpSections);
        }
        sections.push({
            content: `Usage: ${usage}`,
        });
        if (command.subcommands.length) {
            sections.push({
                header: 'Available commands',
                content: command.subcommands.map((s) => ({
                    name: s.definition.name,
                    summary: s.definition.description,
                })),
            });
        }
        if (nonGlobalOptions.length) {
            sections.push({
                header: 'Available options',
                optionList: nonGlobalOptions,
            });
        }
        if (globalOptions.length) {
            sections.push({
                header: 'Global options',
                optionList: globalOptions,
            });
        }
        return (0, command_line_usage_1.default)(sections);
    }
    safeCommandLineArgs(...args) {
        try {
            return (0, sourcemap_tools_1.Ok)((0, command_line_args_1.default)(...args));
        }
        catch (err) {
            if (err instanceof Error) {
                if (err.name === 'UNKNOWN_OPTION') {
                    return (0, sourcemap_tools_1.Err)(err.message);
                }
            }
            throw err;
        }
    }
}
exports.Command = Command;
//# sourceMappingURL=Command.js.map