commandpost

constructor

constructor(arg: string);

• class of argument.

  cmd --path foo/bar buzz.txt
                      ↑ this one!

  Parameter arg

  pass ''(required) or '[foo]'(optional) or '<foo...>'(required & variadic) or '[foo...]'(optional & variadic)

property name

name: string;

• argument name

property required

required: boolean;

• this argument is required

property variadic

variadic: boolean;

• this argument is variadic

method parse

parse: (opts: any, args: string[]) => string[];

• parse args. build to opts.

  e.g. #1 instance member: name=foo, required=true, variadic=false method arguments: opts={}, args=["foo!", "bar!"]. opts are modified to { foo: "foo!" } and return ["bar!"].

  e.g. #2 instance member: name=foo, required=false, variadic=true method arguments: opts={}, args=["foo!", "bar!"]. opts are modified to { foo: ["foo!", "bar!"] } and return [].

  Parameter opts

  build target object

  Parameter args

  Returns

  {string[]} rest args

constructor

constructor(name: string);

• class of command.

  cmd -v sub --path foo/bar buzz.txt
         ↑ this one!

  Parameter name

  name and flags pass flags pass 'foo'(sub command) or 'foo '(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).

property args

args: Argument[];

• e.g.

    git -p clone git@github.com:vvakame/dtsm.git
                 ↑ this!

  {Array}

property name

name: string;

• name of this command.

property options

options: Option[];

• e.g.

    git -p clone git@github.com:vvakame/dtsm.git
        ↑ this!

  {Array}

property parent

parent?: Command<any, any>;

• parent command.

property parsedArgs

parsedArgs: {};

• parsed option arguments. {any}

property parsedOpts

parsedOpts: {};

• parsed option values. {any}

property subCommands

subCommands: Command<any, any>[];

• e.g.

    git -p clone git@github.com:vvakame/dtsm.git
           ↑ this!

  {Array}

property unknownOptions

unknownOptions: string[];

• unknown options. {Array}

method action

action: (fn: (opts: Opt, args: Arg, rest: string[]) => any) => Command<Opt, Arg>;

• add action at this command selected.

  Parameter fn

  Returns

  {Command}

method allowUnknownOption

allowUnknownOption: (flag?: boolean) => Command<Opt, Arg>;

• allow unknown option. by default, An error occured if unknown option is included.

  Parameter flag

  Returns

  {Command}

method description

description: (desc: string) => Command<Opt, Arg>;

• set description for this command.

  Parameter desc

  Returns

  {Command}

method exec

exec: () => Promise<{}>;

• exec action of command. this method MUST call after parse process.

  Returns

  {Promise<{}>}

method help

help: (flags: string, description: string) => this;

• add help this option. in general case, use default help option.

  Parameter flags

  Parameter description

  Returns

  {Command}

method helpText

helpText: () => string;

• generate help text.

  Returns

  {string}

method is

is: (arg: string) => boolean;

• check arg is matches this command.

  Parameter arg

  Returns

  {boolean}

method option

option: (
    flags: string,
    description?: string,
    defaultValue?: any
) => Command<Opt, Arg>;

• add option for this command. see Option.

  Parameter flags

  Parameter description

  Parameter defaultValue

  Returns

  {Command}

method parse

parse: (argv: string[]) => Promise<{}>;

• parse argv.

  Parameter argv

  Returns

  {Promise<{}>}

method subCommand

subCommand: <Opt2, Arg2>(name: string) => Command<Opt2, Arg2>;

• create sub command.

  Parameter name

  Returns

  {Command<Opt2, Arg2>} new command instance

method usage

usage: (usage: string) => Command<Opt, Arg>;

• set usage for this command.

  Parameter usage

  Returns

  {Command}

method version

version: (
    version: string,
    flags: string,
    description?: string
) => Command<Opt, Arg>;

• add show version option to this command.

  Parameter version

  Parameter flags

  Parameter description

  Returns

  {Command}

constructor

constructor(params: ErrorParameters);

property message

readonly message: string;

property name

readonly name: string;

property params

params: ErrorParameters;

property stack

stack?: string;

constructor

constructor(flags: string, description?: string, defaultValue?: any);

• class of option.

  cmd --path foo/bar buzz.txt
        ↑ this one!

  Parameter flags

  pass '-f, --foo'(boolean) or '--foo'(boolean) or '--foo '(string[]) or '--foo [bar]'(string[]).

  Parameter description

  Parameter defaultValue

property defaultValue

defaultValue?: any;

property description

description: string;

• description of this option

property flags

flags: string;

property long

long: string;

• long style. e.g. --option

property no

no: boolean;

• this option is default true. if specified this option, value is become false.

property optional

optional: boolean;

• this option need parameter value. it is optional.

property required

required: boolean;

• this option need parameter value. it is required.

property short

short?: string;

• short style. e.g. -o

method is

is: (arg: string) => boolean;

• check arg is matches this option.

  Parameter arg

  Returns

  {boolean}

method name

name: () => string;

• name of this option.

  Returns

  {any}

method parse

parse: (opts: any, args: string[]) => string[];

• parse args. build to opts.

  e.g. #1 instance member: required=true, optional=false, short=-f, long=--foo method arguments: opts={}, args=["--foo", "foo!", "bar!"]. opts are modified to { foo: ["foo!"] } and return ["bar!"].

  e.g. #2 instance member: required=true, optional=false, short=-f, long=--foo method arguments: opts={ foo: ["foo?"] }, args=["--foo", "foo!", "bar!"]. opts are modified to { foo: ["foo?", "foo!"] } and return ["bar!"].

  e.g. #3 instance member: required=false, optional=false, short=-f, long=--foo method arguments: opts={}, args=["-f", "foo!", "bar!"]. opts are modified to { foo: true } and return ["foo!", "bar!"].

  Parameter opts

  Parameter args

  Returns

  {string[]}

member ArgumentRequired

ArgumentRequired = 'argument required'

member ArgumentsRequired

ArgumentsRequired = '1 or more arguments required'

member OptionNameMismatch

OptionNameMismatch = 'short or long option name mismatch'

member OptionValueRequired

OptionValueRequired = 'option value required'

member ParameterCannPlacedAfterOptional

ParameterCannPlacedAfterOptional = 'required parameter is not placed after optional parameter'

member ParameterCantPlacedAfterVariadic

ParameterCantPlacedAfterVariadic = 'parameter can not placed after variadic parameter'

member UnknownOption

UnknownOption = 'unknown option'

member UnsupportedFormatArgument

UnsupportedFormatArgument = 'unsupported format'