yargs 16.0.3 → 16.2.0

package/build/lib/argsert.js

@@ -5,15 +5,19 @@ export function argsert(arg1, arg2, arg3) {
     function parseArgs() {
         return typeof arg1 === 'object'
             ? [{ demanded: [], optional: [] }, arg1, arg2]
-            : [parseCommand(`cmd ${arg1}`), arg2, arg3];
+            : [
+                parseCommand(`cmd ${arg1}`),
+                arg2,
+                arg3,
+            ];
     }
     try {
         let position = 0;
-        let [parsed, callerArguments, length] = parseArgs();
+        const [parsed, callerArguments, _length] = parseArgs();
         const args = [].slice.call(callerArguments);
         while (args.length && args[args.length - 1] === undefined)
             args.pop();
-        length = length || args.length;
+        const length = _length || args.length;
         if (length < parsed.demanded.length) {
             throw new YError(`Not enough arguments provided. Expected ${parsed.demanded.length} but received ${args.length}.`);
         }
@@ -21,7 +25,7 @@ export function argsert(arg1, arg2, arg3) {
         if (length > totalCommands) {
             throw new YError(`Too many arguments provided. Expected max ${totalCommands} but received ${length}.`);
         }
-        parsed.demanded.forEach((demanded) => {
+        parsed.demanded.forEach(demanded => {
             const arg = args.shift();
             const observedType = guessType(arg);
             const matchingTypes = demanded.cmd.filter(type => type === observedType || type === '*');
@@ -29,7 +33,7 @@ export function argsert(arg1, arg2, arg3) {
                 argumentTypeError(observedType, demanded.cmd, position);
             position += 1;
         });
-        parsed.optional.forEach((optional) => {
+        parsed.optional.forEach(optional => {
             if (args.length === 0)
                 return;
             const arg = args.shift();

package/build/lib/command.js

@@ -1,8 +1,8 @@
-import { assertNotStrictEqual } from './typings/common-types.js';
+import { assertNotStrictEqual, } from './typings/common-types.js';
 import { isPromise } from './utils/is-promise.js';
-import { applyMiddleware, commandMiddlewareFactory } from './middleware.js';
+import { applyMiddleware, commandMiddlewareFactory, } from './middleware.js';
 import { parseCommand } from './parse-command.js';
-import { isYargsInstance } from './yargs-factory.js';
+import { isYargsInstance, } from './yargs-factory.js';
 import whichModule from './utils/which-module.js';
 const DEFAULT_MARKER = /(^\*)|(^\$0)/;
 export function command(yargs, usage, validation, globalMiddleware = [], shim) {
@@ -15,55 +15,65 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
         const middlewares = commandMiddlewareFactory(commandMiddleware);
         handler = handler || (() => { });
         if (Array.isArray(cmd)) {
-            aliases = cmd.slice(1);
-            cmd = cmd[0];
+            if (isCommandAndAliases(cmd)) {
+                [cmd, ...aliases] = cmd;
+            }
+            else {
+                for (const command of cmd) {
+                    self.addHandler(command);
+                }
+            }
         }
         else if (isCommandHandlerDefinition(cmd)) {
-            let command = (Array.isArray(cmd.command) || typeof cmd.command === 'string') ? cmd.command : moduleName(cmd);
+            let command = Array.isArray(cmd.command) || typeof cmd.command === 'string'
+                ? cmd.command
+                : moduleName(cmd);
             if (cmd.aliases)
                 command = [].concat(command).concat(cmd.aliases);
             self.addHandler(command, extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
             return;
         }
-        if (isCommandBuilderDefinition(builder)) {
+        else if (isCommandBuilderDefinition(builder)) {
             self.addHandler([cmd].concat(aliases), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated);
             return;
         }
-        const parsedCommand = parseCommand(cmd);
-        aliases = aliases.map(alias => parseCommand(alias).cmd);
-        let isDefault = false;
-        const parsedAliases = [parsedCommand.cmd].concat(aliases).filter((c) => {
-            if (DEFAULT_MARKER.test(c)) {
-                isDefault = true;
-                return false;
+        if (typeof cmd === 'string') {
+            const parsedCommand = parseCommand(cmd);
+            aliases = aliases.map(alias => parseCommand(alias).cmd);
+            let isDefault = false;
+            const parsedAliases = [parsedCommand.cmd].concat(aliases).filter(c => {
+                if (DEFAULT_MARKER.test(c)) {
+                    isDefault = true;
+                    return false;
+                }
+                return true;
+            });
+            if (parsedAliases.length === 0 && isDefault)
+                parsedAliases.push('$0');
+            if (isDefault) {
+                parsedCommand.cmd = parsedAliases[0];
+                aliases = parsedAliases.slice(1);
+                cmd = cmd.replace(DEFAULT_MARKER, parsedCommand.cmd);
             }
-            return true;
-        });
-        if (parsedAliases.length === 0 && isDefault)
-            parsedAliases.push('$0');
-        if (isDefault) {
-            parsedCommand.cmd = parsedAliases[0];
-            aliases = parsedAliases.slice(1);
-            cmd = cmd.replace(DEFAULT_MARKER, parsedCommand.cmd);
-        }
-        aliases.forEach((alias) => {
-            aliasMap[alias] = parsedCommand.cmd;
-        });
-        if (description !== false) {
-            usage.command(cmd, description, isDefault, aliases, deprecated);
+            aliases.forEach(alias => {
+                aliasMap[alias] = parsedCommand.cmd;
+            });
+            if (description !== false) {
+                usage.command(cmd, description, isDefault, aliases, deprecated);
+            }
+            handlers[parsedCommand.cmd] = {
+                original: cmd,
+                description,
+                handler,
+                builder: builder || {},
+                middlewares,
+                deprecated,
+                demanded: parsedCommand.demanded,
+                optional: parsedCommand.optional,
+            };
+            if (isDefault)
+                defaultCommand = handlers[parsedCommand.cmd];
         }
-        handlers[parsedCommand.cmd] = {
-            original: cmd,
-            description,
-            handler,
-            builder: builder || {},
-            middlewares,
-            deprecated,
-            demanded: parsedCommand.demanded,
-            optional: parsedCommand.optional
-        };
-        if (isDefault)
-            defaultCommand = handlers[parsedCommand.cmd];
     };
     self.addDirectory = function addDirectory(dir, context, req, callerFile, opts) {
         opts = opts || {};
@@ -93,7 +103,7 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
     function commandFromFilename(filename) {
         return shim.path.basename(filename, shim.path.extname(filename));
     }
-    function extractDesc({ describe, description, desc }) {
+    function extractDesc({ describe, description, desc, }) {
         for (const test of [describe, description, desc]) {
             if (typeof test === 'string' || test === false)
                 return test;
@@ -121,7 +131,9 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
             const builderOutput = builder(yargs.reset(parsed.aliases));
             const innerYargs = isYargsInstance(builderOutput) ? builderOutput : yargs;
             if (shouldUpdateUsage(innerYargs)) {
-                innerYargs.getUsageInstance().usage(usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
+                innerYargs
+                    .getUsageInstance()
+                    .usage(usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
             }
             innerArgv = innerYargs._parseArgs(null, null, true, commandIndex);
             aliases = innerYargs.parsed.aliases;
@@ -129,9 +141,11 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
         else if (isCommandBuilderOptionDefinitions(builder)) {
             const innerYargs = yargs.reset(parsed.aliases);
             if (shouldUpdateUsage(innerYargs)) {
-                innerYargs.getUsageInstance().usage(usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
+                innerYargs
+                    .getUsageInstance()
+                    .usage(usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
             }
-            Object.keys(commandHandler.builder).forEach((key) => {
+            Object.keys(commandHandler.builder).forEach(key => {
                 innerYargs.option(key, builder[key]);
             });
             innerArgv = innerYargs._parseArgs(null, null, true, commandIndex);
@@ -140,7 +154,9 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
         if (!yargs._hasOutput()) {
             positionalMap = populatePositionals(commandHandler, innerArgv, currentContext);
         }
-        const middlewares = globalMiddleware.slice(0).concat(commandHandler.middlewares);
+        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);
@@ -148,8 +164,7 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
         if (commandHandler.handler && !yargs._hasOutput()) {
             yargs._setHasOutput();
             const populateDoubleDash = !!yargs.getOptions().configuration['populate--'];
-            if (!populateDoubleDash)
-                yargs._copyDoubleDash(innerArgv);
+            yargs._postProcess(innerArgv, populateDoubleDash);
             innerArgv = applyMiddleware(innerArgv, yargs, middlewares, false);
             let handlerResult;
             if (isPromise(innerArgv)) {
@@ -194,12 +209,16 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
         return innerArgv;
     };
     function shouldUpdateUsage(yargs) {
-        return !yargs.getUsageInstance().getUsageDisabled() &&
-            yargs.getUsageInstance().getUsage().length === 0;
+        return (!yargs.getUsageInstance().getUsageDisabled() &&
+            yargs.getUsageInstance().getUsage().length === 0);
     }
     function usageFromParentCommandsCommandHandler(parentCommands, commandHandler) {
-        const c = DEFAULT_MARKER.test(commandHandler.original) ? commandHandler.original.replace(DEFAULT_MARKER, '').trim() : commandHandler.original;
-        const pc = parentCommands.filter((c) => { return !DEFAULT_MARKER.test(c); });
+        const c = DEFAULT_MARKER.test(commandHandler.original)
+            ? commandHandler.original.replace(DEFAULT_MARKER, '').trim()
+            : commandHandler.original;
+        const pc = parentCommands.filter(c => {
+            return !DEFAULT_MARKER.test(c);
+        });
         pc.push(c);
         return `$0 ${pc.join(' ')}`;
     }
@@ -207,15 +226,16 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
         assertNotStrictEqual(defaultCommand, undefined, shim);
         if (shouldUpdateUsage(yargs)) {
             const commandString = DEFAULT_MARKER.test(defaultCommand.original)
-                ? defaultCommand.original : defaultCommand.original.replace(/^[^[\]<>]*/, '$0 ');
+                ? defaultCommand.original
+                : defaultCommand.original.replace(/^[^[\]<>]*/, '$0 ');
             yargs.getUsageInstance().usage(commandString, defaultCommand.description);
         }
         const builder = defaultCommand.builder;
         if (isCommandBuilderCallback(builder)) {
             builder(yargs);
         }
-        else {
-            Object.keys(builder).forEach((key) => {
+        else if (!isCommandBuilderDefinition(builder)) {
+            Object.keys(builder).forEach(key => {
                 yargs.option(key, builder[key]);
             });
         }
@@ -257,8 +277,8 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
         options.array = options.array.concat(parseOptions.array);
         options.config = {};
         const unparsed = [];
-        Object.keys(positionalMap).forEach((key) => {
-            positionalMap[key].map((value) => {
+        Object.keys(positionalMap).forEach(key => {
+            positionalMap[key].map(value => {
                 if (options.configuration['unknown-options-as-args'])
                     options.key[key] = true;
                 unparsed.push(`--${key}`);
@@ -268,20 +288,20 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
         if (!unparsed.length)
             return;
         const config = Object.assign({}, options.configuration, {
-            'populate--': true
+            'populate--': true,
         });
         const parsed = shim.Parser.detailed(unparsed, Object.assign({}, options, {
-            configuration: config
+            configuration: config,
         }));
         if (parsed.error) {
             yargs.getUsageInstance().fail(parsed.error.message, parsed.error);
         }
         else {
             const positionalKeys = Object.keys(positionalMap);
-            Object.keys(positionalMap).forEach((key) => {
+            Object.keys(positionalMap).forEach(key => {
                 positionalKeys.push(...parsed.aliases[key]);
             });
-            Object.keys(parsed.argv).forEach((key) => {
+            Object.keys(parsed.argv).forEach(key => {
                 if (positionalKeys.indexOf(key) !== -1) {
                     if (!positionalMap[key])
                         positionalMap[key] = parsed.argv[key];
@@ -295,10 +315,10 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
             array: [],
             default: {},
             alias: {},
-            demand: {}
+            demand: {},
         };
         const parsed = parseCommand(cmdString);
-        parsed.demanded.forEach((d) => {
+        parsed.demanded.forEach(d => {
             const [cmd, ...aliases] = d.cmd;
             if (d.variadic) {
                 parseOptions.array.push(cmd);
@@ -307,7 +327,7 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
             parseOptions.alias[cmd] = aliases;
             parseOptions.demand[cmd] = true;
         });
-        parsed.optional.forEach((o) => {
+        parsed.optional.forEach(o => {
             const [cmd, ...aliases] = o.cmd;
             if (o.variadic) {
                 parseOptions.array.push(cmd);
@@ -328,27 +348,28 @@ export function command(yargs, usage, validation, globalMiddleware = [], shim) {
         frozens.push({
             handlers,
             aliasMap,
-            defaultCommand
+            defaultCommand,
         });
     };
     self.unfreeze = () => {
         const frozen = frozens.pop();
         assertNotStrictEqual(frozen, undefined, shim);
-        ({
-            handlers,
-            aliasMap,
-            defaultCommand
-        } = frozen);
+        ({ handlers, aliasMap, defaultCommand } = frozen);
     };
     return self;
 }
-export function isCommandHandlerDefinition(cmd) {
-    return typeof cmd === 'object';
-}
 export function isCommandBuilderDefinition(builder) {
-    return typeof builder === 'object' &&
+    return (typeof builder === 'object' &&
         !!builder.builder &&
-        typeof builder.handler === 'function';
+        typeof builder.handler === 'function');
+}
+function isCommandAndAliases(cmd) {
+    if (cmd.every(c => typeof c === 'string')) {
+        return true;
+    }
+    else {
+        return false;
+    }
 }
 export function isCommandBuilderCallback(builder) {
     return typeof builder === 'function';
@@ -356,3 +377,6 @@ export function isCommandBuilderCallback(builder) {
 function isCommandBuilderOptionDefinitions(builder) {
     return typeof builder === 'object';
 }
+export function isCommandHandlerDefinition(cmd) {
+    return typeof cmd === 'object' && !Array.isArray(cmd);
+}

package/build/lib/completion.js

@@ -5,7 +5,7 @@ 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'
+        completionKey: 'get-yargs-completions',
     };
     let aliases;
     self.setParsed = function setParsed(parsed) {
@@ -23,22 +23,30 @@ export function completion(yargs, usage, command, 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 result
+                        .then(list => {
+                        shim.process.nextTick(() => {
+                            done(list);
+                        });
+                    })
+                        .catch(err => {
+                        shim.process.nextTick(() => {
+                            throw err;
+                        });
                     });
                 }
                 return done(result);
             }
             else {
-                return completionFunction(current, argv, (completions) => {
+                return completionFunction(current, argv, completions => {
                     done(completions);
                 });
             }
         }
         if (completionFunction) {
-            return isPromise(argv) ? argv.then(runCompletionFunction) : runCompletionFunction(argv);
+            return isPromise(argv)
+                ? argv.then(runCompletionFunction)
+                : runCompletionFunction(argv);
         }
         const handlers = command.getCommandHandlers();
         for (let i = 0, ii = args.length; i < ii; ++i) {
@@ -51,8 +59,9 @@ export function completion(yargs, usage, command, shim) {
                 }
             }
         }
-        if (!current.match(/^-/) && parentCommands[parentCommands.length - 1] !== current) {
-            usage.getCommands().forEach((usageCommand) => {
+        if (!current.match(/^-/) &&
+            parentCommands[parentCommands.length - 1] !== current) {
+            usage.getCommands().forEach(usageCommand => {
                 const commandName = parseCommand(usageCommand[0]).cmd;
                 if (args.indexOf(commandName) === -1) {
                     if (!zshShell) {
@@ -68,8 +77,9 @@ export function completion(yargs, usage, command, shim) {
         if (current.match(/^-/) || (current === '' && completions.length === 0)) {
             const descs = usage.getDescriptions();
             const options = yargs.getOptions();
-            Object.keys(options.key).forEach((key) => {
-                const negable = !!options.configuration['boolean-negation'] && options.boolean.includes(key);
+            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}`));
@@ -84,7 +94,8 @@ export function completion(yargs, usage, command, shim) {
                         }
                         else {
                             const desc = descs[key] || '';
-                            completions.push(dashes + `${key.replace(/:/g, '\\:')}:${desc.replace('__yargsString__:', '')}`);
+                            completions.push(dashes +
+                                `${key.replace(/:/g, '\\:')}:${desc.replace('__yargsString__:', '')}`);
                         }
                     }
                 }
@@ -96,7 +107,9 @@ export function completion(yargs, usage, command, shim) {
         done(completions);
     };
     self.generateCompletionScript = function generateCompletionScript($0, cmd) {
-        let script = zshShell ? templates.completionZshTemplate : templates.completionShTemplate;
+        let script = zshShell
+            ? templates.completionZshTemplate
+            : templates.completionShTemplate;
         const name = shim.path.basename($0);
         if ($0.match(/\.js$/))
             $0 = `./${$0}`;
@@ -105,7 +118,7 @@ export function completion(yargs, usage, command, shim) {
         return script.replace(/{{app_path}}/g, $0);
     };
     let completionFunction = null;
-    self.registerFunction = (fn) => {
+    self.registerFunction = fn => {
         completionFunction = fn;
     };
     return self;

package/build/lib/middleware.js

@@ -29,14 +29,16 @@ 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) => {
+    return middlewares.reduce((acc, middleware) => {
         if (middleware.applyBeforeValidation !== beforeValidation) {
             return acc;
         }
         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 {

package/build/lib/parse-command.js

@@ -8,7 +8,7 @@ export function parseCommand(cmd) {
     const parsedCommand = {
         cmd: firstCommand.replace(bregex, ''),
         demanded: [],
-        optional: []
+        optional: [],
     };
     splitCommand.forEach((cmd, i) => {
         let variadic = false;
@@ -18,13 +18,13 @@ export function parseCommand(cmd) {
         if (/^\[/.test(cmd)) {
             parsedCommand.optional.push({
                 cmd: cmd.replace(bregex, '').split('|'),
-                variadic
+                variadic,
             });
         }
         else {
             parsedCommand.demanded.push({
                 cmd: cmd.replace(bregex, '').split('|'),
-                variadic
+                variadic,
             });
         }
     });