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

package/lib/help/index.js

@@ -1,22 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Help = exports.HelpBase = exports.normalizeArgv = exports.getHelpFlagAdditions = exports.loadHelpClass = exports.standardizeIDFromArgv = exports.CommandHelp = void 0;
+exports.loadHelpClass = exports.Help = exports.HelpBase = exports.normalizeArgv = exports.getHelpFlagAdditions = exports.standardizeIDFromArgv = exports.CommandHelp = void 0;
 const tslib_1 = require("tslib");
 const util_1 = require("../util");
 const util_2 = require("./util");
 const command_1 = require("./command");
 const formatter_1 = require("./formatter");
 const root_1 = tslib_1.__importDefault(require("./root"));
+const cache_default_value_1 = require("../util/cache-default-value");
 const errors_1 = require("../errors");
 const node_util_1 = require("node:util");
+const module_loader_1 = require("../module-loader");
 const stream_1 = require("../cli-ux/stream");
-const config_1 = require("../config/config");
-const stripAnsi = require("strip-ansi");
+const strip_ansi_1 = tslib_1.__importDefault(require("strip-ansi"));
 var command_2 = require("./command");
 Object.defineProperty(exports, "CommandHelp", { enumerable: true, get: function () { return command_2.CommandHelp; } });
 var util_3 = require("./util");
 Object.defineProperty(exports, "standardizeIDFromArgv", { enumerable: true, get: function () { return util_3.standardizeIDFromArgv; } });
