@oclif/core 3.0.0-beta.18 → 3.0.0-beta.19

package/lib/module-loader.js

@@ -33,6 +33,7 @@ async function load(config, modulePath) {
     let filePath;
     let isESM;
     try {
+        ;
         ({ isESM, filePath } = resolvePath(config, modulePath));
         return isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath);
     }
@@ -65,6 +66,7 @@ async function loadWithData(config, modulePath) {
     let filePath;
     let isESM;
     try {
+        ;
         ({ isESM, filePath } = resolvePath(config, modulePath));
         const module = isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath);
         return { isESM, module, filePath };
@@ -114,14 +116,14 @@ async function loadWithDataFromManifest(cached, modulePath) {
 }
 exports.loadWithDataFromManifest = loadWithDataFromManifest;
 /**
-   * For `.js` files uses `getPackageType` to determine if `type` is set to `module` in associated `package.json`. If
-   * the `modulePath` provided ends in `.mjs` it is assumed to be ESM.
-   *
-   * @param {string} filePath - File path to test.
-   *
-   * @returns {boolean} The modulePath is an ES Module.
-   * @see https://www.npmjs.com/package/get-package-type
-   */
+ * For `.js` files uses `getPackageType` to determine if `type` is set to `module` in associated `package.json`. If
+ * the `modulePath` provided ends in `.mjs` it is assumed to be ESM.
+ *
+ * @param {string} filePath - File path to test.
+ *
+ * @returns {boolean} The modulePath is an ES Module.
+ * @see https://www.npmjs.com/package/get-package-type
+ */
 function isPathModule(filePath) {
     const extension = (0, node_path_1.extname)(filePath).toLowerCase();
     switch (extension) {
@@ -160,7 +162,8 @@ function resolvePath(config, modulePath) {
         isESM = isPathModule(filePath);
     }
     catch {
-        filePath = (isPlugin(config) ? (0, ts_node_1.tsPath)(config.root, modulePath, config) : (0, ts_node_1.tsPath)(config.root, modulePath)) ?? modulePath;
+        filePath =
+            (isPlugin(config) ? (0, ts_node_1.tsPath)(config.root, modulePath, config) : (0, ts_node_1.tsPath)(config.root, modulePath)) ?? modulePath;
         let fileExists = false;
         let isDirectory = false;
         if ((0, node_fs_1.existsSync)(filePath)) {

package/lib/parser/errors.d.ts

@@ -22,7 +22,7 @@ export declare class InvalidArgsSpecError extends CLIParseError {
 }
 export declare class RequiredArgsError extends CLIParseError {
     args: Arg<any>[];
-    constructor({ args, parse, flagsWithMultiple }: CLIParseErrorOptions & {
+    constructor({ args, parse, flagsWithMultiple, }: CLIParseErrorOptions & {
         args: Arg<any>[];
         flagsWithMultiple?: string[];
     });

package/lib/parser/errors.js

@@ -6,7 +6,7 @@ const errors_1 = require("../errors");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const help_1 = require("./help");
 const list_1 = require("../cli-ux/list");
-const util_1 = require("../util");
+const index_1 = require("../util/index");
 var errors_2 = require("../errors");
 Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return errors_2.CLIError; } });
 class CLIParseError extends errors_1.CLIError {
@@ -22,9 +22,9 @@ class InvalidArgsSpecError extends CLIParseError {
     args;
     constructor({ args, parse }) {
         let message = 'Invalid argument spec';
-        const namedArgs = Object.values(args).filter(a => a.name);
+        const namedArgs = Object.values(args).filter((a) => a.name);
         if (namedArgs.length > 0) {
-            const list = (0, list_1.renderList)(namedArgs.map(a => [`${a.name} (${a.required ? 'required' : 'optional'})`, a.description]));
+            const list = (0, list_1.renderList)(namedArgs.map((a) => [`${a.name} (${a.required ? 'required' : 'optional'})`, a.description]));
             message += `:\n${list}`;
         }
         super({ parse, message });
@@ -34,15 +34,15 @@ class InvalidArgsSpecError extends CLIParseError {
 exports.InvalidArgsSpecError = InvalidArgsSpecError;
 class RequiredArgsError extends CLIParseError {
     args;
-    constructor({ args, parse, flagsWithMultiple }) {
+    constructor({ args, parse, flagsWithMultiple, }) {
         let message = `Missing ${args.length} required arg${args.length === 1 ? '' : 's'}`;
-        const namedArgs = args.filter(a => a.name);
+        const namedArgs = args.filter((a) => a.name);
         if (namedArgs.length > 0) {
-            const list = (0, list_1.renderList)(namedArgs.map(a => [a.name, a.description]));
+            const list = (0, list_1.renderList)(namedArgs.map((a) => [a.name, a.description]));
             message += `:\n${list}`;
         }
         if (flagsWithMultiple?.length) {
-            const flags = flagsWithMultiple.map(f => `--${f}`).join(', ');
+            const flags = flagsWithMultiple.map((f) => `--${f}`).join(', ');
             message += `\n\nNote: ${flags} allow${flagsWithMultiple.length === 1 ? 's' : ''} multiple values. Because of this you need to provide all arguments before providing ${flagsWithMultiple.length === 1 ? 'that flag' : 'those flags'}.`;
             message += '\nAlternatively, you can use "--" to signify the end of the flags and the beginning of arguments.';
         }
@@ -95,8 +95,8 @@ class ArgInvalidOptionError extends CLIParseError {
 exports.ArgInvalidOptionError = ArgInvalidOptionError;
 class FailedFlagValidationError extends CLIParseError {
     constructor({ parse, failed }) {
-        const reasons = failed.map(r => r.reason);
-        const deduped = (0, util_1.uniq)(reasons);
+        const reasons = failed.map((r) => r.reason);
+        const deduped = (0, index_1.uniq)(reasons);
         const errString = deduped.length === 1 ? 'error' : 'errors';
         const message = `The following ${errString} occurred:\n  ${chalk_1.default.dim(deduped.join('\n  '))}`;
         super({ parse, message });

package/lib/parser/help.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flagUsages = exports.flagUsage = void 0;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const util_1 = require("../util");
+const index_1 = require("../util/index");
 function flagUsage(flag, options = {}) {
     const label = [];
     if (flag.helpLabel) {
@@ -26,7 +26,6 @@ exports.flagUsage = flagUsage;
 function flagUsages(flags, options = {}) {
     if (flags.length === 0)
         return [];
-    return (0, util_1.sortBy)(flags, f => [f.char ? -1 : 1, f.char, f.name])
-        .map(f => flagUsage(f, options));
+    return (0, index_1.sortBy)(flags, (f) => [f.char ? -1 : 1, f.char, f.name]).map((f) => flagUsage(f, options));
 }
 exports.flagUsages = flagUsages;

package/lib/parser/parse.js

@@ -3,13 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parser = void 0;
 /* eslint-disable no-await-in-loop */
 const errors_1 = require("./errors");
-const util_1 = require("../util");
+const index_1 = require("../util/index");
 const node_readline_1 = require("node:readline");
 let debug;
 try {
-    debug = process.env.CLI_FLAGS_DEBUG === '1' ? require('debug')('../parser') : () => {
-        // noop
-    };
+    debug =
+        process.env.CLI_FLAGS_DEBUG === '1'
+            ? require('debug')('../parser')
+            : () => {
+                // noop
+            };
 }
 catch {
     debug = () => {
@@ -25,7 +28,7 @@ const readStdin = async () => {
     // Because of this, we have to set a timeout to prevent the process from hanging.
     if (stdin.isTTY)
         return null;
-    return new Promise(resolve => {
+    return new Promise((resolve) => {
         let result = '';
         const ac = new AbortController();
         const { signal } = ac;
@@ -35,7 +38,7 @@ const readStdin = async () => {
             output: stdout,
             terminal: false,
         });
-        rl.on('line', line => {
+        rl.on('line', (line) => {
             result += line;
         });
         rl.once('close', () => {
@@ -72,8 +75,8 @@ class Parser {
         this.context = input.context ?? {};
         this.argv = [...input.argv];
         this._setNames();
-        this.booleanFlags = (0, util_1.pickBy)(input.flags, f => f.type === 'boolean');
-        this.flagAliases = Object.fromEntries(Object.values(input.flags).flatMap(flag => ([...flag.aliases ?? [], ...flag.charAliases ?? []]).map(a => [a, flag])));
+        this.booleanFlags = (0, index_1.pickBy)(input.flags, (f) => f.type === 'boolean');
+        this.flagAliases = Object.fromEntries(Object.values(input.flags).flatMap((flag) => [...(flag.aliases ?? []), ...(flag.charAliases ?? [])].map((a) => [a, flag])));
     }
     async parse() {
         this._debugInput();
@@ -94,13 +97,13 @@ class Parser {
             }
             const flag = this.input.flags[name];
             if (flag.type === 'option') {
-                if (!flag.multiple && this.raw.some(o => o.type === 'flag' && o.flag === name)) {
+                if (!flag.multiple && this.raw.some((o) => o.type === 'flag' && o.flag === name)) {
                     throw new errors_1.CLIError(`Flag --${name} can only be specified once`);
                 }
                 this.currentFlag = flag;
                 const input = isLong || arg.length < 3 ? this.argv.shift() : arg.slice(arg[2] === '=' ? 3 : 2);
                 // if the value ends up being one of the command's flags, the user didn't provide an input
-                if ((typeof input !== 'string') || this.findFlag(input).name) {
+                if (typeof input !== 'string' || this.findFlag(input).name) {
                     throw new errors_1.CLIError(`Flag --${name} expects a value`);
                 }
                 this.raw.push({ type: 'flag', flag: flag.name, input });
@@ -187,41 +190,50 @@ class Parser {
             }
         };
         /* Could add a valueFunction (if there is a value/env/default) and could metadata.
-        *  Value function can be resolved later.
-        */
+         *  Value function can be resolved later.
+         */
         const addValueFunction = (fws) => {
             const tokenLength = fws.tokens?.length;
             // user provided some input
             if (tokenLength) {
                 // boolean
-                if (fws.inputFlag.flag.type === 'boolean' && (0, util_1.last)(fws.tokens)?.input) {
+                if (fws.inputFlag.flag.type === 'boolean' && (0, index_1.last)(fws.tokens)?.input) {
                     return {
                         ...fws,
-                        valueFunction: async (i) => parseFlagOrThrowError((0, util_1.last)(i.tokens)?.input !== `--no-${i.inputFlag.name}`, i.inputFlag.flag, this.context, (0, util_1.last)(i.tokens)),
+                        valueFunction: async (i) => parseFlagOrThrowError((0, index_1.last)(i.tokens)?.input !== `--no-${i.inputFlag.name}`, i.inputFlag.flag, this.context, (0, index_1.last)(i.tokens)),
                     };
                 }
                 // multiple with custom delimiter
                 if (fws.inputFlag.flag.type === 'option' && fws.inputFlag.flag.delimiter && fws.inputFlag.flag.multiple) {
                     return {
                         ...fws,
-                        valueFunction: async (i) => (await Promise.all(((i.tokens ?? []).flatMap(token => token.input.split(i.inputFlag.flag.delimiter ?? ',')))
+                        valueFunction: async (i) => (await Promise.all((i.tokens ?? [])
+                            .flatMap((token) => token.input.split(i.inputFlag.flag.delimiter ?? ','))
                             // trim, and remove surrounding doubleQuotes (which would hav been needed if the elements contain spaces)
-                            .map(v => v.trim().replace(/^"(.*)"$/, '$1').replace(/^'(.*)'$/, '$1'))
-                            .map(async (v) => parseFlagOrThrowError(v, i.inputFlag.flag, this.context, { ...(0, util_1.last)(i.tokens), input: v })))).map(v => validateOptions(i.inputFlag.flag, v)),
+                            .map((v) => v
+                            .trim()
+                            .replace(/^"(.*)"$/, '$1')
+                            .replace(/^'(.*)'$/, '$1'))
+                            .map(async (v) => parseFlagOrThrowError(v, i.inputFlag.flag, this.context, {
+                            ...(0, index_1.last)(i.tokens),
+                            input: v,
+                        }))))
+                            // eslint-disable-next-line unicorn/no-await-expression-member
+                            .map((v) => validateOptions(i.inputFlag.flag, v)),
                     };
                 }
                 // multiple in the oclif-core style
                 if (fws.inputFlag.flag.type === 'option' && fws.inputFlag.flag.multiple) {
                     return {
                         ...fws,
-                        valueFunction: async (i) => Promise.all((fws.tokens ?? []).map(token => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, token.input), i.inputFlag.flag, this.context, token))),
+                        valueFunction: async (i) => Promise.all((fws.tokens ?? []).map((token) => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, token.input), i.inputFlag.flag, this.context, token))),
                     };
                 }
                 // simple option flag
                 if (fws.inputFlag.flag.type === 'option') {
                     return {
                         ...fws,
-                        valueFunction: async (i) => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, (0, util_1.last)(fws.tokens)?.input), i.inputFlag.flag, this.context, (0, util_1.last)(fws.tokens)),
+                        valueFunction: async (i) => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, (0, index_1.last)(fws.tokens)?.input), i.inputFlag.flag, this.context, (0, index_1.last)(fws.tokens)),
                     };
                 }
             }
@@ -237,7 +249,7 @@ class Parser {
                 if (fws.inputFlag.flag.type === 'boolean') {
                     return {
                         ...fws,
-                        valueFunction: async (i) => (0, util_1.isTruthy)(process.env[i.inputFlag.flag.env] ?? 'false'),
+                        valueFunction: async (i) => (0, index_1.isTruthy)(process.env[i.inputFlag.flag.env] ?? 'false'),
                     };
                 }
             }
@@ -245,7 +257,8 @@ class Parser {
             // eslint-disable-next-line no-constant-binary-expression, valid-typeof
             if (typeof fws.inputFlag.flag.default !== undefined) {
                 return {
-                    ...fws, metadata: { setFromDefault: true },
+                    ...fws,
+                    metadata: { setFromDefault: true },
                     valueFunction: typeof fws.inputFlag.flag.default === 'function'
                         ? (i, allFlags = {}) => fws.inputFlag.flag.default({ options: i.inputFlag.flag, flags: allFlags })
                         : async () => fws.inputFlag.flag.default,
@@ -257,17 +270,19 @@ class Parser {
         const addHelpFunction = (fws) => {
             if (fws.inputFlag.flag.type === 'option' && fws.inputFlag.flag.defaultHelp) {
                 return {
-                    ...fws, helpFunction: typeof fws.inputFlag.flag.defaultHelp === 'function'
-                        // @ts-expect-error flag type isn't specific enough to know defaultHelp will definitely be there
-                        ? (i, flags, ...context) => i.inputFlag.flag.defaultHelp({ options: i.inputFlag, flags }, ...context)
+                    ...fws,
+                    helpFunction: typeof fws.inputFlag.flag.defaultHelp === 'function'
+                        ? (i, flags, ...context) => 
                         // @ts-expect-error flag type isn't specific enough to know defaultHelp will definitely be there
-                        : (i) => i.inputFlag.flag.defaultHelp,
+                        i.inputFlag.flag.defaultHelp({ options: i.inputFlag, flags }, ...context)
+                        : // @ts-expect-error flag type isn't specific enough to know defaultHelp will definitely be there
+                            (i) => i.inputFlag.flag.defaultHelp,
                 };
             }
             return fws;
         };
         const addDefaultHelp = async (fwsArray) => {
-            const valueReferenceForHelp = fwsArrayToObject(flagsWithAllValues.filter(fws => !fws.metadata?.setFromDefault));
+            const valueReferenceForHelp = fwsArrayToObject(flagsWithAllValues.filter((fws) => !fws.metadata?.setFromDefault));
             return Promise.all(fwsArray.map(async (fws) => {
                 try {
                     if (fws.helpFunction) {
@@ -286,26 +301,32 @@ class Parser {
                 return fws;
             }));
         };
-        const fwsArrayToObject = (fwsArray) => Object.fromEntries(fwsArray.filter(fws => fws.value !== undefined)
-            .map(fws => [fws.inputFlag.name, fws.value]));
+        const fwsArrayToObject = (fwsArray) => Object.fromEntries(fwsArray.filter((fws) => fws.value !== undefined).map((fws) => [fws.inputFlag.name, fws.value]));
         const flagTokenMap = this.mapAndValidateFlags();
         const flagsWithValues = await Promise.all(Object.entries(this.input.flags)
             // we check them if they have a token, or might have env, default, or defaultHelp.  Also include booleans so they get their default value
-            .filter(([name, flag]) => flag.type === 'boolean' || flag.env || flag.default !== undefined || 'defaultHelp' in flag || flagTokenMap.has(name))
+            .filter(([name, flag]) => flag.type === 'boolean' ||
+            flag.env ||
+            flag.default !== undefined ||
+            'defaultHelp' in flag ||
+            flagTokenMap.has(name))
             // match each possible flag to its token, if there is one
             .map(([name, flag]) => ({ inputFlag: { name, flag }, tokens: flagTokenMap.get(name) }))
-            .map(fws => addValueFunction(fws))
-            .filter(fws => fws.valueFunction !== undefined)
-            .map(fws => addHelpFunction(fws))
+            .map((fws) => addValueFunction(fws))
+            .filter((fws) => fws.valueFunction !== undefined)
+            .map((fws) => addHelpFunction(fws))
             // we can't apply the default values until all the other flags are resolved because `flag.default` can reference other flags
             .map(async (fws) => (fws.metadata?.setFromDefault ? fws : { ...fws, value: await fws.valueFunction?.(fws) })));
-        const valueReference = fwsArrayToObject(flagsWithValues.filter(fws => !fws.metadata?.setFromDefault));
-        const flagsWithAllValues = await Promise.all(flagsWithValues
-            .map(async (fws) => (fws.metadata?.setFromDefault ? { ...fws, value: await fws.valueFunction?.(fws, valueReference) } : fws)));
-        const finalFlags = (flagsWithAllValues.some(fws => typeof fws.helpFunction === 'function')) ? await addDefaultHelp(flagsWithAllValues) : flagsWithAllValues;
+        const valueReference = fwsArrayToObject(flagsWithValues.filter((fws) => !fws.metadata?.setFromDefault));
+        const flagsWithAllValues = await Promise.all(flagsWithValues.map(async (fws) => fws.metadata?.setFromDefault ? { ...fws, value: await fws.valueFunction?.(fws, valueReference) } : fws));
+        const finalFlags = flagsWithAllValues.some((fws) => typeof fws.helpFunction === 'function')
+            ? await addDefaultHelp(flagsWithAllValues)
+            : flagsWithAllValues;
         return {
             flags: fwsArrayToObject(finalFlags),
-            metadata: { flags: Object.fromEntries(finalFlags.filter(fws => fws.metadata).map(fws => [fws.inputFlag.name, fws.metadata])) },
+            metadata: {
+                flags: Object.fromEntries(finalFlags.filter((fws) => fws.metadata).map((fws) => [fws.inputFlag.name, fws.metadata])),
+            },
         };
     }
     async _args() {
@@ -315,7 +336,7 @@ class Parser {
         let stdinRead = false;
         const ctx = this.context;
         for (const [name, arg] of Object.entries(this.input.args)) {
-            const token = tokens.find(t => t.arg === name);
+            const token = tokens.find((t) => t.arg === name);
             ctx.token = token;
             if (token) {
                 if (arg.options && !arg.options.includes(token.input)) {
@@ -374,11 +395,11 @@ class Parser {
         if (Object.keys(this.input.flags).length === 0)
             return;
         debug('available flags: %s', Object.keys(this.input.flags)
-            .map(f => `--${f}`)
+            .map((f) => `--${f}`)
             .join(' '));
     }
     get _argTokens() {
-        return this.raw.filter(o => o.type === 'arg');
+        return this.raw.filter((o) => o.type === 'arg');
     }
     _setNames() {
         for (const k of Object.keys(this.input.flags)) {
@@ -390,7 +411,7 @@ class Parser {
     }
     mapAndValidateFlags() {
         const flagTokenMap = new Map();
-        for (const token of this.raw.filter(o => o.type === 'flag')) {
+        for (const token of this.raw.filter((o) => o.type === 'flag')) {
             // fail fast if there are any invalid flags
             if (!(token.flag in this.input.flags)) {
                 throw new errors_1.CLIError(`Unexpected flag ${token.flag}`);
@@ -418,12 +439,12 @@ class Parser {
         if (this.flagAliases[char]) {
             return this.flagAliases[char].name;
         }
-        return Object.keys(this.input.flags).find(k => (this.input.flags[k].char === char && char !== undefined && this.input.flags[k].char !== undefined));
+        return Object.keys(this.input.flags).find((k) => this.input.flags[k].char === char && char !== undefined && this.input.flags[k].char !== undefined);
     }
     findFlag(arg) {
         const isLong = arg.startsWith('--');
         const short = isLong ? false : arg.startsWith('-');
-        const name = isLong ? this.findLongFlag(arg) : (short ? this.findShortFlag(arg) : undefined);
+        const name = isLong ? this.findLongFlag(arg) : short ? this.findShortFlag(arg) : undefined;
         return { name, isLong };
     }
 }

package/lib/parser/validate.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validate = void 0;
 const errors_1 = require("./errors");
-const util_1 = require("../util");
+const index_1 = require("../util/index");
 async function validate(parse) {
     let cachedResolvedFlags;
     function validateArgs() {
@@ -40,10 +40,10 @@ async function validate(parse) {
         const promises = Object.entries(parse.input.flags).flatMap(([name, flag]) => {
             if (parse.output.flags[name] !== undefined) {
                 return [
-                    ...flag.relationships ? validateRelationships(name, flag) : [],
-                    ...flag.dependsOn ? [validateDependsOn(name, flag.dependsOn)] : [],
-                    ...flag.exclusive ? [validateExclusive(name, flag.exclusive)] : [],
-                    ...flag.exactlyOne ? [validateExactlyOne(name, flag.exactlyOne)] : [],
+                    ...(flag.relationships ? validateRelationships(name, flag) : []),
+                    ...(flag.dependsOn ? [validateDependsOn(name, flag.dependsOn)] : []),
+                    ...(flag.exclusive ? [validateExclusive(name, flag.exclusive)] : []),
+                    ...(flag.exactlyOne ? [validateExactlyOne(name, flag.exactlyOne)] : []),
                 ];
             }
             if (flag.required) {
@@ -54,8 +54,8 @@ async function validate(parse) {
             }
             return [];
         });
-        const results = (await Promise.all(promises));
-        const failed = results.filter(r => r.status === 'failed');
+        const results = await Promise.all(promises);
+        const failed = results.filter((r) => r.status === 'failed');
         if (failed.length > 0)
             throw new errors_1.FailedFlagValidationError({ parse, failed });
     }
@@ -70,19 +70,19 @@ async function validate(parse) {
             return result ? [flag.name, parse.output.flags[flag.name]] : null;
         });
         const resolved = await Promise.all(promises);
-        cachedResolvedFlags = Object.fromEntries(resolved.filter(r => r !== null));
+        cachedResolvedFlags = Object.fromEntries(resolved.filter((r) => r !== null));
         return cachedResolvedFlags;
     }
-    const getPresentFlags = (flags) => Object.keys(flags).filter(key => key !== undefined);
+    const getPresentFlags = (flags) => Object.keys(flags).filter((key) => key !== undefined);
     function validateAcrossFlags(flag) {
         const base = { name: flag.name, validationFn: 'validateAcrossFlags' };
         const intersection = Object.entries(parse.input.flags)
-            .map(entry => entry[0]) // array of flag names
-            .filter(flagName => parse.output.flags[flagName] !== undefined) // with values
-            .filter(flagName => flag.exactlyOne && flag.exactlyOne.includes(flagName)); // and in the exactlyOne list
+            .map((entry) => entry[0]) // array of flag names
+            .filter((flagName) => parse.output.flags[flagName] !== undefined) // with values
+            .filter((flagName) => flag.exactlyOne && flag.exactlyOne.includes(flagName)); // and in the exactlyOne list
         if (intersection.length === 0) {
             // the command's exactlyOne may or may not include itself, so we'll use Set to add + de-dupe
-            const deduped = (0, util_1.uniq)(flag.exactlyOne?.map(flag => `--${flag}`) ?? []).join(', ');
+            const deduped = (0, index_1.uniq)(flag.exactlyOne?.map((flag) => `--${flag}`) ?? []).join(', ');
             const reason = `Exactly one of the following must be provided: ${deduped}`;
             return { ...base, status: 'failed', reason };
         }
@@ -100,7 +100,11 @@ async function validate(parse) {
                 continue;
             if (parse.output.flags[flag] !== undefined) {
                 const flagValue = parse.output.metadata.flags?.[flag]?.defaultHelp ?? parse.output.flags[flag];
-                return { ...base, status: 'failed', reason: `--${flag}=${flagValue} cannot also be provided when using --${name}` };
+                return {
+                    ...base,
+                    status: 'failed',
+                    reason: `--${flag}=${flagValue} cannot also be provided when using --${name}`,
+                };
             }
         }
         return { ...base, status: 'success' };
@@ -119,10 +123,16 @@ async function validate(parse) {
     async function validateDependsOn(name, flags) {
         const base = { name, validationFn: 'validateDependsOn' };
         const resolved = await resolveFlags(flags);
-        const foundAll = Object.values(resolved).every(val => val !== undefined);
+        const foundAll = Object.values(resolved).every((val) => val !== undefined);
         if (!foundAll) {
-            const formattedFlags = Object.keys(resolved).map(f => `--${f}`).join(', ');
-            return { ...base, status: 'failed', reason: `All of the following must be provided when using --${name}: ${formattedFlags}` };
+            const formattedFlags = Object.keys(resolved)
+                .map((f) => `--${f}`)
+                .join(', ');
+            return {
+                ...base,
+                status: 'failed',
+                reason: `All of the following must be provided when using --${name}: ${formattedFlags}`,
+            };
         }
         return { ...base, status: 'success' };
     }
@@ -131,13 +141,19 @@ async function validate(parse) {
         const resolved = await resolveFlags(flags);
         const foundAtLeastOne = Object.values(resolved).some(Boolean);
         if (!foundAtLeastOne) {
-            const formattedFlags = Object.keys(resolved).map(f => `--${f}`).join(', ');
-            return { ...base, status: 'failed', reason: `One of the following must be provided when using --${name}: ${formattedFlags}` };
+            const formattedFlags = Object.keys(resolved)
+                .map((f) => `--${f}`)
+                .join(', ');
+            return {
+                ...base,
+                status: 'failed',
+                reason: `One of the following must be provided when using --${name}: ${formattedFlags}`,
+            };
         }
         return { ...base, status: 'success' };
     }
     function validateRelationships(name, flag) {
-        return ((flag.relationships ?? []).map(relationship => {
+        return (flag.relationships ?? []).map((relationship) => {
             switch (relationship.type) {
                 case 'all': {
                     return validateDependsOn(name, relationship.flags);
@@ -152,7 +168,7 @@ async function validate(parse) {
                     throw new Error(`Unknown relationship type: ${relationship.type}`);
                 }
             }
-        }));
+        });
     }
     validateArgs();
     return validateFlags();

package/lib/performance.js

@@ -50,7 +50,7 @@ class Performance {
         throw new Error('Perf results not available. Did you forget to call await Performance.collect()?');
     }
     static getResult(name) {
-        return Performance.results.find(r => r.name === name);
+        return Performance.results.find((r) => r.name === name);
     }
     static get highlights() {
         if (!Performance.enabled)
@@ -86,11 +86,11 @@ class Performance {
         const markers = Object.values(Performance.markers);
         if (markers.length === 0)
             return;
-        for (const marker of markers.filter(m => !m.stopped)) {
+        for (const marker of markers.filter((m) => !m.stopped)) {
             marker.stop();
         }
-        return new Promise(resolve => {
-            const perfObserver = new node_perf_hooks_1.PerformanceObserver(items => {
+        return new Promise((resolve) => {
+            const perfObserver = new node_perf_hooks_1.PerformanceObserver((items) => {
                 for (const entry of items.getEntries()) {
                     if (Performance.markers[entry.name]) {
                         const marker = Performance.markers[entry.name];
@@ -104,8 +104,11 @@ class Performance {
                         });
                     }
                 }
-                const command = Performance.results.find(r => r.name.startsWith('config.runCommand'));
-                const commandLoadTime = command ? Performance.getResult(`plugin.findCommand#${command.details.plugin}.${command.details.command}`)?.duration ?? 0 : 0;
+                const command = Performance.results.find((r) => r.name.startsWith('config.runCommand'));
+                const commandLoadTime = command
+                    ? Performance.getResult(`plugin.findCommand#${command.details.plugin}.${command.details.command}`)
+                        ?.duration ?? 0
+                    : 0;
                 const pluginLoadTimes = Object.fromEntries(Performance.results
                     .filter(({ name }) => name.startsWith('plugin.load#'))
                     .sort((a, b) => b.duration - a.duration)

package/lib/util/aggregate-flags.js

@@ -8,8 +8,6 @@ const json = (0, flags_1.boolean)({
 });
 function aggregateFlags(flags, baseFlags, enableJsonFlag) {
     const combinedFlags = { ...baseFlags, ...flags };
-    return (enableJsonFlag
-        ? { json, ...combinedFlags }
-        : combinedFlags);
+    return (enableJsonFlag ? { json, ...combinedFlags } : combinedFlags);
 }
 exports.aggregateFlags = aggregateFlags;