@oclif/core 3.0.0-beta.8 → 3.0.0

package/lib/config/index.d.ts

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

package/lib/config/index.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tsPath = exports.Plugin = exports.toCached = exports.Config = void 0;
+exports.tsPath = exports.Plugin = exports.Config = void 0;
 var config_1 = require("./config");
 Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
-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

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

package/lib/config/plugin-loader.js

@@ -1,44 +1,26 @@
 "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 tslib_1 = require("tslib");
+const node_path_1 = require("node:path");
 const performance_1 = require("../performance");
+const fs_1 = require("../util/fs");
+const util_1 = require("../util/util");
+const Plugin = tslib_1.__importStar(require("./plugin"));
+const util_2 = require("./util");
 // eslint-disable-next-line new-cap
-const debug = (0, util_1.Debug)();
+const debug = (0, util_2.Debug)();
 class PluginLoader {
+    options;
+    pluginsProvided = false;
+    errors = [];
+    plugins = new Map();
     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;
+            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);
@@ -47,10 +29,10 @@ class PluginLoader {
     async loadDevPlugins(opts) {
         if (opts.devPlugins !== false) {
             // do not load oclif.devPlugins in production
-            if ((0, util_2.isProd)())
+            if ((0, util_1.isProd)())
                 return;
             try {
-                const devPlugins = opts.rootPlugin.pjson.oclif.devPlugins;
+                const { devPlugins } = opts.rootPlugin.pjson.oclif;
                 if (devPlugins)
                     await this.loadPlugins(opts.rootPlugin.root, 'dev', devPlugins);
             }
@@ -59,54 +41,38 @@ class PluginLoader {
             }
         }
     }
-    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}`);
+        const mark = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `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,
+                    type,
                 };
                 if (typeof plugin !== 'string') {
                     opts.tag = plugin.tag || opts.tag;
                     opts.root = plugin.root || opts.root;
                 }
+                if (parent) {
+                    opts.parent = parent;
+                }
                 if (this.plugins.has(name))
                     return;
-                const pluginMarker = performance_1.default.mark(`plugin.load#${name}`);
+                const pluginMarker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.load#${name}`);
                 const instance = new Plugin.Plugin(opts);
                 await instance.load();
                 pluginMarker?.addDetails({
-                    hasManifest: instance.hasManifest,
                     commandCount: instance.commands.length,
+                    hasManifest: instance.hasManifest,
+                    name: instance.name,
                     topicCount: instance.topics.length,
                     type: instance.type,
                     usesMain: Boolean(instance.pjson.main),
-                    name: instance.name,
                 });
                 pluginMarker?.stop();
                 this.plugins.set(instance.name, instance);
@@ -125,5 +91,55 @@ class PluginLoader {
         mark?.addDetails({ pluginCount: plugins.length });
         mark?.stop();
     }
+    async loadUserPlugins(opts) {
+        if (opts.userPlugins !== false) {
+            try {
+                const userPJSONPath = (0, node_path_1.join)(opts.dataDir, 'package.json');
+                debug('reading user plugins pjson %s', userPJSONPath);
+                const pjson = await (0, fs_1.readJson)(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 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

@@ -1,45 +1,46 @@
-import { Plugin as IPlugin, PluginOptions } from '../interfaces/plugin';
+import { Command } from '../command';
 import { Manifest } from '../interfaces/manifest';
 import { PJSON } from '../interfaces/pjson';
+import { Plugin as IPlugin, PluginOptions } from '../interfaces/plugin';
 import { Topic } from '../interfaces/topic';
-import { Command } from '../command';
 export declare class Plugin implements IPlugin {
     options: PluginOptions;
     _base: string;
-    name: string;
-    version: string;
-    pjson: PJSON.Plugin;
-    type: string;
-    moduleType: 'module' | 'commonjs';
-    root: string;
+    private _commandsDir;
+    protected _debug: (..._: any) => void;
+    private flexibleTaxonomy;
     alias: string;
-    tag?: string;
-    manifest: Manifest;
+    alreadyLoaded: boolean;
+    children: Plugin[];
     commands: Command.Loadable[];
+    hasManifest: boolean;
     hooks: {
         [k: string]: string[];
     };
-    valid: boolean;
-    alreadyLoaded: boolean;
+    isRoot: boolean;
+    manifest: Manifest;
+    moduleType: 'commonjs' | 'module';
+    name: string;
     parent: Plugin | undefined;
-    children: Plugin[];
-    hasManifest: boolean;
-    private _commandsDir;
-    private flexibleTaxonomy;
-    protected _debug: (..._: any) => void;
+    pjson: PJSON.Plugin;
+    root: string;
+    tag?: string;
+    type: string;
+    valid: boolean;
+    version: string;
     protected warned: boolean;
     constructor(options: PluginOptions);
-    load(): Promise<void>;
-    get topics(): Topic[];
-    get commandsDir(): string | undefined;
-    get commandIDs(): string[];
+    private _manifest;
+    private addErrorScope;
+    private warn;
     findCommand(id: string, opts: {
         must: true;
     }): Promise<Command.Class>;
     findCommand(id: string, opts?: {
         must: boolean;
     }): Promise<Command.Class | undefined>;
-    private _manifest;
-    private warn;
-    private addErrorScope;
+    load(): Promise<void>;
+    get commandIDs(): string[];
+    get commandsDir(): string | undefined;
+    get topics(): Topic[];
 }