yargs 17.0.0-candidate.7 → 17.0.1

package/build/lib/command.js

@@ -111,63 +111,77 @@ export class CommandInstance {
     hasDefaultCommand() {
         return !!this.defaultCommand;
     }
-    runCommand(command, yargs, parsed, commandIndex, helpOnly) {
+    runCommand(command, yargs, parsed, commandIndex, helpOnly, helpOrVersionSet) {
         const commandHandler = this.handlers[command] ||
             this.handlers[this.aliasMap[command]] ||
             this.defaultCommand;
-        const currentContext = yargs.getContext();
+        const currentContext = yargs.getInternalMethods().getContext();
         const parentCommands = currentContext.commands.slice();
+        const isDefaultCommand = !command;
         if (command) {
             currentContext.commands.push(command);
             currentContext.fullCommands.push(commandHandler.original);
         }
-        const builderResult = this.applyBuilderUpdateUsageAndParse(command, commandHandler, yargs, parsed.aliases, parentCommands, commandIndex, helpOnly);
+        const builderResult = this.applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, parsed.aliases, parentCommands, commandIndex, helpOnly, helpOrVersionSet);
         if (isPromise(builderResult)) {
             return builderResult.then(result => {
-                return this.applyMiddlewareAndGetResult(command, commandHandler, result.innerArgv, currentContext, helpOnly, result.aliases, yargs);
+                return this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, result.innerArgv, currentContext, helpOnly, result.aliases, yargs);
             });
         }
         else {
-            return this.applyMiddlewareAndGetResult(command, commandHandler, builderResult.innerArgv, currentContext, helpOnly, builderResult.aliases, yargs);
+            return this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, builderResult.innerArgv, currentContext, helpOnly, builderResult.aliases, yargs);
         }
     }
-    applyBuilderUpdateUsageAndParse(command, commandHandler, yargs, aliases, parentCommands, commandIndex, helpOnly) {
+    applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, aliases, parentCommands, commandIndex, helpOnly, helpOrVersionSet) {
         const builder = commandHandler.builder;
         let innerYargs = yargs;
         if (isCommandBuilderCallback(builder)) {
-            const builderOutput = builder(yargs.reset(aliases));
+            const builderOutput = builder(yargs.getInternalMethods().reset(aliases), helpOrVersionSet);
             if (isPromise(builderOutput)) {
                 return builderOutput.then(output => {
                     innerYargs = isYargsInstance(output) ? output : yargs;
-                    return this.parseAndUpdateUsage(command, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);
+                    return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);
                 });
             }
         }
         else if (isCommandBuilderOptionDefinitions(builder)) {
-            innerYargs = yargs.reset(aliases);
+            innerYargs = yargs.getInternalMethods().reset(aliases);
             Object.keys(commandHandler.builder).forEach(key => {
                 innerYargs.option(key, builder[key]);
             });
         }
-        return this.parseAndUpdateUsage(command, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);
+        return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);
     }
