@oclif/core 3.0.0-beta.8 → 3.0.0

package/lib/help/command.d.ts

@@ -1,31 +1,33 @@
+import { Command } from '../command';
 import * as Interfaces from '../interfaces';
 import { HelpFormatter, HelpSectionRenderer } from './formatter';
-import { Command } from '../command';
 export declare class CommandHelp extends HelpFormatter {
-    command: Command.Class | Command.Loadable | Command.Cached;
+    command: Command.Cached | Command.Class | Command.Loadable;
     config: Interfaces.Config;
     opts: Interfaces.HelpOptions;
-    constructor(command: Command.Class | Command.Loadable | Command.Cached, config: Interfaces.Config, opts: Interfaces.HelpOptions);
+    constructor(command: Command.Cached | Command.Class | Command.Loadable, config: Interfaces.Config, opts: Interfaces.HelpOptions);
+    private formatIfCommand;
+    private isCommand;
+    protected aliases(aliases: string[] | undefined): string | undefined;
+    protected arg(arg: Command.Arg.Any): string;
+    protected args(args: Command.Arg.Any[]): [string, string | undefined][] | undefined;
+    protected defaultUsage(): string;
+    protected description(): string | undefined;
+    protected examples(examples: Command.Example[] | string | undefined): string | undefined;
+    protected flagHelpLabel(flag: Command.Flag.Any, showOptions?: boolean): string;
+    protected flags(flags: Array<Command.Flag.Any>): [string, string | undefined][] | undefined;
+    protected flagsDescriptions(flags: Array<Command.Flag.Any>): string | undefined;
     generate(): string;
     protected groupFlags(flags: Array<Command.Flag.Any>): {
-        mainFlags: Array<Command.Flag.Any>;
         flagGroups: {
             [name: string]: Array<Command.Flag.Any>;
         };
+        mainFlags: Array<Command.Flag.Any>;
     };
     protected sections(): Array<{
-        header: string;
         generate: HelpSectionRenderer;
+        header: string;
     }>;
     protected usage(): string;
-    protected defaultUsage(): string;
-    protected description(): string | undefined;
-    protected aliases(aliases: string[] | undefined): string | undefined;
-    protected examples(examples: Command.Example[] | undefined | string): string | undefined;
-    protected args(args: Command.Arg.Any[]): [string, string | undefined][] | undefined;
-    protected arg(arg: Command.Arg.Any): string;
-    protected flagHelpLabel(flag: Command.Flag.Any, showOptions?: boolean): string;
-    protected flags(flags: Array<Command.Flag.Any>): [string, string | undefined][] | undefined;
-    protected flagsDescriptions(flags: Array<Command.Flag.Any>): string | undefined;
 }
 export default CommandHelp;

package/lib/help/command.js

@@ -1,126 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandHelp = void 0;
-const chalk = require("chalk");
-const stripAnsi = require("strip-ansi");
-const util_1 = require("../util");
-const formatter_1 = require("./formatter");
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const strip_ansi_1 = tslib_1.__importDefault(require("strip-ansi"));
+const ensure_arg_object_1 = require("../util/ensure-arg-object");
+const util_1 = require("../util/util");
 const docopts_1 = require("./docopts");
+const formatter_1 = require("./formatter");
 // Don't use os.EOL because we need to ensure that a string
 // written on any platform, that may use \r\n or \n, will be
 // split on any platform, not just the os specific EOL at runtime.
 const POSSIBLE_LINE_FEED = /\r\n|\n/;
