robojerk/codeql-action

Upgrade Ava to v4

Browse source
This commit is contained in:
Henry Mercer 2022-02-01 18:01:11 +00:00
parent 9a40cc5274
commit ce89f1b611
1153 changed files with 27264 additions and 95308 deletions
Download patch file Download diff file Expand all files Collapse all files

2921
node_modules/yargs/build/index.cjs generated vendored
View file

File diff suppressed because one or more lines are too long

500
node_modules/yargs/build/lib/command.js generated vendored
View file

@ -3,14 +3,41 @@ import { isPromise } from './utils/is-promise.js';
import { applyMiddleware, commandMiddlewareFactory, } from './middleware.js';
import { parseCommand } from './parse-command.js';
import { isYargsInstance, } from './yargs-factory.js';
import { maybeAsyncResult } from './utils/maybe-async-result.js';
import whichModule from './utils/which-module.js';
const DEFAULT_MARKER = /(^\*)|(^\$0)/;
export function command(yargs, usage, validation, globalMiddleware = [], shim) {
const self = {};
let handlers = {};
let aliasMap = {};
let defaultCommand;
self.addHandler = function addHandler(cmd, description, builder, handler, commandMiddleware, deprecated) {
export class CommandInstance {
constructor(usage, validation, globalMiddleware, shim) {
this.requireCache = new Set();
this.handlers = {};
this.aliasMap = {};
this.frozens = [];
this.shim = shim;
this.usage = usage;
this.globalMiddleware = globalMiddleware;
this.validation = validation;
}
addDirectory(dir, req, callerFile, opts) {
opts = opts || {};
if (typeof opts.recurse !== 'boolean')
opts.recurse = false;
if (!Array.isArray(opts.extensions))
opts.extensions = ['js'];
const parentVisit = typeof opts.visit === 'function' ? opts.visit : (o) => o;
opts.visit = (obj, joined, filename) => {
const visited = parentVisit(obj, joined, filename);
if (visited) {
if (this.requireCache.has(joined))
return visited;
else
this.requireCache.add(joined);
this.addHandler(visited);
}
return visited;
};
this.shim.requireDirectory({ require: req, filename: callerFile }, dir, opts);
}
addHandler(cmd, description, builder, handler, commandMiddleware, deprecated) {
let aliases = [];
const middlewares = commandMiddlewareFactory(commandMiddleware);
handler = handler || (() => { });
@ -20,21 +47,21 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
}
else {
for (const command of cmd) {
self.addHandler(command);
this.addHandler(command);
}
}
}
else if (isCommandHandlerDefinition(cmd)) {
let command = Array.isArray(cmd.command) || typeof cmd.command === 'string'
? cmd.command
: moduleName(cmd);
: this.moduleName(cmd);
if (cmd.aliases)
command = [].concat(command).concat(cmd.aliases);
self.addHandler(command, extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
this.addHandler(command, this.extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
return;
}
else if (isCommandBuilderDefinition(builder)) {
self.addHandler([cmd].concat(aliases), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated);
this.addHandler([cmd].concat(aliases), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated);
return;
}
if (typeof cmd === 'string') {
@ -56,12 +83,12 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
cmd = cmd.replace(DEFAULT_MARKER, parsedCommand.cmd);
}
aliases.forEach(alias => {
aliasMap[alias] = parsedCommand.cmd;
this.aliasMap[alias] = parsedCommand.cmd;
});
if (description !== false) {
usage.command(cmd, description, isDefault, aliases, deprecated);
this.usage.command(cmd, description, isDefault, aliases, deprecated);
}
handlers[parsedCommand.cmd] = {
this.handlers[parsedCommand.cmd] = {
original: cmd,
description,
handler,
@ -72,147 +99,81 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
optional: parsedCommand.optional,
};
if (isDefault)
defaultCommand = handlers[parsedCommand.cmd];
this.defaultCommand = this.handlers[parsedCommand.cmd];
}
};
self.addDirectory = function addDirectory(dir, context, req, callerFile, opts) {
opts = opts || {};
if (typeof opts.recurse !== 'boolean')
opts.recurse = false;
if (!Array.isArray(opts.extensions))
opts.extensions = ['js'];
const parentVisit = typeof opts.visit === 'function' ? opts.visit : (o) => o;
opts.visit = function visit(obj, joined, filename) {
const visited = parentVisit(obj, joined, filename);
if (visited) {
if (~context.files.indexOf(joined))
return visited;
context.files.push(joined);
self.addHandler(visited);
}
return visited;
};
shim.requireDirectory({ require: req, filename: callerFile }, dir, opts);
};
function moduleName(obj) {
const mod = whichModule(obj);
if (!mod)
throw new Error(`No command name given for module: ${shim.inspect(obj)}`);
return commandFromFilename(mod.filename);
}
function commandFromFilename(filename) {
return shim.path.basename(filename, shim.path.extname(filename));
getCommandHandlers() {
return this.handlers;
}
function extractDesc({ describe, description, desc, }) {
for (const test of [describe, description, desc]) {
if (typeof test === 'string' || test === false)
return test;
assertNotStrictEqual(test, true, shim);
}
return false;
getCommands() {
return Object.keys(this.handlers).concat(Object.keys(this.aliasMap));
}
self.getCommands = () => Object.keys(handlers).concat(Object.keys(aliasMap));
self.getCommandHandlers = () => handlers;
self.hasDefaultCommand = () => !!defaultCommand;
self.runCommand = function runCommand(command, yargs, parsed, commandIndex) {
let aliases = parsed.aliases;
const commandHandler = handlers[command] || handlers[aliasMap[command]] || defaultCommand;
const currentContext = yargs.getContext();
let numFiles = currentContext.files.length;
hasDefaultCommand() {
return !!this.defaultCommand;
}
runCommand(command, yargs, parsed, commandIndex, helpOnly, helpOrVersionSet) {
const commandHandler = this.handlers[command] ||
this.handlers[this.aliasMap[command]] ||
this.defaultCommand;
const currentContext = yargs.getInternalMethods().getContext();
const parentCommands = currentContext.commands.slice();
let innerArgv = parsed.argv;
let positionalMap = {};
const isDefaultCommand = !command;
if (command) {
currentContext.commands.push(command);
currentContext.fullCommands.push(commandHandler.original);
}
const builderResult = this.applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, parsed.aliases, parentCommands, commandIndex, helpOnly, helpOrVersionSet);
return isPromise(builderResult)
? builderResult.then(result => this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, result.innerArgv, currentContext, helpOnly, result.aliases, yargs))
: this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, builderResult.innerArgv, currentContext, helpOnly, builderResult.aliases, yargs);
}
applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, aliases, parentCommands, commandIndex, helpOnly, helpOrVersionSet) {
const builder = commandHandler.builder;
let innerYargs = yargs;
if (isCommandBuilderCallback(builder)) {
const builderOutput = builder(yargs.reset(parsed.aliases));
const innerYargs = isYargsInstance(builderOutput) ? builderOutput : yargs;
if (shouldUpdateUsage(innerYargs)) {
innerYargs
.getUsageInstance()
.usage(usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
const builderOutput = builder(yargs.getInternalMethods().reset(aliases), helpOrVersionSet);
if (isPromise(builderOutput)) {
return builderOutput.then(output => {
innerYargs = isYargsInstance(output) ? output : yargs;
return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);
});
}
innerArgv = innerYargs._parseArgs(null, null, true, commandIndex);
aliases = innerYargs.parsed.aliases;
}
else if (isCommandBuilderOptionDefinitions(builder)) {
const innerYargs = yargs.reset(parsed.aliases);
if (shouldUpdateUsage(innerYargs)) {
innerYargs
.getUsageInstance()
.usage(usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
}
innerYargs = yargs.getInternalMethods().reset(aliases);
Object.keys(commandHandler.builder).forEach(key => {
innerYargs.option(key, builder[key]);
});
innerArgv = innerYargs._parseArgs(null, null, true, commandIndex);
aliases = innerYargs.parsed.aliases;
}
if (!yargs._hasOutput()) {
positionalMap = populatePositionals(commandHandler, innerArgv, currentContext);
}
const middlewares = globalMiddleware
.slice(0)
.concat(commandHandler.middlewares);
applyMiddleware(innerArgv, yargs, middlewares, true);
if (!yargs._hasOutput()) {
yargs._runValidation(innerArgv, aliases, positionalMap, yargs.parsed.error, !command);
}
if (commandHandler.handler && !yargs._hasOutput()) {
yargs._setHasOutput();
const populateDoubleDash = !!yargs.getOptions().configuration['populate--'];
yargs._postProcess(innerArgv, populateDoubleDash);
innerArgv = applyMiddleware(innerArgv, yargs, middlewares, false);
let handlerResult;
if (isPromise(innerArgv)) {
handlerResult = innerArgv.then(argv => commandHandler.handler(argv));
}
else {
handlerResult = commandHandler.handler(innerArgv);
}
const handlerFinishCommand = yargs.getHandlerFinishCommand();
if (isPromise(handlerResult)) {
yargs.getUsageInstance().cacheHelpMessage();
handlerResult
.then(value => {
if (handlerFinishCommand) {
handlerFinishCommand(value);
}
})
.catch(error => {
try {
yargs.getUsageInstance().fail(null, error);
}
catch (err) {
}
})
.then(() => {
yargs.getUsageInstance().clearCachedHelpMessage();
});
}
else {
if (handlerFinishCommand) {
handlerFinishCommand(handlerResult);
}
}
}
if (command) {
currentContext.commands.pop();
currentContext.fullCommands.pop();
}
numFiles = currentContext.files.length - numFiles;
if (numFiles > 0)
currentContext.files.splice(numFiles * -1, numFiles);
return innerArgv;
};
function shouldUpdateUsage(yargs) {
return (!yargs.getUsageInstance().getUsageDisabled() &&
yargs.getUsageInstance().getUsage().length === 0);
return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);
}
function usageFromParentCommandsCommandHandler(parentCommands, commandHandler) {
parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly) {
if (isDefaultCommand)
innerYargs.getInternalMethods().getUsageInstance().unfreeze();
if (this.shouldUpdateUsage(innerYargs)) {
innerYargs
.getInternalMethods()
.getUsageInstance()
.usage(this.usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
}
const innerArgv = innerYargs
.getInternalMethods()
.runYargsParserAndExecuteCommands(null, undefined, true, commandIndex, helpOnly);
return isPromise(innerArgv)
? innerArgv.then(argv => ({
aliases: innerYargs.parsed.aliases,
innerArgv: argv,
}))
: {
aliases: innerYargs.parsed.aliases,
innerArgv: innerArgv,
};
}
shouldUpdateUsage(yargs) {
return (!yargs.getInternalMethods().getUsageInstance().getUsageDisabled() &&
yargs.getInternalMethods().getUsageInstance().getUsage().length === 0);
}
usageFromParentCommandsCommandHandler(parentCommands, commandHandler) {
const c = DEFAULT_MARKER.test(commandHandler.original)
? commandHandler.original.replace(DEFAULT_MARKER, '').trim()
: commandHandler.original;
@ -222,43 +183,79 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
pc.push(c);
return `$0 ${pc.join(' ')}`;
}
self.runDefaultBuilderOn = function (yargs) {
assertNotStrictEqual(defaultCommand, undefined, shim);
if (shouldUpdateUsage(yargs)) {
const commandString = DEFAULT_MARKER.test(defaultCommand.original)
? defaultCommand.original
: defaultCommand.original.replace(/^[^[\]<>]*/, '$0 ');
yargs.getUsageInstance().usage(commandString, defaultCommand.description);
applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, innerArgv, currentContext, helpOnly, aliases, yargs) {
let positionalMap = {};
if (helpOnly)
return innerArgv;
if (!yargs.getInternalMethods().getHasOutput()) {
positionalMap = this.populatePositionals(commandHandler, innerArgv, currentContext, yargs);
}
const builder = defaultCommand.builder;
if (isCommandBuilderCallback(builder)) {
builder(yargs);
}
else if (!isCommandBuilderDefinition(builder)) {
Object.keys(builder).forEach(key => {
yargs.option(key, builder[key]);
const middlewares = this.globalMiddleware
.getMiddleware()
.slice(0)
.concat(commandHandler.middlewares);
innerArgv = applyMiddleware(innerArgv, yargs, middlewares, true);
if (!yargs.getInternalMethods().getHasOutput()) {
const validation = yargs
.getInternalMethods()
.runValidation(aliases, positionalMap, yargs.parsed.error, isDefaultCommand);
innerArgv = maybeAsyncResult(innerArgv, result => {
validation(result);
return result;
});
}
};
function populatePositionals(commandHandler, argv, context) {
if (commandHandler.handler && !yargs.getInternalMethods().getHasOutput()) {
yargs.getInternalMethods().setHasOutput();
const populateDoubleDash = !!yargs.getOptions().configuration['populate--'];
yargs
.getInternalMethods()
.postProcess(innerArgv, populateDoubleDash, false, false);
innerArgv = applyMiddleware(innerArgv, yargs, middlewares, false);
innerArgv = maybeAsyncResult(innerArgv, result => {
const handlerResult = commandHandler.handler(result);
return isPromise(handlerResult)
? handlerResult.then(() => result)
: result;
});
if (!isDefaultCommand) {
yargs.getInternalMethods().getUsageInstance().cacheHelpMessage();
}
if (isPromise(innerArgv) &&
!yargs.getInternalMethods().hasParseCallback()) {
innerArgv.catch(error => {
try {
yargs.getInternalMethods().getUsageInstance().fail(null, error);
}
catch (_err) {
}
});
}
}
if (!isDefaultCommand) {
currentContext.commands.pop();
currentContext.fullCommands.pop();
}
return innerArgv;
}
populatePositionals(commandHandler, argv, context, yargs) {
argv._ = argv._.slice(context.commands.length);
const demanded = commandHandler.demanded.slice(0);
const optional = commandHandler.optional.slice(0);
const positionalMap = {};
validation.positionalCount(demanded.length, argv._.length);
this.validation.positionalCount(demanded.length, argv._.length);
while (demanded.length) {
const demand = demanded.shift();
populatePositional(demand, argv, positionalMap);
this.populatePositional(demand, argv, positionalMap);
}
while (optional.length) {
const maybe = optional.shift();
populatePositional(maybe, argv, positionalMap);
this.populatePositional(maybe, argv, positionalMap);
}
argv._ = context.commands.concat(argv._.map(a => '' + a));
postProcessPositionals(argv, positionalMap, self.cmdToParseOptions(commandHandler.original));
this.postProcessPositionals(argv, positionalMap, this.cmdToParseOptions(commandHandler.original), yargs);
return positionalMap;
}
function populatePositional(positional, argv, positionalMap) {
populatePositional(positional, argv, positionalMap) {
const cmd = positional.cmd[0];
if (positional.variadic) {
positionalMap[cmd] = argv._.splice(0).map(String);
@ -268,49 +265,7 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
positionalMap[cmd] = [String(argv._.shift())];
}
}
function postProcessPositionals(argv, positionalMap, parseOptions) {
const options = Object.assign({}, yargs.getOptions());
options.default = Object.assign(parseOptions.default, options.default);
for (const key of Object.keys(parseOptions.alias)) {
options.alias[key] = (options.alias[key] || []).concat(parseOptions.alias[key]);
}
options.array = options.array.concat(parseOptions.array);
options.config = {};
const unparsed = [];
Object.keys(positionalMap).forEach(key => {
positionalMap[key].map(value => {
if (options.configuration['unknown-options-as-args'])
options.key[key] = true;
unparsed.push(`--${key}`);
unparsed.push(value);
});
});
if (!unparsed.length)
return;
const config = Object.assign({}, options.configuration, {
'populate--': true,
});
const parsed = shim.Parser.detailed(unparsed, Object.assign({}, options, {
configuration: config,
}));
if (parsed.error) {
yargs.getUsageInstance().fail(parsed.error.message, parsed.error);
}
else {
const positionalKeys = Object.keys(positionalMap);
Object.keys(positionalMap).forEach(key => {
positionalKeys.push(...parsed.aliases[key]);
});
Object.keys(parsed.argv).forEach(key => {
if (positionalKeys.indexOf(key) !== -1) {
if (!positionalMap[key])
positionalMap[key] = parsed.argv[key];
argv[key] = parsed.argv[key];
}
});
}
}
self.cmdToParseOptions = function (cmdString) {
cmdToParseOptions(cmdString) {
const parseOptions = {
array: [],
default: {},
@ -336,27 +291,127 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
parseOptions.alias[cmd] = aliases;
});
return parseOptions;
};
self.reset = () => {
handlers = {};
aliasMap = {};
defaultCommand = undefined;
return self;
};
const frozens = [];
self.freeze = () => {
frozens.push({
handlers,
aliasMap,
defaultCommand,
}
postProcessPositionals(argv, positionalMap, parseOptions, yargs) {
const options = Object.assign({}, yargs.getOptions());
options.default = Object.assign(parseOptions.default, options.default);
for (const key of Object.keys(parseOptions.alias)) {
options.alias[key] = (options.alias[key] || []).concat(parseOptions.alias[key]);
}
options.array = options.array.concat(parseOptions.array);
options.config = {};
const unparsed = [];
Object.keys(positionalMap).forEach(key => {
positionalMap[key].map(value => {
if (options.configuration['unknown-options-as-args'])
options.key[key] = true;
unparsed.push(`--${key}`);
unparsed.push(value);
});
});
};
self.unfreeze = () => {
const frozen = frozens.pop();
assertNotStrictEqual(frozen, undefined, shim);
({ handlers, aliasMap, defaultCommand } = frozen);
};
return self;
if (!unparsed.length)
return;
const config = Object.assign({}, options.configuration, {
'populate--': false,
});
const parsed = this.shim.Parser.detailed(unparsed, Object.assign({}, options, {
configuration: config,
}));
if (parsed.error) {
yargs
.getInternalMethods()
.getUsageInstance()
.fail(parsed.error.message, parsed.error);
}
else {
const positionalKeys = Object.keys(positionalMap);
Object.keys(positionalMap).forEach(key => {
positionalKeys.push(...parsed.aliases[key]);
});
const defaults = yargs.getOptions().default;
Object.keys(parsed.argv).forEach(key => {
if (positionalKeys.includes(key)) {
if (!positionalMap[key])
positionalMap[key] = parsed.argv[key];
if (!Object.prototype.hasOwnProperty.call(defaults, key) &&
Object.prototype.hasOwnProperty.call(argv, key) &&
Object.prototype.hasOwnProperty.call(parsed.argv, key) &&
(Array.isArray(argv[key]) || Array.isArray(parsed.argv[key]))) {
argv[key] = [].concat(argv[key], parsed.argv[key]);
}
else {
argv[key] = parsed.argv[key];
}
}
});
}
}
runDefaultBuilderOn(yargs) {
if (!this.defaultCommand)
return;
if (this.shouldUpdateUsage(yargs)) {
const commandString = DEFAULT_MARKER.test(this.defaultCommand.original)
? this.defaultCommand.original
: this.defaultCommand.original.replace(/^[^[\]<>]*/, '$0 ');
yargs
.getInternalMethods()
.getUsageInstance()
.usage(commandString, this.defaultCommand.description);
}
const builder = this.defaultCommand.builder;
if (isCommandBuilderCallback(builder)) {
return builder(yargs, true);
}
else if (!isCommandBuilderDefinition(builder)) {
Object.keys(builder).forEach(key => {
yargs.option(key, builder[key]);
});
}
return undefined;
}
moduleName(obj) {
const mod = whichModule(obj);
if (!mod)
throw new Error(`No command name given for module: ${this.shim.inspect(obj)}`);
return this.commandFromFilename(mod.filename);
}
commandFromFilename(filename) {
return this.shim.path.basename(filename, this.shim.path.extname(filename));
}
extractDesc({ describe, description, desc }) {
for (const test of [describe, description, desc]) {
if (typeof test === 'string' || test === false)
return test;
assertNotStrictEqual(test, true, this.shim);
}
return false;
}
freeze() {
this.frozens.push({
handlers: this.handlers,
aliasMap: this.aliasMap,
defaultCommand: this.defaultCommand,
});
}
unfreeze() {
const frozen = this.frozens.pop();
assertNotStrictEqual(frozen, undefined, this.shim);
({
handlers: this.handlers,
aliasMap: this.aliasMap,
defaultCommand: this.defaultCommand,
} = frozen);
}
reset() {
this.handlers = {};
this.aliasMap = {};
this.defaultCommand = undefined;
this.requireCache = new Set();
return this;
}
}
export function command(usage, validation, globalMiddleware, shim) {
return new CommandInstance(usage, validation, globalMiddleware, shim);
}
export function isCommandBuilderDefinition(builder) {
return (typeof builder === 'object' &&
@ -364,12 +419,7 @@ export function isCommandBuilderDefinition(builder) {
typeof builder.handler === 'function');
}
function isCommandAndAliases(cmd) {
if (cmd.every(c => typeof c === 'string')) {
return true;
}
else {
return false;
}
return cmd.every(c => typeof c === 'string');
}
export function isCommandBuilderCallback(builder) {
return typeof builder === 'function';

7
node_modules/yargs/build/lib/completion-templates.js generated vendored
View file

@ -5,7 +5,7 @@ export const completionShTemplate = `###-begin-{{app_name}}-completions-###
# Installation: {{app_path}} {{completion_command}} >> ~/.bashrc
# or {{app_path}} {{completion_command}} >> ~/.bash_profile on OSX.
#
_yargs_completions()
_{{app_name}}_yargs_completions()
{
local cur_word args type_list
@ -24,10 +24,11 @@ _yargs_completions()
return 0
}
complete -o default -F _yargs_completions {{app_name}}
complete -o bashdefault -o default -F _{{app_name}}_yargs_completions {{app_name}}
###-end-{{app_name}}-completions-###
`;
export const completionZshTemplate = `###-begin-{{app_name}}-completions-###
export const completionZshTemplate = `#compdef {{app_name}}
###-begin-{{app_name}}-completions-###
#
# yargs command completion script
#

244
node_modules/yargs/build/lib/completion.js generated vendored
View file

@ -3,68 +3,49 @@ import { assertNotStrictEqual } from './typings/common-types.js';
import * as templates from './completion-templates.js';
import { isPromise } from './utils/is-promise.js';
import { parseCommand } from './parse-command.js';
export function completion(yargs, usage, command, shim) {
const self = {
completionKey: 'get-yargs-completions',
};
let aliases;
self.setParsed = function setParsed(parsed) {
aliases = parsed.aliases;
};
const zshShell = (shim.getEnv('SHELL') && shim.getEnv('SHELL').indexOf('zsh') !== -1) ||
(shim.getEnv('ZSH_NAME') && shim.getEnv('ZSH_NAME').indexOf('zsh') !== -1);
self.getCompletion = function getCompletion(args, done) {
const completions = [];
const current = args.length ? args[args.length - 1] : '';
const argv = yargs.parse(args, true);
const parentCommands = yargs.getContext().commands;
function runCompletionFunction(argv) {
assertNotStrictEqual(completionFunction, null, shim);
if (isSyncCompletionFunction(completionFunction)) {
const result = completionFunction(current, argv);
if (isPromise(result)) {
return result
.then(list => {
shim.process.nextTick(() => {
done(list);
});
})
.catch(err => {
shim.process.nextTick(() => {
throw err;
});
});
}
return done(result);
}
else {
return completionFunction(current, argv, completions => {
done(completions);
});
}
}
if (completionFunction) {
return isPromise(argv)
? argv.then(runCompletionFunction)
: runCompletionFunction(argv);
}
const handlers = command.getCommandHandlers();
export class Completion {
constructor(yargs, usage, command, shim) {
var _a, _b, _c;
this.yargs = yargs;
this.usage = usage;
this.command = command;
this.shim = shim;
this.completionKey = 'get-yargs-completions';
this.aliases = null;
this.customCompletionFunction = null;
this.zshShell =
(_c = (((_a = this.shim.getEnv('SHELL')) === null || _a === void 0 ? void 0 : _a.includes('zsh')) ||
((_b = this.shim.getEnv('ZSH_NAME')) === null || _b === void 0 ? void 0 : _b.includes('zsh')))) !== null && _c !== void 0 ? _c : false;
}
defaultCompletion(args, argv, current, done) {
const handlers = this.command.getCommandHandlers();
for (let i = 0, ii = args.length; i < ii; ++i) {
if (handlers[args[i]] && handlers[args[i]].builder) {
const builder = handlers[args[i]].builder;
if (isCommandBuilderCallback(builder)) {
const y = yargs.reset();
builder(y);
const y = this.yargs.getInternalMethods().reset();
builder(y, true);
return y.argv;
}
}
}
const completions = [];
this.commandCompletions(completions, args, current);
this.optionCompletions(completions, args, argv, current);
this.choicesCompletions(completions, args, argv, current);
done(null, completions);
}
commandCompletions(completions, args, current) {
const parentCommands = this.yargs
.getInternalMethods()
.getContext().commands;
if (!current.match(/^-/) &&
parentCommands[parentCommands.length - 1] !== current) {
usage.getCommands().forEach(usageCommand => {
parentCommands[parentCommands.length - 1] !== current &&
!this.previousArgHasChoices(args)) {
this.usage.getCommands().forEach(usageCommand => {
const commandName = parseCommand(usageCommand[0]).cmd;
if (args.indexOf(commandName) === -1) {
if (!zshShell) {
if (!this.zshShell) {
completions.push(commandName);
}
else {
@ -74,55 +55,146 @@ export function completion(yargs, usage, command, shim) {
}
});
}
if (current.match(/^-/) || (current === '' && completions.length === 0)) {
const descs = usage.getDescriptions();
const options = yargs.getOptions();
}
optionCompletions(completions, args, argv, current) {
if ((current.match(/^-/) || (current === '' && completions.length === 0)) &&
!this.previousArgHasChoices(args)) {
const options = this.yargs.getOptions();
const positionalKeys = this.yargs.getGroups()[this.usage.getPositionalGroupName()] || [];
Object.keys(options.key).forEach(key => {
const negable = !!options.configuration['boolean-negation'] &&
options.boolean.includes(key);
let keyAndAliases = [key].concat(aliases[key] || []);
if (negable)
keyAndAliases = keyAndAliases.concat(keyAndAliases.map(key => `no-${key}`));
function completeOptionKey(key) {
const notInArgs = keyAndAliases.every(val => args.indexOf(`--${val}`) === -1);
if (notInArgs) {
const startsByTwoDashes = (s) => /^--/.test(s);
const isShortOption = (s) => /^[^0-9]$/.test(s);
const dashes = !startsByTwoDashes(current) && isShortOption(key) ? '-' : '--';
if (!zshShell) {
completions.push(dashes + key);
}
else {
const desc = descs[key] || '';
completions.push(dashes +
`${key.replace(/:/g, '\\:')}:${desc.replace('__yargsString__:', '')}`);
}
}
const isPositionalKey = positionalKeys.includes(key);
if (!isPositionalKey &&
!this.argsContainKey(args, argv, key, negable)) {
this.completeOptionKey(key, completions, current);
if (negable && !!options.default[key])
this.completeOptionKey(`no-${key}`, completions, current);
}
completeOptionKey(key);
if (negable && !!options.default[key])
completeOptionKey(`no-${key}`);
});
}
done(completions);
};
self.generateCompletionScript = function generateCompletionScript($0, cmd) {
let script = zshShell
}
choicesCompletions(completions, args, argv, current) {
if (this.previousArgHasChoices(args)) {
const choices = this.getPreviousArgChoices(args);
if (choices && choices.length > 0) {
completions.push(...choices);
}
}
}
getPreviousArgChoices(args) {
if (args.length < 1)
return;
let previousArg = args[args.length - 1];
let filter = '';
if (!previousArg.startsWith('--') && args.length > 1) {
filter = previousArg;
previousArg = args[args.length - 2];
}
if (!previousArg.startsWith('--'))
return;
const previousArgKey = previousArg.replace(/-/g, '');
const options = this.yargs.getOptions();
if (Object.keys(options.key).some(key => key === previousArgKey) &&
Array.isArray(options.choices[previousArgKey])) {
return options.choices[previousArgKey].filter(choice => !filter || choice.startsWith(filter));
}
}
previousArgHasChoices(args) {
const choices = this.getPreviousArgChoices(args);
return choices !== undefined && choices.length > 0;
}
argsContainKey(args, argv, key, negable) {
if (args.indexOf(`--${key}`) !== -1)
return true;
if (negable && args.indexOf(`--no-${key}`) !== -1)
return true;
if (this.aliases) {
for (const alias of this.aliases[key]) {
if (argv[alias] !== undefined)
return true;
}
}
return false;
}
completeOptionKey(key, completions, current) {
const descs = this.usage.getDescriptions();
const startsByTwoDashes = (s) => /^--/.test(s);
const isShortOption = (s) => /^[^0-9]$/.test(s);
const dashes = !startsByTwoDashes(current) && isShortOption(key) ? '-' : '--';
if (!this.zshShell) {
completions.push(dashes + key);
}
else {
const desc = descs[key] || '';
completions.push(dashes +
`${key.replace(/:/g, '\\:')}:${desc.replace('__yargsString__:', '')}`);
}
}
customCompletion(args, argv, current, done) {
assertNotStrictEqual(this.customCompletionFunction, null, this.shim);
if (isSyncCompletionFunction(this.customCompletionFunction)) {
const result = this.customCompletionFunction(current, argv);
if (isPromise(result)) {
return result
.then(list => {
this.shim.process.nextTick(() => {
done(null, list);
});
})
.catch(err => {
this.shim.process.nextTick(() => {
done(err, undefined);
});
});
}
return done(null, result);
}
else if (isFallbackCompletionFunction(this.customCompletionFunction)) {
return this.customCompletionFunction(current, argv, (onCompleted = done) => this.defaultCompletion(args, argv, current, onCompleted), completions => {
done(null, completions);
});
}
else {
return this.customCompletionFunction(current, argv, completions => {
done(null, completions);
});
}
}
getCompletion(args, done) {
const current = args.length ? args[args.length - 1] : '';
const argv = this.yargs.parse(args, true);
const completionFunction = this.customCompletionFunction
? (argv) => this.customCompletion(args, argv, current, done)
: (argv) => this.defaultCompletion(args, argv, current, done);
return isPromise(argv)
? argv.then(completionFunction)
: completionFunction(argv);
}
generateCompletionScript($0, cmd) {
let script = this.zshShell
? templates.completionZshTemplate
: templates.completionShTemplate;
const name = shim.path.basename($0);
const name = this.shim.path.basename($0);
if ($0.match(/\.js$/))
$0 = `./${$0}`;
script = script.replace(/{{app_name}}/g, name);
script = script.replace(/{{completion_command}}/g, cmd);
return script.replace(/{{app_path}}/g, $0);
};
let completionFunction = null;
self.registerFunction = fn => {
completionFunction = fn;
};
return self;
}
registerFunction(fn) {
this.customCompletionFunction = fn;
}
setParsed(parsed) {
this.aliases = parsed.aliases;
}
}
export function completion(yargs, usage, command, shim) {
return new Completion(yargs, usage, command, shim);
}
function isSyncCompletionFunction(completionFunction) {
return completionFunction.length < 3;
}
function isFallbackCompletionFunction(completionFunction) {
return completionFunction.length > 3;
}

67
node_modules/yargs/build/lib/middleware.js generated vendored
View file

@ -1,23 +1,59 @@
import { argsert } from './argsert.js';
import { isPromise } from './utils/is-promise.js';
export function globalMiddlewareFactory(globalMiddleware, context) {
return function (callback, applyBeforeValidation = false) {
argsert('<array|function> [boolean]', [callback, applyBeforeValidation], arguments.length);
export class GlobalMiddleware {
constructor(yargs) {
this.globalMiddleware = [];
this.frozens = [];
this.yargs = yargs;
}
addMiddleware(callback, applyBeforeValidation, global = true, mutates = false) {
argsert('<array|function> [boolean] [boolean] [boolean]', [callback, applyBeforeValidation, global], arguments.length);
if (Array.isArray(callback)) {
for (let i = 0; i < callback.length; i++) {
if (typeof callback[i] !== 'function') {
throw Error('middleware must be a function');
}
callback[i].applyBeforeValidation = applyBeforeValidation;
const m = callback[i];
m.applyBeforeValidation = applyBeforeValidation;
m.global = global;
}
Array.prototype.push.apply(globalMiddleware, callback);
Array.prototype.push.apply(this.globalMiddleware, callback);
}
else if (typeof callback === 'function') {
callback.applyBeforeValidation = applyBeforeValidation;
globalMiddleware.push(callback);
const m = callback;
m.applyBeforeValidation = applyBeforeValidation;
m.global = global;
m.mutates = mutates;
this.globalMiddleware.push(callback);
}
return context;
};
return this.yargs;
}
addCoerceMiddleware(callback, option) {
const aliases = this.yargs.getAliases();
this.globalMiddleware = this.globalMiddleware.filter(m => {
const toCheck = [...(aliases[option] || []), option];
if (!m.option)
return true;
else
return !toCheck.includes(m.option);
});
callback.option = option;
return this.addMiddleware(callback, true, true, true);
}
getMiddleware() {
return this.globalMiddleware;
}
freeze() {
this.frozens.push([...this.globalMiddleware]);
}
unfreeze() {
const frozen = this.frozens.pop();
if (frozen !== undefined)
this.globalMiddleware = frozen;
}
reset() {
this.globalMiddleware = this.globalMiddleware.filter(m => m.global);
}
}
export function commandMiddlewareFactory(commandMiddleware) {
if (!commandMiddleware)
@ -28,23 +64,22 @@ export function commandMiddlewareFactory(commandMiddleware) {
});
}
export function applyMiddleware(argv, yargs, middlewares, beforeValidation) {
const beforeValidationError = new Error('middleware cannot return a promise when applyBeforeValidation is true');
return middlewares.reduce((acc, middleware) => {
if (middleware.applyBeforeValidation !== beforeValidation) {
return acc;
}
if (middleware.mutates) {
if (middleware.applied)
return acc;
middleware.applied = true;
}
if (isPromise(acc)) {
return acc
.then(initialObj => Promise.all([
initialObj,
middleware(initialObj, yargs),
]))
.then(initialObj => Promise.all([initialObj, middleware(initialObj, yargs)]))
.then(([initialObj, middlewareObj]) => Object.assign(initialObj, middlewareObj));
}
else {
const result = middleware(acc, yargs);
if (beforeValidation && isPromise(result))
throw beforeValidationError;
return isPromise(result)
? result.then(middlewareObj => Object.assign(acc, middlewareObj))
: Object.assign(acc, result);

84
node_modules/yargs/build/lib/usage.js generated vendored
View file

@ -1,9 +1,11 @@
import { assertNotStrictEqual, } from './typings/common-types.js';
import { objFilter } from './utils/obj-filter.js';
import { YError } from './yerror.js';
import setBlocking from './utils/set-blocking.js';
export function usage(yargs, y18n, shim) {
const __ = y18n.__;
function isBoolean(fail) {
return typeof fail === 'boolean';
}
export function usage(yargs, shim) {
const __ = shim.y18n.__;
const self = {};
const fails = [];
self.failFn = function failFn(f) {
@ -22,10 +24,19 @@ export function usage(yargs, y18n, shim) {
};
let failureOutput = false;
self.fail = function fail(msg, err) {
const logger = yargs._getLoggerInstance();
const logger = yargs.getInternalMethods().getLoggerInstance();
if (fails.length) {
for (let i = fails.length - 1; i >= 0; --i) {
fails[i](msg, err, self);
const fail = fails[i];
if (isBoolean(fail)) {
if (err)
throw err;
else if (msg)
throw Error(msg);
}
else {
fail(msg, err, self);
}
}
}
else {
@ -49,7 +60,7 @@ export function usage(yargs, y18n, shim) {
if (yargs.getExitProcess()) {
return yargs.exit(1);
}
else if (yargs._hasParseCallback()) {
else if (yargs.getInternalMethods().hasParseCallback()) {
return yargs.exit(1, err);
}
else {
@ -160,7 +171,7 @@ export function usage(yargs, y18n, shim) {
if (!usageDisabled) {
if (usages.length) {
usages.forEach(usage => {
ui.div(`${usage[0].replace(/\$0/g, base$0)}`);
ui.div({ text: `${usage[0].replace(/\$0/g, base$0)}` });
if (usage[1]) {
ui.div({ text: `${usage[1]}`, padding: [1, 0, 0, 0] });
}
@ -178,17 +189,19 @@ export function usage(yargs, y18n, shim) {
ui.div(`${u}`);
}
}
if (commands.length) {
if (commands.length > 1 || (commands.length === 1 && !commands[0][2])) {
ui.div(__('Commands:'));
const context = yargs.getContext();
const context = yargs.getInternalMethods().getContext();
const parentCommands = context.commands.length
? `${context.commands.join(' ')} `
: '';
if (yargs.getParserConfiguration()['sort-commands'] === true) {
if (yargs.getInternalMethods().getParserConfiguration()['sort-commands'] ===
true) {
commands = commands.sort((a, b) => a[0].localeCompare(b[0]));
}
const prefix = base$0 ? `${base$0} ` : '';
commands.forEach(command => {
const commandString = `${base$0} ${parentCommands}${command[0].replace(/^\$0 ?/, '')}`;
const commandString = `${prefix}${parentCommands}${command[0].replace(/^\$0 ?/, '')}`;
ui.span({
text: commandString,
padding: [0, 2, 0, 2],
@ -235,10 +248,10 @@ export function usage(yargs, y18n, shim) {
const normalizedKeys = groups[groupName]
.filter(filterHiddenOptions)
.map(key => {
if (~aliasKeys.indexOf(key))
if (aliasKeys.includes(key))
return key;
for (let i = 0, aliasKey; (aliasKey = aliasKeys[i]) !== undefined; i++) {
if (~(options.alias[aliasKey] || []).indexOf(key))
if ((options.alias[aliasKey] || []).includes(key))
return aliasKey;
}
return key;
@ -255,7 +268,7 @@ export function usage(yargs, y18n, shim) {
return sw;
else {
return ((/^[0-9]$/.test(sw)
? ~options.boolean.indexOf(key)
? options.boolean.includes(key)
? '-'
: '--'
: sw.length > 1
@ -293,19 +306,19 @@ export function usage(yargs, y18n, shim) {
const kswitch = switches[key];
let desc = descriptions[key] || '';
let type = null;
if (~desc.lastIndexOf(deferY18nLookupPrefix))
if (desc.includes(deferY18nLookupPrefix))
desc = __(desc.substring(deferY18nLookupPrefix.length));
if (~options.boolean.indexOf(key))
if (options.boolean.includes(key))
type = `[${__('boolean')}]`;
if (~options.count.indexOf(key))
if (options.count.includes(key))
type = `[${__('count')}]`;
if (~options.string.indexOf(key))
if (options.string.includes(key))
type = `[${__('string')}]`;
if (~options.normalize.indexOf(key))
if (options.normalize.includes(key))
type = `[${__('string')}]`;
if (~options.array.indexOf(key))
if (options.array.includes(key))
type = `[${__('array')}]`;
if (~options.number.indexOf(key))
if (options.number.includes(key))
type = `[${__('number')}]`;
const deprecatedExtra = (deprecated) => typeof deprecated === 'string'
? `[${__('deprecated: %s', deprecated)}]`
@ -388,17 +401,17 @@ export function usage(yargs, y18n, shim) {
self.describe(key, descriptions[alias]);
if (alias in demandedOptions)
yargs.demandOption(key, demandedOptions[alias]);
if (~options.boolean.indexOf(alias))
if (options.boolean.includes(alias))
yargs.boolean(key);
if (~options.count.indexOf(alias))
if (options.count.includes(alias))
yargs.count(key);
if (~options.string.indexOf(alias))
if (options.string.includes(alias))
yargs.string(key);
if (~options.normalize.indexOf(alias))
if (options.normalize.includes(alias))
yargs.normalize(key);
if (~options.array.indexOf(alias))
if (options.array.includes(alias))
yargs.array(key);
if (~options.number.indexOf(alias))
if (options.number.includes(alias))
yargs.number(key);
});
});
@ -410,6 +423,9 @@ export function usage(yargs, y18n, shim) {
self.clearCachedHelpMessage = function () {
cachedHelpMessage = undefined;
};
self.hasCachedHelpMessage = function () {
return !!cachedHelpMessage;
};
function addUngroupedKeys(keys, aliases, groups, defaultGroup) {
let groupedKeys = [];
let toCheck = null;
@ -429,7 +445,7 @@ export function usage(yargs, y18n, shim) {
yargs.parsed.argv[yargs.getOptions().showHiddenOpt]);
}
self.showHelp = (level) => {
const logger = yargs._getLoggerInstance();
const logger = yargs.getInternalMethods().getLoggerInstance();
if (!level)
level = 'error';
const emit = typeof level === 'function' ? level : logger[level];
@ -488,9 +504,12 @@ export function usage(yargs, y18n, shim) {
self.version = ver => {
version = ver;
};
self.showVersion = () => {
const logger = yargs._getLoggerInstance();
logger.log(version);
self.showVersion = level => {
const logger = yargs.getInternalMethods().getLoggerInstance();
if (!level)
level = 'error';
const emit = typeof level === 'function' ? level : logger[level];
emit(version);
};
self.reset = function reset(localLookup) {
failMessage = null;
@ -518,7 +537,8 @@ export function usage(yargs, y18n, shim) {
};
self.unfreeze = function unfreeze() {
const frozen = frozens.pop();
assertNotStrictEqual(frozen, undefined, shim);
if (!frozen)
return;
({
failMessage,
failureOutput,

10
node_modules/yargs/build/lib/utils/levenshtein.js generated vendored
View file

@ -18,7 +18,15 @@ export function levenshtein(a, b) {
matrix[i][j] = matrix[i - 1][j - 1];
}
else {
matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
if (i > 1 &&
j > 1 &&
b.charAt(i - 2) === a.charAt(j - 1) &&
b.charAt(i - 1) === a.charAt(j - 2)) {
matrix[i][j] = matrix[i - 2][j - 2] + 1;
}
else {
matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
}
}
}
}

17
node_modules/yargs/build/lib/utils/maybe-async-result.js generated vendored Normal file
View file

@ -0,0 +1,17 @@
import { isPromise } from './is-promise.js';
export function maybeAsyncResult(getResult, resultHandler, errorHandler = (err) => {
throw err;
}) {
try {
const result = isFunction(getResult) ? getResult() : getResult;
return isPromise(result)
? result.then((result) => resultHandler(result))
: resultHandler(result);
}
catch (err) {
return errorHandler(err);
}
}
function isFunction(arg) {
return typeof arg === 'function';
}

103
node_modules/yargs/build/lib/validation.js generated vendored
View file

@ -3,14 +3,14 @@ import { assertNotStrictEqual, } from './typings/common-types.js';
import { levenshtein as distance } from './utils/levenshtein.js';
import { objFilter } from './utils/obj-filter.js';
const specialKeys = ['$0', '--', '_'];
export function validation(yargs, usage, y18n, shim) {
const __ = y18n.__;
const __n = y18n.__n;
export function validation(yargs, usage, shim) {
const __ = shim.y18n.__;
const __n = shim.y18n.__n;
const self = {};
self.nonOptionCount = function nonOptionCount(argv) {
const demandedCommands = yargs.getDemandedCommands();
const positionalCount = argv._.length + (argv['--'] ? argv['--'].length : 0);
const _s = positionalCount - yargs.getContext().commands.length;
const _s = positionalCount - yargs.getInternalMethods().getContext().commands.length;
if (demandedCommands._ &&
(_s < demandedCommands._.min || _s > demandedCommands._.max)) {
if (_s < demandedCommands._.min) {
@ -44,8 +44,7 @@ export function validation(yargs, usage, y18n, shim) {
usage.fail(__n('Not enough non-option arguments: got %s, need at least %s', 'Not enough non-option arguments: got %s, need at least %s', observed, observed + '', required + ''));
}
};
self.requiredArguments = function requiredArguments(argv) {
const demandedOptions = yargs.getDemandedOptions();
self.requiredArguments = function requiredArguments(argv, demandedOptions) {
let missing = null;
for (const key of Object.keys(demandedOptions)) {
if (!Object.prototype.hasOwnProperty.call(argv, key) ||
@ -67,13 +66,17 @@ export function validation(yargs, usage, y18n, shim) {
}
};
self.unknownArguments = function unknownArguments(argv, aliases, positionalMap, isDefaultCommand, checkPositionals = true) {
const commandKeys = yargs.getCommandInstance().getCommands();
var _a;
const commandKeys = yargs
.getInternalMethods()
.getCommandInstance()
.getCommands();
const unknown = [];
const currentContext = yargs.getContext();
const currentContext = yargs.getInternalMethods().getContext();
Object.keys(argv).forEach(key => {
if (specialKeys.indexOf(key) === -1 &&
if (!specialKeys.includes(key) &&
!Object.prototype.hasOwnProperty.call(positionalMap, key) &&
!Object.prototype.hasOwnProperty.call(yargs._getParseContext(), key) &&
!Object.prototype.hasOwnProperty.call(yargs.getInternalMethods().getParseContext(), key) &&
!self.isValidAndSomeAliasIsNotNew(key, aliases)) {
unknown.push(key);
}
@ -83,22 +86,39 @@ export function validation(yargs, usage, y18n, shim) {
commandKeys.length > 0 ||
isDefaultCommand)) {
argv._.slice(currentContext.commands.length).forEach(key => {
if (commandKeys.indexOf('' + key) === -1) {
if (!commandKeys.includes('' + key)) {
unknown.push('' + key);
}
});
}
if (unknown.length > 0) {
if (checkPositionals) {
const demandedCommands = yargs.getDemandedCommands();
const maxNonOptDemanded = ((_a = demandedCommands._) === null || _a === void 0 ? void 0 : _a.max) || 0;
const expected = currentContext.commands.length + maxNonOptDemanded;
if (expected < argv._.length) {
argv._.slice(expected).forEach(key => {
key = String(key);
if (!currentContext.commands.includes(key) &&
!unknown.includes(key)) {
unknown.push(key);
}
});
}
}
if (unknown.length) {
usage.fail(__n('Unknown argument: %s', 'Unknown arguments: %s', unknown.length, unknown.join(', ')));
}
};
self.unknownCommands = function unknownCommands(argv) {
const commandKeys = yargs.getCommandInstance().getCommands();
const commandKeys = yargs
.getInternalMethods()
.getCommandInstance()
.getCommands();
const unknown = [];
const currentContext = yargs.getContext();
const currentContext = yargs.getInternalMethods().getContext();
if (currentContext.commands.length > 0 || commandKeys.length > 0) {
argv._.slice(currentContext.commands.length).forEach(key => {
if (commandKeys.indexOf('' + key) === -1) {
if (!commandKeys.includes('' + key)) {
unknown.push('' + key);
}
});
@ -116,13 +136,7 @@ export function validation(yargs, usage, y18n, shim) {
return false;
}
const newAliases = yargs.parsed.newAliases;
for (const a of [key, ...aliases[key]]) {
if (!Object.prototype.hasOwnProperty.call(newAliases, a) ||
!newAliases[key]) {
return true;
}
}
return false;
return [key, ...aliases[key]].some(a => !Object.prototype.hasOwnProperty.call(newAliases, a) || !newAliases[key]);
};
self.limitedChoices = function limitedChoices(argv) {
const options = yargs.getOptions();
@ -149,32 +163,6 @@ export function validation(yargs, usage, y18n, shim) {
});
usage.fail(msg);
};
let checks = [];
self.check = function check(f, global) {
checks.push({
func: f,
global,
});
};
self.customChecks = function customChecks(argv, aliases) {
for (let i = 0, f; (f = checks[i]) !== undefined; i++) {
const func = f.func;
let result = null;
try {
result = func(argv, aliases);
}
catch (err) {
usage.fail(err.message ? err.message : err, err);
continue;
}
if (!result) {
usage.fail(__('Argument check failed: %s', func.toString()));
}
else if (typeof result === 'string' || result instanceof Error) {
usage.fail(result.toString(), result);
}
}
};
let implied = {};
self.implies = function implies(key, value) {
argsert('<string|object> [array|number|string]', [key, value], arguments.length);
@ -208,10 +196,10 @@ export function validation(yargs, usage, y18n, shim) {
}
else if (val.match(/^--no-.+/)) {
val = val.match(/^--no-(.+)/)[1];
val = !argv[val];
val = !Object.prototype.hasOwnProperty.call(argv, val);
}
else {
val = argv[val];
val = Object.prototype.hasOwnProperty.call(argv, val);
}
return val;
}
@ -269,6 +257,17 @@ export function validation(yargs, usage, y18n, shim) {
});
}
});
if (yargs.getInternalMethods().getParserConfiguration()['strip-dashed']) {
Object.keys(conflicting).forEach(key => {
conflicting[key].forEach(value => {
if (value &&
argv[shim.Parser.camelCase(key)] !== undefined &&
argv[shim.Parser.camelCase(value)] !== undefined) {
usage.fail(__('Arguments %s and %s are mutually exclusive', key, value));
}
});
});
}
};
self.recommendCommands = function recommendCommands(cmd, potentialCommands) {
const threshold = 3;
@ -288,21 +287,19 @@ export function validation(yargs, usage, y18n, shim) {
self.reset = function reset(localLookup) {
implied = objFilter(implied, k => !localLookup[k]);
conflicting = objFilter(conflicting, k => !localLookup[k]);
checks = checks.filter(c => c.global);
return self;
};
const frozens = [];
self.freeze = function freeze() {
frozens.push({
implied,
checks,
conflicting,
});
};
self.unfreeze = function unfreeze() {
const frozen = frozens.pop();
assertNotStrictEqual(frozen, undefined, shim);
({ implied, checks, conflicting } = frozen);
({ implied, conflicting } = frozen);
};
return self;
}

2388
node_modules/yargs/build/lib/yargs-factory.js generated vendored
View file

File diff suppressed because it is too large Load diff