-    parseAndUpdateUsage(command, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly) {
-        if (!command)
-            innerYargs.getUsageInstance().unfreeze();
+    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._parseArgs(null, undefined, true, commandIndex, helpOnly);
-        return {
-            aliases: innerYargs.parsed.aliases,
-            innerArgv: innerArgv,
-        };
+        const innerArgv = innerYargs
+            .getInternalMethods()
+            .runYargsParserAndExecuteCommands(null, undefined, true, commandIndex, helpOnly);
+        if (isPromise(innerArgv)) {
+            return innerArgv.then(argv => {
+                return {
+                    aliases: innerYargs.parsed.aliases,
+                    innerArgv: argv,
+                };
+            });
+        }
+        else {
+            return {
+                aliases: innerYargs.parsed.aliases,
+                innerArgv: innerArgv,
+            };
+        }
     }
     shouldUpdateUsage(yargs) {
-        return (!yargs.getUsageInstance().getUsageDisabled() &&
-            yargs.getUsageInstance().getUsage().length === 0);
+        return (!yargs.getInternalMethods().getUsageInstance().getUsageDisabled() &&
+            yargs.getInternalMethods().getUsageInstance().getUsage().length === 0);
     }
     usageFromParentCommandsCommandHandler(parentCommands, commandHandler) {
         const c = DEFAULT_MARKER.test(commandHandler.original)
@@ -179,29 +193,33 @@ export class CommandInstance {
         pc.push(c);
         return `$0 ${pc.join(' ')}`;
     }
-    applyMiddlewareAndGetResult(command, commandHandler, innerArgv, currentContext, helpOnly, aliases, yargs) {
+    applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, innerArgv, currentContext, helpOnly, aliases, yargs) {
         let positionalMap = {};
-        if (!yargs._hasOutput()) {
-            positionalMap = this.populatePositionals(commandHandler, innerArgv, currentContext, yargs);
-        }
         if (helpOnly)
             return innerArgv;
+        if (!yargs.getInternalMethods().getHasOutput()) {
+            positionalMap = this.populatePositionals(commandHandler, innerArgv, currentContext, yargs);
+        }
         const middlewares = this.globalMiddleware
             .getMiddleware()
             .slice(0)
             .concat(commandHandler.middlewares);
         innerArgv = applyMiddleware(innerArgv, yargs, middlewares, true);
-        if (!yargs._hasOutput()) {
-            const validation = yargs._runValidation(aliases, positionalMap, yargs.parsed.error, !command);
+        if (!yargs.getInternalMethods().getHasOutput()) {
+            const validation = yargs
+                .getInternalMethods()
+                .runValidation(aliases, positionalMap, yargs.parsed.error, isDefaultCommand);
             innerArgv = maybeAsyncResult(innerArgv, result => {
                 validation(result);
                 return result;
             });
         }
-        if (commandHandler.handler && !yargs._hasOutput()) {
-            yargs._setHasOutput();
+        if (commandHandler.handler && !yargs.getInternalMethods().getHasOutput()) {
+            yargs.getInternalMethods().setHasOutput();
             const populateDoubleDash = !!yargs.getOptions().configuration['populate--'];
-            yargs._postProcess(innerArgv, populateDoubleDash, false, false);
+            yargs
+                .getInternalMethods()
+                .postProcess(innerArgv, populateDoubleDash, false, false);
             innerArgv = applyMiddleware(innerArgv, yargs, middlewares, false);
             innerArgv = maybeAsyncResult(innerArgv, result => {
                 const handlerResult = commandHandler.handler(result);
@@ -212,18 +230,21 @@ export class CommandInstance {
                     return result;
                 }
             });
-            yargs.getUsageInstance().cacheHelpMessage();
-            if (isPromise(innerArgv) && !yargs._hasParseCallback()) {
+            if (!isDefaultCommand) {
+                yargs.getInternalMethods().getUsageInstance().cacheHelpMessage();
+            }
+            if (isPromise(innerArgv) &&
+                !yargs.getInternalMethods().hasParseCallback()) {
                 innerArgv.catch(error => {
                     try {
-                        yargs.getUsageInstance().fail(null, error);
+                        yargs.getInternalMethods().getUsageInstance().fail(null, error);
                     }
                     catch (_err) {
                     }
                 });
             }
         }
-        if (command) {
+        if (!isDefaultCommand) {
             currentContext.commands.pop();
             currentContext.fullCommands.pop();
         }
@@ -310,7 +331,10 @@ export class CommandInstance {
             configuration: config,
         }));
         if (parsed.error) {
-            yargs.getUsageInstance().fail(parsed.error.message, parsed.error);
+            yargs
+                .getInternalMethods()
+                .getUsageInstance()
+                .fail(parsed.error.message, parsed.error);
         }
         else {
             const positionalKeys = Object.keys(positionalMap);
@@ -327,24 +351,27 @@ export class CommandInstance {
         }
     }
     runDefaultBuilderOn(yargs) {
-        assertNotStrictEqual(this.defaultCommand, undefined, this.shim);
+        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)) {
-            builder(yargs);
+            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);
@@ -396,12 +423,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';

package/build/lib/completion-templates.js

@@ -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,7 +24,7 @@ _yargs_completions()
 
     return 0
 }
-complete -o default -F _yargs_completions {{app_name}}
+complete -o default -F _{{app_name}}_yargs_completions {{app_name}}
 ###-end-{{app_name}}-completions-###
 `;
 export const completionZshTemplate = `#compdef {{app_name}}

package/build/lib/completion.js

@@ -13,7 +13,9 @@ export class Completion {
         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;
+        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();
@@ -21,8 +23,8 @@ export class Completion {
             if (handlers[args[i]] && handlers[args[i]].builder) {
                 const builder = handlers[args[i]].builder;
                 if (isCommandBuilderCallback(builder)) {
-                    const y = this.yargs.reset();
-                    builder(y);
+                    const y = this.yargs.getInternalMethods().reset();
+                    builder(y, true);
                     return y.argv;
                 }
             }
@@ -33,7 +35,8 @@ export class Completion {
         done(null, completions);
     }
     commandCompletions(completions, args, current) {
-        const parentCommands = this.yargs.getContext().commands;
+        const parentCommands = this.yargs.getInternalMethods().getContext()
+            .commands;
         if (!current.match(/^-/) &&
             parentCommands[parentCommands.length - 1] !== current) {
             this.usage.getCommands().forEach(usageCommand => {

package/build/lib/middleware.js

@@ -30,7 +30,7 @@ export class GlobalMiddleware {
     addCoerceMiddleware(callback, option) {
         const aliases = this.yargs.getAliases();
         this.globalMiddleware = this.globalMiddleware.filter(m => {
-            const toCheck = [...(aliases[option] ? aliases[option] : []), option];
+            const toCheck = [...(aliases[option] || []), option];
             if (!m.option)
                 return true;
             else

package/build/lib/usage.js

@@ -4,8 +4,8 @@ import setBlocking from './utils/set-blocking.js';
 function isBoolean(fail) {
     return typeof fail === 'boolean';
 }
-export function usage(yargs, y18n, shim) {
-    const __ = y18n.__;
+export function usage(yargs, shim) {
+    const __ = shim.y18n.__;
     const self = {};
     const fails = [];
     self.failFn = function failFn(f) {
@@ -24,7 +24,7 @@ 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) {
                 const fail = fails[i];
@@ -60,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 {
@@ -191,11 +191,12 @@ export function usage(yargs, y18n, shim) {
         }
         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]));
             }
             commands.forEach(command => {
@@ -443,7 +444,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];
@@ -503,7 +504,7 @@ export function usage(yargs, y18n, shim) {
         version = ver;
     };
     self.showVersion = level => {
-        const logger = yargs._getLoggerInstance();
+        const logger = yargs.getInternalMethods().getLoggerInstance();
         if (!level)
             level = 'error';
         const emit = typeof level === 'function' ? level : logger[level];

package/build/lib/utils/maybe-async-result.js

@@ -4,14 +4,9 @@ export function maybeAsyncResult(getResult, resultHandler, errorHandler = (err)
 }) {
     try {
         const result = isFunction(getResult) ? getResult() : getResult;
-        if (isPromise(result)) {
-            return result.then((result) => {
-                return resultHandler(result);
-            });
-        }
-        else {
-            return resultHandler(result);
-        }
+        return isPromise(result)
+            ? result.then((result) => resultHandler(result))
+            : resultHandler(result);
     }
     catch (err) {
         return errorHandler(err);

package/build/lib/validation.js

@@ -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) {
@@ -66,13 +66,16 @@ export function validation(yargs, usage, y18n, shim) {
         }
     };
     self.unknownArguments = function unknownArguments(argv, aliases, positionalMap, isDefaultCommand, checkPositionals = true) {
-        const commandKeys = yargs.getCommandInstance().getCommands();
+        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 &&
                 !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);
             }
@@ -92,9 +95,12 @@ export function validation(yargs, usage, y18n, shim) {
         }
     };
     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) {
@@ -115,13 +121,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();