@oclif/core 3.0.0-beta.9 → 3.0.1

package/lib/parser/validate.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validate = void 0;
+const util_1 = require("../util/util");
 const errors_1 = require("./errors");
-const util_1 = require("../config/util");
 async function validate(parse) {
     let cachedResolvedFlags;
     function validateArgs() {
         if (parse.output.nonExistentFlags?.length > 0) {
-            throw new errors_1.NonExistentFlagsError({ parse, flags: parse.output.nonExistentFlags });
+            throw new errors_1.NonExistentFlagsError({ flags: parse.output.nonExistentFlags, parse });
         }
         const maxArgs = Object.keys(parse.input.args).length;
         if (parse.input.strict && parse.output.argv.length > maxArgs) {
             const extras = parse.output.argv.slice(maxArgs);
-            throw new errors_1.UnexpectedArgsError({ parse, args: extras });
+            throw new errors_1.UnexpectedArgsError({ args: extras, parse });
         }
         const missingRequiredArgs = [];
         let hasOptional = false;
@@ -23,7 +23,7 @@ async function validate(parse) {
             else if (hasOptional) {
                 // (required arg) check whether an optional has occurred before
                 // optionals should follow required, not before
-                throw new errors_1.InvalidArgsSpecError({ parse, args: parse.input.args });
+                throw new errors_1.InvalidArgsSpecError({ args: parse.input.args, parse });
             }
             if (arg.required && !parse.output.args[name] && parse.output.args[name] !== 0) {
                 missingRequiredArgs.push(arg);
@@ -33,31 +33,31 @@ async function validate(parse) {
             const flagsWithMultiple = Object.entries(parse.input.flags)
                 .filter(([_, flagDef]) => flagDef.type === 'option' && Boolean(flagDef.multiple))
                 .map(([name]) => name);
-            throw new errors_1.RequiredArgsError({ parse, args: missingRequiredArgs, flagsWithMultiple });
+            throw new errors_1.RequiredArgsError({ args: missingRequiredArgs, flagsWithMultiple, parse });
         }
     }
     async function validateFlags() {
         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) {
-                return [{ status: 'failed', name, validationFn: 'required', reason: `Missing required flag ${name}` }];
+                return [{ name, reason: `Missing required flag ${name}`, status: 'failed', validationFn: 'required' }];
             }
             if (flag.exactlyOne && flag.exactlyOne.length > 0) {
                 return [validateAcrossFlags(flag)];
             }
             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 });
+            throw new errors_1.FailedFlagValidationError({ failed, parse });
     }
     async function resolveFlags(flags) {
         if (cachedResolvedFlags)
@@ -70,21 +70,21 @@ 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, util_1.uniq)(flag.exactlyOne?.map((flag) => `--${flag}`) ?? []).join(', ');
             const reason = `Exactly one of the following must be provided: ${deduped}`;
-            return { ...base, status: 'failed', reason };
+            return { ...base, reason, status: 'failed' };
         }
         return { ...base, status: 'success' };
     }
@@ -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,
+                    reason: `--${flag}=${flagValue} cannot also be provided when using --${name}`,
+                    status: 'failed',
+                };
             }
         }
         return { ...base, status: 'success' };
@@ -111,7 +115,7 @@ async function validate(parse) {
         const keys = getPresentFlags(resolved);
         for (const flag of keys) {
             if (flag !== name && parse.output.flags[flag] !== undefined) {
-                return { ...base, status: 'failed', reason: `--${flag} cannot also be provided when using --${name}` };
+                return { ...base, reason: `--${flag} cannot also be provided when using --${name}`, status: 'failed' };
             }
         }
         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,
+                reason: `All of the following must be provided when using --${name}: ${formattedFlags}`,
+                status: 'failed',
+            };
         }
         return { ...base, status: 'success' };
     }
