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

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', () => {
@@ -60,14 +63,20 @@ const validateOptions = (flag, input) => {
     return input;
 };
 class Parser {
+    input;
+    argv;
+    raw = [];
+    booleanFlags;
+    flagAliases;
+    context;
+    currentFlag;
     constructor(input) {
         this.input = input;
-        this.raw = [];
         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();
@@ -88,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 });
@@ -181,40 +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)))
+                        ...fws,
+                        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)),
                     };
                 }
             }
@@ -230,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'),
                     };
                 }
             }
@@ -238,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,
@@ -250,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) {
@@ -279,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() {
@@ -308,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)) {
@@ -367,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)) {
@@ -383,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}`);
@@ -411,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

@@ -4,10 +4,17 @@ exports.Performance = void 0;
 const node_perf_hooks_1 = require("node:perf_hooks");
 const settings_1 = require("./settings");
 class Marker {
+    name;
+    details;
+    module;
+    method;
+    scope;
+    stopped = false;
+    startMarker;
+    stopMarker;
     constructor(name, details = {}) {
         this.name = name;
         this.details = details;
-        this.stopped = false;
         this.startMarker = `${this.name}-start`;
         this.stopMarker = `${this.name}-stop`;
         const [caller, scope] = name.split('#');
@@ -29,6 +36,9 @@ class Marker {
     }
 }
 class Performance {
+    static markers = {};
+    static _results = [];
+    static _highlights;
     static get enabled() {
         return settings_1.settings.performanceEnabled ?? false;
     }
@@ -40,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)
@@ -76,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];
@@ -94,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)
@@ -185,5 +198,3 @@ class Performance {
     }
 }
 exports.Performance = Performance;
-Performance.markers = {};
-Performance._results = [];

package/lib/util/aggregate-flags.d.ts

@@ -0,0 +1,2 @@
+import { FlagInput, FlagOutput } from '../interfaces/parser';
+export declare function aggregateFlags<F extends FlagOutput, B extends FlagOutput>(flags: FlagInput<F> | undefined, baseFlags: FlagInput<B> | undefined, enableJsonFlag: boolean | undefined): FlagInput<F>;

package/lib/util/aggregate-flags.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateFlags = void 0;
+const flags_1 = require("../flags");
+const json = (0, flags_1.boolean)({
+    description: 'Format output as json.',
+    helpGroup: 'GLOBAL',
+});
+function aggregateFlags(flags, baseFlags, enableJsonFlag) {
+    const combinedFlags = { ...baseFlags, ...flags };
+    return (enableJsonFlag ? { json, ...combinedFlags } : combinedFlags);
+}
+exports.aggregateFlags = aggregateFlags;

package/lib/util/cache-command.d.ts

@@ -0,0 +1,3 @@
+import { Command } from '../command';
+import { Plugin as IPlugin } from '../interfaces/plugin';
+export declare function cacheCommand(uncachedCmd: Command.Class, plugin?: IPlugin, respectNoCacheDefault?: boolean): Promise<Command.Cached>;

package/lib/util/cache-command.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheCommand = void 0;
+const index_1 = require("./index");
+const aggregate_flags_1 = require("./aggregate-flags");
+const cache_default_value_1 = require("./cache-default-value");
+// In order to collect static properties up the inheritance chain, we need to recursively
+// access the prototypes until there's nothing left. This allows us to combine baseFlags
+// and flags as well as add in the json flag if enableJsonFlag is enabled.
+function mergePrototype(result, cmd) {
+    const proto = Object.getPrototypeOf(cmd);
+    const filteredProto = (0, index_1.pickBy)(proto, (v) => v !== undefined);
+    return Object.keys(proto).length > 0 ? mergePrototype({ ...filteredProto, ...result }, proto) : result;
+}
+async function cacheFlags(cmdFlags, respectNoCacheDefault) {
+    const promises = Object.entries(cmdFlags).map(async ([name, flag]) => [
+        name,
+        {
+            name,
+            char: flag.char,
+            summary: flag.summary,
+            hidden: flag.hidden,
+            required: flag.required,
+            helpLabel: flag.helpLabel,
+            helpGroup: flag.helpGroup,
+            description: flag.description,
+            dependsOn: flag.dependsOn,
+            relationships: flag.relationships,
+            exclusive: flag.exclusive,
+            deprecated: flag.deprecated,
+            deprecateAliases: flag.deprecateAliases,
+            aliases: flag.aliases,
+            charAliases: flag.charAliases,
+            noCacheDefault: flag.noCacheDefault,
+            ...(flag.type === 'boolean'
+                ? {
+                    allowNo: flag.allowNo,
+                    type: flag.type,
+                }
+                : {
+                    type: flag.type,
+                    helpValue: flag.helpValue,
+                    multiple: flag.multiple,
+                    options: flag.options,
+                    delimiter: flag.delimiter,
+                    default: await (0, cache_default_value_1.cacheDefaultValue)(flag, respectNoCacheDefault),
+                    hasDynamicHelp: typeof flag.defaultHelp === 'function',
+                }),
+        },
+    ]);
+    return Object.fromEntries(await Promise.all(promises));
+}
+async function cacheArgs(cmdArgs, respectNoCacheDefault) {
+    const promises = Object.entries(cmdArgs).map(async ([name, arg]) => [
+        name,
+        {
+            name,
+            description: arg.description,
+            required: arg.required,
+            options: arg.options,
+            default: await (0, cache_default_value_1.cacheDefaultValue)(arg, respectNoCacheDefault),
+            hidden: arg.hidden,
+            noCacheDefault: arg.noCacheDefault,
+        },
+    ]);
+    return Object.fromEntries(await Promise.all(promises));
+}
+async function cacheCommand(uncachedCmd, plugin, respectNoCacheDefault = false) {
+    const cmd = mergePrototype(uncachedCmd, uncachedCmd);
+    const flags = await cacheFlags((0, aggregate_flags_1.aggregateFlags)(cmd.flags, cmd.baseFlags, cmd.enableJsonFlag), respectNoCacheDefault);
+    const args = await cacheArgs((0, index_1.ensureArgObject)(cmd.args), respectNoCacheDefault);
+    const stdProperties = {
+        id: cmd.id,
+        summary: cmd.summary,
+        description: cmd.description,
+        strict: cmd.strict,
+        usage: cmd.usage,
+        pluginName: plugin && plugin.name,
+        pluginAlias: plugin && plugin.alias,
+        pluginType: plugin && plugin.type,
+        hidden: cmd.hidden,
+        state: cmd.state,
+        aliases: cmd.aliases || [],
+        examples: cmd.examples || cmd.example,
+        deprecationOptions: cmd.deprecationOptions,
+        deprecateAliases: cmd.deprecateAliases,
+        flags,
+        args,
+        hasDynamicHelp: Object.values(flags).some((f) => f.hasDynamicHelp),
+    };
+    // do not include these properties in manifest
+    const ignoreCommandProperties = [
+        'plugin',
+        '_flags',
+        '_enableJsonFlag',
+        '_globalFlags',
+        '_baseFlags',
+        'baseFlags',
+        '_--',
+        '_base',
+    ];
+    // Add in any additional properties that are not standard command properties.
+    const stdKeysAndIgnored = new Set([...Object.keys(stdProperties), ...ignoreCommandProperties]);
+    const keysToAdd = Object.keys(cmd).filter((property) => !stdKeysAndIgnored.has(property));
+    const additionalProperties = Object.fromEntries(keysToAdd.map((key) => [key, cmd[key]]));
+    return { ...stdProperties, ...additionalProperties };
+}
+exports.cacheCommand = cacheCommand;

package/lib/util/cache-default-value.d.ts

@@ -0,0 +1,2 @@
+import { Arg, OptionFlag } from '../interfaces/parser';
+export declare const cacheDefaultValue: (flagOrArg: OptionFlag<any> | Arg<any>, respectNoCacheDefault: boolean) => Promise<any>;

package/lib/util/cache-default-value.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheDefaultValue = void 0;
+// when no manifest exists, the default is calculated.  This may throw, so we need to catch it
+const cacheDefaultValue = async (flagOrArg, respectNoCacheDefault) => {
+    if (respectNoCacheDefault && flagOrArg.noCacheDefault)
+        return;
+    // Prefer the defaultHelp function (returns a friendly string for complex types)
+    if (typeof flagOrArg.defaultHelp === 'function') {
+        try {
+            return await flagOrArg.defaultHelp({ options: flagOrArg, flags: {} });
+        }
+        catch {
+            return;
+        }
+    }
+    // if not specified, try the default function
+    if (typeof flagOrArg.default === 'function') {
+        try {
+            return await flagOrArg.default({ options: flagOrArg, flags: {} });
+        }
+        catch { }
+    }
+    else {
+        return flagOrArg.default;
+    }
+};
+exports.cacheDefaultValue = cacheDefaultValue;

package/lib/{util.d.ts → util/index.d.ts}

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import { ArgInput } from './interfaces/parser';
-import { Command } from './command';
+import { ArgInput } from '../interfaces/parser';
+import { Command } from '../command';
 export declare function pickBy<T extends {
     [s: string]: T[keyof T];
 } | ArrayLike<T[keyof T]>>(obj: T, fn: (i: T[keyof T]) => boolean): Partial<T>;
@@ -52,4 +52,9 @@ export declare function getPlatform(): NodeJS.Platform;
 export declare function readJson<T = unknown>(path: string): Promise<T>;
 export declare function readJsonSync(path: string, parse: false): string;
 export declare function readJsonSync<T = unknown>(path: string, parse?: true): T;
+export declare function mapValues<T extends Record<string, any>, TResult>(obj: {
+    [P in keyof T]: T[P];
+}, fn: (i: T[keyof T], k: keyof T) => TResult): {
+    [P in keyof T]: TResult;
+};
 export {};