@oclif/core 2.14.0 → 2.15.0

package/lib/config/config.d.ts

@@ -1,7 +1,6 @@
 import { Options, Plugin as IPlugin } from '../interfaces/plugin';
 import { Config as IConfig, ArchTypes, PlatformTypes, LoadOptions, VersionDetails } from '../interfaces/config';
 import { Hook, Hooks, PJSON, Topic } from '../interfaces';
-import * as Plugin from './plugin';
 import { Command } from '../command';
 export declare class Config implements IConfig {
     options: Options;
@@ -39,13 +38,14 @@ export declare class Config implements IConfig {
     private _commands;
     private _topics;
     private _commandIDs;
+    private pluginLoader;
+    private rootPlugin;
     constructor(options: Options);
     static load(opts?: LoadOptions): Promise<Config>;
     load(): Promise<void>;
-    loadPluginsAndCommands(): Promise<void>;
-    loadCorePlugins(): Promise<void>;
-    loadDevPlugins(): Promise<void>;
-    loadUserPlugins(): Promise<void>;
+    loadPluginsAndCommands(opts?: {
+        force: boolean;
+    }): Promise<void>;
     runHook<T extends keyof Hooks>(event: T, opts: Hooks[T]['options'], timeout?: number, captureErrors?: boolean): Promise<Hook.Result<Hooks[T]['return']>>;
     runCommand<T = unknown>(id: string, argv?: string[], cachedCommand?: Command.Loadable | null): Promise<T>;
     scopedEnvVar(k: string): string | undefined;
@@ -112,11 +112,6 @@ export declare class Config implements IConfig {
     protected macosCacheDir(): string | undefined;
     protected _shell(): string;
     protected _debug(): number;
-    protected loadPlugins(root: string, type: string, plugins: (string | {
-        root?: string;
-        name?: string;
-        tag?: string;
-    })[], parent?: Plugin.Plugin): Promise<void>;
     protected warn(err: string | Error | {
         name: string;
         detail: string;

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");
@@ -17,6 +16,7 @@ const performance_1 = require("../performance");
 const settings_1 = require("../settings");
 const os_1 = require("os");
 const path_1 = require("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');
@@ -70,24 +70,6 @@ class Config {
         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;
         }
@@ -122,18 +103,15 @@ class Config {
     }
     // 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 });
+        this.rootPlugin = await this.pluginLoader.loadRoot();
+        this.root = this.rootPlugin.root;
+        this.pjson = this.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 = this.rootPlugin.valid;
         this.arch = (os.arch() === 'ia32' ? 'x86' : os.arch());
         this.platform = WSL ? 'wsl' : os.platform();
         this.windows = this.platform === 'win32';
@@ -192,56 +170,24 @@ class Config {
         });
         marker?.stop();
     }
-    async loadPluginsAndCommands() {
+    async loadPluginsAndCommands(opts) {
         const marker = performance_1.Performance.mark('config.loadPluginsAndCommands');
-        await this.loadUserPlugins();
-        await this.loadDevPlugins();
-        await this.loadCorePlugins();
+        const { plugins, errors } = await this.pluginLoader.loadChildren({
+            devPlugins: this.options.devPlugins,
+            userPlugins: this.options.userPlugins,
+            dataDir: this.dataDir,
+            rootPlugin: this.rootPlugin,
+            force: opts?.force ?? false,
+        });
+        this.plugins = [...plugins.values()];
         for (const plugin of this.plugins) {
             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}`);
@@ -350,7 +296,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 {
@@ -546,52 +492,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;

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

package/lib/interfaces/config.d.ts

@@ -96,7 +96,6 @@ export interface Config {
      * npm registry to use for installing plugins
      */
     npmRegistry?: string;
-    userPJSON?: PJSON.User;
     plugins: Plugin[];
     binPath?: string;
     /**

package/lib/interfaces/plugin.d.ts

@@ -1,4 +1,3 @@
-import { Config } from './config';
 import { Command } from '../command';
 import { PJSON } from './pjson';
 import { Topic } from './topic';
@@ -19,7 +18,7 @@ export interface Options extends PluginOptions {
     channel?: string;
     version?: string;
     enablePerf?: boolean;
-    config?: Config;
+    plugins?: Plugin[];
 }
 export interface Plugin {
     /**
@@ -76,5 +75,5 @@ export interface Plugin {
     findCommand(id: string, opts?: {
         must: boolean;
     }): Promise<Command.Class> | undefined;
-    load(isWritingManifest: boolean): Promise<void>;
+    load(isWritingManifest?: boolean): Promise<void>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {
@@ -23,7 +23,6 @@
     "natural-orderby": "^2.0.3",
     "object-treeify": "^1.1.33",
     "password-prompt": "^1.1.2",
-    "semver": "^7.5.4",
     "slice-ansi": "^4.0.0",
     "string-width": "^4.2.3",
     "strip-ansi": "^6.0.1",
@@ -53,7 +52,6 @@
     "@types/node": "^16",
     "@types/node-notifier": "^8.0.2",
     "@types/proxyquire": "^1.3.28",
-    "@types/semver": "^7.5.1",
     "@types/shelljs": "^0.8.11",
     "@types/slice-ansi": "^4.0.0",
     "@types/strip-ansi": "^5.2.1",