@@ -131,24 +141,34 @@ 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,
+                reason: `One of the following must be provided when using --${name}: ${formattedFlags}`,
+                status: 'failed',
+            };
         }
         return { ...base, status: 'success' };
     }
     function validateRelationships(name, flag) {
-        return ((flag.relationships ?? []).map(relationship => {
+        return (flag.relationships ?? []).map((relationship) => {
             switch (relationship.type) {
-                case 'all':
+                case 'all': {
                     return validateDependsOn(name, relationship.flags);
-                case 'some':
+                }
+                case 'some': {
                     return validateSome(name, relationship.flags);
-                case 'none':
+                }
+                case 'none': {
                     return validateExclusive(name, relationship.flags);
-                default:
+                }
+                default: {
                     throw new Error(`Unknown relationship type: ${relationship.type}`);
+                }
             }
-        }));
+        });
     }
     validateArgs();
     return validateFlags();

package/lib/performance.d.ts

@@ -1,53 +1,50 @@
-type Details = Record<string, string | boolean | number | string[]>;
+type Details = Record<string, boolean | number | string | string[]>;
 type PerfResult = {
-    name: string;
-    duration: number;
     details: Details;
-    module: string;
+    duration: number;
     method: string | undefined;
+    module: string;
+    name: string;
     scope: string | undefined;
 };
 type PerfHighlights = {
-    configLoadTime: number;
-    runTime: number;
-    initTime: number;
-    commandLoadTime: number;
-    pluginLoadTimes: Record<string, number>;
-    corePluginsLoadTime: number;
-    userPluginsLoadTime: number;
-    linkedPluginsLoadTime: number;
     hookRunTimes: Record<string, Record<string, number>>;
+    'oclif.commandLoadMs': number;
+    'oclif.commandRunMs': number;
+    'oclif.configLoadMs': number;
+    'oclif.corePluginsLoadMs': number;
+    'oclif.initHookMs': number;
+    'oclif.initMs': number;
+    'oclif.linkedPluginsLoadMs': number;
+    'oclif.postrunHookMs': number;
+    'oclif.prerunHookMs': number;
+    'oclif.runMs': number;
+    'oclif.userPluginsLoadMs': number;
+    pluginLoadTimes: Record<string, {
+        details: Details;
+        duration: number;
+    }>;
 };
+export declare const OCLIF_MARKER_OWNER = "@oclif/core";
 declare class Marker {
+    owner: string;
     name: string;
     details: Details;
-    module: string;
+    private startMarker;
+    private stopMarker;
     method: string;
+    module: string;
     scope: string;
     stopped: boolean;
-    private startMarker;
-    private stopMarker;
-    constructor(name: string, details?: Details);
+    constructor(owner: string, name: string, details?: Details);
     addDetails(details: Details): void;
-    stop(): void;
     measure(): void;
+    stop(): void;
 }
