code
stringlengths 24
2.07M
| docstring
stringlengths 25
85.3k
| func_name
stringlengths 1
92
| language
stringclasses 1
value | repo
stringlengths 5
64
| path
stringlengths 4
172
| url
stringlengths 44
218
| license
stringclasses 7
values |
|---|---|---|---|---|---|---|---|
hook(event, listener) {
const allowedValues = ['preSubcommand', 'preAction', 'postAction'];
if (!allowedValues.includes(event)) {
throw new Error(`Unexpected value for event passed to hook : '${event}'.
Expecting one of '${allowedValues.join("', '")}'`);
}
if (this._lifeCycleHooks[event]) {
this._lifeCycleHooks[event].push(listener);
} else {
this._lifeCycleHooks[event] = [listener];
}
return this;
} | Add hook for life cycle event.
@param {string} event
@param {Function} listener
@return {Command} `this` command for chaining | hook | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
exitOverride(fn) {
if (fn) {
this._exitCallback = fn;
} else {
this._exitCallback = (err) => {
if (err.code !== 'commander.executeSubCommandAsync') {
throw err;
} else {
// Async callback from spawn events, not useful to throw.
}
};
}
return this;
} | Register callback to use as replacement for calling process.exit.
@param {Function} [fn] optional callback which will be passed a CommanderError, defaults to throwing
@return {Command} `this` command for chaining | exitOverride | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_exit(exitCode, code, message) {
if (this._exitCallback) {
this._exitCallback(new CommanderError(exitCode, code, message));
// Expecting this line is not reached.
}
process.exit(exitCode);
} | Call process.exit, and _exitCallback if defined.
@param {number} exitCode exit code for using with process.exit
@param {string} code an id string representing the error
@param {string} message human-readable description of the error
@return never
@private | _exit | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
action(fn) {
const listener = (args) => {
// The .action callback takes an extra parameter which is the command or options.
const expectedArgsCount = this.registeredArguments.length;
const actionArgs = args.slice(0, expectedArgsCount);
if (this._storeOptionsAsProperties) {
actionArgs[expectedArgsCount] = this; // backwards compatible "options"
} else {
actionArgs[expectedArgsCount] = this.opts();
}
actionArgs.push(this);
return fn.apply(this, actionArgs);
};
this._actionHandler = listener;
return this;
} | Register callback `fn` for the command.
@example
program
.command('serve')
.description('start service')
.action(function() {
// do work here
});
@param {Function} fn
@return {Command} `this` command for chaining | action | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
listener = (args) => {
// The .action callback takes an extra parameter which is the command or options.
const expectedArgsCount = this.registeredArguments.length;
const actionArgs = args.slice(0, expectedArgsCount);
if (this._storeOptionsAsProperties) {
actionArgs[expectedArgsCount] = this; // backwards compatible "options"
} else {
actionArgs[expectedArgsCount] = this.opts();
}
actionArgs.push(this);
return fn.apply(this, actionArgs);
} | Register callback `fn` for the command.
@example
program
.command('serve')
.description('start service')
.action(function() {
// do work here
});
@param {Function} fn
@return {Command} `this` command for chaining | listener | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
listener = (args) => {
// The .action callback takes an extra parameter which is the command or options.
const expectedArgsCount = this.registeredArguments.length;
const actionArgs = args.slice(0, expectedArgsCount);
if (this._storeOptionsAsProperties) {
actionArgs[expectedArgsCount] = this; // backwards compatible "options"
} else {
actionArgs[expectedArgsCount] = this.opts();
}
actionArgs.push(this);
return fn.apply(this, actionArgs);
} | Register callback `fn` for the command.
@example
program
.command('serve')
.description('start service')
.action(function() {
// do work here
});
@param {Function} fn
@return {Command} `this` command for chaining | listener | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
createOption(flags, description) {
return new Option(flags, description);
} | Factory routine to create a new unattached option.
See .option() for creating an attached option, which uses this routine to
create the option. You can override createOption to return a custom option.
@param {string} flags
@param {string} [description]
@return {Option} new option | createOption | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_callParseArg(target, value, previous, invalidArgumentMessage) {
try {
return target.parseArg(value, previous);
} catch (err) {
if (err.code === 'commander.invalidArgument') {
const message = `${invalidArgumentMessage} ${err.message}`;
this.error(message, { exitCode: err.exitCode, code: err.code });
}
throw err;
}
} | Wrap parseArgs to catch 'commander.invalidArgument'.
@param {(Option | Argument)} target
@param {string} value
@param {*} previous
@param {string} invalidArgumentMessage
@private | _callParseArg | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_registerOption(option) {
const matchingOption =
(option.short && this._findOption(option.short)) ||
(option.long && this._findOption(option.long));
if (matchingOption) {
const matchingFlag =
option.long && this._findOption(option.long)
? option.long
: option.short;
throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
- already used by option '${matchingOption.flags}'`);
}
this._initOptionGroup(option);
this.options.push(option);
} | Check for option flag conflicts.
Register option if no conflicts found, or throw on conflict.
@param {Option} option
@private | _registerOption | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_registerCommand(command) {
const knownBy = (cmd) => {
return [cmd.name()].concat(cmd.aliases());
};
const alreadyUsed = knownBy(command).find((name) =>
this._findCommand(name),
);
if (alreadyUsed) {
const existingCmd = knownBy(this._findCommand(alreadyUsed)).join('|');
const newCmd = knownBy(command).join('|');
throw new Error(
`cannot add command '${newCmd}' as already have command '${existingCmd}'`,
);
}
this._initCommandGroup(command);
this.commands.push(command);
} | Check for command name and alias conflicts with existing commands.
Register command if no conflicts found, or throw on conflict.
@param {Command} command
@private | _registerCommand | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
knownBy = (cmd) => {
return [cmd.name()].concat(cmd.aliases());
} | Check for command name and alias conflicts with existing commands.
Register command if no conflicts found, or throw on conflict.
@param {Command} command
@private | knownBy | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
knownBy = (cmd) => {
return [cmd.name()].concat(cmd.aliases());
} | Check for command name and alias conflicts with existing commands.
Register command if no conflicts found, or throw on conflict.
@param {Command} command
@private | knownBy | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
addOption(option) {
this._registerOption(option);
const oname = option.name();
const name = option.attributeName();
// store default value
if (option.negate) {
// --no-foo is special and defaults foo to true, unless a --foo option is already defined
const positiveLongFlag = option.long.replace(/^--no-/, '--');
if (!this._findOption(positiveLongFlag)) {
this.setOptionValueWithSource(
name,
option.defaultValue === undefined ? true : option.defaultValue,
'default',
);
}
} else if (option.defaultValue !== undefined) {
this.setOptionValueWithSource(name, option.defaultValue, 'default');
}
// handler for cli and env supplied values
const handleOptionValue = (val, invalidValueMessage, valueSource) => {
// val is null for optional option used without an optional-argument.
// val is undefined for boolean and negated option.
if (val == null && option.presetArg !== undefined) {
val = option.presetArg;
}
// custom processing
const oldValue = this.getOptionValue(name);
if (val !== null && option.parseArg) {
val = this._callParseArg(option, val, oldValue, invalidValueMessage);
} else if (val !== null && option.variadic) {
val = option._concatValue(val, oldValue);
}
// Fill-in appropriate missing values. Long winded but easy to follow.
if (val == null) {
if (option.negate) {
val = false;
} else if (option.isBoolean() || option.optional) {
val = true;
} else {
val = ''; // not normal, parseArg might have failed or be a mock function for testing
}
}
this.setOptionValueWithSource(name, val, valueSource);
};
this.on('option:' + oname, (val) => {
const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`;
handleOptionValue(val, invalidValueMessage, 'cli');
});
if (option.envVar) {
this.on('optionEnv:' + oname, (val) => {
const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`;
handleOptionValue(val, invalidValueMessage, 'env');
});
}
return this;
} | Add an option.
@param {Option} option
@return {Command} `this` command for chaining | addOption | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
handleOptionValue = (val, invalidValueMessage, valueSource) => {
// val is null for optional option used without an optional-argument.
// val is undefined for boolean and negated option.
if (val == null && option.presetArg !== undefined) {
val = option.presetArg;
}
// custom processing
const oldValue = this.getOptionValue(name);
if (val !== null && option.parseArg) {
val = this._callParseArg(option, val, oldValue, invalidValueMessage);
} else if (val !== null && option.variadic) {
val = option._concatValue(val, oldValue);
}
// Fill-in appropriate missing values. Long winded but easy to follow.
if (val == null) {
if (option.negate) {
val = false;
} else if (option.isBoolean() || option.optional) {
val = true;
} else {
val = ''; // not normal, parseArg might have failed or be a mock function for testing
}
}
this.setOptionValueWithSource(name, val, valueSource);
} | Add an option.
@param {Option} option
@return {Command} `this` command for chaining | handleOptionValue | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
handleOptionValue = (val, invalidValueMessage, valueSource) => {
// val is null for optional option used without an optional-argument.
// val is undefined for boolean and negated option.
if (val == null && option.presetArg !== undefined) {
val = option.presetArg;
}
// custom processing
const oldValue = this.getOptionValue(name);
if (val !== null && option.parseArg) {
val = this._callParseArg(option, val, oldValue, invalidValueMessage);
} else if (val !== null && option.variadic) {
val = option._concatValue(val, oldValue);
}
// Fill-in appropriate missing values. Long winded but easy to follow.
if (val == null) {
if (option.negate) {
val = false;
} else if (option.isBoolean() || option.optional) {
val = true;
} else {
val = ''; // not normal, parseArg might have failed or be a mock function for testing
}
}
this.setOptionValueWithSource(name, val, valueSource);
} | Add an option.
@param {Option} option
@return {Command} `this` command for chaining | handleOptionValue | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_optionEx(config, flags, description, fn, defaultValue) {
if (typeof flags === 'object' && flags instanceof Option) {
throw new Error(
'To add an Option object use addOption() instead of option() or requiredOption()',
);
}
const option = this.createOption(flags, description);
option.makeOptionMandatory(!!config.mandatory);
if (typeof fn === 'function') {
option.default(defaultValue).argParser(fn);
} else if (fn instanceof RegExp) {
// deprecated
const regex = fn;
fn = (val, def) => {
const m = regex.exec(val);
return m ? m[0] : def;
};
option.default(defaultValue).argParser(fn);
} else {
option.default(fn);
}
return this.addOption(option);
} | Internal implementation shared by .option() and .requiredOption()
@return {Command} `this` command for chaining
@private | _optionEx | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
option(flags, description, parseArg, defaultValue) {
return this._optionEx({}, flags, description, parseArg, defaultValue);
} | Define option with `flags`, `description`, and optional argument parsing function or `defaultValue` or both.
The `flags` string contains the short and/or long flags, separated by comma, a pipe or space. A required
option-argument is indicated by `<>` and an optional option-argument by `[]`.
See the README for more details, and see also addOption() and requiredOption().
@example
program
.option('-p, --pepper', 'add pepper')
.option('--pt, --pizza-type <TYPE>', 'type of pizza') // required option-argument
.option('-c, --cheese [CHEESE]', 'add extra cheese', 'mozzarella') // optional option-argument with default
.option('-t, --tip <VALUE>', 'add tip to purchase cost', parseFloat) // custom parse function
@param {string} flags
@param {string} [description]
@param {(Function|*)} [parseArg] - custom option processing function or default value
@param {*} [defaultValue]
@return {Command} `this` command for chaining | option | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
requiredOption(flags, description, parseArg, defaultValue) {
return this._optionEx(
{ mandatory: true },
flags,
description,
parseArg,
defaultValue,
);
} | Add a required option which must have a value after parsing. This usually means
the option must be specified on the command line. (Otherwise the same as .option().)
The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
@param {string} flags
@param {string} [description]
@param {(Function|*)} [parseArg] - custom option processing function or default value
@param {*} [defaultValue]
@return {Command} `this` command for chaining | requiredOption | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
enablePositionalOptions(positional = true) {
this._enablePositionalOptions = !!positional;
return this;
} | Enable positional options. Positional means global options are specified before subcommands which lets
subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
The default behaviour is non-positional and global options may appear anywhere on the command line.
@param {boolean} [positional]
@return {Command} `this` command for chaining | enablePositionalOptions | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
passThroughOptions(passThrough = true) {
this._passThroughOptions = !!passThrough;
this._checkForBrokenPassThrough();
return this;
} | Pass through options that come after command-arguments rather than treat them as command-options,
so actual command-options come before command-arguments. Turning this on for a subcommand requires
positional options to have been enabled on the program (parent commands).
The default behaviour is non-positional and options may appear before or after command-arguments.
@param {boolean} [passThrough] for unknown options.
@return {Command} `this` command for chaining | passThroughOptions | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
storeOptionsAsProperties(storeAsProperties = true) {
if (this.options.length) {
throw new Error('call .storeOptionsAsProperties() before adding options');
}
if (Object.keys(this._optionValues).length) {
throw new Error(
'call .storeOptionsAsProperties() before setting option values',
);
}
this._storeOptionsAsProperties = !!storeAsProperties;
return this;
} | Whether to store option values as properties on command object,
or store separately (specify false). In both cases the option values can be accessed using .opts().
@param {boolean} [storeAsProperties=true]
@return {Command} `this` command for chaining | storeOptionsAsProperties | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
getOptionValue(key) {
if (this._storeOptionsAsProperties) {
return this[key];
}
return this._optionValues[key];
} | Retrieve option value.
@param {string} key
@return {object} value | getOptionValue | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
setOptionValue(key, value) {
return this.setOptionValueWithSource(key, value, undefined);
} | Store option value.
@param {string} key
@param {object} value
@return {Command} `this` command for chaining | setOptionValue | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
setOptionValueWithSource(key, value, source) {
if (this._storeOptionsAsProperties) {
this[key] = value;
} else {
this._optionValues[key] = value;
}
this._optionValueSources[key] = source;
return this;
} | Store option value and where the value came from.
@param {string} key
@param {object} value
@param {string} source - expected values are default/config/env/cli/implied
@return {Command} `this` command for chaining | setOptionValueWithSource | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
getOptionValueSource(key) {
return this._optionValueSources[key];
} | Get source of option value.
Expected values are default | config | env | cli | implied
@param {string} key
@return {string} | getOptionValueSource | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
getOptionValueSourceWithGlobals(key) {
// global overwrites local, like optsWithGlobals
let source;
this._getCommandAndAncestors().forEach((cmd) => {
if (cmd.getOptionValueSource(key) !== undefined) {
source = cmd.getOptionValueSource(key);
}
});
return source;
} | Get source of option value. See also .optsWithGlobals().
Expected values are default | config | env | cli | implied
@param {string} key
@return {string} | getOptionValueSourceWithGlobals | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_prepareUserArgs(argv, parseOptions) {
if (argv !== undefined && !Array.isArray(argv)) {
throw new Error('first parameter to parse must be array or undefined');
}
parseOptions = parseOptions || {};
// auto-detect argument conventions if nothing supplied
if (argv === undefined && parseOptions.from === undefined) {
if (process.versions?.electron) {
parseOptions.from = 'electron';
}
// check node specific options for scenarios where user CLI args follow executable without scriptname
const execArgv = process.execArgv ?? [];
if (
execArgv.includes('-e') ||
execArgv.includes('--eval') ||
execArgv.includes('-p') ||
execArgv.includes('--print')
) {
parseOptions.from = 'eval'; // internal usage, not documented
}
}
// default to using process.argv
if (argv === undefined) {
argv = process.argv;
}
this.rawArgs = argv.slice();
// extract the user args and scriptPath
let userArgs;
switch (parseOptions.from) {
case undefined:
case 'node':
this._scriptPath = argv[1];
userArgs = argv.slice(2);
break;
case 'electron':
// @ts-ignore: because defaultApp is an unknown property
if (process.defaultApp) {
this._scriptPath = argv[1];
userArgs = argv.slice(2);
} else {
userArgs = argv.slice(1);
}
break;
case 'user':
userArgs = argv.slice(0);
break;
case 'eval':
userArgs = argv.slice(1);
break;
default:
throw new Error(
`unexpected parse option { from: '${parseOptions.from}' }`,
);
}
// Find default name for program from arguments.
if (!this._name && this._scriptPath)
this.nameFromFilename(this._scriptPath);
this._name = this._name || 'program';
return userArgs;
} | Get user arguments from implied or explicit arguments.
Side-effects: set _scriptPath if args included script. Used for default program name, and subcommand searches.
@private | _prepareUserArgs | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
parse(argv, parseOptions) {
this._prepareForParse();
const userArgs = this._prepareUserArgs(argv, parseOptions);
this._parseCommand([], userArgs);
return this;
} | Parse `argv`, setting options and invoking commands when defined.
Use parseAsync instead of parse if any of your action handlers are async.
Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!
Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:
- `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that
- `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged
- `'user'`: just user arguments
@example
program.parse(); // parse process.argv and auto-detect electron and special node flags
program.parse(process.argv); // assume argv[0] is app and argv[1] is script
program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
@param {string[]} [argv] - optional, defaults to process.argv
@param {object} [parseOptions] - optionally specify style of options with from: node/user/electron
@param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron'
@return {Command} `this` command for chaining | parse | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
async parseAsync(argv, parseOptions) {
this._prepareForParse();
const userArgs = this._prepareUserArgs(argv, parseOptions);
await this._parseCommand([], userArgs);
return this;
} | Parse `argv`, setting options and invoking commands when defined.
Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!
Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:
- `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that
- `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged
- `'user'`: just user arguments
@example
await program.parseAsync(); // parse process.argv and auto-detect electron and special node flags
await program.parseAsync(process.argv); // assume argv[0] is app and argv[1] is script
await program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
@param {string[]} [argv]
@param {object} [parseOptions]
@param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'
@return {Promise} | parseAsync | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_prepareForParse() {
if (this._savedState === null) {
this.saveStateBeforeParse();
} else {
this.restoreStateBeforeParse();
}
} | Parse `argv`, setting options and invoking commands when defined.
Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!
Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:
- `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that
- `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged
- `'user'`: just user arguments
@example
await program.parseAsync(); // parse process.argv and auto-detect electron and special node flags
await program.parseAsync(process.argv); // assume argv[0] is app and argv[1] is script
await program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
@param {string[]} [argv]
@param {object} [parseOptions]
@param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'
@return {Promise} | _prepareForParse | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
saveStateBeforeParse() {
this._savedState = {
// name is stable if supplied by author, but may be unspecified for root command and deduced during parsing
_name: this._name,
// option values before parse have default values (including false for negated options)
// shallow clones
_optionValues: { ...this._optionValues },
_optionValueSources: { ...this._optionValueSources },
};
} | Called the first time parse is called to save state and allow a restore before subsequent calls to parse.
Not usually called directly, but available for subclasses to save their custom state.
This is called in a lazy way. Only commands used in parsing chain will have state saved. | saveStateBeforeParse | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
restoreStateBeforeParse() {
if (this._storeOptionsAsProperties)
throw new Error(`Can not call parse again when storeOptionsAsProperties is true.
- either make a new Command for each call to parse, or stop storing options as properties`);
// clear state from _prepareUserArgs
this._name = this._savedState._name;
this._scriptPath = null;
this.rawArgs = [];
// clear state from setOptionValueWithSource
this._optionValues = { ...this._savedState._optionValues };
this._optionValueSources = { ...this._savedState._optionValueSources };
// clear state from _parseCommand
this.args = [];
// clear state from _processArguments
this.processedArgs = [];
} | Restore state before parse for calls after the first.
Not usually called directly, but available for subclasses to save their custom state.
This is called in a lazy way. Only commands used in parsing chain will have state restored. | restoreStateBeforeParse | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_checkForMissingExecutable(executableFile, executableDir, subcommandName) {
if (fs.existsSync(executableFile)) return;
const executableDirMessage = executableDir
? `searched for local subcommand relative to directory '${executableDir}'`
: 'no directory for search for local subcommand, use .executableDir() to supply a custom directory';
const executableMissing = `'${executableFile}' does not exist
- if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- if the default executable name is not suitable, use the executableFile option to supply a custom name or path
- ${executableDirMessage}`;
throw new Error(executableMissing);
} | Throw if expected executable is missing. Add lots of help for author.
@param {string} executableFile
@param {string} executableDir
@param {string} subcommandName | _checkForMissingExecutable | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_dispatchHelpCommand(subcommandName) {
if (!subcommandName) {
this.help();
}
const subCommand = this._findCommand(subcommandName);
if (subCommand && !subCommand._executableHandler) {
subCommand.help();
}
// Fallback to parsing the help flag to invoke the help.
return this._dispatchSubcommand(
subcommandName,
[],
[this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? '--help'],
);
} | Invoke help directly if possible, or dispatch if necessary.
e.g. help foo
@private | _dispatchHelpCommand | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_checkNumberOfArguments() {
// too few
this.registeredArguments.forEach((arg, i) => {
if (arg.required && this.args[i] == null) {
this.missingArgument(arg.name());
}
});
// too many
if (
this.registeredArguments.length > 0 &&
this.registeredArguments[this.registeredArguments.length - 1].variadic
) {
return;
}
if (this.args.length > this.registeredArguments.length) {
this._excessArguments(this.args);
}
} | Check this.args against expected this.registeredArguments.
@private | _checkNumberOfArguments | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_processArguments() {
const myParseArg = (argument, value, previous) => {
// Extra processing for nice error message on parsing failure.
let parsedValue = value;
if (value !== null && argument.parseArg) {
const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
parsedValue = this._callParseArg(
argument,
value,
previous,
invalidValueMessage,
);
}
return parsedValue;
};
this._checkNumberOfArguments();
const processedArgs = [];
this.registeredArguments.forEach((declaredArg, index) => {
let value = declaredArg.defaultValue;
if (declaredArg.variadic) {
// Collect together remaining arguments for passing together as an array.
if (index < this.args.length) {
value = this.args.slice(index);
if (declaredArg.parseArg) {
value = value.reduce((processed, v) => {
return myParseArg(declaredArg, v, processed);
}, declaredArg.defaultValue);
}
} else if (value === undefined) {
value = [];
}
} else if (index < this.args.length) {
value = this.args[index];
if (declaredArg.parseArg) {
value = myParseArg(declaredArg, value, declaredArg.defaultValue);
}
}
processedArgs[index] = value;
});
this.processedArgs = processedArgs;
} | Process this.args using this.registeredArguments and save as this.processedArgs!
@private | _processArguments | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
myParseArg = (argument, value, previous) => {
// Extra processing for nice error message on parsing failure.
let parsedValue = value;
if (value !== null && argument.parseArg) {
const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
parsedValue = this._callParseArg(
argument,
value,
previous,
invalidValueMessage,
);
}
return parsedValue;
} | Process this.args using this.registeredArguments and save as this.processedArgs!
@private | myParseArg | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
myParseArg = (argument, value, previous) => {
// Extra processing for nice error message on parsing failure.
let parsedValue = value;
if (value !== null && argument.parseArg) {
const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
parsedValue = this._callParseArg(
argument,
value,
previous,
invalidValueMessage,
);
}
return parsedValue;
} | Process this.args using this.registeredArguments and save as this.processedArgs!
@private | myParseArg | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_chainOrCall(promise, fn) {
// thenable
if (promise && promise.then && typeof promise.then === 'function') {
// already have a promise, chain callback
return promise.then(() => fn());
}
// callback might return a promise
return fn();
} | Once we have a promise we chain, but call synchronously until then.
@param {(Promise|undefined)} promise
@param {Function} fn
@return {(Promise|undefined)}
@private | _chainOrCall | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_chainOrCallHooks(promise, event) {
let result = promise;
const hooks = [];
this._getCommandAndAncestors()
.reverse()
.filter((cmd) => cmd._lifeCycleHooks[event] !== undefined)
.forEach((hookedCommand) => {
hookedCommand._lifeCycleHooks[event].forEach((callback) => {
hooks.push({ hookedCommand, callback });
});
});
if (event === 'postAction') {
hooks.reverse();
}
hooks.forEach((hookDetail) => {
result = this._chainOrCall(result, () => {
return hookDetail.callback(hookDetail.hookedCommand, this);
});
});
return result;
} | @param {(Promise|undefined)} promise
@param {string} event
@return {(Promise|undefined)}
@private | _chainOrCallHooks | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_chainOrCallSubCommandHook(promise, subCommand, event) {
let result = promise;
if (this._lifeCycleHooks[event] !== undefined) {
this._lifeCycleHooks[event].forEach((hook) => {
result = this._chainOrCall(result, () => {
return hook(this, subCommand);
});
});
}
return result;
} | @param {(Promise|undefined)} promise
@param {Command} subCommand
@param {string} event
@return {(Promise|undefined)}
@private | _chainOrCallSubCommandHook | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_parseCommand(operands, unknown) {
const parsed = this.parseOptions(unknown);
this._parseOptionsEnv(); // after cli, so parseArg not called on both cli and env
this._parseOptionsImplied();
operands = operands.concat(parsed.operands);
unknown = parsed.unknown;
this.args = operands.concat(unknown);
if (operands && this._findCommand(operands[0])) {
return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
}
if (
this._getHelpCommand() &&
operands[0] === this._getHelpCommand().name()
) {
return this._dispatchHelpCommand(operands[1]);
}
if (this._defaultCommandName) {
this._outputHelpIfRequested(unknown); // Run the help for default command from parent rather than passing to default command
return this._dispatchSubcommand(
this._defaultCommandName,
operands,
unknown,
);
}
if (
this.commands.length &&
this.args.length === 0 &&
!this._actionHandler &&
!this._defaultCommandName
) {
// probably missing subcommand and no handler, user needs help (and exit)
this.help({ error: true });
}
this._outputHelpIfRequested(parsed.unknown);
this._checkForMissingMandatoryOptions();
this._checkForConflictingOptions();
// We do not always call this check to avoid masking a "better" error, like unknown command.
const checkForUnknownOptions = () => {
if (parsed.unknown.length > 0) {
this.unknownOption(parsed.unknown[0]);
}
};
const commandEvent = `command:${this.name()}`;
if (this._actionHandler) {
checkForUnknownOptions();
this._processArguments();
let promiseChain;
promiseChain = this._chainOrCallHooks(promiseChain, 'preAction');
promiseChain = this._chainOrCall(promiseChain, () =>
this._actionHandler(this.processedArgs),
);
if (this.parent) {
promiseChain = this._chainOrCall(promiseChain, () => {
this.parent.emit(commandEvent, operands, unknown); // legacy
});
}
promiseChain = this._chainOrCallHooks(promiseChain, 'postAction');
return promiseChain;
}
if (this.parent && this.parent.listenerCount(commandEvent)) {
checkForUnknownOptions();
this._processArguments();
this.parent.emit(commandEvent, operands, unknown); // legacy
} else if (operands.length) {
if (this._findCommand('*')) {
// legacy default command
return this._dispatchSubcommand('*', operands, unknown);
}
if (this.listenerCount('command:*')) {
// skip option check, emit event for possible misspelling suggestion
this.emit('command:*', operands, unknown);
} else if (this.commands.length) {
this.unknownCommand();
} else {
checkForUnknownOptions();
this._processArguments();
}
} else if (this.commands.length) {
checkForUnknownOptions();
// This command has subcommands and nothing hooked up at this level, so display help (and exit).
this.help({ error: true });
} else {
checkForUnknownOptions();
this._processArguments();
// fall through for caller to handle after calling .parse()
}
} | Process arguments in context of this command.
Returns action result, in case it is a promise.
@private | _parseCommand | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
checkForUnknownOptions = () => {
if (parsed.unknown.length > 0) {
this.unknownOption(parsed.unknown[0]);
}
} | Process arguments in context of this command.
Returns action result, in case it is a promise.
@private | checkForUnknownOptions | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
checkForUnknownOptions = () => {
if (parsed.unknown.length > 0) {
this.unknownOption(parsed.unknown[0]);
}
} | Process arguments in context of this command.
Returns action result, in case it is a promise.
@private | checkForUnknownOptions | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_findCommand(name) {
if (!name) return undefined;
return this.commands.find(
(cmd) => cmd._name === name || cmd._aliases.includes(name),
);
} | Find matching command.
@private
@return {Command | undefined} | _findCommand | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_findOption(arg) {
return this.options.find((option) => option.is(arg));
} | Return an option matching `arg` if any.
@param {string} arg
@return {Option}
@package | _findOption | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_checkForMissingMandatoryOptions() {
// Walk up hierarchy so can call in subcommand after checking for displaying help.
this._getCommandAndAncestors().forEach((cmd) => {
cmd.options.forEach((anOption) => {
if (
anOption.mandatory &&
cmd.getOptionValue(anOption.attributeName()) === undefined
) {
cmd.missingMandatoryOptionValue(anOption);
}
});
});
} | Display an error message if a mandatory option does not have a value.
Called after checking for help flags in leaf subcommand.
@private | _checkForMissingMandatoryOptions | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_checkForConflictingLocalOptions() {
const definedNonDefaultOptions = this.options.filter((option) => {
const optionKey = option.attributeName();
if (this.getOptionValue(optionKey) === undefined) {
return false;
}
return this.getOptionValueSource(optionKey) !== 'default';
});
const optionsWithConflicting = definedNonDefaultOptions.filter(
(option) => option.conflictsWith.length > 0,
);
optionsWithConflicting.forEach((option) => {
const conflictingAndDefined = definedNonDefaultOptions.find((defined) =>
option.conflictsWith.includes(defined.attributeName()),
);
if (conflictingAndDefined) {
this._conflictingOption(option, conflictingAndDefined);
}
});
} | Display an error message if conflicting options are used together in this.
@private | _checkForConflictingLocalOptions | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_checkForConflictingOptions() {
// Walk up hierarchy so can call in subcommand after checking for displaying help.
this._getCommandAndAncestors().forEach((cmd) => {
cmd._checkForConflictingLocalOptions();
});
} | Display an error message if conflicting options are used together.
Called after checking for help flags in leaf subcommand.
@private | _checkForConflictingOptions | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
parseOptions(argv) {
const operands = []; // operands, not options or values
const unknown = []; // first unknown option and remaining unknown args
let dest = operands;
const args = argv.slice();
function maybeOption(arg) {
return arg.length > 1 && arg[0] === '-';
}
const negativeNumberArg = (arg) => {
// return false if not a negative number
if (!/^-\d*\.?\d+(e[+-]?\d+)?$/.test(arg)) return false;
// negative number is ok unless digit used as an option in command hierarchy
return !this._getCommandAndAncestors().some((cmd) =>
cmd.options
.map((opt) => opt.short)
.some((short) => /^-\d$/.test(short)),
);
};
// parse options
let activeVariadicOption = null;
while (args.length) {
const arg = args.shift();
// literal
if (arg === '--') {
if (dest === unknown) dest.push(arg);
dest.push(...args);
break;
}
if (
activeVariadicOption &&
(!maybeOption(arg) || negativeNumberArg(arg))
) {
this.emit(`option:${activeVariadicOption.name()}`, arg);
continue;
}
activeVariadicOption = null;
if (maybeOption(arg)) {
const option = this._findOption(arg);
// recognised option, call listener to assign value with possible custom processing
if (option) {
if (option.required) {
const value = args.shift();
if (value === undefined) this.optionMissingArgument(option);
this.emit(`option:${option.name()}`, value);
} else if (option.optional) {
let value = null;
// historical behaviour is optional value is following arg unless an option
if (
args.length > 0 &&
(!maybeOption(args[0]) || negativeNumberArg(args[0]))
) {
value = args.shift();
}
this.emit(`option:${option.name()}`, value);
} else {
// boolean flag
this.emit(`option:${option.name()}`);
}
activeVariadicOption = option.variadic ? option : null;
continue;
}
}
// Look for combo options following single dash, eat first one if known.
if (arg.length > 2 && arg[0] === '-' && arg[1] !== '-') {
const option = this._findOption(`-${arg[1]}`);
if (option) {
if (
option.required ||
(option.optional && this._combineFlagAndOptionalValue)
) {
// option with value following in same argument
this.emit(`option:${option.name()}`, arg.slice(2));
} else {
// boolean option, emit and put back remainder of arg for further processing
this.emit(`option:${option.name()}`);
args.unshift(`-${arg.slice(2)}`);
}
continue;
}
}
// Look for known long flag with value, like --foo=bar
if (/^--[^=]+=/.test(arg)) {
const index = arg.indexOf('=');
const option = this._findOption(arg.slice(0, index));
if (option && (option.required || option.optional)) {
this.emit(`option:${option.name()}`, arg.slice(index + 1));
continue;
}
}
// Not a recognised option by this command.
// Might be a command-argument, or subcommand option, or unknown option, or help command or option.
// An unknown option means further arguments also classified as unknown so can be reprocessed by subcommands.
// A negative number in a leaf command is not an unknown option.
if (
dest === operands &&
maybeOption(arg) &&
!(this.commands.length === 0 && negativeNumberArg(arg))
) {
dest = unknown;
}
// If using positionalOptions, stop processing our options at subcommand.
if (
(this._enablePositionalOptions || this._passThroughOptions) &&
operands.length === 0 &&
unknown.length === 0
) {
if (this._findCommand(arg)) {
operands.push(arg);
if (args.length > 0) unknown.push(...args);
break;
} else if (
this._getHelpCommand() &&
arg === this._getHelpCommand().name()
) {
operands.push(arg);
if (args.length > 0) operands.push(...args);
break;
} else if (this._defaultCommandName) {
unknown.push(arg);
if (args.length > 0) unknown.push(...args);
break;
}
}
// If using passThroughOptions, stop processing options at first command-argument.
if (this._passThroughOptions) {
dest.push(arg);
if (args.length > 0) dest.push(...args);
break;
}
// add arg
dest.push(arg);
}
return { operands, unknown };
} | Parse options from `argv` removing known options,
and return argv split into operands and unknown arguments.
Side effects: modifies command by storing options. Does not reset state if called again.
Examples:
argv => operands, unknown
--known kkk op => [op], []
op --known kkk => [op], []
sub --unknown uuu op => [sub], [--unknown uuu op]
sub -- --unknown uuu op => [sub --unknown uuu op], []
@param {string[]} argv
@return {{operands: string[], unknown: string[]}} | parseOptions | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
function maybeOption(arg) {
return arg.length > 1 && arg[0] === '-';
} | Parse options from `argv` removing known options,
and return argv split into operands and unknown arguments.
Side effects: modifies command by storing options. Does not reset state if called again.
Examples:
argv => operands, unknown
--known kkk op => [op], []
op --known kkk => [op], []
sub --unknown uuu op => [sub], [--unknown uuu op]
sub -- --unknown uuu op => [sub --unknown uuu op], []
@param {string[]} argv
@return {{operands: string[], unknown: string[]}} | maybeOption | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
negativeNumberArg = (arg) => {
// return false if not a negative number
if (!/^-\d*\.?\d+(e[+-]?\d+)?$/.test(arg)) return false;
// negative number is ok unless digit used as an option in command hierarchy
return !this._getCommandAndAncestors().some((cmd) =>
cmd.options
.map((opt) => opt.short)
.some((short) => /^-\d$/.test(short)),
);
} | Parse options from `argv` removing known options,
and return argv split into operands and unknown arguments.
Side effects: modifies command by storing options. Does not reset state if called again.
Examples:
argv => operands, unknown
--known kkk op => [op], []
op --known kkk => [op], []
sub --unknown uuu op => [sub], [--unknown uuu op]
sub -- --unknown uuu op => [sub --unknown uuu op], []
@param {string[]} argv
@return {{operands: string[], unknown: string[]}} | negativeNumberArg | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
negativeNumberArg = (arg) => {
// return false if not a negative number
if (!/^-\d*\.?\d+(e[+-]?\d+)?$/.test(arg)) return false;
// negative number is ok unless digit used as an option in command hierarchy
return !this._getCommandAndAncestors().some((cmd) =>
cmd.options
.map((opt) => opt.short)
.some((short) => /^-\d$/.test(short)),
);
} | Parse options from `argv` removing known options,
and return argv split into operands and unknown arguments.
Side effects: modifies command by storing options. Does not reset state if called again.
Examples:
argv => operands, unknown
--known kkk op => [op], []
op --known kkk => [op], []
sub --unknown uuu op => [sub], [--unknown uuu op]
sub -- --unknown uuu op => [sub --unknown uuu op], []
@param {string[]} argv
@return {{operands: string[], unknown: string[]}} | negativeNumberArg | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
opts() {
if (this._storeOptionsAsProperties) {
// Preserve original behaviour so backwards compatible when still using properties
const result = {};
const len = this.options.length;
for (let i = 0; i < len; i++) {
const key = this.options[i].attributeName();
result[key] =
key === this._versionOptionName ? this._version : this[key];
}
return result;
}
return this._optionValues;
} | Return an object containing local option values as key-value pairs.
@return {object} | opts | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
optsWithGlobals() {
// globals overwrite locals
return this._getCommandAndAncestors().reduce(
(combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()),
{},
);
} | Return an object containing merged local and global option values as key-value pairs.
@return {object} | optsWithGlobals | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
error(message, errorOptions) {
// output handling
this._outputConfiguration.outputError(
`${message}\n`,
this._outputConfiguration.writeErr,
);
if (typeof this._showHelpAfterError === 'string') {
this._outputConfiguration.writeErr(`${this._showHelpAfterError}\n`);
} else if (this._showHelpAfterError) {
this._outputConfiguration.writeErr('\n');
this.outputHelp({ error: true });
}
// exit handling
const config = errorOptions || {};
const exitCode = config.exitCode || 1;
const code = config.code || 'commander.error';
this._exit(exitCode, code, message);
} | Display error message and exit (or call exitOverride).
@param {string} message
@param {object} [errorOptions]
@param {string} [errorOptions.code] - an id string representing the error
@param {number} [errorOptions.exitCode] - used with process.exit | error | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_parseOptionsEnv() {
this.options.forEach((option) => {
if (option.envVar && option.envVar in process.env) {
const optionKey = option.attributeName();
// Priority check. Do not overwrite cli or options from unknown source (client-code).
if (
this.getOptionValue(optionKey) === undefined ||
['default', 'config', 'env'].includes(
this.getOptionValueSource(optionKey),
)
) {
if (option.required || option.optional) {
// option can take a value
// keep very simple, optional always takes value
this.emit(`optionEnv:${option.name()}`, process.env[option.envVar]);
} else {
// boolean
// keep very simple, only care that envVar defined and not the value
this.emit(`optionEnv:${option.name()}`);
}
}
}
});
} | Apply any option related environment variables, if option does
not have a value from cli or client code.
@private | _parseOptionsEnv | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_parseOptionsImplied() {
const dualHelper = new DualOptions(this.options);
const hasCustomOptionValue = (optionKey) => {
return (
this.getOptionValue(optionKey) !== undefined &&
!['default', 'implied'].includes(this.getOptionValueSource(optionKey))
);
};
this.options
.filter(
(option) =>
option.implied !== undefined &&
hasCustomOptionValue(option.attributeName()) &&
dualHelper.valueFromOption(
this.getOptionValue(option.attributeName()),
option,
),
)
.forEach((option) => {
Object.keys(option.implied)
.filter((impliedKey) => !hasCustomOptionValue(impliedKey))
.forEach((impliedKey) => {
this.setOptionValueWithSource(
impliedKey,
option.implied[impliedKey],
'implied',
);
});
});
} | Apply any implied option values, if option is undefined or default value.
@private | _parseOptionsImplied | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
hasCustomOptionValue = (optionKey) => {
return (
this.getOptionValue(optionKey) !== undefined &&
!['default', 'implied'].includes(this.getOptionValueSource(optionKey))
);
} | Apply any implied option values, if option is undefined or default value.
@private | hasCustomOptionValue | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
hasCustomOptionValue = (optionKey) => {
return (
this.getOptionValue(optionKey) !== undefined &&
!['default', 'implied'].includes(this.getOptionValueSource(optionKey))
);
} | Apply any implied option values, if option is undefined or default value.
@private | hasCustomOptionValue | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
missingArgument(name) {
const message = `error: missing required argument '${name}'`;
this.error(message, { code: 'commander.missingArgument' });
} | Argument `name` is missing.
@param {string} name
@private | missingArgument | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
optionMissingArgument(option) {
const message = `error: option '${option.flags}' argument missing`;
this.error(message, { code: 'commander.optionMissingArgument' });
} | `Option` is missing an argument.
@param {Option} option
@private | optionMissingArgument | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
missingMandatoryOptionValue(option) {
const message = `error: required option '${option.flags}' not specified`;
this.error(message, { code: 'commander.missingMandatoryOptionValue' });
} | `Option` does not have a value, and is a mandatory option.
@param {Option} option
@private | missingMandatoryOptionValue | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_conflictingOption(option, conflictingOption) {
// The calling code does not know whether a negated option is the source of the
// value, so do some work to take an educated guess.
const findBestOptionFromValue = (option) => {
const optionKey = option.attributeName();
const optionValue = this.getOptionValue(optionKey);
const negativeOption = this.options.find(
(target) => target.negate && optionKey === target.attributeName(),
);
const positiveOption = this.options.find(
(target) => !target.negate && optionKey === target.attributeName(),
);
if (
negativeOption &&
((negativeOption.presetArg === undefined && optionValue === false) ||
(negativeOption.presetArg !== undefined &&
optionValue === negativeOption.presetArg))
) {
return negativeOption;
}
return positiveOption || option;
};
const getErrorMessage = (option) => {
const bestOption = findBestOptionFromValue(option);
const optionKey = bestOption.attributeName();
const source = this.getOptionValueSource(optionKey);
if (source === 'env') {
return `environment variable '${bestOption.envVar}'`;
}
return `option '${bestOption.flags}'`;
};
const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`;
this.error(message, { code: 'commander.conflictingOption' });
} | `Option` conflicts with another option.
@param {Option} option
@param {Option} conflictingOption
@private | _conflictingOption | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
findBestOptionFromValue = (option) => {
const optionKey = option.attributeName();
const optionValue = this.getOptionValue(optionKey);
const negativeOption = this.options.find(
(target) => target.negate && optionKey === target.attributeName(),
);
const positiveOption = this.options.find(
(target) => !target.negate && optionKey === target.attributeName(),
);
if (
negativeOption &&
((negativeOption.presetArg === undefined && optionValue === false) ||
(negativeOption.presetArg !== undefined &&
optionValue === negativeOption.presetArg))
) {
return negativeOption;
}
return positiveOption || option;
} | `Option` conflicts with another option.
@param {Option} option
@param {Option} conflictingOption
@private | findBestOptionFromValue | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
findBestOptionFromValue = (option) => {
const optionKey = option.attributeName();
const optionValue = this.getOptionValue(optionKey);
const negativeOption = this.options.find(
(target) => target.negate && optionKey === target.attributeName(),
);
const positiveOption = this.options.find(
(target) => !target.negate && optionKey === target.attributeName(),
);
if (
negativeOption &&
((negativeOption.presetArg === undefined && optionValue === false) ||
(negativeOption.presetArg !== undefined &&
optionValue === negativeOption.presetArg))
) {
return negativeOption;
}
return positiveOption || option;
} | `Option` conflicts with another option.
@param {Option} option
@param {Option} conflictingOption
@private | findBestOptionFromValue | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
getErrorMessage = (option) => {
const bestOption = findBestOptionFromValue(option);
const optionKey = bestOption.attributeName();
const source = this.getOptionValueSource(optionKey);
if (source === 'env') {
return `environment variable '${bestOption.envVar}'`;
}
return `option '${bestOption.flags}'`;
} | `Option` conflicts with another option.
@param {Option} option
@param {Option} conflictingOption
@private | getErrorMessage | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
getErrorMessage = (option) => {
const bestOption = findBestOptionFromValue(option);
const optionKey = bestOption.attributeName();
const source = this.getOptionValueSource(optionKey);
if (source === 'env') {
return `environment variable '${bestOption.envVar}'`;
}
return `option '${bestOption.flags}'`;
} | `Option` conflicts with another option.
@param {Option} option
@param {Option} conflictingOption
@private | getErrorMessage | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
unknownOption(flag) {
if (this._allowUnknownOption) return;
let suggestion = '';
if (flag.startsWith('--') && this._showSuggestionAfterError) {
// Looping to pick up the global options too
let candidateFlags = [];
// eslint-disable-next-line @typescript-eslint/no-this-alias
let command = this;
do {
const moreFlags = command
.createHelp()
.visibleOptions(command)
.filter((option) => option.long)
.map((option) => option.long);
candidateFlags = candidateFlags.concat(moreFlags);
command = command.parent;
} while (command && !command._enablePositionalOptions);
suggestion = suggestSimilar(flag, candidateFlags);
}
const message = `error: unknown option '${flag}'${suggestion}`;
this.error(message, { code: 'commander.unknownOption' });
} | Unknown option `flag`.
@param {string} flag
@private | unknownOption | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_excessArguments(receivedArgs) {
if (this._allowExcessArguments) return;
const expected = this.registeredArguments.length;
const s = expected === 1 ? '' : 's';
const forSubcommand = this.parent ? ` for '${this.name()}'` : '';
const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
this.error(message, { code: 'commander.excessArguments' });
} | Excess arguments, more than expected.
@param {string[]} receivedArgs
@private | _excessArguments | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
version(str, flags, description) {
if (str === undefined) return this._version;
this._version = str;
flags = flags || '-V, --version';
description = description || 'output the version number';
const versionOption = this.createOption(flags, description);
this._versionOptionName = versionOption.attributeName();
this._registerOption(versionOption);
this.on('option:' + versionOption.name(), () => {
this._outputConfiguration.writeOut(`${str}\n`);
this._exit(0, 'commander.version', str);
});
return this;
} | Get or set the program version.
This method auto-registers the "-V, --version" option which will print the version number.
You can optionally supply the flags and description to override the defaults.
@param {string} [str]
@param {string} [flags]
@param {string} [description]
@return {(this | string | undefined)} `this` command for chaining, or version string if no arguments | version | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
description(str, argsDescription) {
if (str === undefined && argsDescription === undefined)
return this._description;
this._description = str;
if (argsDescription) {
this._argsDescription = argsDescription;
}
return this;
} | Set the description.
@param {string} [str]
@param {object} [argsDescription]
@return {(string|Command)} | description | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
summary(str) {
if (str === undefined) return this._summary;
this._summary = str;
return this;
} | Set the summary. Used when listed as subcommand of parent.
@param {string} [str]
@return {(string|Command)} | summary | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
alias(alias) {
if (alias === undefined) return this._aliases[0]; // just return first, for backwards compatibility
/** @type {Command} */
// eslint-disable-next-line @typescript-eslint/no-this-alias
let command = this;
if (
this.commands.length !== 0 &&
this.commands[this.commands.length - 1]._executableHandler
) {
// assume adding alias for last added executable subcommand, rather than this
command = this.commands[this.commands.length - 1];
}
if (alias === command._name)
throw new Error("Command alias can't be the same as its name");
const matchingCommand = this.parent?._findCommand(alias);
if (matchingCommand) {
// c.f. _registerCommand
const existingCmd = [matchingCommand.name()]
.concat(matchingCommand.aliases())
.join('|');
throw new Error(
`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`,
);
}
command._aliases.push(alias);
return this;
} | Set an alias for the command.
You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.
@param {string} [alias]
@return {(string|Command)} | alias | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
aliases(aliases) {
// Getter for the array of aliases is the main reason for having aliases() in addition to alias().
if (aliases === undefined) return this._aliases;
aliases.forEach((alias) => this.alias(alias));
return this;
} | Set aliases for the command.
Only the first alias is shown in the auto-generated help.
@param {string[]} [aliases]
@return {(string[]|Command)} | aliases | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
usage(str) {
if (str === undefined) {
if (this._usage) return this._usage;
const args = this.registeredArguments.map((arg) => {
return humanReadableArgName(arg);
});
return []
.concat(
this.options.length || this._helpOption !== null ? '[options]' : [],
this.commands.length ? '[command]' : [],
this.registeredArguments.length ? args : [],
)
.join(' ');
}
this._usage = str;
return this;
} | Set / get the command usage `str`.
@param {string} [str]
@return {(string|Command)} | usage | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
name(str) {
if (str === undefined) return this._name;
this._name = str;
return this;
} | Get or set the name of the command.
@param {string} [str]
@return {(string|Command)} | name | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
helpGroup(heading) {
if (heading === undefined) return this._helpGroupHeading ?? '';
this._helpGroupHeading = heading;
return this;
} | Set/get the help group heading for this subcommand in parent command's help.
@param {string} [heading]
@return {Command | string} | helpGroup | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
commandsGroup(heading) {
if (heading === undefined) return this._defaultCommandGroup ?? '';
this._defaultCommandGroup = heading;
return this;
} | Set/get the default help group heading for subcommands added to this command.
(This does not override a group set directly on the subcommand using .helpGroup().)
@example
program.commandsGroup('Development Commands:);
program.command('watch')...
program.command('lint')...
...
@param {string} [heading]
@returns {Command | string} | commandsGroup | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
optionsGroup(heading) {
if (heading === undefined) return this._defaultOptionGroup ?? '';
this._defaultOptionGroup = heading;
return this;
} | Set/get the default help group heading for options added to this command.
(This does not override a group set directly on the option using .helpGroup().)
@example
program
.optionsGroup('Development Options:')
.option('-d, --debug', 'output extra debugging')
.option('-p, --profile', 'output profiling information')
@param {string} [heading]
@returns {Command | string} | optionsGroup | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
nameFromFilename(filename) {
this._name = path.basename(filename, path.extname(filename));
return this;
} | Set the name of the command from script filename, such as process.argv[1],
or require.main.filename, or __filename.
(Used internally and public although not documented in README.)
@example
program.nameFromFilename(require.main.filename);
@param {string} filename
@return {Command} | nameFromFilename | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
executableDir(path) {
if (path === undefined) return this._executableDir;
this._executableDir = path;
return this;
} | Get or set the directory for searching for executable subcommands of this command.
@example
program.executableDir(__dirname);
// or
program.executableDir('subcommands');
@param {string} [path]
@return {(string|null|Command)} | executableDir | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
helpInformation(contextOptions) {
const helper = this.createHelp();
const context = this._getOutputContext(contextOptions);
helper.prepareContext({
error: context.error,
helpWidth: context.helpWidth,
outputHasColors: context.hasColors,
});
const text = helper.formatHelp(this, helper);
if (context.hasColors) return text;
return this._outputConfiguration.stripColor(text);
} | Return program help documentation.
@param {{ error: boolean }} [contextOptions] - pass {error:true} to wrap for stderr instead of stdout
@return {string} | helpInformation | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_getOutputContext(contextOptions) {
contextOptions = contextOptions || {};
const error = !!contextOptions.error;
let baseWrite;
let hasColors;
let helpWidth;
if (error) {
baseWrite = (str) => this._outputConfiguration.writeErr(str);
hasColors = this._outputConfiguration.getErrHasColors();
helpWidth = this._outputConfiguration.getErrHelpWidth();
} else {
baseWrite = (str) => this._outputConfiguration.writeOut(str);
hasColors = this._outputConfiguration.getOutHasColors();
helpWidth = this._outputConfiguration.getOutHelpWidth();
}
const write = (str) => {
if (!hasColors) str = this._outputConfiguration.stripColor(str);
return baseWrite(str);
};
return { error, write, hasColors, helpWidth };
} | @typedef HelpContext
@type {object}
@property {boolean} error
@property {number} helpWidth
@property {boolean} hasColors
@property {function} write - includes stripColor if needed
@returns {HelpContext}
@private | _getOutputContext | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
write = (str) => {
if (!hasColors) str = this._outputConfiguration.stripColor(str);
return baseWrite(str);
} | @typedef HelpContext
@type {object}
@property {boolean} error
@property {number} helpWidth
@property {boolean} hasColors
@property {function} write - includes stripColor if needed
@returns {HelpContext}
@private | write | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
write = (str) => {
if (!hasColors) str = this._outputConfiguration.stripColor(str);
return baseWrite(str);
} | @typedef HelpContext
@type {object}
@property {boolean} error
@property {number} helpWidth
@property {boolean} hasColors
@property {function} write - includes stripColor if needed
@returns {HelpContext}
@private | write | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
outputHelp(contextOptions) {
let deprecatedCallback;
if (typeof contextOptions === 'function') {
deprecatedCallback = contextOptions;
contextOptions = undefined;
}
const outputContext = this._getOutputContext(contextOptions);
/** @type {HelpTextEventContext} */
const eventContext = {
error: outputContext.error,
write: outputContext.write,
command: this,
};
this._getCommandAndAncestors()
.reverse()
.forEach((command) => command.emit('beforeAllHelp', eventContext));
this.emit('beforeHelp', eventContext);
let helpInformation = this.helpInformation({ error: outputContext.error });
if (deprecatedCallback) {
helpInformation = deprecatedCallback(helpInformation);
if (
typeof helpInformation !== 'string' &&
!Buffer.isBuffer(helpInformation)
) {
throw new Error('outputHelp callback must return a string or a Buffer');
}
}
outputContext.write(helpInformation);
if (this._getHelpOption()?.long) {
this.emit(this._getHelpOption().long); // deprecated
}
this.emit('afterHelp', eventContext);
this._getCommandAndAncestors().forEach((command) =>
command.emit('afterAllHelp', eventContext),
);
} | Output help information for this command.
Outputs built-in help, and custom text added using `.addHelpText()`.
@param {{ error: boolean } | Function} [contextOptions] - pass {error:true} to write to stderr instead of stdout | outputHelp | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
helpOption(flags, description) {
// Support enabling/disabling built-in help option.
if (typeof flags === 'boolean') {
if (flags) {
if (this._helpOption === null) this._helpOption = undefined; // reenable
if (this._defaultOptionGroup) {
// make the option to store the group
this._initOptionGroup(this._getHelpOption());
}
} else {
this._helpOption = null; // disable
}
return this;
}
// Customise flags and description.
this._helpOption = this.createOption(
flags ?? '-h, --help',
description ?? 'display help for command',
);
// init group unless lazy create
if (flags || description) this._initOptionGroup(this._helpOption);
return this;
} | You can pass in flags and a description to customise the built-in help option.
Pass in false to disable the built-in help option.
@example
program.helpOption('-?, --help' 'show help'); // customise
program.helpOption(false); // disable
@param {(string | boolean)} flags
@param {string} [description]
@return {Command} `this` command for chaining | helpOption | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_getHelpOption() {
// Lazy create help option on demand.
if (this._helpOption === undefined) {
this.helpOption(undefined, undefined);
}
return this._helpOption;
} | Lazy create help option.
Returns null if has been disabled with .helpOption(false).
@returns {(Option | null)} the help option
@package | _getHelpOption | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
addHelpOption(option) {
this._helpOption = option;
this._initOptionGroup(option);
return this;
} | Supply your own option to use for the built-in help option.
This is an alternative to using helpOption() to customise the flags and description etc.
@param {Option} option
@return {Command} `this` command for chaining | addHelpOption | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
help(contextOptions) {
this.outputHelp(contextOptions);
let exitCode = Number(process.exitCode ?? 0); // process.exitCode does allow a string or an integer, but we prefer just a number
if (
exitCode === 0 &&
contextOptions &&
typeof contextOptions !== 'function' &&
contextOptions.error
) {
exitCode = 1;
}
// message: do not have all displayed text available so only passing placeholder.
this._exit(exitCode, 'commander.help', '(outputHelp)');
} | Output help information and exit.
Outputs built-in help, and custom text added using `.addHelpText()`.
@param {{ error: boolean }} [contextOptions] - pass {error:true} to write to stderr instead of stdout | help | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
addHelpText(position, text) {
const allowedValues = ['beforeAll', 'before', 'after', 'afterAll'];
if (!allowedValues.includes(position)) {
throw new Error(`Unexpected value for position to addHelpText.
Expecting one of '${allowedValues.join("', '")}'`);
}
const helpEvent = `${position}Help`;
this.on(helpEvent, (/** @type {HelpTextEventContext} */ context) => {
let helpStr;
if (typeof text === 'function') {
helpStr = text({ error: context.error, command: context.command });
} else {
helpStr = text;
}
// Ignore falsy value when nothing to output.
if (helpStr) {
context.write(`${helpStr}\n`);
}
});
return this;
} | Add additional text to be displayed with the built-in help.
Position is 'before' or 'after' to affect just this command,
and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
@param {string} position - before or after built-in help
@param {(string | Function)} text - string to add, or a function returning a string
@return {Command} `this` command for chaining | addHelpText | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
_outputHelpIfRequested(args) {
const helpOption = this._getHelpOption();
const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
if (helpRequested) {
this.outputHelp();
// (Do not have all displayed text available so only passing placeholder.)
this._exit(0, 'commander.helpDisplayed', '(outputHelp)');
}
} | Output help information if help flags specified
@param {Array} args - array of options to search for help flags
@private | _outputHelpIfRequested | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
function incrementNodeInspectorPort(args) {
// Testing for these options:
// --inspect[=[host:]port]
// --inspect-brk[=[host:]port]
// --inspect-port=[host:]port
return args.map((arg) => {
if (!arg.startsWith('--inspect')) {
return arg;
}
let debugOption;
let debugHost = '127.0.0.1';
let debugPort = '9229';
let match;
if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
// e.g. --inspect
debugOption = match[1];
} else if (
(match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null
) {
debugOption = match[1];
if (/^\d+$/.test(match[3])) {
// e.g. --inspect=1234
debugPort = match[3];
} else {
// e.g. --inspect=localhost
debugHost = match[3];
}
} else if (
(match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null
) {
// e.g. --inspect=localhost:1234
debugOption = match[1];
debugHost = match[3];
debugPort = match[4];
}
if (debugOption && debugPort !== '0') {
return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
}
return arg;
});
} | Scan arguments and increment port number for inspect calls (to avoid conflicts when spawning new command).
@param {string[]} args - array of arguments from node.execArgv
@returns {string[]}
@private | incrementNodeInspectorPort | javascript | tj/commander.js | lib/command.js | https://github.com/tj/commander.js/blob/master/lib/command.js | MIT |
constructor(exitCode, code, message) {
super(message);
// properly capture stack trace in Node.js
Error.captureStackTrace(this, this.constructor);
this.name = this.constructor.name;
this.code = code;
this.exitCode = exitCode;
this.nestedError = undefined;
} | Constructs the CommanderError class
@param {number} exitCode suggested exit code which could be used with process.exit
@param {string} code an id string representing the error
@param {string} message human-readable description of the error | constructor | javascript | tj/commander.js | lib/error.js | https://github.com/tj/commander.js/blob/master/lib/error.js | MIT |
constructor(message) {
super(1, 'commander.invalidArgument', message);
// properly capture stack trace in Node.js
Error.captureStackTrace(this, this.constructor);
this.name = this.constructor.name;
} | Constructs the InvalidArgumentError class
@param {string} [message] explanation of why argument is invalid | constructor | javascript | tj/commander.js | lib/error.js | https://github.com/tj/commander.js/blob/master/lib/error.js | MIT |
constructor() {
this.helpWidth = undefined;
this.minWidthToWrap = 40;
this.sortSubcommands = false;
this.sortOptions = false;
this.showGlobalOptions = false;
} | TypeScript import types for JSDoc, used by Visual Studio Code IntelliSense and `npm run typescript-checkJS`
https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html#import-types
@typedef { import("./argument.js").Argument } Argument
@typedef { import("./command.js").Command } Command
@typedef { import("./option.js").Option } Option | constructor | javascript | tj/commander.js | lib/help.js | https://github.com/tj/commander.js/blob/master/lib/help.js | MIT |
prepareContext(contextOptions) {
this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
} | prepareContext is called by Commander after applying overrides from `Command.configureHelp()`
and just before calling `formatHelp()`.
Commander just uses the helpWidth and the rest is provided for optional use by more complex subclasses.
@param {{ error?: boolean, helpWidth?: number, outputHasColors?: boolean }} contextOptions | prepareContext | javascript | tj/commander.js | lib/help.js | https://github.com/tj/commander.js/blob/master/lib/help.js | MIT |
visibleCommands(cmd) {
const visibleCommands = cmd.commands.filter((cmd) => !cmd._hidden);
const helpCommand = cmd._getHelpCommand();
if (helpCommand && !helpCommand._hidden) {
visibleCommands.push(helpCommand);
}
if (this.sortSubcommands) {
visibleCommands.sort((a, b) => {
// @ts-ignore: because overloaded return type
return a.name().localeCompare(b.name());
});
}
return visibleCommands;
} | Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
@param {Command} cmd
@returns {Command[]} | visibleCommands | javascript | tj/commander.js | lib/help.js | https://github.com/tj/commander.js/blob/master/lib/help.js | MIT |
compareOptions(a, b) {
const getSortKey = (option) => {
// WYSIWYG for order displayed in help. Short used for comparison if present. No special handling for negated.
return option.short
? option.short.replace(/^-/, '')
: option.long.replace(/^--/, '');
};
return getSortKey(a).localeCompare(getSortKey(b));
} | Compare options for sort.
@param {Option} a
@param {Option} b
@returns {number} | compareOptions | javascript | tj/commander.js | lib/help.js | https://github.com/tj/commander.js/blob/master/lib/help.js | MIT |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.