commandpost/lib/command.d.ts

commandline option parser

import Option from "./option";
import Argument from "./argument";
export default class Command<Opt, Arg> {
    /**
     * @private
     */
    _description?: string;
    /**
     * @private
     */
    _usage?: string;
    /**
     * @private
     */
    _help: Option;
    /**
     * @private
     */
    _version?: Option;
    /**
     * @private
     */
    _versionStr?: string;
    /**
     * @private
     */
    _action: (opts: Opt, args: Arg, rest: string[]) => any;
    /**
     * e.g. -abc --foo bar
     * @private
     */
    _rawArgs?: string[];
    /**
     * e.g. -a -b -c --foo bar
     * @private
     */
    _args?: string[];
    /**
     * e.g. bar
     * @private
     */
    _rest: string[];
    /**
     * @private
     */
    _allowUnknownOption?: boolean;
    /**
     * parent command.
     */
    parent?: Command<any, any>;
    /**
     * name of this command.
     */
    name: string;
    /**
     * e.g.
     * ```
     *   git -p clone git@github.com:vvakame/dtsm.git
     *       ↑ this!
     * ```
     * @type {Array}
     */
    options: Option[];
    /**
     * e.g.
     * ```
     *   git -p clone git@github.com:vvakame/dtsm.git
     *          ↑ this!
     * ```
     * @type {Array}
     */
    subCommands: Command<any, any>[];
    /**
     * e.g.
     * ```
     *   git -p clone git@github.com:vvakame/dtsm.git
     *                ↑ this!
     * ```
     * @type {Array}
     */
    args: Argument[];
    /**
     * parsed option values.
     * @type {any}
     */
    parsedOpts: Opt;
    /**
     * parsed option arguments.
     * @type {any}
     */
    parsedArgs: Arg;
    /**
     * unknown options.
     * @type {Array}
     */
    unknownOptions: string[];
    /**
     * class of command.
     * ```
     * cmd -v sub --path foo/bar buzz.txt
     *        ↑ this one!
     * ```
     * @param name name and flags pass flags pass 'foo'(sub command) or 'foo <bar>'(sub command & required argument) or 'foo [bar]'(sub command & optional argument) or 'foo <bar...>'(sub command & required variadic argument) or 'foo [bar...]'(sub command & optional variadic argument).
     * @class
     */
    constructor(name: string);
    /**
     * set description for this command.
     * @param desc
     * @returns {Command}
     * @method
     */
    description(desc: string): Command<Opt, Arg>;
    /**
     * set usage for this command.
     * @param usage
     * @returns {Command}
     * @method
     */
    usage(usage: string): Command<Opt, Arg>;
    /**
     * add option for this command.
     * see {@link Option}.
     * @param flags
     * @param description
     * @param defaultValue
     * @returns {Command}
     */
    option(flags: string, description?: string, defaultValue?: any): Command<Opt, Arg>;
    /**
     * allow unknown option.
     * by default, An error occured if unknown option is included.
     * @param flag
     * @returns {Command}
     */
    allowUnknownOption(flag?: boolean): Command<Opt, Arg>;
    /**
     * add action at this command selected.
     * @param fn
     * @returns {Command}
     */
    action(fn: (opts: Opt, args: Arg, rest: string[]) => any): Command<Opt, Arg>;
    /**
     * create sub command.
     * @param name
     * @returns {Command<Opt2, Arg2>} new command instance
     */
    subCommand<Opt2, Arg2>(name: string): Command<Opt2, Arg2>;
    /**
     * check arg is matches this command.
     * @param arg
     * @returns {boolean}
     */
    is(arg: string): boolean;
    /**
     * add help this option.
     * in general case, use default help option.
     * @param flags
     * @param description
     * @returns {Command}
     */
    help(flags: string, description: string): this;
    /**
     * add show version option to this command.
     * @param version
     * @param flags
     * @param description
     * @returns {Command}
     */
    version(version: string, flags: string, description?: string): Command<Opt, Arg>;
    /**
     * exec action of command.
     * this method MUST call after parse process.
     * @returns {Promise<{}>}
     */
    exec(): Promise<{}>;
    /**
     * parse argv.
     * @param argv
     * @returns {Promise<{}>}
     */
    parse(argv: string[]): Promise<{}>;
    /**
     * @returns {*}
     * @private
     */
    _getAncestorsAndMe(): Command<any, any>[];
    /**
     * @param args
     * @returns {string[]}
     * @private
     */
    _parseRawArgs(args: string[]): string[];
    /**
     * @param rest
     * @returns {boolean}
     * @private
     */
    _matchSubCommand(rest: string[]): boolean;
    /**
     * @param args
     * @returns {string[]}
     * @private
     */
    _parseOptions(args: string[]): string[];
    /**
     * @param rest
     * @returns {string[]}
     * @private
     */
    _parseArgs(rest: string[]): string[];
    /**
     * @param args
     * @returns {string[]}
     * @private
     */
    _normalize(args: string[]): string[];
    /**
     * generate help text.
     * @returns {string}
     */
    helpText(): string;
}