@oclif/core 3.0.4 → 3.0.5-dev.0

package/lib/config/config.js

@@ -58,14 +58,6 @@ class Permutations extends Map {
 }
 class Config {
     options;
-    _base = BASE;
-    _commandIDs;
-    _commands = new Map();
-    static _rootPlugin;
-    _topics = new Map();
-    commandPermutations = new Permutations();
-    pluginLoader;
-    topicPermutations = new Permutations();
     arch;
     bin;
     binAliases;
@@ -94,6 +86,14 @@ class Config {
     version;
     warned = false;
     windows;
+    _base = BASE;
+    _commandIDs;
+    _commands = new Map();
+    static _rootPlugin;
+    _topics = new Map();
+    commandPermutations = new Permutations();
+    pluginLoader;
+    topicPermutations = new Permutations();
     constructor(options) {
         this.options = options;
     }
@@ -130,190 +130,32 @@ class Config {
     static get rootPlugin() {
         return Config._rootPlugin;
     }
-    _debug() {
-        if (this.scopedEnvVarTrue('DEBUG'))
-            return 1;
-        try {
-            const { enabled } = require('debug')(this.bin);
-            if (enabled)
-                return 1;
-        }
-        catch { }
-        return 0;
-    }
-    _shell() {
-        let shellPath;
-        const { COMSPEC } = process.env;
-        const SHELL = process.env.SHELL ?? (0, node_os_1.userInfo)().shell?.split(node_path_1.sep)?.pop();
-        if (SHELL) {
-            shellPath = SHELL.split('/');
-        }
-        else if (this.windows && COMSPEC) {
-            shellPath = COMSPEC.split(/\\|\//);
-        }
-        else {
-            shellPath = ['unknown'];
-        }
-        return shellPath.at(-1) ?? 'unknown';
-    }
-    /**
-     * This method is responsible for locating the correct plugin to use for a named command id
-     * It searches the {Config} registered commands to match either the raw command id or the command alias
-     * It is possible that more than one command will be found. This is due the ability of two distinct plugins to
-     * create the same command or command alias.
-     *
-     * In the case of more than one found command, the function will select the command based on the order in which
-     * the plugin is included in the package.json `oclif.plugins` list. The command that occurs first in the list
-     * is selected as the command to run.
-     *
-     * Commands can also be present from either an install or a link. When a command is one of these and a core plugin
-     * is present, this function defers to the core plugin.
-     *
-     * If there is not a core plugin command present, this function will return the first
-     * plugin as discovered (will not change the order)
-     *
-     * @param commands commands to determine the priority of
-     * @returns command instance {Command.Loadable} or undefined
-     */
-    determinePriority(commands) {
-        const oclifPlugins = this.pjson.oclif?.plugins ?? [];
-        const commandPlugins = commands.sort((a, b) => {
-            const pluginAliasA = a.pluginAlias ?? 'A-Cannot-Find-This';
-            const pluginAliasB = b.pluginAlias ?? 'B-Cannot-Find-This';
-            const aIndex = oclifPlugins.indexOf(pluginAliasA);
-            const bIndex = oclifPlugins.indexOf(pluginAliasB);
-            // When both plugin types are 'core' plugins sort based on index
-            if (a.pluginType === 'core' && b.pluginType === 'core') {
-                // If b appears first in the pjson.plugins sort it first
-                return aIndex - bIndex;
-            }
-            // if b is a core plugin and a is not sort b first
-            if (b.pluginType === 'core' && a.pluginType !== 'core') {
-                return 1;
-            }
-            // if a is a core plugin and b is not sort a first
-            if (a.pluginType === 'core' && b.pluginType !== 'core') {
-                return -1;
-            }
-            // if a is a jit plugin and b is not sort b first
-            if (a.pluginType === 'jit' && b.pluginType !== 'jit') {
-                return 1;
-            }
-            // if b is a jit plugin and a is not sort a first
-            if (b.pluginType === 'jit' && a.pluginType !== 'jit') {
-                return -1;
-            }
-            // neither plugin is core, so do not change the order
-            return 0;
-        });
-        return commandPlugins[0];
-    }
-    getCmdLookupId(id) {
-        if (this._commands.has(id))
-            return id;
-        if (this.commandPermutations.hasValid(id))
-            return this.commandPermutations.getValid(id);
-        return id;
-    }
-    getTopicLookupId(id) {
-        if (this._topics.has(id))
-            return id;
-        if (this.topicPermutations.hasValid(id))
-            return this.topicPermutations.getValid(id);
-        return id;
+    get commandIDs() {
+        if (this._commandIDs)
+            return this._commandIDs;
+        this._commandIDs = this.commands.map((c) => c.id);
+        return this._commandIDs;
     }
-    /**
-     * Insert legacy plugins
-     *
-     * Replace invalid CLI plugins (cli-engine plugins, mostly Heroku) loaded via `this.loadPlugins`
-     * with oclif-compatible ones returned by @oclif/plugin-legacy init hook.
-     *
-     * @param plugins array of oclif-compatible plugins
-     * @returns void
-     */
-    insertLegacyPlugins(plugins) {
-        for (const plugin of plugins) {
-            this.plugins.set(plugin.name, plugin);
-            this.loadCommands(plugin);
-        }
+    get commands() {
+        return [...this._commands.values()];
     }
-    isJitPluginCommand(c) {
-        // Return true if the command's plugin is listed under oclif.jitPlugins AND if the plugin hasn't been loaded to this.plugins
-        return (Object.keys(this.pjson.oclif.jitPlugins ?? {}).includes(c.pluginName ?? '') &&
-            Boolean(c?.pluginName && !this.plugins.has(c.pluginName)));
+    get isProd() {
+        return (0, util_2.isProd)();
     }
-    loadCommands(plugin) {
-        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.loadCommands#${plugin.name}`, { plugin: plugin.name });
-        for (const command of plugin.commands) {
-            // set canonical command id
-            if (this._commands.has(command.id)) {
-                const prioritizedCommand = this.determinePriority([this._commands.get(command.id), command]);
-                this._commands.set(prioritizedCommand.id, prioritizedCommand);
-            }
-            else {
-                this._commands.set(command.id, command);
-            }
-            // v3 moved command id permutations to the manifest, but some plugins may not have
-            // the new manifest yet. For those, we need to calculate the permutations here.
-            const permutations = this.flexibleTaxonomy && command.permutations === undefined
-                ? (0, util_3.getCommandIdPermutations)(command.id)
-                : command.permutations ?? [command.id];
-            // set every permutation
-            for (const permutation of permutations) {
-                this.commandPermutations.add(permutation, command.id);
-            }
-            // set command aliases
-            for (const alias of command.aliases ?? []) {
-                if (this._commands.has(alias)) {
-                    const prioritizedCommand = this.determinePriority([this._commands.get(alias), command]);
-                    this._commands.set(alias, { ...prioritizedCommand, id: alias });
-                }
-                else {
-                    this._commands.set(alias, { ...command, id: alias });
-                }
-                // set every permutation of the aliases
-                // v3 moved command alias permutations to the manifest, but some plugins may not have
-                // the new manifest yet. For those, we need to calculate the permutations here.
-                const aliasPermutations = this.flexibleTaxonomy && command.aliasPermutations === undefined
-                    ? (0, util_3.getCommandIdPermutations)(alias)
-                    : command.permutations ?? [alias];
-                // set every permutation
-                for (const permutation of aliasPermutations) {
-                    this.commandPermutations.add(permutation, command.id);
-                }
-            }
-        }
-        marker?.addDetails({ commandCount: plugin.commands.length });
-        marker?.stop();
+    get topics() {
+        return [...this._topics.values()];
     }
-    loadTopics(plugin) {
-        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.loadTopics#${plugin.name}`, { plugin: plugin.name });
-        for (const topic of (0, util_2.compact)(plugin.topics)) {
-            const existing = this._topics.get(topic.name);
-            if (existing) {
-                existing.description = topic.description || existing.description;
-                existing.hidden = existing.hidden || topic.hidden;
-            }
-            else {
-                this._topics.set(topic.name, topic);
-            }
-            const permutations = this.flexibleTaxonomy ? (0, util_3.getCommandIdPermutations)(topic.name) : [topic.name];
-            for (const permutation of permutations) {
-                this.topicPermutations.add(permutation, topic.name);
-            }
-        }
-        // Add missing topics for displaying help when partial commands are entered.
-        for (const c of plugin.commands.filter((c) => !c.hidden)) {
-            const parts = c.id.split(':');
-            while (parts.length > 0) {
-                const name = parts.join(':');
-                if (name && !this._topics.has(name)) {
-                    this._topics.set(name, { description: c.summary || c.description, name });
-                }
-                parts.pop();
-            }
-        }
-        marker?.stop();
+    get versionDetails() {
+        const [cliVersion, architecture, nodeVersion] = this.userAgent.split(' ');
+        return {
+            architecture,
+            cliVersion,
+            nodeVersion,
+            osVersion: `${(0, node_os_1.type)()} ${(0, node_os_1.release)()}`,
+            pluginVersions: Object.fromEntries([...this.plugins.values()].map((p) => [p.name, { root: p.root, type: p.type, version: p.version }])),
+            rootPath: this.root,
+            shell: this.shell,
+        };
     }
     dir(category) {
         const base = process.env[`XDG_${category.toUpperCase()}_HOME`] ||
@@ -705,32 +547,190 @@ class Config {
     windowsUserprofileHome() {
         return process.env.USERPROFILE;
     }
-    get commandIDs() {
-        if (this._commandIDs)
-            return this._commandIDs;
-        this._commandIDs = this.commands.map((c) => c.id);
-        return this._commandIDs;
+    _debug() {
+        if (this.scopedEnvVarTrue('DEBUG'))
+            return 1;
+        try {
+            const { enabled } = require('debug')(this.bin);
+            if (enabled)
+                return 1;
+        }
+        catch { }
+        return 0;
     }
-    get commands() {
-        return [...this._commands.values()];
+    _shell() {
+        let shellPath;
+        const { COMSPEC } = process.env;
+        const SHELL = process.env.SHELL ?? (0, node_os_1.userInfo)().shell?.split(node_path_1.sep)?.pop();
+        if (SHELL) {
+            shellPath = SHELL.split('/');
+        }
+        else if (this.windows && COMSPEC) {
+            shellPath = COMSPEC.split(/\\|\//);
+        }
+        else {
+            shellPath = ['unknown'];
+        }
+        return shellPath.at(-1) ?? 'unknown';
     }
-    get isProd() {
-        return (0, util_2.isProd)();
+    /**
+     * This method is responsible for locating the correct plugin to use for a named command id
+     * It searches the {Config} registered commands to match either the raw command id or the command alias
+     * It is possible that more than one command will be found. This is due the ability of two distinct plugins to
+     * create the same command or command alias.
+     *
+     * In the case of more than one found command, the function will select the command based on the order in which
+     * the plugin is included in the package.json `oclif.plugins` list. The command that occurs first in the list
+     * is selected as the command to run.
+     *
+     * Commands can also be present from either an install or a link. When a command is one of these and a core plugin
+     * is present, this function defers to the core plugin.
+     *
+     * If there is not a core plugin command present, this function will return the first
+     * plugin as discovered (will not change the order)
+     *
+     * @param commands commands to determine the priority of
+     * @returns command instance {Command.Loadable} or undefined
+     */
+    determinePriority(commands) {
+        const oclifPlugins = this.pjson.oclif?.plugins ?? [];
+        const commandPlugins = commands.sort((a, b) => {
+            const pluginAliasA = a.pluginAlias ?? 'A-Cannot-Find-This';
+            const pluginAliasB = b.pluginAlias ?? 'B-Cannot-Find-This';
+            const aIndex = oclifPlugins.indexOf(pluginAliasA);
+            const bIndex = oclifPlugins.indexOf(pluginAliasB);
+            // When both plugin types are 'core' plugins sort based on index
+            if (a.pluginType === 'core' && b.pluginType === 'core') {
+                // If b appears first in the pjson.plugins sort it first
+                return aIndex - bIndex;
+            }
+            // if b is a core plugin and a is not sort b first
+            if (b.pluginType === 'core' && a.pluginType !== 'core') {
+                return 1;
+            }
+            // if a is a core plugin and b is not sort a first
+            if (a.pluginType === 'core' && b.pluginType !== 'core') {
+                return -1;
+            }
+            // if a is a jit plugin and b is not sort b first
+            if (a.pluginType === 'jit' && b.pluginType !== 'jit') {
+                return 1;
+            }
+            // if b is a jit plugin and a is not sort a first
+            if (b.pluginType === 'jit' && a.pluginType !== 'jit') {
+                return -1;
+            }
+            // neither plugin is core, so do not change the order
+            return 0;
+        });
+        return commandPlugins[0];
     }
-    get topics() {
-        return [...this._topics.values()];
+    getCmdLookupId(id) {
+        if (this._commands.has(id))
+            return id;
+        if (this.commandPermutations.hasValid(id))
+            return this.commandPermutations.getValid(id);
+        return id;
     }
-    get versionDetails() {
-        const [cliVersion, architecture, nodeVersion] = this.userAgent.split(' ');
-        return {
-            architecture,
-            cliVersion,
-            nodeVersion,
-            osVersion: `${(0, node_os_1.type)()} ${(0, node_os_1.release)()}`,
-            pluginVersions: Object.fromEntries([...this.plugins.values()].map((p) => [p.name, { root: p.root, type: p.type, version: p.version }])),
-            rootPath: this.root,
-            shell: this.shell,
-        };
+    getTopicLookupId(id) {
+        if (this._topics.has(id))
+            return id;
+        if (this.topicPermutations.hasValid(id))
+            return this.topicPermutations.getValid(id);
+        return id;
+    }
+    /**
+     * Insert legacy plugins
+     *
+     * Replace invalid CLI plugins (cli-engine plugins, mostly Heroku) loaded via `this.loadPlugins`
+     * with oclif-compatible ones returned by @oclif/plugin-legacy init hook.
+     *
+     * @param plugins array of oclif-compatible plugins
+     * @returns void
+     */
+    insertLegacyPlugins(plugins) {
+        for (const plugin of plugins) {
+            this.plugins.set(plugin.name, plugin);
+            this.loadCommands(plugin);
+        }
+    }
+    isJitPluginCommand(c) {
+        // Return true if the command's plugin is listed under oclif.jitPlugins AND if the plugin hasn't been loaded to this.plugins
+        return (Object.keys(this.pjson.oclif.jitPlugins ?? {}).includes(c.pluginName ?? '') &&
+            Boolean(c?.pluginName && !this.plugins.has(c.pluginName)));
+    }
+    loadCommands(plugin) {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.loadCommands#${plugin.name}`, { plugin: plugin.name });
+        for (const command of plugin.commands) {
+            // set canonical command id
+            if (this._commands.has(command.id)) {
+                const prioritizedCommand = this.determinePriority([this._commands.get(command.id), command]);
+                this._commands.set(prioritizedCommand.id, prioritizedCommand);
+            }
+            else {
+                this._commands.set(command.id, command);
+            }
+            // v3 moved command id permutations to the manifest, but some plugins may not have
+            // the new manifest yet. For those, we need to calculate the permutations here.
+            const permutations = this.flexibleTaxonomy && command.permutations === undefined
+                ? (0, util_3.getCommandIdPermutations)(command.id)
+                : command.permutations ?? [command.id];
+            // set every permutation
+            for (const permutation of permutations) {
+                this.commandPermutations.add(permutation, command.id);
+            }
+            // set command aliases
+            for (const alias of command.aliases ?? []) {
+                if (this._commands.has(alias)) {
+                    const prioritizedCommand = this.determinePriority([this._commands.get(alias), command]);
+                    this._commands.set(alias, { ...prioritizedCommand, id: alias });
+                }
+                else {
+                    this._commands.set(alias, { ...command, id: alias });
+                }
+                // set every permutation of the aliases
+                // v3 moved command alias permutations to the manifest, but some plugins may not have
+                // the new manifest yet. For those, we need to calculate the permutations here.
+                const aliasPermutations = this.flexibleTaxonomy && command.aliasPermutations === undefined
+                    ? (0, util_3.getCommandIdPermutations)(alias)
+                    : command.permutations ?? [alias];
+                // set every permutation
+                for (const permutation of aliasPermutations) {
+                    this.commandPermutations.add(permutation, command.id);
+                }
+            }
+        }
+        marker?.addDetails({ commandCount: plugin.commands.length });
+        marker?.stop();
+    }
+    loadTopics(plugin) {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.loadTopics#${plugin.name}`, { plugin: plugin.name });
+        for (const topic of (0, util_2.compact)(plugin.topics)) {
+            const existing = this._topics.get(topic.name);
+            if (existing) {
+                existing.description = topic.description || existing.description;
+                existing.hidden = existing.hidden || topic.hidden;
+            }
+            else {
+                this._topics.set(topic.name, topic);
+            }
+            const permutations = this.flexibleTaxonomy ? (0, util_3.getCommandIdPermutations)(topic.name) : [topic.name];
+            for (const permutation of permutations) {
+                this.topicPermutations.add(permutation, topic.name);
+            }
+        }
+        // Add missing topics for displaying help when partial commands are entered.
+        for (const c of plugin.commands.filter((c) => !c.hidden)) {
+            const parts = c.id.split(':');
+            while (parts.length > 0) {
+                const name = parts.join(':');
+                if (name && !this._topics.has(name)) {
+                    this._topics.set(name, { description: c.summary || c.description, name });
+                }
+                parts.pop();
+            }
+        }
+        marker?.stop();
     }
 }
 exports.Config = Config;

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

@@ -13,18 +13,18 @@ type LoadOpts = {
 type PluginsMap = Map<string, IPlugin>;
 export default class PluginLoader {
     options: PluginLoaderOptions;
-    private pluginsProvided;
     errors: (Error | string)[];
     plugins: PluginsMap;
+    private pluginsProvided;
     constructor(options: PluginLoaderOptions);
-    private loadCorePlugins;
-    private loadDevPlugins;
-    private loadPlugins;
-    private loadUserPlugins;
     loadChildren(opts: LoadOpts): Promise<{
         errors: (Error | string)[];
         plugins: PluginsMap;
     }>;
     loadRoot(): Promise<IPlugin>;
+    private loadCorePlugins;
+    private loadDevPlugins;
+    private loadPlugins;
+    private loadUserPlugins;
 }
 export {};

package/lib/config/plugin-loader.js

@@ -11,9 +11,9 @@ const util_2 = require("./util");
 const debug = (0, util_2.Debug)();
 class PluginLoader {
     options;
-    pluginsProvided = false;
     errors = [];
     plugins = new Map();
+    pluginsProvided = false;
     constructor(options) {
         this.options = options;
         if (options.plugins) {
@@ -21,6 +21,37 @@ class PluginLoader {
             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) {
+            await this.loadUserPlugins(opts);
+            await this.loadDevPlugins(opts);
+            await this.loadCorePlugins(opts);
+        }
+        return { errors: this.errors, plugins: this.plugins };
+    }
+    async loadRoot() {
+        let rootPlugin;
+        if (this.pluginsProvided) {
+            const plugins = [...this.plugins.values()];
+            rootPlugin = plugins.find((p) => p.root === this.options.root) ?? plugins[0];
+        }
+        else {
+            const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'plugin.load#root');
+            rootPlugin = new Plugin.Plugin({ isRoot: true, root: this.options.root });
+            await rootPlugin.load();
+            marker?.addDetails({
+                commandCount: rootPlugin.commands.length,
+                hasManifest: rootPlugin.hasManifest ?? false,
+                name: rootPlugin.name,
+                topicCount: rootPlugin.topics.length,
+                type: rootPlugin.type,
+                usesMain: Boolean(rootPlugin.pjson.main),
+            });
+            marker?.stop();
+        }
+        this.plugins.set(rootPlugin.name, rootPlugin);
+        return rootPlugin;
+    }
     async loadCorePlugins(opts) {
         if (opts.rootPlugin.pjson.oclif.plugins) {
             await this.loadPlugins(opts.rootPlugin.root, 'core', opts.rootPlugin.pjson.oclif.plugins);
@@ -110,36 +141,5 @@ class PluginLoader {
             }
         }
     }
-    async loadChildren(opts) {
-        if (!this.pluginsProvided || opts.force) {
-            await this.loadUserPlugins(opts);
-            await this.loadDevPlugins(opts);
-            await this.loadCorePlugins(opts);
-        }
-        return { errors: this.errors, plugins: this.plugins };
-    }
-    async loadRoot() {
-        let rootPlugin;
-        if (this.pluginsProvided) {
-            const plugins = [...this.plugins.values()];
-            rootPlugin = plugins.find((p) => p.root === this.options.root) ?? plugins[0];
-        }
-        else {
-            const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'plugin.load#root');
-            rootPlugin = new Plugin.Plugin({ isRoot: true, root: this.options.root });
-            await rootPlugin.load();
-            marker?.addDetails({
-                commandCount: rootPlugin.commands.length,
-                hasManifest: rootPlugin.hasManifest ?? false,
-                name: rootPlugin.name,
-                topicCount: rootPlugin.topics.length,
-                type: rootPlugin.type,
-                usesMain: Boolean(rootPlugin.pjson.main),
-            });
-            marker?.stop();
-        }
-        this.plugins.set(rootPlugin.name, rootPlugin);
-        return rootPlugin;
-    }
 }
 exports.default = PluginLoader;

package/lib/config/plugin.d.ts

@@ -5,10 +5,6 @@ import { Plugin as IPlugin, PluginOptions } from '../interfaces/plugin';
 import { Topic } from '../interfaces/topic';
 export declare class Plugin implements IPlugin {
     options: PluginOptions;
-    _base: string;
-    private _commandsDir;
-    protected _debug: (..._: any) => void;
-    private flexibleTaxonomy;
     alias: string;
     alreadyLoaded: boolean;
     children: Plugin[];
@@ -29,10 +25,14 @@ export declare class Plugin implements IPlugin {
     valid: boolean;
     version: string;
     protected warned: boolean;
+    _base: string;
+    private _commandsDir;
+    protected _debug: (..._: any) => void;
+    private flexibleTaxonomy;
     constructor(options: PluginOptions);
-    private _manifest;
-    private addErrorScope;
-    private warn;
+    get commandIDs(): string[];
+    get commandsDir(): string | undefined;
+    get topics(): Topic[];
     findCommand(id: string, opts: {
         must: true;
     }): Promise<Command.Class>;
@@ -40,7 +40,7 @@ export declare class Plugin implements IPlugin {
         must: boolean;
     }): Promise<Command.Class | undefined>;
     load(): Promise<void>;
-    get commandIDs(): string[];
-    get commandsDir(): string | undefined;
-    get topics(): Topic[];
+    private _manifest;
+    private addErrorScope;
+    private warn;
 }