avo-cli 0.0.3 → 4.2.0.beta.2

data/payload/node_modules/@oclif/core/lib/parser/validate.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = validate;
+const util_1 = require("../util/util");
+const errors_1 = require("./errors");
+async function validate(parse) {
+    let cachedResolvedFlags;
+    function validateArgs() {
+        // Validate variadic arg constraints (definition-time checks)
+        const argEntries = Object.entries(parse.input.args);
+        const variadicIndex = argEntries.findIndex(([, arg]) => arg.multiple);
+        if (variadicIndex !== -1) {
+            // Only one variadic arg is allowed
+            const secondVariadic = argEntries.findIndex(([, arg], i) => i > variadicIndex && arg.multiple);
+            if (secondVariadic !== -1) {
+                throw new errors_1.InvalidArgsSpecError({
+                    args: parse.input.args,
+                    parse,
+                    reason: 'only one variadic arg (multiple: true) is allowed',
+                });
+            }
+            // All args before a variadic arg must be required (otherwise assignment is ambiguous)
+            for (let i = 0; i < variadicIndex; i++) {
+                if (!argEntries[i][1].required) {
+                    throw new errors_1.InvalidArgsSpecError({
+                        args: parse.input.args,
+                        parse,
+                        reason: `args before a variadic arg must be required, but "${argEntries[i][0]}" is optional`,
+                    });
+                }
+            }
+            // All args after a variadic arg must be required (otherwise assignment is ambiguous)
+            for (let i = variadicIndex + 1; i < argEntries.length; i++) {
+                if (!argEntries[i][1].required) {
+                    throw new errors_1.InvalidArgsSpecError({
+                        args: parse.input.args,
+                        parse,
+                        reason: `args after a variadic arg must be required, but "${argEntries[i][0]}" is optional`,
+                    });
+                }
+            }
+        }
+        const variadicArgFound = variadicIndex !== -1;
+        if (parse.output.nonExistentFlags?.length > 0) {
+            throw new errors_1.NonExistentFlagsError({
+                flags: parse.output.nonExistentFlags,
+                parse,
+            });
+        }
+        const maxArgs = Object.keys(parse.input.args).length;
+        const hasVariadicArg = Object.values(parse.input.args).some((arg) => arg.multiple);
+        if (parse.input.strict && !hasVariadicArg && parse.output.argv.length > maxArgs) {
+            const extras = parse.output.argv.slice(maxArgs);
+            throw new errors_1.UnexpectedArgsError({
+                args: extras,
+                parse,
+            });
+        }
+        const missingRequiredArgs = [];
+        let hasOptional = false;
+        for (const [name, arg] of Object.entries(parse.input.args)) {
+            if (!arg.required) {
+                hasOptional = true;
+            }
+            else if (hasOptional && !variadicArgFound) {
+                // (required arg) check whether an optional has occurred before
+                // optionals should follow required, not before
+                // Skip this check when a variadic arg is present, since the variadic
+                // validation above already enforces that args after a variadic are required
+                throw new errors_1.InvalidArgsSpecError({
+                    args: parse.input.args,
+                    parse,
+                });
+            }
+            // Only add if it's required and undefined. Allow falsy values like empty strings and 0.
+            if (arg.required && parse.output.args[name] === undefined) {
+                missingRequiredArgs.push(arg);
+            }
+        }
+        if (missingRequiredArgs.length > 0) {
+            const flagsWithMultiple = Object.entries(parse.input.flags)
+                .filter(([_, flagDef]) => flagDef.type === 'option' && Boolean(flagDef.multiple))
+                .map(([name]) => name);
+            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.combinable ? [validateCombinable(name, flag.combinable)] : []),
+                    ...(flag.exactlyOne ? [validateExactlyOne(name, flag.exactlyOne)] : []),
+                ];
+            }
+            if (flag.required) {
+                return [{ name, reason: `Missing required flag ${name}`, status: 'failed', validationFn: 'required' }];
+            }
+            if (flag.exactlyOne && flag.exactlyOne.length > 0) {
+                return [validateExactlyOneAcrossFlags(flag)];
+            }
+            if (flag.atLeastOne && flag.atLeastOne.length > 0) {
+                return [validateAtLeastOneAcrossFlags(flag)];
+            }
+            return [];
+        });
+        const results = await Promise.all(promises);
+        const failed = results.filter((r) => r.status === 'failed');
+        if (failed.length > 0)
+            throw new errors_1.FailedFlagValidationError({
+                failed,
+                parse,
+            });
+    }
+    function validateConstraints() {
+        if (parse.input.constraints) {
+            const validations = parse.input.constraints.map((c) => c._evaluateAgainstFlags(parse.output.flags));
+            const failed = validations.filter((v) => v.status === 'failed');
+            if (failed.length > 0) {
+                throw new errors_1.ViolatedFlagConstraintError({
+                    failed,
+                    parse,
+                });
+            }
+        }
+    }
+    async function resolveFlags(flags) {
+        if (cachedResolvedFlags)
+            return cachedResolvedFlags;
+        const promises = flags.map(async (flag) => {
+            if (typeof flag === 'string') {
+                return [flag, parse.output.flags[flag]];
+            }
+            const result = await flag.when(parse.output.flags);
+            return result ? [flag.name, parse.output.flags[flag.name]] : null;
+        });
+        const resolved = await Promise.all(promises);
+        cachedResolvedFlags = Object.fromEntries(resolved.filter((r) => r !== null));
+        return cachedResolvedFlags;
+    }
+    const getPresentFlags = (flags) => Object.keys(flags).filter((key) => key !== undefined);
+    function validateExactlyOneAcrossFlags(flag) {
+        const base = { name: flag.name, validationFn: 'validateExactlyOneAcrossFlags' };
+        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
+        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 reason = `Exactly one of the following must be provided: ${deduped}`;
+            return { ...base, reason, status: 'failed' };
+        }
+        return { ...base, status: 'success' };
+    }
+    function validateAtLeastOneAcrossFlags(flag) {
+        const base = { name: flag.name, validationFn: 'validateAtLeastOneAcrossFlags' };
+        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.atLeastOne && flag.atLeastOne.includes(flagName)); // and in the atLeastOne list
+        if (intersection.length === 0) {
+            // the command's atLeastOne may or may not include itself, so we'll use Set to add + de-dupe
+            const deduped = (0, util_1.uniq)(flag.atLeastOne?.map((flag) => `--${flag}`) ?? []).join(', ');
+            const reason = `At least one of the following must be provided: ${deduped}`;
+            return { ...base, reason, status: 'failed' };
+        }
+        return { ...base, status: 'success' };
+    }
+    async function validateExclusive(name, flags) {
+        const base = { name, validationFn: 'validateExclusive' };
+        const resolved = await resolveFlags(flags);
+        const keys = getPresentFlags(resolved);
+        for (const flag of keys) {
+            // do not enforce exclusivity for flags that were defaulted
+            if (parse.output.metadata.flags && parse.output.metadata.flags[flag]?.setFromDefault)
+                continue;
+            if (parse.output.metadata.flags && parse.output.metadata.flags[name]?.setFromDefault)
+                continue;
+            if (parse.output.flags[flag] !== undefined) {
+                const flagValue = parse.output.metadata.flags?.[flag]?.defaultHelp ?? parse.output.flags[flag];
+                return {
+                    ...base,
+                    reason: `--${flag}=${flagValue} cannot also be provided when using --${name}`,
+                    status: 'failed',
+                };
+            }
+        }
+        return { ...base, status: 'success' };
+    }
+    async function validateCombinable(name, flags) {
+        const base = { name, validationFn: 'validateCombinable' };
+        const combinableFlags = new Set(flags.map((flag) => (typeof flag === 'string' ? flag : flag.name)));
+        const resolved = await resolveFlags(flags);
+        for (const flag of Object.keys(parse.output.flags)) {
+            // do not enforce exclusivity for flags that were defaulted
+            if (parse.output.metadata.flags && parse.output.metadata.flags[flag]?.setFromDefault)
+                continue;
+            if (parse.output.metadata.flags && parse.output.metadata.flags[name]?.setFromDefault)
+                continue;
+            if (flag !== name && parse.output.flags[flag] !== undefined && !combinableFlags.has(flag)) {
+                const formattedFlags = Object.keys(resolved)
+                    .map((f) => `--${f}`)
+                    .join(', ');
+                return {
+                    ...base,
+                    reason: `Only the following can be provided when using --${name}: ${formattedFlags}`,
+                    status: 'failed',
+                };
+            }
+        }
+        return { ...base, status: 'success' };
+    }
+    async function validateExactlyOne(name, flags) {
+        const base = { name, validationFn: 'validateExactlyOne' };
+        const resolved = await resolveFlags(flags);
+        const keys = getPresentFlags(resolved);
+        for (const flag of keys) {
+            if (flag !== name && parse.output.flags[flag] !== undefined) {
+                return { ...base, reason: `--${flag} cannot also be provided when using --${name}`, status: 'failed' };
+            }
+        }
+        return { ...base, status: 'success' };
+    }
+    async function validateDependsOn(name, flags) {
+        const base = { name, validationFn: 'validateDependsOn' };
+        const resolved = await resolveFlags(flags);
+        const foundAll = Object.values(resolved).every((val) => val !== undefined);
+        if (!foundAll) {
+            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' };
+    }
+    async function validateSome(name, flags) {
+        const base = { name, validationFn: 'validateSome' };
+        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,
+                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) => {
+            switch (relationship.type) {
+                case 'all': {
+                    return validateDependsOn(name, relationship.flags);
+                }
+                case 'none': {
+                    return validateExclusive(name, relationship.flags);
+                }
+                case 'only': {
+                    return validateCombinable(name, relationship.flags);
+                }
+                case 'some': {
+                    return validateSome(name, relationship.flags);
+                }
+                default: {
+                    throw new Error(`Unknown relationship type: ${relationship.type}`);
+                }
+            }
+        });
+    }
+    validateArgs();
+    await validateFlags();
+    validateConstraints();
+}

