@oclif/core 5.0.1 → 5.1.1

package/lib/args.d.ts

@@ -1,5 +1,5 @@
 import { URL } from 'node:url';
-import { Arg, ArgDefinition } from './interfaces/parser';
+import { type Arg, type ArgDefinition } from './interfaces/parser';
 /**
  * Create a custom arg.
  *
@@ -36,7 +36,7 @@ export declare const file: ArgDefinition<string, {
 export declare const url: ArgDefinition<URL, Record<string, unknown>>;
 declare const stringArg: ArgDefinition<string, Record<string, unknown>>;
 export { stringArg as string };
-type ReadonlyElementOf<T extends ReadonlyArray<unknown>> = T[number];
+type ReadonlyElementOf<T extends readonly unknown[]> = T[number];
 /**
  * Create an arg that infers the type from the provided options.
  *

package/lib/cache.d.ts

@@ -1,5 +1,5 @@
-import { Config } from './config/config';
-import { OclifConfiguration, Plugin } from './interfaces';
+import { type Config } from './config/config';
+import { type OclifConfiguration, type Plugin } from './interfaces';
 type CacheContents = {
     rootPlugin: Plugin;
     config: Config;

package/lib/command.d.ts

@@ -1,9 +1,9 @@
 import { Config } from './config';
-import { PrettyPrintableError } from './errors';
-import { LoadOptions } from './interfaces/config';
-import { CommandError } from './interfaces/errors';
-import { ArgInput, ArgOutput, ArgProps, BooleanFlagProps, Constraint, Deprecation, FlagInput, FlagOutput, Arg as IArg, Flag as IFlag, Input, OptionFlagProps, ParserOutput } from './interfaces/parser';
-import { Plugin } from './interfaces/plugin';
+import { type PrettyPrintableError } from './errors';
+import { type LoadOptions } from './interfaces/config';
+import { type CommandError } from './interfaces/errors';
+import { type ArgInput, type ArgOutput, type ArgProps, type BooleanFlagProps, type Constraint, type Deprecation, type FlagInput, type FlagOutput, type Arg as IArg, type Flag as IFlag, type Input, type OptionFlagProps, type ParserOutput } from './interfaces/parser';
+import { type Plugin } from './interfaces/plugin';
 /**
  * An abstract class which acts as the base for each command
  * in your project.
@@ -137,7 +137,7 @@ export declare namespace Command {
      * is executed then the `load` method is used to require the command class.
      */
     type Loadable = Cached & {
-        load(): Promise<Command.Class>;
+        load(): Promise<Class>;
     };
     /**
      * A cached version of the command. This is created by the cachedCommand utility and
@@ -147,16 +147,12 @@ export declare namespace Command {
         [key: string]: unknown;
         aliasPermutations?: string[] | undefined;
         aliases: string[];
-        args: {
-            [name: string]: Arg.Cached;
-        };
+        args: Record<string, Arg.Cached>;
         deprecateAliases?: boolean | undefined;
         deprecationOptions?: Deprecation | undefined;
         description?: string | undefined;
         examples?: Example[] | undefined;
-        flags: {
-            [name: string]: Flag.Cached;
-        };
+        flags: Record<string, Flag.Cached>;
         hasDynamicHelp?: boolean;
         hidden: boolean;
         hiddenAliases: string[];
@@ -185,8 +181,8 @@ export declare namespace Command {
         type Cached = Omit<Arg, 'input' | 'parse'> & ArgProps;
         type Any = Arg | Cached;
     }
-    type Example = {
+    type Example = string | {
         command: string;
         description: string;
-    } | string;
+    };
 }

package/lib/command.js

@@ -214,7 +214,7 @@ class Command {
         }
     }
     error(input, options = {}) {
-        return Errors.error(input, options);
+        Errors.error(input, options);
     }
     exit(code = 0) {
         Errors.exit(code);
@@ -248,19 +248,21 @@ class Command {
                 jsonIndex !== -1 && jsonIndex < passThroughIndex;
     }
     log(message = '', ...args) {
-        if (!this.jsonEnabled()) {
-            message = typeof message === 'string' ? message : (0, node_util_1.inspect)(message);
-            ux_1.ux.stdout(message, ...args);
+        if (this.jsonEnabled()) {
+            return;
         }
+        message = typeof message === 'string' ? message : (0, node_util_1.inspect)(message);
+        ux_1.ux.stdout(message, ...args);
     }
     logJson(json) {
         ux_1.ux.stdout(ux_1.ux.colorizeJson(json, { pretty: true, theme: this.config.theme?.json }));
     }
     logToStderr(message = '', ...args) {
-        if (!this.jsonEnabled()) {
-            message = typeof message === 'string' ? message : (0, node_util_1.inspect)(message);
-            ux_1.ux.stderr(message, ...args);
+        if (this.jsonEnabled()) {
+            return;
         }
+        message = typeof message === 'string' ? message : (0, node_util_1.inspect)(message);
+        ux_1.ux.stderr(message, ...args);
     }
     async parse(options, argv = this.argv) {
         if (!options)

package/lib/config/config.d.ts

@@ -1,8 +1,8 @@
-import { Command } from '../command';
-import { Hook, Hooks, OclifConfiguration, PJSON, S3Templates, Topic, UserPJSON } from '../interfaces';
-import { ArchTypes, Config as IConfig, LoadOptions, PlatformTypes, VersionDetails } from '../interfaces/config';
-import { Plugin as IPlugin, Options } from '../interfaces/plugin';
-import { Theme } from '../interfaces/theme';
+import { type Command } from '../command';
+import { type Hook, type Hooks, type OclifConfiguration, type PJSON, type S3Templates, type Topic, type UserPJSON } from '../interfaces';
+import { type ArchTypes, type Config as IConfig, type LoadOptions, type PlatformTypes, type VersionDetails } from '../interfaces/config';
+import { type Plugin as IPlugin, type Options } from '../interfaces/plugin';
+import { type Theme } from '../interfaces/theme';
 export declare class Config implements IConfig {
     options: Options;
     arch: ArchTypes;
@@ -34,14 +34,14 @@ export declare class Config implements IConfig {
     version: string;
     protected warned: boolean;
     windows: boolean;
-    private _base;
+    private readonly _base;
     private _commandIDs;
-    private _commands;
-    private _topics;
-    private commandPermutations;
+    private readonly _commands;
+    private readonly _topics;
+    private readonly commandPermutations;
     private pluginLoader;
     private rootPlugin;
-    private topicPermutations;
+    private readonly topicPermutations;
     constructor(options: Options);
     static load(opts?: LoadOptions): Promise<Config>;
     get commandIDs(): string[];

package/lib/config/config.js

@@ -39,7 +39,7 @@ function displayWarnings() {
     });
 }
 function channelFromVersion(version) {
-    const m = version.match(/[^-]+(?:-([^.]+))?/);
+    const m = /[^-]+(?:-([^.]+))?/.exec(version);
     return (m && m[1]) || 'stable';
 }
 function isConfig(o) {
@@ -151,7 +151,7 @@ class Config {
         return [...this._topics.values()];
     }
     get versionDetails() {
-        const [cliVersion, architecture, nodeVersion] = this.userAgent.split(' ');
+        const [cliVersion, architecture, nodeVersion] = this.userAgent.split(' ', 3);
         return {
             architecture,
             cliVersion,
@@ -194,9 +194,9 @@ class Config {
             .map((a) => a.replaceAll('-', ''));
         const possibleMatches = [...this.commandPermutations.get(partialCmdId)].map((k) => this._commands.get(k));
         const matches = possibleMatches.filter((command) => {
-            const cmdFlags = Object.entries(command.flags).flatMap(([flag, def]) => def.char ? [def.char, flag] : [flag]);
+            const cmdFlags = new Set(Object.entries(command.flags).flatMap(([flag, def]) => (def.char ? [def.char, flag] : [flag])));
             // A command is a match if the provided flags belong to the full command
-            return flags.every((f) => cmdFlags.includes(f));
+            return flags.every((f) => cmdFlags.has(f));
         });
         return matches;
     }
@@ -223,10 +223,11 @@ class Config {
         const commands = [...this._commands.values()];
         const validPermutations = [...this.commandPermutations.getAllValid()];
         for (const permutation of validPermutations) {
-            if (!this._commands.has(permutation)) {
-                const cmd = this._commands.get(this.getCmdLookupId(permutation));
-                commands.push({ ...cmd, id: permutation });
+            if (this._commands.has(permutation)) {
+                continue;
             }
+            const cmd = this._commands.get(this.getCmdLookupId(permutation));
+            commands.push({ ...cmd, id: permutation });
         }
         return commands;
     }
@@ -343,7 +344,9 @@ class Config {
     macosCacheDir() {
         return (this.platform === 'darwin' && (0, node_path_1.join)(this.home, 'Library', 'Caches', this.dirname)) || undefined;
     }
-    async runCommand(id, argv = [], cachedCommand = null) {
+    async runCommand(id, argv = [], 
+    // eslint-disable-next-line @typescript-eslint/no-restricted-types
+    cachedCommand = null) {
         const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.runCommand#${id}`);
         debug('runCommand %s %o', id, argv);
         let c = cachedCommand ?? this.findCommand(id);
@@ -557,14 +560,14 @@ class Config {
                 manifest: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- platform %>-<%- arch %>",
                 unversioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %>-<%- platform %>-<%- arch %><%- ext %>",
                 versioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %>-v<%- version %>/<%- bin %>-v<%- version %>-<%- platform %>-<%- arch %><%- ext %>",
-                ...(s3?.templates && s3?.templates.target),
+                ...s3?.templates?.target,
             },
             vanilla: {
                 baseDir: '<%- bin %>',
                 manifest: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %>version",
                 unversioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %><%- ext %>",
                 versioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %>-v<%- version %>/<%- bin %>-v<%- version %><%- ext %>",
-                ...(s3?.templates && s3?.templates.vanilla),
+                ...s3?.templates?.vanilla,
             },
         };
         return {
@@ -706,10 +709,11 @@ class Config {
         marker?.stop();
     }
     maybeAdjustDebugSetting() {
-        if (this.scopedEnvVarTrue('DEBUG')) {
-            settings_1.settings.debug = true;
-            displayWarnings();
+        if (!this.scopedEnvVarTrue('DEBUG')) {
+            return;
         }
+        settings_1.settings.debug = true;
+        displayWarnings();
     }
     warn(err, scope) {
         if (this.warned)

package/lib/config/plugin-loader.d.ts

@@ -1,5 +1,5 @@
-import { PJSON } from '../interfaces';
-import { Plugin as IPlugin } from '../interfaces/plugin';
+import { type PJSON } from '../interfaces';
+import { type Plugin as IPlugin } from '../interfaces/plugin';
 type PluginLoaderOptions = {
     plugins?: IPlugin[] | PluginsMap | undefined;
     root: string;
@@ -19,12 +19,12 @@ type LoadOpts = {
 type PluginsMap = Map<string, IPlugin>;
 export default class PluginLoader {
     options: PluginLoaderOptions;
-    errors: (Error | string)[];
+    errors: Array<Error | string>;
     plugins: PluginsMap;
-    private pluginsProvided;
+    private readonly pluginsProvided;
     constructor(options: PluginLoaderOptions);
     loadChildren(opts: LoadOpts): Promise<{
-        errors: (Error | string)[];
+        errors: Array<Error | string>;
         plugins: PluginsMap;
     }>;
     loadRoot({ pjson }: {

package/lib/config/plugin-loader.js

@@ -18,10 +18,11 @@ class PluginLoader {
     pluginsProvided = false;
     constructor(options) {
         this.options = options;
-        if (options.plugins) {
-            this.pluginsProvided = true;
-            this.plugins = Array.isArray(options.plugins) ? new Map(options.plugins.map((p) => [p.name, p])) : options.plugins;
+        if (!options.plugins) {
+            return;
         }
+        this.pluginsProvided = true;
+        this.plugins = Array.isArray(options.plugins) ? new Map(options.plugins.map((p) => [p.name, p])) : options.plugins;
     }
     async loadChildren(opts) {
         if (!this.pluginsProvided || opts.force) {
@@ -75,37 +76,38 @@ class PluginLoader {
         }
     }
     async loadDevPlugins(opts) {
-        if (opts.devPlugins !== false) {
-            // do not load oclif.devPlugins in production
-            if ((0, util_1.isProd)())
-                return;
-            try {
-                const { devPlugins } = opts.rootPlugin.pjson.oclif;
-                if (devPlugins) {
+        if (opts.devPlugins === false) {
+            return;
+        }
+        // do not load oclif.devPlugins in production
+        if ((0, util_1.isProd)())
+            return;
+        try {
+            const { devPlugins } = opts.rootPlugin.pjson.oclif;
+            if (devPlugins) {
+                const allDeps = { ...opts.rootPlugin.pjson.dependencies, ...opts.rootPlugin.pjson.devDependencies };
+                const plugins = findMatchingDependencies(allDeps ?? {}, devPlugins);
+                await this.loadPlugins(opts.rootPlugin.root, 'dev', plugins);
+            }
+            const { dev: pluginAdditionsDev, path } = opts.pluginAdditions ?? { core: [] };
+            if (pluginAdditionsDev) {
+                if (path) {
+                    // If path is provided, load plugins from the path
+                    const pjson = await (0, fs_1.readJson)((0, node_path_1.join)(path, 'package.json'));
+                    const allDeps = { ...pjson.dependencies, ...pjson.devDependencies };
+                    const plugins = findMatchingDependencies(allDeps ?? {}, pluginAdditionsDev);
+                    await this.loadPlugins(path, 'dev', plugins);
+                }
+                else {
                     const allDeps = { ...opts.rootPlugin.pjson.dependencies, ...opts.rootPlugin.pjson.devDependencies };
-                    const plugins = findMatchingDependencies(allDeps ?? {}, devPlugins);
+                    const plugins = findMatchingDependencies(allDeps ?? {}, pluginAdditionsDev);
                     await this.loadPlugins(opts.rootPlugin.root, 'dev', plugins);
                 }
-                const { dev: pluginAdditionsDev, path } = opts.pluginAdditions ?? { core: [] };
-                if (pluginAdditionsDev) {
-                    if (path) {
-                        // If path is provided, load plugins from the path
-                        const pjson = await (0, fs_1.readJson)((0, node_path_1.join)(path, 'package.json'));
-                        const allDeps = { ...pjson.dependencies, ...pjson.devDependencies };
-                        const plugins = findMatchingDependencies(allDeps ?? {}, pluginAdditionsDev);
-                        await this.loadPlugins(path, 'dev', plugins);
-                    }
-                    else {
-                        const allDeps = { ...opts.rootPlugin.pjson.dependencies, ...opts.rootPlugin.pjson.devDependencies };
-                        const plugins = findMatchingDependencies(allDeps ?? {}, pluginAdditionsDev);
-                        await this.loadPlugins(opts.rootPlugin.root, 'dev', plugins);
-                    }
-                }
-            }
-            catch (error) {
-                process.emitWarning(error);
             }
         }
+        catch (error) {
+            process.emitWarning(error);
+        }
     }
     async loadPlugins(root, type, plugins, parent) {
         if (!plugins || plugins.length === 0)

package/lib/config/plugin.d.ts

@@ -1,9 +1,10 @@
-import { Command } from '../command';
-import { Manifest } from '../interfaces/manifest';
-import { HookOptions, PJSON } from '../interfaces/pjson';
-import { Plugin as IPlugin, PluginOptions } from '../interfaces/plugin';
-import { Topic } from '../interfaces/topic';
+import { type Command } from '../command';
+import { type Manifest } from '../interfaces/manifest';
+import { type HookOptions, type PJSON } from '../interfaces/pjson';
+import { type Plugin as IPlugin, type PluginOptions } from '../interfaces/plugin';
+import { type Topic } from '../interfaces/topic';
 export declare class Plugin implements IPlugin {
+    #private;
     options: PluginOptions;
     _base: string;
     protected _debug: (..._: any) => void;
@@ -14,9 +15,7 @@ export declare class Plugin implements IPlugin {
     commands: Command.Loadable[];
     commandsDir: string | undefined;
     hasManifest: boolean;
-    hooks: {
-        [key: string]: HookOptions[];
-    };
+    hooks: Record<string, HookOptions[]>;
     isRoot: boolean;
     manifest: Manifest;
     moduleType: 'commonjs' | 'module';

package/lib/config/plugin.js

@@ -36,7 +36,7 @@ const cachedCommandCanBeUsed = (manifest, id) => Boolean(manifest?.commands[id]
 const searchForCommandClass = (cmd) => {
     if (typeof cmd.run === 'function')
         return cmd;
-    if (cmd.default && cmd.default.run)
+    if (cmd.default?.run)
         return cmd.default;
     return Object.values(cmd).find((cmd) => typeof cmd.run === 'function');
 };
@@ -103,6 +103,7 @@ class Plugin {
     type;
     valid = false;
     version;
+    #base = `${_pjson.name}@${_pjson.version}`;
     commandCache;
     commandDiscoveryOpts;
     flexibleTaxonomy;
@@ -172,11 +173,9 @@ class Plugin {
         // Linked plugins already have a root so there's no need to search for it.
         // However there could be child plugins nested inside the linked plugin, in which
         // case we still need to search for the child plugin's root.
-        const root = this.options.pjson && this.options.isRoot
+        const root = (this.options.pjson && this.options.isRoot) || (this.type === 'link' && !this.parent)
             ? this.options.root
-            : this.type === 'link' && !this.parent
-                ? this.options.root
-                : await (0, find_root_1.findRoot)(this.options.name, this.options.root);
+            : await (0, find_root_1.findRoot)(this.options.name, this.options.root);
         if (!root)
             throw new errors_1.CLIError(`could not find package.json with ${(0, node_util_1.inspect)(this.options)}`);
         this.root = root;
@@ -213,14 +212,14 @@ class Plugin {
             .sort((a, b) => a.id.localeCompare(b.id));
     }
     async _manifest() {
-        const ignoreManifest = Boolean(this.options.ignoreManifest);
-        const errorOnManifestCreate = Boolean(this.options.errorOnManifestCreate);
-        const respectNoCacheDefault = Boolean(this.options.respectNoCacheDefault);
+        const isIgnoreManifest = Boolean(this.options.ignoreManifest);
+        const isErrorOnManifestCreate = Boolean(this.options.errorOnManifestCreate);
+        const isRespectNoCacheDefault = Boolean(this.options.respectNoCacheDefault);
         const readManifest = async (dotfile = false) => {
             try {
                 const p = (0, node_path_1.join)(this.root, `${dotfile ? '.' : ''}oclif.manifest.json`);
                 const manifest = await (0, fs_1.readJson)(p);
-                if (!process.env.OCLIF_NEXT_VERSION && manifest.version.split('-')[0] !== this.version.split('-')[0]) {
+                if (!process.env.OCLIF_NEXT_VERSION && manifest.version.split('-', 1)[0] !== this.version.split('-', 1)[0]) {
                     process.emitWarning(`Mismatched version in ${this.name} plugin manifest. Expected: ${this.version} Received: ${manifest.version}\nThis usually means you have an oclif.manifest.json file that should be deleted in development. This file should be automatically generated when publishing.`);
                 }
                 else {
@@ -240,7 +239,7 @@ class Plugin {
             }
         };
         const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.manifest#${this.name}`, { plugin: this.name });
-        if (!ignoreManifest) {
+        if (!isIgnoreManifest) {
             const manifest = await readManifest();
             if (manifest) {
                 marker?.addDetails({ commandCount: Object.keys(manifest.commands).length, fromCache: true });
@@ -254,7 +253,7 @@ class Plugin {
             commands: (await Promise.all(this.commandIDs.map(async (id) => {
                 try {
                     const found = await this.findCommand(id, { must: true });
-                    const cached = await (0, cache_command_1.cacheCommand)(found, this, respectNoCacheDefault);
+                    const cached = await (0, cache_command_1.cacheCommand)(found, this, isRespectNoCacheDefault);
                     // Ensure that id is set to the id being processed
                     // This is necessary because the id is set by findCommand but if there
                     // are multiple instances of a Command, then the id will be set to the
@@ -269,10 +268,10 @@ class Plugin {
                 }
                 catch (error) {
                     const scope = `findCommand (${id})`;
-                    if (Boolean(errorOnManifestCreate) === false)
-                        this.warn(error, scope);
-                    else
+                    if (isErrorOnManifestCreate) {
                         throw this.addErrorScope(error, scope);
+                    }
+                    this.warn(error, scope);
                 }
             })))
                 .filter((f) => Boolean(f))
@@ -290,7 +289,7 @@ class Plugin {
         err.name = err.name ?? (0, node_util_1.inspect)(err).trim();
         err.detail = (0, util_1.compact)([
             err.detail,
-            `module: ${this._base}`,
+            `module: ${this.#base}`,
             scope && `task: ${scope}`,
             `plugin: ${this.name}`,
             `root: ${this.root}`,

package/lib/config/ts-path.d.ts

@@ -1,4 +1,4 @@
-import { Plugin, TSConfig } from '../interfaces';
+import { type Plugin, type TSConfig } from '../interfaces';
 export declare const TS_CONFIGS: Record<string, TSConfig | undefined>;
 /**
  * Convert a path from the compiled ./lib files to the ./src typescript source
@@ -6,4 +6,4 @@ export declare const TS_CONFIGS: Record<string, TSConfig | undefined>;
  * if there is a tsconfig and the original sources exist, it attempts to require ts-node
  */
 export declare function tsPath(root: string, orig: string, plugin: Plugin): Promise<string>;
