@oclif/core 2.14.0 → 3.0.0-beta.10

package/lib/config/config.js

@@ -7,7 +7,6 @@ const os = require("os");
 const path = require("path");
 const url_1 = require("url");
 const util_1 = require("util");
-const Plugin = require("./plugin");
 const util_2 = require("./util");
 const util_3 = require("../util");
 const module_loader_1 = require("../module-loader");
@@ -15,8 +14,9 @@ const help_1 = require("../help");
 const stream_1 = require("../cli-ux/stream");
 const performance_1 = require("../performance");
 const settings_1 = require("../settings");
-const os_1 = require("os");
-const path_1 = require("path");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const plugin_loader_1 = require("./plugin-loader");
 // eslint-disable-next-line new-cap
 const debug = (0, util_2.Debug)();
 const _pjson = (0, util_3.requireJson)(__dirname, '..', '..', 'package.json');
@@ -63,31 +63,13 @@ class Config {
         this.options = options;
         this._base = BASE;
         this.debug = 0;
-        this.plugins = [];
+        this.plugins = new Map();
         this.topicSeparator = ':';
         this.warned = false;
         this.commandPermutations = new Permutations();
         this.topicPermutations = new Permutations();
         this._commands = new Map();
         this._topics = new Map();
-        if (options.config) {
-            if (Array.isArray(options.config.plugins) && Array.isArray(this.plugins)) {
-                // incoming config is v2 with plugins array and this config is v2 with plugins array
-                Object.assign(this, options.config);
-            }
-            else if (Array.isArray(options.config.plugins) && !Array.isArray(this.plugins)) {
-                // incoming config is v2 with plugins array and this config is v3 with plugin Map
-                Object.assign(this, options.config, { plugins: new Map(options.config.plugins.map(p => [p.name, p])) });
-            }
-            else if (!Array.isArray(options.config.plugins) && Array.isArray(this.plugins)) {
-                // incoming config is v3 with plugin Map and this config is v2 with plugins array
-                Object.assign(this, options.config, { plugins: options.config.getPluginsList() });
-            }
-            else {
-                // incoming config is v3 with plugin Map and this config is v3 with plugin Map
-                Object.assign(this, options.config);
-            }
-        }
     }
     static async load(opts = module.filename || __dirname) {
         // Handle the case when a file URL string is passed in such as 'import.meta.url'; covert to file path.
@@ -97,9 +79,6 @@ class Config {
         if (typeof opts === 'string')
             opts = { root: opts };
         if (isConfig(opts)) {
-            const { lt } = await import('semver');
-            const currentConfigBase = BASE.replace('@oclif/core@', '');
-            const incomingConfigBase = opts._base.replace('@oclif/core@', '');
             /**
              * Reload the Config based on the version required by the command.
              * This is needed because the command is given the Config instantiated
@@ -110,9 +89,11 @@ class Config {
              * exists in the version of Config required by the command but may not exist on the
              * root's instance of Config.
              */
-            if (lt(incomingConfigBase, currentConfigBase)) {
+            if (BASE !== opts._base) {
                 debug(`reloading config from ${opts._base} to ${BASE}`);
-                return new Config({ ...opts.options, config: opts });
+                const config = new Config({ ...opts.options, plugins: opts.plugins });
+                await config.load();
+                return config;
             }
             return opts;
         }
@@ -120,20 +101,23 @@ class Config {
         await config.load();
         return config;
     }
+    static get rootPlugin() {
+        return Config._rootPlugin;
+    }
     // eslint-disable-next-line complexity
     async load() {
-        if (this.options.config)
-            return;
         settings_1.settings.performanceEnabled = (settings_1.settings.performanceEnabled === undefined ? this.options.enablePerf : settings_1.settings.performanceEnabled) ?? false;
-        const plugin = new Plugin.Plugin({ root: this.options.root });
-        await plugin.load();
-        this.plugins.push(plugin);
-        this.root = plugin.root;
-        this.pjson = plugin.pjson;
+        this.pluginLoader = new plugin_loader_1.default({ root: this.options.root, plugins: this.options.plugins });
+        Config._rootPlugin = await this.pluginLoader.loadRoot();
+        this.root = Config._rootPlugin.root;
+        this.pjson = Config._rootPlugin.pjson;
+        this.plugins.set(Config._rootPlugin.name, Config._rootPlugin);
+        this.root = Config._rootPlugin.root;
+        this.pjson = Config._rootPlugin.pjson;
         this.name = this.pjson.name;
         this.version = this.options.version || this.pjson.version || '0.0.0';
         this.channel = this.options.channel || channelFromVersion(this.version);
-        this.valid = plugin.valid;
+        this.valid = Config._rootPlugin.valid;
         this.arch = (os.arch() === 'ia32' ? 'x86' : os.arch());
         this.platform = WSL ? 'wsl' : os.platform();
         this.windows = this.platform === 'win32';
@@ -181,70 +165,38 @@ class Config {
                 ...s3.templates && s3.templates.vanilla,
             },
         };
-        const marker = performance_1.Performance.mark('config.load');
+        const marker = performance_1.default.mark('config.load');
         await this.loadPluginsAndCommands();
         debug('config done');
         marker?.addDetails({
-            plugins: this.plugins.length,
+            plugins: this.plugins.size,
             commandPermutations: this.commands.length,
-            commands: this.plugins.reduce((acc, p) => acc + p.commands.length, 0),
+            commands: [...this.plugins.values()].reduce((acc, p) => acc + p.commands.length, 0),
             topics: this.topics.length,
         });
         marker?.stop();
     }
-    async loadPluginsAndCommands() {
-        const marker = performance_1.Performance.mark('config.loadPluginsAndCommands');
-        await this.loadUserPlugins();
-        await this.loadDevPlugins();
-        await this.loadCorePlugins();
-        for (const plugin of this.plugins) {
+    async loadPluginsAndCommands(opts) {
+        const marker = performance_1.default.mark('config.loadPluginsAndCommands');
+        const { plugins, errors } = await this.pluginLoader.loadChildren({
+            devPlugins: this.options.devPlugins,
+            userPlugins: this.options.userPlugins,
+            dataDir: this.dataDir,
+            rootPlugin: Config._rootPlugin,
+            force: opts?.force ?? false,
+        });
+        this.plugins = plugins;
+        for (const plugin of this.plugins.values()) {
             this.loadCommands(plugin);
             this.loadTopics(plugin);
         }
-        marker?.stop();
-    }
-    async loadCorePlugins() {
-        if (this.pjson.oclif.plugins) {
-            await this.loadPlugins(this.root, 'core', this.pjson.oclif.plugins);
-        }
-    }
-    async loadDevPlugins() {
-        if (this.options.devPlugins !== false) {
-            // do not load oclif.devPlugins in production
-            if (this.isProd)
-                return;
-            try {
-                const devPlugins = this.pjson.oclif.devPlugins;
-                if (devPlugins)
-                    await this.loadPlugins(this.root, 'dev', devPlugins);
-            }
-            catch (error) {
-                process.emitWarning(error);
-            }
-        }
-    }
-    async loadUserPlugins() {
-        if (this.options.userPlugins !== false) {
-            try {
-                const userPJSONPath = path.join(this.dataDir, 'package.json');
-                debug('reading user plugins pjson %s', userPJSONPath);
-                const pjson = await (0, util_2.loadJSON)(userPJSONPath);
-                this.userPJSON = pjson;
-                if (!pjson.oclif)
-                    pjson.oclif = { schema: 1 };
-                if (!pjson.oclif.plugins)
-                    pjson.oclif.plugins = [];
-                await this.loadPlugins(userPJSONPath, 'user', pjson.oclif.plugins.filter((p) => p.type === 'user'));
-                await this.loadPlugins(userPJSONPath, 'link', pjson.oclif.plugins.filter((p) => p.type === 'link'));
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT')
-                    process.emitWarning(error);
-            }
+        for (const error of errors) {
+            this.warn(error);
         }
+        marker?.stop();
     }
     async runHook(event, opts, timeout, captureErrors) {
-        const marker = performance_1.Performance.mark(`config.runHook#${event}`);
+        const marker = performance_1.default.mark(`config.runHook#${event}`);
         debug('start %s hook', event);
         const search = (m) => {
             if (typeof m === 'function')
@@ -269,7 +221,7 @@ class Config {
             successes: [],
             failures: [],
         };
-        const promises = this.plugins.map(async (p) => {
+        const promises = [...this.plugins.values()].map(async (p) => {
             const debug = require('debug')([this.bin, p.name, 'hooks', event].join(':'));
             const context = {
                 config: this,
@@ -289,7 +241,7 @@ class Config {
             };
             const hooks = p.hooks[event] || [];
             for (const hook of hooks) {
-                const marker = performance_1.Performance.mark(`config.runHook#${p.name}(${hook})`);
+                const marker = performance_1.default.mark(`config.runHook#${p.name}(${hook})`);
                 try {
                     /* eslint-disable no-await-in-loop */
                     const { isESM, module, filePath } = await module_loader_1.default.loadWithData(p, hook);
@@ -323,7 +275,7 @@ class Config {
         return final;
     }
     async runCommand(id, argv = [], cachedCommand = null) {
-        const marker = performance_1.Performance.mark(`config.runCommand#${id}`);
+        const marker = performance_1.default.mark(`config.runCommand#${id}`);
         debug('runCommand %s %o', id, argv);
         let c = cachedCommand ?? this.findCommand(id);
         if (!c) {
@@ -350,7 +302,7 @@ class Config {
             if (jitResult.failures[0])
                 throw jitResult.failures[0].error;
             if (jitResult.successes[0]) {
-                await this.loadPluginsAndCommands();
+                await this.loadPluginsAndCommands({ force: true });
                 c = this.findCommand(id) ?? c;
             }
             else {
@@ -477,7 +429,7 @@ class Config {
             cliVersion,
             architecture,
             nodeVersion,
-            pluginVersions: Object.fromEntries(this.plugins.map(p => [p.name, { version: p.version, type: p.type, root: p.root }])),
+            pluginVersions: Object.fromEntries([...this.plugins.values()].map(p => [p.name, { version: p.version, type: p.type, root: p.root }])),
             osVersion: `${os.type()} ${os.release()}`,
             shell: this.shell,
             rootPath: this.root,
@@ -500,7 +452,7 @@ class Config {
         return url.toString();
     }
     getPluginsList() {
-        return this.plugins;
+        return [...this.plugins.values()];
     }
     dir(category) {
         const base = process.env[`XDG_${category.toUpperCase()}_HOME`] ||
@@ -523,7 +475,7 @@ class Config {
     _shell() {
         let shellPath;
         const COMSPEC = process.env.COMSPEC;
-        const SHELL = process.env.SHELL ?? (0, os_1.userInfo)().shell?.split(path_1.sep)?.pop();
+        const SHELL = process.env.SHELL ?? (0, node_os_1.userInfo)().shell?.split(node_path_1.sep)?.pop();
         if (SHELL) {
             shellPath = SHELL.split('/');
         }
@@ -546,52 +498,6 @@ class Config {
         catch { }
         return 0;
     }
-    async loadPlugins(root, type, plugins, parent) {
-        if (!plugins || plugins.length === 0)
-            return;
-        const mark = performance_1.Performance.mark(`config.loadPlugins#${type}`);
-        debug('loading plugins', plugins);
-        await Promise.all((plugins || []).map(async (plugin) => {
-            try {
-                const opts = { type, root };
-                if (typeof plugin === 'string') {
-                    opts.name = plugin;
-                }
-                else {
-                    opts.name = plugin.name || opts.name;
-                    opts.tag = plugin.tag || opts.tag;
-                    opts.root = plugin.root || opts.root;
-                }
-                const pluginMarker = performance_1.Performance.mark(`plugin.load#${opts.name}`);
-                const instance = new Plugin.Plugin(opts);
-                await instance.load();
-                pluginMarker?.addDetails({
-                    hasManifest: instance.hasManifest,
-                    commandCount: instance.commands.length,
-                    topicCount: instance.topics.length,
-                    type: instance.type,
-                    usesMain: Boolean(instance.pjson.main),
-                    name: instance.name,
-                });
-                pluginMarker?.stop();
-                if (this.plugins.find(p => p.name === instance.name))
-                    return;
-                this.plugins.push(instance);
-                if (parent) {
-                    instance.parent = parent;
-                    if (!parent.children)
-                        parent.children = [];
-                    parent.children.push(instance);
-                }
-                await this.loadPlugins(instance.root, type, instance.pjson.oclif.plugins || [], instance);
-            }
-            catch (error) {
-                this.warn(error, 'loadPlugins');
-            }
-        }));
-        mark?.addDetails({ pluginCount: plugins.length });
-        mark?.stop();
-    }
     warn(err, scope) {
         if (this.warned)
             return;
@@ -630,7 +536,8 @@ class Config {
         return (0, util_3.isProd)();
     }
     isJitPluginCommand(c) {
-        return Object.keys(this.pjson.oclif.jitPlugins ?? {}).includes(c.pluginName ?? '') && !this.plugins.find(p => p.name === c?.pluginName);
+        // 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));
     }
     getCmdLookupId(id) {
         if (this._commands.has(id))
@@ -647,8 +554,9 @@ class Config {
         return id;
     }
     loadCommands(plugin) {
-        const marker = performance_1.Performance.mark(`config.loadCommands#${plugin.name}`, { plugin: plugin.name });
+        const marker = performance_1.default.mark(`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);
@@ -656,10 +564,11 @@ class Config {
             else {
                 this._commands.set(command.id, command);
             }
-            const permutations = this.flexibleTaxonomy ? (0, util_2.getCommandIdPermutations)(command.id) : [command.id];
-            for (const permutation of permutations) {
+            // set every permutation
+            for (const permutation of command.permutations ?? [command.id]) {
                 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]);
@@ -668,8 +577,8 @@ class Config {
                 else {
                     this._commands.set(alias, { ...command, id: alias });
                 }
-                const aliasPermutations = this.flexibleTaxonomy ? (0, util_2.getCommandIdPermutations)(alias) : [alias];
-                for (const permutation of aliasPermutations) {
+                // set every permutation of the aliases
+                for (const permutation of command.aliasPermutations ?? [alias]) {
                     this.commandPermutations.add(permutation, command.id);
                 }
             }
@@ -678,7 +587,7 @@ class Config {
         marker?.stop();
     }
     loadTopics(plugin) {
-        const marker = performance_1.Performance.mark(`config.loadTopics#${plugin.name}`, { plugin: plugin.name });
+        const marker = performance_1.default.mark(`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) {
@@ -769,23 +678,20 @@ class Config {
       */
     insertLegacyPlugins(plugins) {
         for (const plugin of plugins) {
-            const idx = this.plugins.findIndex(p => p.name === plugin.name);
-            if (idx !== -1) {
-                // invalid plugin instance found in `this.plugins`
-                // replace with the oclif-compatible one
-                this.plugins.splice(idx, 1, plugin);
-            }
+            this.plugins.set(plugin.name, plugin);
             this.loadCommands(plugin);
         }
     }
 }
 exports.Config = Config;
 // when no manifest exists, the default is calculated.  This may throw, so we need to catch it
-const defaultFlagToCached = async (flag, isWritingManifest = false) => {
-    // Prefer the helpDefaultValue function (returns a friendly string for complex types)
+const defaultFlagToCached = async (flag, respectNoCacheDefault) => {
+    if (respectNoCacheDefault && flag.noCacheDefault)
+        return;
+    // Prefer the defaultHelp function (returns a friendly string for complex types)
     if (typeof flag.defaultHelp === 'function') {
         try {
-            return await flag.defaultHelp({ options: flag, flags: {} }, isWritingManifest);
+            return await flag.defaultHelp({ options: flag, flags: {} });
         }
         catch {
             return;
@@ -794,7 +700,7 @@ const defaultFlagToCached = async (flag, isWritingManifest = false) => {
     // if not specified, try the default function
     if (typeof flag.default === 'function') {
         try {
-            return await flag.default({ options: flag, flags: {} }, isWritingManifest);
+            return await flag.default({ options: flag, flags: {} });
         }
         catch { }
     }
@@ -802,11 +708,13 @@ const defaultFlagToCached = async (flag, isWritingManifest = false) => {
         return flag.default;
     }
 };
-const defaultArgToCached = async (arg, isWritingManifest = false) => {
-    // Prefer the helpDefaultValue function (returns a friendly string for complex types)
+const defaultArgToCached = async (arg, respectNoCacheDefault) => {
+    if (respectNoCacheDefault && arg.noCacheDefault)
+        return;
+    // Prefer the defaultHelp function (returns a friendly string for complex types)
     if (typeof arg.defaultHelp === 'function') {
         try {
-            return await arg.defaultHelp({ options: arg, flags: {} }, isWritingManifest);
+            return await arg.defaultHelp({ options: arg, flags: {} });
         }
         catch {
             return;
@@ -815,7 +723,7 @@ const defaultArgToCached = async (arg, isWritingManifest = false) => {
     // if not specified, try the default function
     if (typeof arg.default === 'function') {
         try {
-            return await arg.default({ options: arg, flags: {} }, isWritingManifest);
+            return await arg.default({ options: arg, flags: {} });
         }
         catch { }
     }
@@ -823,7 +731,7 @@ const defaultArgToCached = async (arg, isWritingManifest = false) => {
         return arg.default;
     }
 };
-async function toCached(c, plugin, isWritingManifest) {
+async function toCached(c, plugin, respectNoCacheDefault = false) {
     const flags = {};
     for (const [name, flag] of Object.entries(c.flags || {})) {
         if (flag.type === 'boolean') {
@@ -845,6 +753,7 @@ async function toCached(c, plugin, isWritingManifest) {
                 deprecateAliases: c.deprecateAliases,
                 aliases: flag.aliases,
                 delimiter: flag.delimiter,
+                noCacheDefault: flag.noCacheDefault,
             };
         }
         else {
@@ -864,11 +773,12 @@ async function toCached(c, plugin, isWritingManifest) {
                 dependsOn: flag.dependsOn,
                 relationships: flag.relationships,
                 exclusive: flag.exclusive,
-                default: await defaultFlagToCached(flag, isWritingManifest),
+                default: await defaultFlagToCached(flag, respectNoCacheDefault),
                 deprecated: flag.deprecated,
                 deprecateAliases: c.deprecateAliases,
                 aliases: flag.aliases,
                 delimiter: flag.delimiter,
+                noCacheDefault: flag.noCacheDefault,
             };
             // a command-level placeholder in the manifest so that oclif knows it should regenerate the command during help-time
             if (typeof flag.defaultHelp === 'function') {
@@ -883,8 +793,9 @@ async function toCached(c, plugin, isWritingManifest) {
             description: arg.description,
             required: arg.required,
             options: arg.options,
-            default: await defaultArgToCached(arg, isWritingManifest),
+            default: await defaultArgToCached(arg, respectNoCacheDefault),
             hidden: arg.hidden,
+            noCacheDefault: arg.noCacheDefault,
         };
     }
     const stdProperties = {

package/lib/config/index.d.ts

@@ -1,3 +1,4 @@
-export { Config, toCached } from './config';
+export { Config } from './config';
+export { toCached } from './config';
 export { Plugin } from './plugin';
 export { tsPath } from './ts-node';

package/lib/config/index.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsPath = exports.Plugin = exports.toCached = exports.Config = void 0;
 var config_1 = require("./config");
 Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
-Object.defineProperty(exports, "toCached", { enumerable: true, get: function () { return config_1.toCached; } });
+var config_2 = require("./config");
+Object.defineProperty(exports, "toCached", { enumerable: true, get: function () { return config_2.toCached; } });
 var plugin_1 = require("./plugin");
 Object.defineProperty(exports, "Plugin", { enumerable: true, get: function () { return plugin_1.Plugin; } });
 var ts_node_1 = require("./ts-node");

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

@@ -0,0 +1,30 @@
+import { Plugin as IPlugin } from '../interfaces/plugin';
+type PluginLoaderOptions = {
+    root: string;
+    plugins?: IPlugin[] | PluginsMap;
+};
+type LoadOpts = {
+    devPlugins?: boolean;
+    userPlugins?: boolean;
+    dataDir: string;
+    rootPlugin: IPlugin;
+    force?: boolean;
+};
+type PluginsMap = Map<string, IPlugin>;
+export default class PluginLoader {
+    options: PluginLoaderOptions;
+    plugins: PluginsMap;
+    errors: (string | Error)[];
+    private pluginsProvided;
+    constructor(options: PluginLoaderOptions);
+    loadRoot(): Promise<IPlugin>;
+    loadChildren(opts: LoadOpts): Promise<{
+        plugins: PluginsMap;
+        errors: (string | Error)[];
+    }>;
+    private loadCorePlugins;
+    private loadDevPlugins;
+    private loadUserPlugins;
+    private loadPlugins;
+}
+export {};

package/lib/config/plugin-loader.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const Plugin = require("./plugin");
+const util_1 = require("./util");
+const util_2 = require("../util");
+const performance_1 = require("../performance");
+// eslint-disable-next-line new-cap
+const debug = (0, util_1.Debug)();
+class PluginLoader {
+    constructor(options) {
+        this.options = options;
+        this.plugins = new Map();
+        this.errors = [];
+        this.pluginsProvided = false;
+        if (options.plugins) {
+            this.pluginsProvided = true;
+            this.plugins = Array.isArray(options.plugins) ? new Map(options.plugins.map(p => [p.name, p])) : options.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 {
+            rootPlugin = new Plugin.Plugin({ root: this.options.root });
+            await rootPlugin.load();
+        }
+        this.plugins.set(rootPlugin.name, rootPlugin);
+        return rootPlugin;
+    }
+    async loadChildren(opts) {
+        if (!this.pluginsProvided || opts.force) {
+            await this.loadUserPlugins(opts);
+            await this.loadDevPlugins(opts);
+            await this.loadCorePlugins(opts);
+        }
+        return { plugins: this.plugins, errors: this.errors };
+    }
+    async loadCorePlugins(opts) {
+        if (opts.rootPlugin.pjson.oclif.plugins) {
+            await this.loadPlugins(opts.rootPlugin.root, 'core', opts.rootPlugin.pjson.oclif.plugins);
+        }
+    }
+    async loadDevPlugins(opts) {
+        if (opts.devPlugins !== false) {
+            // do not load oclif.devPlugins in production
+            if ((0, util_2.isProd)())
+                return;
+            try {
+                const devPlugins = opts.rootPlugin.pjson.oclif.devPlugins;
+                if (devPlugins)
+                    await this.loadPlugins(opts.rootPlugin.root, 'dev', devPlugins);
+            }
+            catch (error) {
+                process.emitWarning(error);
+            }
+        }
+    }
+    async loadUserPlugins(opts) {
+        if (opts.userPlugins !== false) {
+            try {
+                const userPJSONPath = path.join(opts.dataDir, 'package.json');
+                debug('reading user plugins pjson %s', userPJSONPath);
+                const pjson = await (0, util_1.loadJSON)(userPJSONPath);
+                if (!pjson.oclif)
+                    pjson.oclif = { schema: 1 };
+                if (!pjson.oclif.plugins)
+                    pjson.oclif.plugins = [];
+                await this.loadPlugins(userPJSONPath, 'user', pjson.oclif.plugins.filter((p) => p.type === 'user'));
+                await this.loadPlugins(userPJSONPath, 'link', pjson.oclif.plugins.filter((p) => p.type === 'link'));
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    process.emitWarning(error);
+            }
+        }
+    }
+    async loadPlugins(root, type, plugins, parent) {
+        if (!plugins || plugins.length === 0)
+            return;
+        const mark = performance_1.default.mark(`config.loadPlugins#${type}`);
+        debug('loading plugins', plugins);
+        await Promise.all((plugins || []).map(async (plugin) => {
+            try {
+                const name = typeof plugin === 'string' ? plugin : plugin.name;
+                const opts = {
+                    name,
+                    type,
+                    root,
+                };
+                if (typeof plugin !== 'string') {
+                    opts.tag = plugin.tag || opts.tag;
+                    opts.root = plugin.root || opts.root;
+                }
+                if (this.plugins.has(name))
+                    return;
+                const pluginMarker = performance_1.default.mark(`plugin.load#${name}`);
+                const instance = new Plugin.Plugin(opts);
+                await instance.load();
+                pluginMarker?.addDetails({
+                    hasManifest: instance.hasManifest,
+                    commandCount: instance.commands.length,
+                    topicCount: instance.topics.length,
+                    type: instance.type,
+                    usesMain: Boolean(instance.pjson.main),
+                    name: instance.name,
+                });
+                pluginMarker?.stop();
+                this.plugins.set(instance.name, instance);
+                if (parent) {
+                    instance.parent = parent;
+                    if (!parent.children)
+                        parent.children = [];
+                    parent.children.push(instance);
+                }
+                await this.loadPlugins(instance.root, type, instance.pjson.oclif.plugins || [], instance);
+            }
+            catch (error) {
+                this.errors.push(error);
+            }
+        }));
+        mark?.addDetails({ pluginCount: plugins.length });
+        mark?.stop();
+    }
+}
+exports.default = PluginLoader;