-Object.defineProperty(exports, "loadHelpClass", { enumerable: true, get: function () { return util_3.loadHelpClass; } });
 Object.defineProperty(exports, "getHelpFlagAdditions", { enumerable: true, get: function () { return util_3.getHelpFlagAdditions; } });
 Object.defineProperty(exports, "normalizeArgv", { enumerable: true, get: function () { return util_3.normalizeArgv; } });
 function getHelpSubject(args, config) {
@@ -41,6 +41,7 @@ class HelpBase extends formatter_1.HelpFormatter {
 }
 exports.HelpBase = HelpBase;
 class Help extends HelpBase {
+    CommandHelpClass = command_1.CommandHelp;
     /*
      * _topics is to work around Interfaces.topics mistakenly including commands that do
      * not have children, as well as topics. A topic has children, either commands or other topics. When
@@ -70,7 +71,6 @@ class Help extends HelpBase {
     }
     constructor(config, opts = {}) {
         super(config, opts);
-        this.CommandHelpClass = command_1.CommandHelp;
     }
     async showHelp(argv) {
         const originalArgv = argv.slice(1);
@@ -92,8 +92,14 @@ class Help extends HelpBase {
         const command = this.config.findCommand(subject);
         if (command) {
             if (command.hasDynamicHelp && command.pluginType !== 'jit') {
-                const dynamicCommand = await (0, config_1.toCached)(await command.load());
-                await this.showCommandHelp(dynamicCommand);
+                const loaded = await command.load();
+                for (const [name, flag] of Object.entries(loaded.flags)) {
+                    if (flag.type === 'boolean' || !command.flags[name].hasDynamicHelp)
+                        continue;
+                    // eslint-disable-next-line no-await-in-loop
+                    command.flags[name].default = await (0, cache_default_value_1.cacheDefaultValue)(flag, false);
+                }
+                await this.showCommandHelp(command);
             }
             else {
                 await this.showCommandHelp(command);
@@ -251,7 +257,7 @@ class Help extends HelpBase {
             description && this.section('DESCRIPTION', this.wrap(description)),
         ]).join('\n\n');
         if (this.opts.stripAnsi)
-            output = stripAnsi(output);
+            output = (0, strip_ansi_1.default)(output);
         return output + '\n';
     }
     formatTopics(topics) {
@@ -279,3 +285,21 @@ class Help extends HelpBase {
     }
 }
 exports.Help = Help;
+function extractClass(exported) {
+    return exported && exported.default ? exported.default : exported;
+}
+async function loadHelpClass(config) {
+    const { pjson } = config;
+    const configuredClass = pjson.oclif?.helpClass;
+    if (configuredClass) {
+        try {
+            const exported = await (0, module_loader_1.load)(config, configuredClass);
+            return extractClass(exported);
+        }
+        catch (error) {
+            throw new Error(`Unable to load configured help class "${configuredClass}", failed with message:\n${error.message}`);
+        }
+    }
+    return Help;
+}
+exports.loadHelpClass = loadHelpClass;

package/lib/help/root.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 const formatter_1 = require("./formatter");
 const util_1 = require("../util");
-const stripAnsi = require("strip-ansi");
+const strip_ansi_1 = tslib_1.__importDefault(require("strip-ansi"));
 class RootHelp extends formatter_1.HelpFormatter {
+    config;
+    opts;
     constructor(config, opts) {
         super(config, opts);
         this.config = config;
@@ -20,7 +23,7 @@ class RootHelp extends formatter_1.HelpFormatter {
             this.description(),
         ]).join('\n\n');
         if (this.opts.stripAnsi)
-            output = stripAnsi(output);
+            output = (0, strip_ansi_1.default)(output);
         return output;
     }
     usage() {

package/lib/help/util.d.ts

@@ -1,9 +1,4 @@
-import { Deprecation, HelpOptions, Config as IConfig } from '../interfaces';
-import { HelpBase } from '.';
-interface HelpBaseDerived {
-    new (config: IConfig, opts?: Partial<HelpOptions>): HelpBase;
-}
-export declare function loadHelpClass(config: IConfig): Promise<HelpBaseDerived>;
+import { Deprecation, Config as IConfig } from '../interfaces';
 export declare function template(context: any): (t: string) => string;
 export declare function toStandardizedId(commandID: string, config: IConfig): string;
 export declare function toConfiguredId(commandID: string, config: IConfig): string;
@@ -12,4 +7,3 @@ export declare function getHelpFlagAdditions(config: IConfig): string[];
 export declare function formatFlagDeprecationWarning(flag: string, opts: true | Deprecation): string;
 export declare function formatCommandDeprecationWarning(command: string, opts?: Deprecation): string;
 export declare function normalizeArgv(config: IConfig, argv?: string[]): string[];
-export {};

package/lib/help/util.js

@@ -1,29 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeArgv = exports.formatCommandDeprecationWarning = exports.formatFlagDeprecationWarning = exports.getHelpFlagAdditions = exports.standardizeIDFromArgv = exports.toConfiguredId = exports.toStandardizedId = exports.template = exports.loadHelpClass = void 0;
+exports.normalizeArgv = exports.formatCommandDeprecationWarning = exports.formatFlagDeprecationWarning = exports.getHelpFlagAdditions = exports.standardizeIDFromArgv = exports.toConfiguredId = exports.toStandardizedId = exports.template = void 0;
 const tslib_1 = require("tslib");
 const ejs = tslib_1.__importStar(require("ejs"));
-const _1 = require(".");
 const util_1 = require("../config/util");
-const module_loader_1 = require("../module-loader");
-function extractClass(exported) {
-    return exported && exported.default ? exported.default : exported;
-}
-async function loadHelpClass(config) {
-    const { pjson } = config;
-    const configuredClass = pjson && pjson.oclif && pjson.oclif.helpClass;
-    if (configuredClass) {
-        try {
-            const exported = await (0, module_loader_1.load)(config, configuredClass);
-            return extractClass(exported);
-        }
-        catch (error) {
-            throw new Error(`Unable to load configured help class "${configuredClass}", failed with message:\n${error.message}`);
-        }
-    }
-    return _1.Help;
-}
-exports.loadHelpClass = loadHelpClass;
 function template(context) {
     function render(t) {
         return ejs.render(t, context);

package/lib/index.d.ts

@@ -1,11 +1,11 @@
 export * as Args from './args';
 export * as Errors from './errors';
-export * as Flags from './flags';
 export * as Interfaces from './interfaces';
+export * as Flags from './flags';
 export * as Parser from './parser';
 export * as ux from './cli-ux';
 export { CommandHelp, HelpBase, Help, loadHelpClass } from './help';
-export { Config, toCached, Plugin, tsPath } from './config';
+export { Config, Plugin, tsPath } from './config';
 export { HelpSection, HelpSectionRenderer, HelpSectionKeyValueTable } from './help/formatter';
 export { Settings, settings } from './settings';
 export { stdout, stderr } from './cli-ux/stream';

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = exports.handle = exports.flush = exports.execute = exports.Performance = exports.Command = exports.toStandardizedId = exports.toConfiguredId = exports.stderr = exports.stdout = exports.settings = exports.tsPath = exports.Plugin = exports.toCached = exports.Config = exports.loadHelpClass = exports.Help = exports.HelpBase = exports.CommandHelp = exports.ux = exports.Parser = exports.Interfaces = exports.Flags = exports.Errors = exports.Args = void 0;
+exports.run = exports.handle = exports.flush = exports.execute = exports.Performance = exports.Command = exports.toStandardizedId = exports.toConfiguredId = exports.stderr = exports.stdout = exports.settings = exports.tsPath = exports.Plugin = exports.Config = exports.loadHelpClass = exports.Help = exports.HelpBase = exports.CommandHelp = exports.ux = exports.Parser = exports.Flags = exports.Interfaces = exports.Errors = exports.Args = void 0;
 const tslib_1 = require("tslib");
 const stream_1 = require("./cli-ux/stream");
 function checkCWD() {
@@ -16,8 +16,8 @@ function checkCWD() {
 checkCWD();
 exports.Args = tslib_1.__importStar(require("./args"));
 exports.Errors = tslib_1.__importStar(require("./errors"));
-exports.Flags = tslib_1.__importStar(require("./flags"));
 exports.Interfaces = tslib_1.__importStar(require("./interfaces"));
+exports.Flags = tslib_1.__importStar(require("./flags"));
 exports.Parser = tslib_1.__importStar(require("./parser"));
 exports.ux = tslib_1.__importStar(require("./cli-ux"));
 var help_1 = require("./help");
@@ -27,7 +27,6 @@ Object.defineProperty(exports, "Help", { enumerable: true, get: function () { re
 Object.defineProperty(exports, "loadHelpClass", { enumerable: true, get: function () { return help_1.loadHelpClass; } });
 var config_1 = require("./config");
 Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
-Object.defineProperty(exports, "toCached", { enumerable: true, get: function () { return config_1.toCached; } });
 Object.defineProperty(exports, "Plugin", { enumerable: true, get: function () { return config_1.Plugin; } });
 Object.defineProperty(exports, "tsPath", { enumerable: true, get: function () { return config_1.tsPath; } });
 var settings_1 = require("./settings");

package/lib/interfaces/parser.d.ts

@@ -161,12 +161,6 @@ export type FlagProps = {
      * Emit deprecation warning when a flag alias is provided
      */
     deprecateAliases?: boolean;
-    /**
-     * Delimiter to separate the values for a multiple value flag.
-     * Only respected if multiple is set to true. Default behavior is to
-     * separate on spaces.
-     */
-    delimiter?: ',';
     /**
      * If true, the value returned by defaultHelp will not be cached in the oclif.manifest.json.
      * This is helpful if the default value contains sensitive data that shouldn't be published to npm.
@@ -206,6 +200,12 @@ export type OptionFlagProps = FlagProps & {
     helpValue?: string;
     options?: readonly string[];
     multiple?: boolean;
+    /**
+   * Delimiter to separate the values for a multiple value flag.
+   * Only respected if multiple is set to true. Default behavior is to
+   * separate on spaces.
+   */
+    delimiter?: ',';
 };
 export type FlagParserContext = Command & {
     token: FlagToken;
@@ -238,7 +238,7 @@ export type BooleanFlag<T> = FlagProps & BooleanFlagProps & {
     parse: (input: boolean, context: FlagParserContext, opts: FlagProps & BooleanFlagProps) => Promise<T>;
 };
 export type OptionFlag<T, P = CustomOptions> = FlagProps & OptionFlagProps & {
-    parse: FlagParser<T, string, P>;
+    parse: FlagParser<T | undefined, string, P>;
     defaultHelp?: FlagDefaultHelp<T, P>;
     input: string[];
     default?: FlagDefault<T | undefined, P>;
@@ -415,6 +415,7 @@ export type Flag<T> = BooleanFlag<T> | OptionFlag<T>;
 export type Input<TFlags extends FlagOutput, BFlags extends FlagOutput, AFlags extends ArgOutput> = {
     flags?: FlagInput<TFlags>;
     baseFlags?: FlagInput<BFlags>;
+    enableJsonFlag?: true | false;
     args?: ArgInput<AFlags>;
     strict?: boolean;
     context?: ParserContext;

package/lib/interfaces/plugin.d.ts

@@ -12,6 +12,7 @@ export interface PluginOptions {
     parent?: Plugin;
     children?: Plugin[];
     flexibleTaxonomy?: boolean;
+    isRoot?: boolean;
 }
 export interface Options extends PluginOptions {
     devPlugins?: boolean;
@@ -69,6 +70,10 @@ export interface Plugin {
      * if it appears to be an npm package but does not look like it's really a CLI plugin, this is set to false
      */
     valid: boolean;
+    /**
+     * True if the plugin is the root plugin.
+     */
+    isRoot: boolean;
     commands: Command.Loadable[];
     hooks: {
         [k: string]: string[];

package/lib/module-loader.js

@@ -5,7 +5,7 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const errors_1 = require("./errors");
 const node_url_1 = require("node:url");
-const config_1 = require("./config");
+const ts_node_1 = require("./config/ts-node");
 const getPackageType = require('get-package-type');
 /**
  * Defines file extension resolution when source files do not have an extension.
@@ -160,7 +160,7 @@ function resolvePath(config, modulePath) {
         isESM = isPathModule(filePath);
     }
     catch {
-        filePath = (isPlugin(config) ? (0, config_1.tsPath)(config.root, modulePath, config) : (0, config_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.js

@@ -10,6 +10,7 @@ const util_1 = require("../util");
 var errors_2 = require("../errors");
 Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return errors_2.CLIError; } });
 class CLIParseError extends errors_1.CLIError {
+    parse;
     constructor(options) {
         options.message += '\nSee more help with --help';
         super(options.message);
@@ -18,6 +19,7 @@ class CLIParseError extends errors_1.CLIError {
 }
 exports.CLIParseError = CLIParseError;
 class InvalidArgsSpecError extends CLIParseError {
+    args;
     constructor({ args, parse }) {
         let message = 'Invalid argument spec';
         const namedArgs = Object.values(args).filter(a => a.name);
@@ -31,6 +33,7 @@ class InvalidArgsSpecError extends CLIParseError {
 }
 exports.InvalidArgsSpecError = InvalidArgsSpecError;
 class RequiredArgsError extends CLIParseError {
+    args;
     constructor({ args, parse, flagsWithMultiple }) {
         let message = `Missing ${args.length} required arg${args.length === 1 ? '' : 's'}`;
         const namedArgs = args.filter(a => a.name);
@@ -49,6 +52,7 @@ class RequiredArgsError extends CLIParseError {
 }
 exports.RequiredArgsError = RequiredArgsError;
 class RequiredFlagError extends CLIParseError {
+    flag;
     constructor({ flag, parse }) {
         const usage = (0, list_1.renderList)((0, help_1.flagUsages)([flag], { displayRequired: false }));
         const message = `Missing required flag:\n${usage}`;
@@ -58,6 +62,7 @@ class RequiredFlagError extends CLIParseError {
 }
 exports.RequiredFlagError = RequiredFlagError;
 class UnexpectedArgsError extends CLIParseError {
+    args;
     constructor({ parse, args }) {
         const message = `Unexpected argument${args.length === 1 ? '' : 's'}: ${args.join(', ')}`;
         super({ parse, message });
@@ -66,6 +71,7 @@ class UnexpectedArgsError extends CLIParseError {
 }
 exports.UnexpectedArgsError = UnexpectedArgsError;
 class NonExistentFlagsError extends CLIParseError {
+    flags;
     constructor({ parse, flags }) {
         const message = `Nonexistent flag${flags.length === 1 ? '' : 's'}: ${flags.join(', ')}`;
         super({ parse, message });

package/lib/parser/parse.js

@@ -60,9 +60,15 @@ 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();
@@ -197,7 +203,8 @@ class Parser {
                 // 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)),

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;
     }
@@ -185,5 +195,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,15 @@
+"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,100 @@
+"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 {};

package/lib/{util.js → util/index.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readJsonSync = exports.readJson = exports.getPlatform = exports.getHomeDir = exports.uniq = exports.ensureArgObject = exports.requireJson = exports.isNotFalsy = exports.isTruthy = exports.fileExists = exports.dirExists = exports.exists = exports.capitalize = exports.sumBy = exports.maxBy = exports.isProd = exports.castArray = exports.sortBy = exports.last = exports.uniqBy = exports.compact = exports.pickBy = void 0;
+exports.mapValues = exports.readJsonSync = exports.readJson = exports.getPlatform = exports.getHomeDir = exports.uniq = exports.ensureArgObject = exports.requireJson = exports.isNotFalsy = exports.isTruthy = exports.fileExists = exports.dirExists = exports.exists = exports.capitalize = exports.sumBy = exports.maxBy = exports.isProd = exports.castArray = exports.sortBy = exports.last = exports.uniqBy = exports.compact = exports.pickBy = void 0;
 const promises_1 = require("node:fs/promises");
 const node_os_1 = require("node:os");
-const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
 const debug = require('debug');
 function pickBy(obj, fn) {
     return Object.entries(obj)
@@ -166,21 +166,10 @@ function getPlatform() {
     return (0, node_os_1.platform)();
 }
 exports.getPlatform = getPlatform;
-function readJson(path) {
+async function readJson(path) {
     debug('config')('readJson %s', path);
-    return new Promise((resolve, reject) => {
-        (0, node_fs_1.readFile)(path, 'utf8', (err, d) => {
-            try {
-                if (err)
-                    reject(err);
-                else
-                    resolve(JSON.parse(d));
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    });
+    const contents = await (0, promises_1.readFile)(path, 'utf8');
+    return JSON.parse(contents);
 }
 exports.readJson = readJson;
 function readJsonSync(path, parse = true) {
@@ -188,3 +177,11 @@ function readJsonSync(path, parse = true) {
     return parse ? JSON.parse(contents) : contents;
 }
 exports.readJsonSync = readJsonSync;
+function mapValues(obj, fn) {
+    return Object.entries(obj)
+        .reduce((o, [k, v]) => {
+        o[k] = fn(v, k);
+        return o;
+    }, {});
+}
+exports.mapValues = mapValues;