-export declare function tsPath(root: string, orig: string | undefined, plugin?: Plugin | undefined): Promise<string | undefined>;
+export declare function tsPath(root: string, orig: string | undefined, plugin?: Plugin): Promise<string | undefined>;

package/lib/config/ts-path.js

@@ -188,7 +188,7 @@ function cannotTranspileEsm(rootPlugin, plugin, isProduction) {
 function cannotUseTsNode(root, plugin, isProduction) {
     if (plugin?.moduleType !== 'module' || isProduction)
         return false;
-    const nodeMajor = Number.parseInt(process.version.replace('v', '').split('.')[0], 10);
+    const nodeMajor = Number.parseInt(process.version.replace('v', '').split('.', 1)[0], 10);
     return RUN_TIME === 'ts-node' && nodeMajor >= 20;
 }
 /**

package/lib/config/util.d.ts

@@ -1,5 +1,5 @@
 export declare function makeDebug(...scope: string[]): (..._: any) => void;
-export declare function getPermutations(arr: string[]): Array<string[]>;
+export declare function getPermutations(arr: string[]): string[][];
 export declare function getCommandIdPermutations(commandId: string): string[];
 /**
  * Return an array of ids that represent all the usable combinations that a user could enter.

package/lib/config/util.js

@@ -6,7 +6,9 @@ exports.getPermutations = getPermutations;
 exports.getCommandIdPermutations = getCommandIdPermutations;
 const logger_1 = require("../logger");
 function makeDebug(...scope) {
-    return (formatter, ...args) => (0, logger_1.getLogger)(['config', ...scope].join(':')).debug(formatter, ...args);
+    return (formatter, ...args) => {
+        (0, logger_1.getLogger)(['config', ...scope].join(':')).debug(formatter, ...args);
+    };
 }
 // Adapted from https://github.com/angus-c/just/blob/master/packages/array-permutations/index.js
 function getPermutations(arr) {
@@ -17,8 +19,7 @@ function getPermutations(arr) {
     const output = [];
     const partialPermutations = getPermutations(arr.slice(1));
     const first = arr[0];
-    for (let i = 0, len = partialPermutations.length; i < len; i++) {
-        const partial = partialPermutations[i];
+    for (const partial of partialPermutations) {
         for (let j = 0, len2 = partial.length; j <= len2; j++) {
             const start = partial.slice(0, j);
             const end = partial.slice(j);