-const { underline, } = chalk;
-let { dim, } = chalk;
+let { dim } = chalk_1.default;
 if (process.env.ConEmuANSI === 'ON') {
     // eslint-disable-next-line unicorn/consistent-destructuring
-    dim = chalk.gray;
+    dim = chalk_1.default.gray;
 }
 class CommandHelp extends formatter_1.HelpFormatter {
+    command;
+    config;
+    opts;
     constructor(command, config, opts) {
         super(config, opts);
         this.command = command;
         this.config = config;
         this.opts = opts;
     }
-    generate() {
-        const cmd = this.command;
-        const flags = (0, util_1.sortBy)(Object.entries(cmd.flags || {})
-            .filter(([, v]) => !v.hidden)
-            .map(([k, v]) => {
-            v.name = k;
-            return v;
-        }), f => [!f.char, f.char, f.name]);
-        const args = Object.values((0, util_1.ensureArgObject)(cmd.args)).filter(a => !a.hidden);
-        const output = (0, util_1.compact)(this.sections().map(({ header, generate }) => {
-            const body = generate({ cmd, flags, args }, header);
-            // Generate can return a list of sections
-            if (Array.isArray(body)) {
-                return body.map(helpSection => helpSection && helpSection.body && this.section(helpSection.header, helpSection.body)).join('\n\n');
-            }
-            return body && this.section(header, body);
-        })).join('\n\n');
-        return output;
+    formatIfCommand(example) {
+        example = this.render(example);
+        if (example.startsWith(this.config.bin))
+            return dim(`$ ${example}`);
+        if (example.startsWith(`$ ${this.config.bin}`))
+            return dim(example);
+        return example;
     }
-    groupFlags(flags) {
-        const mainFlags = [];
-        const flagGroups = {};
-        for (const flag of flags) {
-            const group = flag.helpGroup;
-            if (group) {
-                if (!flagGroups[group])
-                    flagGroups[group] = [];
-                flagGroups[group].push(flag);
-            }
-            else {
-                mainFlags.push(flag);
-            }
-        }
-        return { mainFlags, flagGroups };
+    isCommand(example) {
+        return (0, strip_ansi_1.default)(this.formatIfCommand(example)).startsWith(`$ ${this.config.bin}`);
     }
-    sections() {
-        return [
-            {
-                header: this.opts.usageHeader || 'USAGE',
-                generate: () => this.usage(),
-            },
-            {
-                header: 'ARGUMENTS',
-                generate: ({ args }, header) => [{ header, body: this.args(args) }],
-            },
-            {
-                header: 'FLAGS',
-                generate: ({ flags }, header) => {
-                    const { mainFlags, flagGroups } = this.groupFlags(flags);
-                    const flagSections = [];
-                    const mainFlagBody = this.flags(mainFlags);
-                    if (mainFlagBody)
-                        flagSections.push({ header, body: mainFlagBody });
-                    for (const [name, flags] of Object.entries(flagGroups)) {
-                        const body = this.flags(flags);
-                        if (body)
-                            flagSections.push({ header: `${name.toUpperCase()} ${header}`, body });
-                    }
-                    return (0, util_1.compact)(flagSections);
-                },
-            },
-            {
-                header: 'DESCRIPTION',
-                generate: () => this.description(),
-            },
-            {
-                header: 'ALIASES',
-                generate: ({ cmd }) => this.aliases(cmd.aliases),
-            },
-            {
-                header: 'EXAMPLES',
-                generate: ({ cmd }) => {
-                    const examples = cmd.examples || cmd.example;
-                    return this.examples(examples);
-                },
-            },
-            {
-                header: 'FLAG DESCRIPTIONS',
-                generate: ({ flags }) => this.flagsDescriptions(flags),
-            },
-        ];
-    }
-    usage() {
-        const usage = this.command.usage;
-        const body = (usage ? (0, util_1.castArray)(usage) : [this.defaultUsage()])
-            .map(u => {
-            const allowedSpacing = this.opts.maxWidth - this.indentSpacing;
-            const line = `$ ${this.config.bin} ${u}`.trim();
-            if (line.length > allowedSpacing) {
-                const splitIndex = line.slice(0, Math.max(0, allowedSpacing)).lastIndexOf(' ');
-                return line.slice(0, Math.max(0, splitIndex)) + '\n' +
-                    this.indent(this.wrap(line.slice(Math.max(0, splitIndex)), this.indentSpacing * 2));
-            }
-            return this.wrap(line);
-        })
-            .join('\n');
+    aliases(aliases) {
+        if (!aliases || aliases.length === 0)
+            return;
+        const body = aliases.map((a) => ['$', this.config.bin, a].join(' ')).join('\n');
         return body;
     }
+    arg(arg) {
+        const name = arg.name.toUpperCase();
+        if (arg.required)
+            return `${name}`;
+        return `[${name}]`;
+    }
+    args(args) {
+        if (args.filter((a) => a.description).length === 0)
+            return;
+        return args.map((a) => {
+            const name = a.name.toUpperCase();
+            let description = a.description || '';
+            if (a.default)
+                description = `[default: ${a.default}] ${description}`;
+            if (a.options)
+                description = `(${a.options.join('|')}) ${description}`;
+            return [name, description ? dim(description) : undefined];
+        });
+    }
     defaultUsage() {
         // Docopts by default
         if (this.opts.docopts === undefined || this.opts.docopts) {
@@ -128,7 +70,10 @@ class CommandHelp extends formatter_1.HelpFormatter {
         }
         return (0, util_1.compact)([
             this.command.id,
-            Object.values(this.command.args ?? {})?.filter(a => !a.hidden).map(a => this.arg(a)).join(' '),
+            Object.values(this.command.args ?? {})
+                ?.filter((a) => !a.hidden)
+                .map((a) => this.arg(a))
+                .join(' '),
         ]).join(' ');
     }
     description() {
@@ -139,88 +84,52 @@ class CommandHelp extends formatter_1.HelpFormatter {
         }
         else if (cmd.description) {
             const summary = cmd.summary ? `${cmd.summary}\n` : null;
-            description = summary ? [
-                ...summary.split(POSSIBLE_LINE_FEED),
-                ...(cmd.description || '').split(POSSIBLE_LINE_FEED),
-            ] : (cmd.description || '').split(POSSIBLE_LINE_FEED);
+            description = summary
+                ? [...summary.split(POSSIBLE_LINE_FEED), ...(cmd.description || '').split(POSSIBLE_LINE_FEED)]
+                : (cmd.description || '').split(POSSIBLE_LINE_FEED);
         }
         if (description) {
             return this.wrap(description.join('\n'));
         }
     }
-    aliases(aliases) {
-        if (!aliases || aliases.length === 0)
-            return;
-        const body = aliases.map(a => ['$', this.config.bin, a].join(' ')).join('\n');
-        return body;
-    }
     examples(examples) {
         if (!examples || examples.length === 0)
             return;
-        const formatIfCommand = (example) => {
-            example = this.render(example);
-            if (example.startsWith(this.config.bin))
-                return dim(`$ ${example}`);
-            if (example.startsWith(`$ ${this.config.bin}`))
-                return dim(example);
-            return example;
-        };
-        const isCommand = (example) => stripAnsi(formatIfCommand(example)).startsWith(`$ ${this.config.bin}`);
-        const body = (0, util_1.castArray)(examples).map(a => {
+        const body = (0, util_1.castArray)(examples)
+            .map((a) => {
             let description;
             let commands;
             if (typeof a === 'string') {
-                const lines = a
-                    .split(POSSIBLE_LINE_FEED)
-                    .filter(line => Boolean(line));
+                const lines = a.split(POSSIBLE_LINE_FEED).filter(Boolean);
                 // If the example is <description>\n<command> then format correctly
-                // eslint-disable-next-line unicorn/no-array-callback-reference
-                if (lines.length >= 2 && !isCommand(lines[0]) && lines.slice(1).every(isCommand)) {
+                if (lines.length >= 2 && !this.isCommand(lines[0]) && lines.slice(1).every((i) => this.isCommand(i))) {
                     description = lines[0];
                     commands = lines.slice(1);
                 }
                 else {
-                    return lines.map(line => formatIfCommand(line)).join('\n');
+                    return lines.map((line) => this.formatIfCommand(line)).join('\n');
                 }
             }
             else {
                 description = a.description;
                 commands = [a.command];
             }
-            const multilineSeparator = this.config.platform === 'win32' ?
-                (this.config.shell.includes('powershell') ? '`' : '^') :
-                '\\';
+            const multilineSeparator = this.config.platform === 'win32' ? (this.config.shell.includes('powershell') ? '`' : '^') : '\\';
             // The command will be indented in the section, which is also indented
             const finalIndentedSpacing = this.indentSpacing * 2;
-            const multilineCommands = commands.map(c => {
-                // First indent keeping room for escaped newlines
-                return this.indent(this.wrap(formatIfCommand(c), finalIndentedSpacing + 4))
-                    // Then add the escaped newline
-                    .split(POSSIBLE_LINE_FEED).join(` ${multilineSeparator}\n  `);
-            }).join('\n');
+            const multilineCommands = commands
+                .map((c) => 
+            // First indent keeping room for escaped newlines
+            this.indent(this.wrap(this.formatIfCommand(c), finalIndentedSpacing + 4))
+                // Then add the escaped newline
+                .split(POSSIBLE_LINE_FEED)
+                .join(` ${multilineSeparator}\n  `))
+                .join('\n');
             return `${this.wrap(description, finalIndentedSpacing)}\n\n${multilineCommands}`;
-        }).join('\n\n');
+        })
+            .join('\n\n');
         return body;
     }
-    args(args) {
-        if (args.filter(a => a.description).length === 0)
-            return;
-        return args.map(a => {
-            const name = a.name.toUpperCase();
-            let description = a.description || '';
-            if (a.default)
-                description = `[default: ${a.default}] ${description}`;
-            if (a.options)
-                description = `(${a.options.join('|')}) ${description}`;
-            return [name, description ? dim(description) : undefined];
-        });
-    }
-    arg(arg) {
-        const name = arg.name.toUpperCase();
-        if (arg.required)
-            return `${name}`;
-        return `[${name}]`;
-    }
     flagHelpLabel(flag, showOptions = false) {
         let label = flag.helpLabel;
         if (!label) {
@@ -245,7 +154,7 @@ class CommandHelp extends formatter_1.HelpFormatter {
             if (flag.multiple)
                 value += '...';
             if (!value.includes('|'))
-                value = underline(value);
+                value = chalk_1.default.underline(value);
             label += `=${value}`;
         }
         return label;
@@ -253,7 +162,7 @@ class CommandHelp extends formatter_1.HelpFormatter {
     flags(flags) {
         if (flags.length === 0)
             return;
-        return flags.map(flag => {
+        return flags.map((flag) => {
             const left = this.flagHelpLabel(flag);
             let right = flag.summary || flag.description || '';
             if (flag.type === 'option' && flag.default) {
@@ -268,16 +177,122 @@ class CommandHelp extends formatter_1.HelpFormatter {
         });
     }
     flagsDescriptions(flags) {
-        const flagsWithExtendedDescriptions = flags.filter(flag => flag.summary && flag.description);
+        const flagsWithExtendedDescriptions = flags.filter((flag) => flag.summary && flag.description);
         if (flagsWithExtendedDescriptions.length === 0)
             return;
-        const body = flagsWithExtendedDescriptions.map(flag => {
+        const body = flagsWithExtendedDescriptions
+            .map((flag) => {
             // Guaranteed to be set because of the filter above, but make ts happy
             const summary = flag.summary || '';
             let flagHelp = this.flagHelpLabel(flag, true);
-            flagHelp += flagHelp.length + summary.length + 2 < this.opts.maxWidth ? '  ' + summary : '\n\n' + this.indent(this.wrap(summary, this.indentSpacing * 2));
+            flagHelp +=
+                flagHelp.length + summary.length + 2 < this.opts.maxWidth
+                    ? '  ' + summary
+                    : '\n\n' + this.indent(this.wrap(summary, this.indentSpacing * 2));
             return `${flagHelp}\n\n${this.indent(this.wrap(flag.description || '', this.indentSpacing * 2))}`;
-        }).join('\n\n');
+        })
+            .join('\n\n');
+        return body;
+    }
+    generate() {
+        const cmd = this.command;
+        const flags = (0, util_1.sortBy)(Object.entries(cmd.flags || {})
+            .filter(([, v]) => !v.hidden)
+            .map(([k, v]) => {
+            v.name = k;
+            return v;
+        }), (f) => [!f.char, f.char, f.name]);
+        const args = Object.values((0, ensure_arg_object_1.ensureArgObject)(cmd.args)).filter((a) => !a.hidden);
+        const output = (0, util_1.compact)(this.sections().map(({ generate, header }) => {
+            const body = generate({ args, cmd, flags }, header);
+            // Generate can return a list of sections
+            if (Array.isArray(body)) {
+                return body
+                    .map((helpSection) => helpSection && helpSection.body && this.section(helpSection.header, helpSection.body))
+                    .join('\n\n');
+            }
+            return body && this.section(header, body);
+        })).join('\n\n');
+        return output;
+    }
+    groupFlags(flags) {
+        const mainFlags = [];
+        const flagGroups = {};
+        for (const flag of flags) {
+            const group = flag.helpGroup;
+            if (group) {
+                if (!flagGroups[group])
+                    flagGroups[group] = [];
+                flagGroups[group].push(flag);
+            }
+            else {
+                mainFlags.push(flag);
+            }
+        }
+        return { flagGroups, mainFlags };
+    }
+    sections() {
+        return [
+            {
+                generate: () => this.usage(),
+                header: this.opts.usageHeader || 'USAGE',
+            },
+            {
+                generate: ({ args }, header) => [{ body: this.args(args), header }],
+                header: 'ARGUMENTS',
+            },
+            {
+                generate: ({ flags }, header) => {
+                    const { flagGroups, mainFlags } = this.groupFlags(flags);
+                    const flagSections = [];
+                    const mainFlagBody = this.flags(mainFlags);
+                    if (mainFlagBody)
+                        flagSections.push({ body: mainFlagBody, header });
+                    for (const [name, flags] of Object.entries(flagGroups)) {
+                        const body = this.flags(flags);
+                        if (body)
+                            flagSections.push({ body, header: `${name.toUpperCase()} ${header}` });
+                    }
+                    return (0, util_1.compact)(flagSections);
+                },
+                header: 'FLAGS',
+            },
+            {
+                generate: () => this.description(),
+                header: 'DESCRIPTION',
+            },
+            {
+                generate: ({ cmd }) => this.aliases(cmd.aliases),
+                header: 'ALIASES',
+            },
+            {
+                generate: ({ cmd }) => {
+                    const examples = cmd.examples || cmd.example;
+                    return this.examples(examples);
+                },
+                header: 'EXAMPLES',
+            },
+            {
+                generate: ({ flags }) => this.flagsDescriptions(flags),
+                header: 'FLAG DESCRIPTIONS',
+            },
+        ];
+    }
+    usage() {
+        const { usage } = this.command;
+        const body = (usage ? (0, util_1.castArray)(usage) : [this.defaultUsage()])
+            .map((u) => {
+            const allowedSpacing = this.opts.maxWidth - this.indentSpacing;
+            const line = `$ ${this.config.bin} ${u}`.trim();
+            if (line.length > allowedSpacing) {
+                const splitIndex = line.slice(0, Math.max(0, allowedSpacing)).lastIndexOf(' ');
+                return (line.slice(0, Math.max(0, splitIndex)) +
+                    '\n' +
+                    this.indent(this.wrap(line.slice(Math.max(0, splitIndex)), this.indentSpacing * 2)));
+            }
+            return this.wrap(line);
+        })
+            .join('\n');
         return body;
     }
 }

package/lib/help/docopts.d.ts

@@ -57,12 +57,12 @@ import { Command } from '../command';
  */
 export declare class DocOpts {
     private cmd;
-    private flagMap;
     private flagList;
-    constructor(cmd: Command.Class | Command.Loadable | Command.Cached);
-    static generate(cmd: Command.Class | Command.Loadable | Command.Cached): string;
-    toString(): string;
-    private groupFlagElements;
+    private flagMap;
+    constructor(cmd: Command.Cached | Command.Class | Command.Loadable);
+    static generate(cmd: Command.Cached | Command.Class | Command.Loadable): string;
     private combineElementsToFlag;
     private generateElements;
+    private groupFlagElements;
+    toString(): string;
 }

package/lib/help/docopts.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocOpts = void 0;
-const util_1 = require("../util");
+const ensure_arg_object_1 = require("../util/ensure-arg-object");
 /**
  * DocOpts - See http://docopt.org/.
  *
@@ -59,6 +59,9 @@ const util_1 = require("../util");
  *
  */
 class DocOpts {
+    cmd;
+    flagList;
+    flagMap;
     constructor(cmd) {
         this.cmd = cmd;
         // Create a new map with references to the flags that we can manipulate.
@@ -73,53 +76,6 @@ class DocOpts {
     static generate(cmd) {
         return new DocOpts(cmd).toString();
     }
-    toString() {
-        const opts = this.cmd.id === '.' || this.cmd.id === '' ? [] : ['<%= command.id %>'];
-        if (this.cmd.args) {
-            const a = Object.values((0, util_1.ensureArgObject)(this.cmd.args)).map(arg => {
-                return arg.required ? arg.name.toUpperCase() : `[${arg.name.toUpperCase()}]`;
-            }) || [];
-            opts.push(...a);
-        }
-        try {
-            opts.push(...Object.values(this.groupFlagElements()));
-        }
-        catch {
-            // If there is an error, just return no usage so we don't fail command help.
-            opts.push(...this.flagList.map(flag => {
-                const name = flag.char ? `-${flag.char}` : `--${flag.name}`;
-                if (flag.type === 'boolean')
-                    return name;
-                return `${name}=<value>`;
-            }));
-        }
-        return opts.join(' ');
-    }
-    groupFlagElements() {
-        const elementMap = {};
-        // Generate all doc opt elements for combining
-        // Show required flags first
-        this.generateElements(elementMap, this.flagList.filter(flag => flag.required));
-        // Then show optional flags
-        this.generateElements(elementMap, this.flagList.filter(flag => !flag.required));
-        for (const flag of this.flagList) {
-            if (Array.isArray(flag.dependsOn)) {
-                this.combineElementsToFlag(elementMap, flag.name, flag.dependsOn, ' ');
-            }
-            if (Array.isArray(flag.exclusive)) {
-                this.combineElementsToFlag(elementMap, flag.name, flag.exclusive, ' | ');
-            }
-        }
-        // Since combineElementsToFlag deletes the references in this.flags when it combines
-        // them, this will go through the remaining list of uncombined elements.
-        for (const remainingFlagName of Object.keys(this.flagMap)) {
-            const remainingFlag = this.flagMap[remainingFlagName] || {};
-            if (!remainingFlag.required) {
-                elementMap[remainingFlag.name] = `[${elementMap[remainingFlag.name] || ''}]`;
-            }
-        }
-        return elementMap;
-    }
     combineElementsToFlag(elementMap, flagName, flagNames, unionString) {
         if (!this.flagMap[flagName]) {
             return;
@@ -134,12 +90,7 @@ class DocOpts {
             delete elementMap[toCombine];
             delete this.flagMap[toCombine];
         }
-        if (isRequired) {
-            elementMap[flagName] = `(${elementMap[flagName] || ''})`;
-        }
-        else {
-            elementMap[flagName] = `[${elementMap[flagName] || ''}]`;
-        }
+        elementMap[flagName] = isRequired ? `(${elementMap[flagName] || ''})` : `[${elementMap[flagName] || ''}]`;
         // We handled this flag, don't handle it again
         delete this.flagMap[flagName];
     }
@@ -158,5 +109,50 @@ class DocOpts {
         }
         return elementStrs;
     }
+    groupFlagElements() {
+        const elementMap = {};
+        // Generate all doc opt elements for combining
+        // Show required flags first
+        this.generateElements(elementMap, this.flagList.filter((flag) => flag.required));
+        // Then show optional flags
+        this.generateElements(elementMap, this.flagList.filter((flag) => !flag.required));
+        for (const flag of this.flagList) {
+            if (Array.isArray(flag.dependsOn)) {
+                this.combineElementsToFlag(elementMap, flag.name, flag.dependsOn, ' ');
+            }
+            if (Array.isArray(flag.exclusive)) {
+                this.combineElementsToFlag(elementMap, flag.name, flag.exclusive, ' | ');
+            }
+        }
+        // Since combineElementsToFlag deletes the references in this.flags when it combines
+        // them, this will go through the remaining list of uncombined elements.
+        for (const remainingFlagName of Object.keys(this.flagMap)) {
+            const remainingFlag = this.flagMap[remainingFlagName] || {};
+            if (!remainingFlag.required) {
+                elementMap[remainingFlag.name] = `[${elementMap[remainingFlag.name] || ''}]`;
+            }
+        }
+        return elementMap;
+    }
+    toString() {
+        const opts = this.cmd.id === '.' || this.cmd.id === '' ? [] : ['<%= command.id %>'];
+        if (this.cmd.args) {
+            const a = Object.values((0, ensure_arg_object_1.ensureArgObject)(this.cmd.args)).map((arg) => arg.required ? arg.name.toUpperCase() : `[${arg.name.toUpperCase()}]`) || [];
+            opts.push(...a);
+        }
+        try {
+            opts.push(...Object.values(this.groupFlagElements()));
+        }
+        catch {
+            // If there is an error, just return no usage so we don't fail command help.
+            opts.push(...this.flagList.map((flag) => {
+                const name = flag.char ? `-${flag.char}` : `--${flag.name}`;
+                if (flag.type === 'boolean')
+                    return name;
+                return `${name}=<value>`;
+            }));
+        }
+        return opts.join(' ');
+    }
 }
 exports.DocOpts = DocOpts;