-export default class Performance {
-    private static markers;
+export declare class Performance {
+    private static _oclifPerf;
     private static _results;
-    private static _highlights;
-    static get enabled(): boolean;
-    static get results(): PerfResult[];
-    static getResult(name: string): PerfResult | undefined;
-    static get highlights(): PerfHighlights;
-    /**
-     * Add a new performance marker
-     *
-     * @param name Name of the marker. Use `module.method#scope` format
-     * @param details Arbitrary details to attach to the marker
-     * @returns Marker instance
-     */
-    static mark(name: string, details?: Details): Marker | undefined;
+    private static markers;
     /**
      * Collect performance results into static Performance.results
      *
@@ -59,5 +56,19 @@ export default class Performance {
      * @returns void
      */
     static debug(): void;
+    static get enabled(): boolean;
+    static getResult(owner: string, name: string): PerfResult | undefined;
+    /**
+     * Add a new performance marker
+     *
+     * @param owner An npm package like `@oclif/core` or `@salesforce/source-tracking`
+     * @param name Name of the marker. Use `module.method#scope` format
+     * @param details Arbitrary details to attach to the marker
+     * @returns Marker instance
+     */
+    static mark(owner: string, name: string, details?: Details): Marker | undefined;
+    static get oclifPerf(): PerfHighlights | Record<string, never>;
+    /** returns a map of owner, PerfResult[].  Excludes oclif PerfResult, which you can get from oclifPerf */
+    static get results(): Map<string, PerfResult[]>;
 }
 export {};

package/lib/performance.js

@@ -1,12 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const perf_hooks_1 = require("perf_hooks");
+exports.Performance = exports.OCLIF_MARKER_OWNER = void 0;
+const node_perf_hooks_1 = require("node:perf_hooks");
 const settings_1 = require("./settings");
+exports.OCLIF_MARKER_OWNER = '@oclif/core';
 class Marker {
-    constructor(name, details = {}) {
+    owner;
+    name;
+    details;
+    startMarker;
+    stopMarker;
+    method;
+    module;
+    scope;
+    stopped = false;
+    constructor(owner, name, details = {}) {
+        this.owner = owner;
         this.name = name;
         this.details = details;
-        this.stopped = false;
         this.startMarker = `${this.name}-start`;
         this.stopMarker = `${this.name}-stop`;
         const [caller, scope] = name.split('#');
@@ -14,54 +25,25 @@ class Marker {
         this.module = module;
         this.method = method;
         this.scope = scope;
-        perf_hooks_1.performance.mark(this.startMarker);
+        node_perf_hooks_1.performance.mark(this.startMarker);
     }
     addDetails(details) {
         this.details = { ...this.details, ...details };
     }
+    measure() {
+        node_perf_hooks_1.performance.measure(this.name, this.startMarker, this.stopMarker);
+    }
     stop() {
         this.stopped = true;
-        perf_hooks_1.performance.mark(this.stopMarker);
-    }
-    measure() {
-        perf_hooks_1.performance.measure(this.name, this.startMarker, this.stopMarker);
+        node_perf_hooks_1.performance.mark(this.stopMarker);
     }
 }
 class Performance {
-    static get enabled() {
-        return settings_1.default.performanceEnabled ?? false;
-    }
-    static get results() {
-        if (!Performance.enabled)
-            return [];
-        if (Performance._results.length > 0)
-            return Performance._results;
-        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);
-    }
-    static get highlights() {
-        if (!Performance.enabled)
-            return {};
-        if (Performance._highlights)
-            return Performance._highlights;
-        throw new Error('Perf results not available. Did you forget to call await Performance.collect()?');
-    }
-    /**
-     * Add a new performance marker
-     *
-     * @param name Name of the marker. Use `module.method#scope` format
-     * @param details Arbitrary details to attach to the marker
-     * @returns Marker instance
-     */
-    static mark(name, details = {}) {
-        if (!Performance.enabled)
-            return;
-        const marker = new Marker(name, details);
-        Performance.markers[marker.name] = marker;
-        return marker;
-    }
+    static _oclifPerf;
+    /* Key: marker.owner */
+    static _results = new Map();
+    /* Key: marker.name */
+    static markers = new Map();
     /**
      * Collect performance results into static Performance.results
      *
@@ -70,36 +52,41 @@ class Performance {
     static async collect() {
         if (!Performance.enabled)
             return;
-        if (Performance._results.length > 0)
+        if (Performance._results.size > 0)
             return;
-        const markers = Object.values(Performance.markers);
+        const markers = [...Performance.markers.values()];
         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 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];
-                        Performance._results.push({
-                            name: entry.name,
-                            module: marker.module,
+                    const marker = Performance.markers.get(entry.name);
+                    if (marker) {
+                        const result = {
+                            details: marker.details,
+                            duration: entry.duration,
                             method: marker.method,
+                            module: marker.module,
+                            name: entry.name,
                             scope: marker.scope,
-                            duration: entry.duration,
-                            details: marker.details,
-                        });
+                        };
+                        const existing = Performance._results.get(marker.owner) ?? [];
+                        Performance._results.set(marker.owner, [...existing, result]);
                     }
                 }
-                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
+                const oclifResults = Performance._results.get(exports.OCLIF_MARKER_OWNER) ?? [];
+                const command = oclifResults.find((r) => r.name.startsWith('config.runCommand'));
+                const commandLoadTime = command
+                    ? Performance.getResult(exports.OCLIF_MARKER_OWNER, `plugin.findCommand#${command.details.plugin}.${command.details.command}`)?.duration ?? 0
+                    : 0;
+                const pluginLoadTimes = Object.fromEntries(oclifResults
                     .filter(({ name }) => name.startsWith('plugin.load#'))
                     .sort((a, b) => b.duration - a.duration)
-                    .map(({ scope, duration }) => [scope, duration]));
-                const hookRunTimes = Performance.results
+                    .map(({ details, duration, scope }) => [scope, { details, duration }]));
+                const hookRunTimes = oclifResults
                     .filter(({ name }) => name.startsWith('config.runHook#'))
                     .reduce((acc, perfResult) => {
                     const event = perfResult.details.event;
@@ -116,24 +103,28 @@ class Performance {
                     }
                     return acc;
                 }, {});
-                const pluginLoadTimeByType = Object.fromEntries(Performance.results
+                const pluginLoadTimeByType = Object.fromEntries(oclifResults
                     .filter(({ name }) => name.startsWith('config.loadPlugins#'))
                     .sort((a, b) => b.duration - a.duration)
-                    .map(({ scope, duration }) => [scope, duration]));
-                Performance._highlights = {
-                    configLoadTime: Performance.getResult('config.load')?.duration ?? 0,
-                    runTime: Performance.getResult('main.run')?.duration ?? 0,
-                    initTime: Performance.getResult('main.run#init')?.duration ?? 0,
-                    commandLoadTime,
-                    pluginLoadTimes,
+                    .map(({ duration, scope }) => [scope, duration]));
+                Performance._oclifPerf = {
                     hookRunTimes,
-                    corePluginsLoadTime: pluginLoadTimeByType.core ?? 0,
-                    userPluginsLoadTime: pluginLoadTimeByType.user ?? 0,
-                    linkedPluginsLoadTime: pluginLoadTimeByType.link ?? 0,
+                    'oclif.commandLoadMs': commandLoadTime,
+                    'oclif.commandRunMs': oclifResults.find(({ name }) => name.startsWith('config.runCommand#'))?.duration ?? 0,
+                    'oclif.configLoadMs': Performance.getResult(exports.OCLIF_MARKER_OWNER, 'config.load')?.duration ?? 0,
+                    'oclif.corePluginsLoadMs': pluginLoadTimeByType.core ?? 0,
+                    'oclif.initHookMs': hookRunTimes.init?.total ?? 0,
+                    'oclif.initMs': Performance.getResult(exports.OCLIF_MARKER_OWNER, 'main.run#init')?.duration ?? 0,
+                    'oclif.linkedPluginsLoadMs': pluginLoadTimeByType.link ?? 0,
+                    'oclif.postrunHookMs': hookRunTimes.postrun?.total ?? 0,
+                    'oclif.prerunHookMs': hookRunTimes.prerun?.total ?? 0,
+                    'oclif.runMs': Performance.getResult(exports.OCLIF_MARKER_OWNER, 'main.run')?.duration ?? 0,
+                    'oclif.userPluginsLoadMs': pluginLoadTimeByType.user ?? 0,
+                    pluginLoadTimes,
                 };
                 resolve();
             });
-            perfObserver.observe({ entryTypes: ['measure'], buffered: true });
+            perfObserver.observe({ buffered: true, entryTypes: ['measure'] });
             for (const marker of markers) {
                 try {
                     marker.measure();
@@ -142,7 +133,7 @@ class Performance {
                     // ignore
                 }
             }
-            perf_hooks_1.performance.clearMarks();
+            node_perf_hooks_1.performance.clearMarks();
         });
     }
     /**
@@ -152,27 +143,78 @@ class Performance {
     static debug() {
         if (!Performance.enabled)
             return;
-        const debug = require('debug')('perf');
-        debug('Init Time: %sms', Performance.highlights.initTime.toFixed(4));
-        debug('Config Load Time: %sms', Performance.highlights.configLoadTime.toFixed(4));
-        debug('Command Load Time: %sms', Performance.highlights.commandLoadTime.toFixed(4));
-        debug('Execution Time: %sms', Performance.highlights.runTime.toFixed(4));
-        debug('Core Plugin Load Time: %sms', Performance.highlights.corePluginsLoadTime.toFixed(4));
-        debug('User Plugin Load Time: %sms', Performance.highlights.userPluginsLoadTime.toFixed(4));
-        debug('Linked Plugin Load Time: %sms', Performance.highlights.linkedPluginsLoadTime.toFixed(4));
-        debug('Plugin Load Times:');
-        for (const [plugin, duration] of Object.entries(Performance.highlights.pluginLoadTimes)) {
-            debug(`  ${plugin}: ${duration.toFixed(4)}ms`);
+        const oclifDebug = require('debug')('oclif-perf');
+        oclifDebug('Total Time: %sms', Performance.oclifPerf['oclif.runMs'].toFixed(4));
+        oclifDebug('Init Time: %sms', Performance.oclifPerf['oclif.initMs'].toFixed(4));
+        oclifDebug('Config Load Time: %sms', Performance.oclifPerf['oclif.configLoadMs'].toFixed(4));
+        oclifDebug('  • Plugins Load Time: %sms', Performance.getResult(exports.OCLIF_MARKER_OWNER, 'config.loadAllPlugins')?.duration.toFixed(4) ?? 0);
+        oclifDebug('  • Commands Load Time: %sms', Performance.getResult(exports.OCLIF_MARKER_OWNER, 'config.loadAllCommands')?.duration.toFixed(4) ?? 0);
+        oclifDebug('Core Plugin Load Time: %sms', Performance.oclifPerf['oclif.corePluginsLoadMs'].toFixed(4));
+        oclifDebug('User Plugin Load Time: %sms', Performance.oclifPerf['oclif.userPluginsLoadMs'].toFixed(4));
+        oclifDebug('Linked Plugin Load Time: %sms', Performance.oclifPerf['oclif.linkedPluginsLoadMs'].toFixed(4));
+        oclifDebug('Plugin Load Times:');
+        for (const [plugin, result] of Object.entries(Performance.oclifPerf.pluginLoadTimes)) {
+            if (result.details.hasManifest) {
+                oclifDebug(`  ${plugin}: ${result.duration.toFixed(4)}ms`);
+            }
+            else {
+                oclifDebug(`  ${plugin}: ${result.duration.toFixed(4)}ms (no manifest!)`);
+            }
         }
-        debug('Hook Run Times:');
-        for (const [event, runTimes] of Object.entries(Performance.highlights.hookRunTimes)) {
-            debug(`  ${event}:`);
+        oclifDebug('Hook Run Times:');
+        for (const [event, runTimes] of Object.entries(Performance.oclifPerf.hookRunTimes)) {
+            oclifDebug(`  ${event}:`);
             for (const [plugin, duration] of Object.entries(runTimes)) {
-                debug(`    ${plugin}: ${duration.toFixed(4)}ms`);
+                oclifDebug(`    ${plugin}: ${duration.toFixed(4)}ms`);
+            }
+        }
+        oclifDebug('Command Load Time: %sms', Performance.oclifPerf['oclif.commandLoadMs'].toFixed(4));
+        oclifDebug('Command Run Time: %sms', Performance.oclifPerf['oclif.commandRunMs'].toFixed(4));
+        const nonCoreDebug = require('debug')('non-oclif-perf');
+        const nonCorePerf = Performance.results;
+        if (nonCorePerf.size > 0) {
+            nonCoreDebug('Non-Core Performance Measurements:');
+            for (const [owner, results] of nonCorePerf) {
+                nonCoreDebug(`  ${owner}:`);
+                for (const result of results) {
+                    nonCoreDebug(`    ${result.name}: ${result.duration.toFixed(4)}ms`);
+                }
             }
         }
     }
+    static get enabled() {
+        return settings_1.settings.performanceEnabled ?? false;
+    }
+    static getResult(owner, name) {
+        return Performance._results.get(owner)?.find((r) => r.name === name);
+    }
+    /**
+     * Add a new performance marker
+     *
+     * @param owner An npm package like `@oclif/core` or `@salesforce/source-tracking`
+     * @param name Name of the marker. Use `module.method#scope` format
+     * @param details Arbitrary details to attach to the marker
+     * @returns Marker instance
+     */
+    static mark(owner, name, details = {}) {
+        if (!Performance.enabled)
+            return;
+        const marker = new Marker(owner, name, details);
+        Performance.markers.set(marker.name, marker);
+        return marker;
+    }
+    static get oclifPerf() {
+        if (!Performance.enabled)
+            return {};
+        if (Performance._oclifPerf)
+            return Performance._oclifPerf;
+        throw new Error('Perf results not available. Did you forget to call await Performance.collect()?');
+    }
+    /** returns a map of owner, PerfResult[].  Excludes oclif PerfResult, which you can get from oclifPerf */
+    static get results() {
+        if (!Performance.enabled)
+            return new Map();
+        return new Map([...Performance._results.entries()].filter(([owner]) => owner !== exports.OCLIF_MARKER_OWNER));
+    }
 }
-exports.default = Performance;
-Performance.markers = {};
-Performance._results = [];
+exports.Performance = Performance;

package/lib/screen.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errtermwidth = exports.stdtermwidth = void 0;
-const stream_1 = require("./ux/stream");
+const stream_1 = require("./cli-ux/stream");
 const settings_1 = require("./settings");
 function termwidth(stream) {
     if (!stream.isTTY) {
@@ -16,6 +16,6 @@ function termwidth(stream) {
     }
     return width;
 }
-const columns = Number.parseInt(process.env.OCLIF_COLUMNS, 10) || settings_1.default.columns;
+const columns = Number.parseInt(process.env.OCLIF_COLUMNS, 10) || settings_1.settings.columns;
 exports.stdtermwidth = columns || termwidth(stream_1.stdout);
 exports.errtermwidth = columns || termwidth(stream_1.stderr);

package/lib/settings.d.ts

@@ -1,4 +1,11 @@
 export type Settings = {
+    /**
+     * Set the terminal width to a specified number of columns (characters)
+     *
+     * Environment Variable:
+     *   OCLIF_COLUMNS=80
+     */
+    columns?: number;
     /**
      * Show additional debug output without DEBUG. Mainly shows stackstraces.
      *
@@ -13,12 +20,10 @@ export type Settings = {
      */
     errlog?: string;
     /**
-     * Set the terminal width to a specified number of columns (characters)
-     *
-     * Environment Variable:
-     *   OCLIF_COLUMNS=80
+     * Enable performance tracking. Resulting data is available in the `perf` property of the `Config` class.
+     * This will be overridden by the `enablePerf` property passed into Config constructor.
      */
-    columns?: number;
+    performanceEnabled?: boolean;
     /**
      * Try to use ts-node to load typescript source files instead of
      * javascript files.
@@ -30,11 +35,5 @@ export type Settings = {
      *   NODE_ENV=development
      */
     tsnodeEnabled?: boolean;
-    /**
-     * Enable performance tracking. Resulting data is available in the `perf` property of the `Config` class.
-     * This will be overridden by the `enablePerf` property passed into Config constructor.
-     */
-    performanceEnabled?: boolean;
 };
-declare const settings: Settings;
-export default settings;
+export declare const settings: Settings;

package/lib/settings.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.settings = void 0;
 // Set global.oclif to the new object if it wasn't set before
 if (!global.oclif)
     global.oclif = {};
-const settings = global.oclif;
-exports.default = settings;
+exports.settings = global.oclif;

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>;