avo-cli 0.0.3 → 4.2.0.beta.1

data/payload/node_modules/@oclif/core/lib/help/command.js

@@ -0,0 +1,352 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandHelp = void 0;
+const ansis_1 = __importDefault(require("ansis"));
+const ensure_arg_object_1 = require("../util/ensure-arg-object");
+const ids_1 = require("../util/ids");
+const util_1 = require("../util/util");
+const theme_1 = require("../ux/theme");
+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/;
+/**
+ * Determines the sort order of flags. Will default to alphabetical if not set or set to an invalid value.
+ */
+function determineSortOrder(flagSortOrder) {
+    if (flagSortOrder === 'alphabetical')
+        return 'alphabetical';
+    if (flagSortOrder === 'none')
+        return 'none';
+    return 'alphabetical';
+}
+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;
+    }
+    aliases(aliases) {
+        if (!aliases || aliases.length === 0)
+            return;
+        const body = aliases
+            .map((a) => [
+            (0, theme_1.colorize)(this.config?.theme?.dollarSign, '$'),
+            (0, theme_1.colorize)(this.config?.theme?.bin, this.config.bin),
+            (0, theme_1.colorize)(this.config?.theme?.alias, 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) => {
+            // Add ellipsis for variadic args, or for all args when strict is false (backward compat)
+            const suffix = a.multiple ? '...' : this.command.strict === false ? '...' : '';
+            let name = `${a.name.toUpperCase()}${suffix}`;
+            name = a.required ? `${name}` : `[${name}]`;
+            let description = a.description || '';
+            if (a.default)
+                description = `${(0, theme_1.colorize)(this.config?.theme?.flagDefaultValue, `[default: ${a.default}]`)} ${description}`;
+            if (a.options)
+                description = `${(0, theme_1.colorize)(this.config?.theme?.flagOptions, `(${a.options.join('|')})`)} ${description}`;
+            return [
+                (0, theme_1.colorize)(this.config?.theme?.flag, name),
+                description ? (0, theme_1.colorize)(this.config?.theme?.sectionDescription, description) : undefined,
+            ];
+        });
+    }
+    defaultUsage() {
+        // Docopts by default
+        if (this.opts.docopts === undefined || this.opts.docopts) {
+            return docopts_1.DocOpts.generate(this.command);
+        }
+        return (0, util_1.compact)([
+            this.command.id,
+            Object.values(this.command.args ?? {})
+                ?.filter((a) => !a.hidden)
+                .map((a) => this.arg(a))
+                .join(' '),
+        ]).join(' ');
+    }
+    description() {
+        const cmd = this.command;
+        let description;
+        if (this.opts.hideCommandSummaryInDescription) {
+            description = [(cmd.description || '').split(POSSIBLE_LINE_FEED).at(-1) ?? ''];
+        }
+        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);
+        }
+        if (description) {
+            return this.wrap(description.join('\n'));
+        }
+    }
+    examples(examples) {
+        if (!examples || examples.length === 0)
+            return;
+        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(Boolean);
+                // If the example is <description>\n<command> then format correctly
+                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) => this.formatIfCommand(line)).join('\n');
+                }
+            }
+            else {
+                description = a.description;
+                commands = [a.command];
+            }
+            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
+            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');
+        return body;
+    }
+    flagHelpLabel(flag, showOptions = false) {
+        let label = flag.helpLabel;
+        if (!label) {
+            const labels = [];
+            labels.push(flag.char ? `-${flag.char[0]}` : '  ');
+            if (flag.name) {
+                if (flag.type === 'boolean' && flag.allowNo) {
+                    labels.push(`--[no-]${flag.name.trim()}`);
+                }
+                else {
+                    labels.push(`--${flag.name.trim()}`);
+                }
+            }
+            label = labels.join(flag.char ? (0, theme_1.colorize)(this.config?.theme?.flagSeparator, ', ') : '  ');
+        }
+        if (flag.type === 'option') {
+            let value = docopts_1.DocOpts.formatUsageType(flag, this.opts.showFlagNameInTitle ?? false, this.opts.showFlagOptionsInTitle ?? showOptions);
+            if (!value.includes('|'))
+                value = (0, theme_1.colorize)('underline', value);
+            label += `=${value}`;
+        }
+        return (0, theme_1.colorize)(this.config.theme?.flag, label);
+    }
+    flags(flags) {
+        if (flags.length === 0)
+            return;
+        const noChar = flags.reduce((previous, current) => previous && current.char === undefined, true);
+        // eslint-disable-next-line complexity
+        return flags.map((flag) => {
+            let left = this.flagHelpLabel(flag);
+            if (noChar)
+                left = left.replace('    ', '');
+            let right = flag.summary || flag.description || '';
+            // Build metadata string (default, env, or both)
+            const metadata = [];
+            const canBeCached = !(this.opts.respectNoCacheDefault === true && flag.noCacheDefault === true);
+            if (flag.type === 'option') {
+                if (flag.default && canBeCached) {
+                    metadata.push(`default: ${flag.default}`);
+                }
+                if (flag.env) {
+                    metadata.push(`env: ${flag.env}`);
+                }
+            }
+            else if (flag.type === 'boolean' && flag.env) {
+                metadata.push(`env: ${flag.env}`);
+            }
+            if (metadata.length > 0) {
+                right = `${(0, theme_1.colorize)(this.config?.theme?.flagDefaultValue, `[${metadata.join(', ')}]`)} ${right}`;
+            }
+            if (flag.required)
+                right = `${(0, theme_1.colorize)(this.config?.theme?.flagRequired, '(required)')} ${right}`;
+            if (flag.type === 'option' && flag.options && !flag.helpValue && !this.opts.showFlagOptionsInTitle) {
+                right += (0, theme_1.colorize)(this.config?.theme?.flagOptions, `\n<options: ${flag.options.join('|')}>`);
+            }
+            return [left, (0, theme_1.colorize)(this.config?.theme?.sectionDescription, right.trim())];
+        });
+    }
+    flagsDescriptions(flags) {
+        const flagsWithExtendedDescriptions = flags.filter((flag) => flag.summary && flag.description);
+        if (flagsWithExtendedDescriptions.length === 0)
+            return;
+        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);
+            if (!flag.char)
+                flagHelp = flagHelp.replace('    ', '');
+            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');
+        return body;
+    }
+    generate() {
+        const cmd = this.command;
+        const unsortedFlags = Object.entries(cmd.flags || {})
+            .filter(([, v]) => !v.hidden)
+            .map(([k, v]) => {
+            v.name = k;
+            return v;
+        });
+        const flags = determineSortOrder(this.opts.flagSortOrder) === 'alphabetical'
+            ? (0, util_1.sortBy)(unsortedFlags, (f) => [!f.char, f.char, f.name])
+            : unsortedFlags;
+        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() {
+        const sections = [
+            {
+                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',
+            },
+        ];
+        const allowedSections = this.opts.sections?.map((s) => s.toLowerCase());
+        return sections.filter(({ header }) => !allowedSections || allowedSections.includes(header.toLowerCase()));
+    }
+    usage() {
+        const { id, usage } = this.command;
+        const standardId = (0, ids_1.toStandardizedId)(id, this.config);
+        const configuredId = (0, ids_1.toConfiguredId)(id, this.config);
+        const body = (usage ? (0, util_1.castArray)(usage) : [this.defaultUsage()])
+            .map((u) => {
+            const allowedSpacing = this.opts.maxWidth - this.indentSpacing;
+            const dollarSign = (0, theme_1.colorize)(this.config?.theme?.dollarSign, '$');
+            const bin = (0, theme_1.colorize)(this.config?.theme?.bin, this.config.bin);
+            const command = (0, theme_1.colorize)(this.config?.theme?.command, '<%= command.id %>');
+            const commandDescription = (0, theme_1.colorize)(this.config?.theme?.sectionDescription, u
+                .replace('<%= command.id %>', '')
+                .replace(new RegExp(`^${standardId}`), '')
+                .replace(new RegExp(`^${configuredId}`), '')
+                .trim());
+            const line = `${dollarSign} ${bin} ${command} ${commandDescription}`.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;
+    }
+    formatIfCommand(example) {
+        example = this.render(example);
+        const dollarSign = (0, theme_1.colorize)(this.config?.theme?.dollarSign, '$');
+        if (example.startsWith(this.config.bin))
+            return `${dollarSign} ${example}`;
+        if (example.startsWith(`$ ${this.config.bin}`))
+            return `${dollarSign}${example.replace(`$`, '')}`;
+        return example;
+    }
+    isCommand(example) {
+        return ansis_1.default
+            .strip(this.formatIfCommand(example))
+            .startsWith(`${(0, theme_1.colorize)(this.config?.theme?.dollarSign, '$')} ${this.config.bin}`);
+    }
+}
+exports.CommandHelp = CommandHelp;
+exports.default = CommandHelp;

data/payload/node_modules/@oclif/core/lib/help/docopts.d.ts

@@ -0,0 +1,69 @@
+import { Command } from '../command';
+/**
+ * DocOpts - See http://docopt.org/.
+ *
+ * flag.exclusive: groups elements when one of the mutually exclusive cases is a required flag: (--apple | --orange)
+ * flag.exclusive: groups elements when none of the mutually exclusive cases is required (optional flags): [--apple | --orange]
+ * flag.dependsOn: specifies that if one element is present, then another one is required: (--apple --orange)
+ *
+ * @example
+ *  {
+ *      name: 'classnames',
+ *      required: true,
+ *      exclusive: ['suitenames']
+ *      ...
+ *  },{
+ *      name: 'suitenames',
+ *      type: 'array'
+ *      required: true
+ *      ...
+ *  }
+ *
+ *  Results in:
+ *      Usage: <%= command.id %> (-n <string> | -s <array>)
+ *
+ * @example
+ *  {
+ *      name: 'classnames',
+ *      ...
+ *      excludes: ['suitenames']
+ *  },{
+ *      name: 'suitenames',
+ *      ...
+ *  }
+ *
+ *  Results in:
+ *      Usage: <%= command.id %> [-n <string> | -s <string>]
+ *
+ * @example
+ *  {
+ *      name: 'classnames',
+ *      ...
+ *      dependsOn: ['suitenames']
+ *  },{
+ *      name: 'suitenames',
+ *      type: 'flag'
+ *      ...
+ *  }
+ *
+ *  Results in:
+ *      Usage: <%= command.id %> (-n <string> -s)
+ *
+ * TODO:
+ *  - Support nesting, eg:
+ *      Usage: my_program (--either-this <and-that> | <or-this>)
+ *      Usage: my_program [(<one-argument> <another-argument>)]
+ *
+ */
+export declare class DocOpts {
+    private cmd;
+    private flagList;
+    private flagMap;
+    constructor(cmd: Command.Loadable);
+    static formatUsageType(flag: Command.Flag.Any, showFlagName: boolean, showOptions: boolean): string;
+    static generate(cmd: Command.Loadable): string;
+    toString(): string;
+    private combineElementsToFlag;
+    private generateElements;
+    private groupFlagElements;
+}

data/payload/node_modules/@oclif/core/lib/help/docopts.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocOpts = void 0;
+const ensure_arg_object_1 = require("../util/ensure-arg-object");
+/**
+ * DocOpts - See http://docopt.org/.
+ *
+ * flag.exclusive: groups elements when one of the mutually exclusive cases is a required flag: (--apple | --orange)
+ * flag.exclusive: groups elements when none of the mutually exclusive cases is required (optional flags): [--apple | --orange]
+ * flag.dependsOn: specifies that if one element is present, then another one is required: (--apple --orange)
+ *
+ * @example
+ *  {
+ *      name: 'classnames',
+ *      required: true,
+ *      exclusive: ['suitenames']
+ *      ...
+ *  },{
+ *      name: 'suitenames',
+ *      type: 'array'
+ *      required: true
+ *      ...
+ *  }
+ *
+ *  Results in:
+ *      Usage: <%= command.id %> (-n <string> | -s <array>)
+ *
+ * @example
+ *  {
+ *      name: 'classnames',
+ *      ...
+ *      excludes: ['suitenames']
+ *  },{
+ *      name: 'suitenames',
+ *      ...
+ *  }
+ *
+ *  Results in:
+ *      Usage: <%= command.id %> [-n <string> | -s <string>]
+ *
+ * @example
+ *  {
+ *      name: 'classnames',
+ *      ...
+ *      dependsOn: ['suitenames']
+ *  },{
+ *      name: 'suitenames',
+ *      type: 'flag'
+ *      ...
+ *  }
+ *
+ *  Results in:
+ *      Usage: <%= command.id %> (-n <string> -s)
+ *
+ * TODO:
+ *  - Support nesting, eg:
+ *      Usage: my_program (--either-this <and-that> | <or-this>)
+ *      Usage: my_program [(<one-argument> <another-argument>)]
+ *
+ */
+class DocOpts {
+    cmd;
+    flagList;
+    flagMap;
+    constructor(cmd) {
+        this.cmd = cmd;
+        // Create a new map with references to the flags that we can manipulate.
+        this.flagMap = {};
+        this.flagList = Object.entries(cmd.flags || {})
+            .filter(([_, flag]) => !flag.hidden)
+            .map(([name, flag]) => {
+            this.flagMap[name] = flag;
+            return flag;
+        });
+    }
+    static formatUsageType(flag, showFlagName, showOptions) {
+        if (flag.type !== 'option')
+            return '';
+        let helpValues;
+        if (flag.helpValue) {
+            // if there is a given helpValue, use it
+            helpValues = typeof flag.helpValue === 'string' ? [flag.helpValue] : flag.helpValue;
+        }
+        else if (flag.options) {
+            // if there are options, show them if wanted
+            helpValues = [showOptions ? flag.options.join('|') : '<option>'];
+        }
+        else if (showFlagName) {
+            helpValues = [flag.name];
+        }
+        else {
+            // default to <value>
+            helpValues = ['<value>'];
+        }
+        return helpValues.map((v) => `${v}${flag.multiple ? '...' : ''}`).join(' ');
+    }
+    static generate(cmd) {
+        return new DocOpts(cmd).toString();
+    }
+    toString() {
+        const opts = ['<%= command.id %>'];
+        if (this.cmd.args) {
+            const a = Object.values((0, ensure_arg_object_1.ensureArgObject)(this.cmd.args))
+                .filter((arg) => !arg.hidden)
+                .map((arg) => {
+                const suffix = arg.multiple ? '...' : this.cmd.strict === false ? '...' : '';
+                return arg.required ? `${arg.name.toUpperCase()}${suffix}` : `[${arg.name.toUpperCase()}${suffix}]`;
+            }) || [];
+            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}=${DocOpts.formatUsageType(flag, false, true)}`;
+            }));
+        }
+        return opts.join(' ');
+    }
+    combineElementsToFlag(elementMap, flagName, flagNames, unionString) {
+        if (!this.flagMap[flagName]) {
+            return;
+        }
+        let isRequired = this.flagMap[flagName]?.required;
+        if (typeof isRequired !== 'boolean' || !isRequired) {
+            isRequired = flagNames.reduce((required, toCombine) => required || this.flagMap[toCombine]?.required || false, false);
+        }
+        for (const toCombine of flagNames) {
+            elementMap[flagName] = `${elementMap[flagName] || ''}${unionString}${elementMap[toCombine] || ''}`;
+            // We handled this flag, don't handle it again
+            delete elementMap[toCombine];
+            delete this.flagMap[toCombine];
+        }
+        elementMap[flagName] = isRequired ? `(${elementMap[flagName] || ''})` : `[${elementMap[flagName] || ''}]`;
+        // We handled this flag, don't handle it again
+        delete this.flagMap[flagName];
+    }
+    generateElements(elementMap = {}, flagGroups = []) {
+        const elementStrs = [];
+        for (const flag of flagGroups) {
+            let type = '';
+            // not all flags have short names
+            const flagName = flag.char ? `-${flag.char}` : `--${flag.name}`;
+            if (flag.type === 'option') {
+                type = ` ${DocOpts.formatUsageType(flag, false, true)}`;
+            }
+            const element = `${flagName}${type}`;
+            elementMap[flag.name] = element;
+            elementStrs.push(element);
+        }
+        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, ' ');
+            }
+            let exclusive;
+            if (Array.isArray(flag.exclusive)) {
+                exclusive = new Set(flag.exclusive);
+            }
+            if (Array.isArray(flag.combinable)) {
+                const combinableFlags = new Set(flag.combinable);
+                exclusive ??= new Set();
+                for (const item of this.flagList) {
+                    // each flag not in the "combinable" list, is equivalent to an "exclusive" flag
+                    if (flag !== item && !combinableFlags.has(item.name)) {
+                        exclusive.add(item.name);
+                    }
+                }
+            }
+            if (exclusive !== undefined && exclusive.size > 0) {
+                this.combineElementsToFlag(elementMap, flag.name, [...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;
+    }
+}
+exports.DocOpts = DocOpts;