data/payload/node_modules/@oclif/core/lib/performance.d.ts

@@ -0,0 +1,73 @@
+type Details = Record<string, boolean | number | string | string[]>;
+type PerfResult = {
+    details: Details;
+    duration: number;
+    method: string | undefined;
+    module: string;
+    name: string;
+    scope: string | undefined;
+};
+type PerfHighlights = {
+    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;
+    method: string;
+    module: string;
+    scope: string;
+    stopped: boolean;
+    private startMarker;
+    private stopMarker;
+    constructor(owner: string, name: string, details?: Details);
+    addDetails(details: Details): void;
+    measure(): void;
+    stop(): void;
+}
+export declare class Performance {
+    private static _oclifPerf;
+    private static _results;
+    private static markers;
+    /**
+     * Collect performance results into static Performance.results
+     *
+     * @returns Promise<void>
+     */
+    static collect(): Promise<void>;
+    /**
+     * Add debug logs for plugin loading performance
+     */
+    static debug(): void;
+    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 enabled(): boolean;
+    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 {};

data/payload/node_modules/@oclif/core/lib/performance.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Performance = exports.OCLIF_MARKER_OWNER = void 0;
+const node_perf_hooks_1 = require("node:perf_hooks");
+const logger_1 = require("./logger");
+const settings_1 = require("./settings");
+exports.OCLIF_MARKER_OWNER = '@oclif/core';
+class Marker {
+    owner;
+    name;
+    details;
+    method;
+    module;
+    scope;
+    stopped = false;
+    startMarker;
+    stopMarker;
+    constructor(owner, name, details = {}) {
+        this.owner = owner;
+        this.name = name;
+        this.details = details;
+        this.startMarker = `${this.name}-start`;
+        this.stopMarker = `${this.name}-stop`;
+        const [caller, scope] = name.split('#');
+        const [module, method] = caller.split('.');
+        this.module = module;
+        this.method = method;
+        this.scope = scope;
+        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;
+        node_perf_hooks_1.performance.mark(this.stopMarker);
+    }
+}
+class Performance {
+    static _oclifPerf;
+    /* Key: marker.owner */
+    static _results = new Map();
+    /* Key: marker.name */
+    static markers = new Map();
+    /**
+     * Collect performance results into static Performance.results
+     *
+     * @returns Promise<void>
+     */
+    static async collect() {
+        if (!Performance.enabled)
+            return;
+        if (Performance._results.size > 0)
+            return;
+        const markers = [...Performance.markers.values()];
+        if (markers.length === 0)
+            return;
+        for (const marker of markers.filter((m) => !m.stopped)) {
+            marker.stop();
+        }
+        return new Promise((resolve) => {
+            // eslint-disable-next-line complexity
+            const perfObserver = new node_perf_hooks_1.PerformanceObserver((items) => {
+                for (const entry of items.getEntries()) {
+                    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,
+                        };
+                        const existing = Performance._results.get(marker.owner) ?? [];
+                        Performance._results.set(marker.owner, [...existing, result]);
+                    }
+                }
+                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(({ details, duration, scope }) => [scope, { details, duration }]));
+                const hookRunTimes = oclifResults
+                    .filter(({ name }) => name.startsWith('config.runHook#'))
+                    .reduce((acc, perfResult) => {
+                    const event = perfResult.details.event;
+                    if (event) {
+                        if (!acc[event])
+                            acc[event] = {};
+                        acc[event][perfResult.scope] = perfResult.duration;
+                    }
+                    else {
+                        const event = perfResult.scope;
+                        if (!acc[event])
+                            acc[event] = {};
+                        acc[event].total = perfResult.duration;
+                    }
+                    return acc;
+                }, {});
+                const pluginLoadTimeByType = Object.fromEntries(oclifResults
+                    .filter(({ name }) => name.startsWith('config.loadPlugins#'))
+                    .sort((a, b) => b.duration - a.duration)
+                    .map(({ duration, scope }) => [scope, duration]));
+                Performance._oclifPerf = {
+                    hookRunTimes,
+                    '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({ buffered: true, entryTypes: ['measure'] });
+            for (const marker of markers) {
+                try {
+                    marker.measure();
+                }
+                catch {
+                    // ignore
+                }
+            }
+            node_perf_hooks_1.performance.clearMarks();
+        });
+    }
+    /**
+     * Add debug logs for plugin loading performance
+     */
+    static debug() {
+        if (!Performance.enabled)
+            return;
+        const oclifDebug = (0, logger_1.makeDebug)('perf');
+        const processUpTime = (process.uptime() * 1000).toFixed(4);
+        oclifDebug('Process Uptime: %sms', processUpTime);
+        oclifDebug('Oclif 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('  • Root Plugin Load Time: %sms', Performance.getResult(exports.OCLIF_MARKER_OWNER, 'plugin.load#root')?.duration.toFixed(4) ?? 0);
+        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!)`);
+            }
+        }
+        oclifDebug('Hook Run Times:');
+        for (const [event, runTimes] of Object.entries(Performance.oclifPerf.hookRunTimes)) {
+            oclifDebug(`  ${event}:`);
+            for (const [plugin, duration] of Object.entries(runTimes)) {
+                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));
+        if (Performance.oclifPerf['oclif.configLoadMs'] > Performance.oclifPerf['oclif.runMs']) {
+            oclifDebug('! Config load time is greater than total oclif time. This might mean that Config was instantiated before oclif was run.');
+        }
+        const nonCoreDebug = (0, logger_1.makeDebug)('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 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 enabled() {
+        return settings_1.settings.performanceEnabled ?? false;
+    }
+    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.Performance = Performance;

data/payload/node_modules/@oclif/core/lib/screen.d.ts

@@ -0,0 +1,2 @@
+export declare const stdtermwidth: number;
+export declare const errtermwidth: number;

data/payload/node_modules/@oclif/core/lib/screen.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errtermwidth = exports.stdtermwidth = void 0;
+const settings_1 = require("./settings");
+function termwidth(stream) {
+    if (!stream.isTTY) {
+        return 80;
+    }
+    const width = stream.getWindowSize()[0];
+    if (width < 1) {
+        return 80;
+    }
+    if (width < 40) {
+        return 40;
+    }
+    return width;
+}
+const columns = Number.parseInt(process.env.OCLIF_COLUMNS, 10) || settings_1.settings.columns;
+exports.stdtermwidth = columns || termwidth(process.stdout);
+exports.errtermwidth = columns || termwidth(process.stderr);

data/payload/node_modules/@oclif/core/lib/settings.d.ts

@@ -0,0 +1,36 @@
+export type Settings = {
+    /**
+     * Set the terminal width to a specified number of columns (characters)
+     *
+     * Environment Variable:
+     *   OCLIF_COLUMNS=80
+     */
+    columns?: number | undefined;
+    /**
+     * Show additional debug output without DEBUG. Mainly shows stackstraces.
+     *
+     * Useful to set in the ./bin/dev.js script.
+     * oclif.settings.debug = true;
+     */
+    debug?: boolean | undefined;
+    /**
+     * 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 | undefined;
+    /**
+     * Try to use ts-node to load typescript source files instead of javascript files.
+     * Defaults to true in development and test environments (e.g. using bin/dev.js or
+     * NODE_ENV=development or NODE_ENV=test).
+     *
+     * @deprecated use enableAutoTranspile instead.
+     */
+    tsnodeEnabled?: boolean | undefined;
+    /**
+     * Enable automatic transpilation of TypeScript files to JavaScript.
+     *
+     * Defaults to true in development and test environments (e.g. using bin/dev.js or NODE_ENV=development or NODE_ENV=test).
+     */
+    enableAutoTranspile?: boolean | undefined;
+};
+export declare const settings: Settings;

data/payload/node_modules/@oclif/core/lib/settings.js

@@ -0,0 +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 (!globalThis.oclif)
+    globalThis.oclif = {};
+exports.settings = globalThis.oclif;

data/payload/node_modules/@oclif/core/lib/symbols.d.ts

@@ -0,0 +1 @@
+export declare const SINGLE_COMMAND_CLI_SYMBOL: string;

data/payload/node_modules/@oclif/core/lib/symbols.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SINGLE_COMMAND_CLI_SYMBOL = void 0;
+exports.SINGLE_COMMAND_CLI_SYMBOL = Symbol('SINGLE_COMMAND_CLI').toString();

data/payload/node_modules/@oclif/core/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>;