@oclif/core 3.0.0-beta.2 → 3.0.0-beta.20

package/lib/config/index.d.ts

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

package/lib/config/index.js

@@ -1,9 +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; } });
-Object.defineProperty(exports, "toCached", { enumerable: true, get: function () { return config_1.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,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Plugin = tslib_1.__importStar(require("./plugin"));
+const util_1 = require("./util");
+const performance_1 = require("../performance");
+const util_2 = require("../util/util");
+const node_path_1 = require("node:path");
+const fs_1 = require("../util/fs");
+// eslint-disable-next-line new-cap
+const debug = (0, util_1.Debug)();
+class PluginLoader {
+    options;
+    plugins = new Map();
+    errors = [];
+    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;
+        }
+    }
+    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('plugin.load#root');
+            rootPlugin = new Plugin.Plugin({ root: this.options.root, isRoot: true });
+            await rootPlugin.load();
+            marker?.addDetails({
+                hasManifest: rootPlugin.hasManifest ?? false,
+                commandCount: rootPlugin.commands.length,
+                topicCount: rootPlugin.topics.length,
+                type: rootPlugin.type,
+                usesMain: Boolean(rootPlugin.pjson.main),
+                name: rootPlugin.name,
+            });
+            marker?.stop();
+        }
+        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;
+                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 = (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 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 (parent) {
+                    opts.parent = parent;
+                }
+                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/config/plugin.d.ts

@@ -1,9 +1,8 @@
-import { CLIError } from '../errors';
 import { Plugin as IPlugin, PluginOptions } from '../interfaces/plugin';
+import { Command } from '../command';
 import { Manifest } from '../interfaces/manifest';
 import { PJSON } from '../interfaces/pjson';
 import { Topic } from '../interfaces/topic';
-import { Command } from '../command';
 export declare class Plugin implements IPlugin {
     options: PluginOptions;
     _base: string;
@@ -25,17 +24,13 @@ export declare class Plugin implements IPlugin {
     parent: Plugin | undefined;
     children: Plugin[];
     hasManifest: boolean;
+    isRoot: boolean;
     private _commandsDir;
+    private flexibleTaxonomy;
     protected _debug: (..._: any) => void;
     protected warned: boolean;
     constructor(options: PluginOptions);
-    /**
-     * Loads a plugin
-     * @param isWritingManifest - if true, exclude selected data from manifest
-     * default is false to maintain backwards compatibility
-     * @returns Promise<void>
-     */
-    load(isWritingManifest?: boolean): Promise<void>;
+    load(): Promise<void>;
     get topics(): Topic[];
     get commandsDir(): string | undefined;
     get commandIDs(): string[];
@@ -45,7 +40,7 @@ export declare class Plugin implements IPlugin {
     findCommand(id: string, opts?: {
         must: boolean;
     }): Promise<Command.Class | undefined>;
-    protected _manifest(ignoreManifest: boolean, errorOnManifestCreate?: boolean, isWritingManifest?: boolean): Promise<Manifest>;
-    protected warn(err: string | Error | CLIError, scope?: string): void;
+    private _manifest;
+    private warn;
     private addErrorScope;
 }

package/lib/config/plugin.js

@@ -2,43 +2,43 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Plugin = void 0;
 const errors_1 = require("../errors");
-const globby = require("globby");
-const path = require("path");
-const util_1 = require("util");
-const config_1 = require("./config");
-const util_2 = require("./util");
-const ts_node_1 = require("./ts-node");
-const util_3 = require("./util");
-const util_4 = require("../util");
+const util_1 = require("./util");
+const util_2 = require("../util/util");
+const node_path_1 = require("node:path");
+const fs_1 = require("../util/fs");
 const module_loader_1 = require("../module-loader");
 const performance_1 = require("../performance");
-const _pjson = (0, util_4.requireJson)(__dirname, '..', '..', 'package.json');
+const cache_command_1 = require("../util/cache-command");
+const node_util_1 = require("node:util");
+const globby_1 = require("globby");
+const ts_node_1 = require("./ts-node");
+const _pjson = (0, fs_1.requireJson)(__dirname, '..', '..', 'package.json');
 function topicsToArray(input, base) {
     if (!input)
         return [];
     base = base ? `${base}:` : '';
     if (Array.isArray(input)) {
-        return [...input, ...(0, util_3.flatMap)(input, t => topicsToArray(t.subtopics, `${base}${t.name}`))];
+        return [...input, input.flatMap((t) => topicsToArray(t.subtopics, `${base}${t.name}`))];
     }
-    return (0, util_3.flatMap)(Object.keys(input), k => {
+    return Object.keys(input).flatMap((k) => {
         input[k].name = k;
         return [{ ...input[k], name: `${base}${k}` }, ...topicsToArray(input[k].subtopics, `${base}${input[k].name}`)];
     });
 }
 // essentially just "cd .."
 function* up(from) {
-    while (path.dirname(from) !== from) {
+    while ((0, node_path_1.dirname)(from) !== from) {
         yield from;
-        from = path.dirname(from);
+        from = (0, node_path_1.dirname)(from);
     }
     yield from;
 }
 async function findSourcesRoot(root) {
     for (const next of up(root)) {
-        const cur = path.join(next, 'package.json');
+        const cur = (0, node_path_1.join)(next, 'package.json');
         // eslint-disable-next-line no-await-in-loop
-        if (await (0, util_3.exists)(cur))
-            return path.dirname(cur);
+        if (await (0, fs_1.exists)(cur))
+            return (0, node_path_1.dirname)(cur);
     }
 }
 /**
@@ -56,23 +56,23 @@ async function findRootLegacy(name, root) {
     for (const next of up(root)) {
         let cur;
         if (name) {
-            cur = path.join(next, 'node_modules', name, 'package.json');
+            cur = (0, node_path_1.join)(next, 'node_modules', name, 'package.json');
             // eslint-disable-next-line no-await-in-loop
-            if (await (0, util_3.exists)(cur))
-                return path.dirname(cur);
+            if (await (0, fs_1.exists)(cur))
+                return (0, node_path_1.dirname)(cur);
             try {
                 // eslint-disable-next-line no-await-in-loop
-                const pkg = await (0, util_3.loadJSON)(path.join(next, 'package.json'));
+                const pkg = await (0, fs_1.readJson)((0, node_path_1.join)(next, 'package.json'));
                 if (pkg.name === name)
                     return next;
             }
             catch { }
         }
         else {
-            cur = path.join(next, 'package.json');
+            cur = (0, node_path_1.join)(next, 'package.json');
             // eslint-disable-next-line no-await-in-loop
-            if (await (0, util_3.exists)(cur))
-                return path.dirname(cur);
+            if (await (0, fs_1.exists)(cur))
+                return (0, node_path_1.dirname)(cur);
         }
     }
 }
@@ -80,51 +80,75 @@ async function findRoot(name, root) {
     if (name) {
         let pkgPath;
         try {
-            pkgPath = (0, util_3.resolvePackage)(name, { paths: [root] });
+            pkgPath = (0, util_1.resolvePackage)(name, { paths: [root] });
         }
         catch { }
-        return pkgPath ? findSourcesRoot(path.dirname(pkgPath)) : findRootLegacy(name, root);
+        return pkgPath ? findSourcesRoot((0, node_path_1.dirname)(pkgPath)) : findRootLegacy(name, root);
     }
     return findSourcesRoot(root);
 }
+const cachedCommandCanBeUsed = (manifest, id) => Boolean(manifest?.commands[id] && 'isESM' in manifest.commands[id] && 'relativePath' in manifest.commands[id]);
+const search = (cmd) => {
+    if (typeof cmd.run === 'function')
+        return cmd;
+    if (cmd.default && cmd.default.run)
+        return cmd.default;
+    return Object.values(cmd).find((cmd) => typeof cmd.run === 'function');
+};
 class Plugin {
+    options;
+    _base = `${_pjson.name}@${_pjson.version}`;
+    name;
+    version;
+    pjson;
+    type;
+    moduleType;
+    root;
+    alias;
+    tag;
+    manifest;
+    commands;
+    hooks;
+    valid = false;
+    alreadyLoaded = false;
+    parent;
+    children = [];
+    hasManifest = false;
+    isRoot = false;
+    _commandsDir;
+    flexibleTaxonomy;
+    // eslint-disable-next-line new-cap
+    _debug = (0, util_1.Debug)();
+    warned = false;
     constructor(options) {
         this.options = options;
-        // static loadedPlugins: {[name: string]: Plugin} = {}
-        this._base = `${_pjson.name}@${_pjson.version}`;
-        this.valid = false;
-        this.alreadyLoaded = false;
-        this.children = [];
-        this.hasManifest = false;
-        // eslint-disable-next-line new-cap
-        this._debug = (0, util_2.Debug)();
-        this.warned = false;
     }
-    /**
-     * Loads a plugin
-     * @param isWritingManifest - if true, exclude selected data from manifest
-     * default is false to maintain backwards compatibility
-     * @returns Promise<void>
-     */
-    async load(isWritingManifest) {
+    async load() {
         this.type = this.options.type || 'core';
         this.tag = this.options.tag;
-        const root = await findRoot(this.options.name, this.options.root);
+        this.isRoot = this.options.isRoot ?? false;
+        if (this.options.parent)
+            this.parent = this.options.parent;
+        // 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.type === 'link' && !this.parent ? this.options.root : await findRoot(this.options.name, this.options.root);
         if (!root)
-            throw new Error(`could not find package.json with ${(0, util_1.inspect)(this.options)}`);
+            throw new errors_1.CLIError(`could not find package.json with ${(0, node_util_1.inspect)(this.options)}`);
         this.root = root;
         this._debug('reading %s plugin %s', this.type, root);
-        this.pjson = await (0, util_3.loadJSON)(path.join(root, 'package.json'));
+        this.pjson = await (0, fs_1.readJson)((0, node_path_1.join)(root, 'package.json'));
+        this.flexibleTaxonomy = this.options?.flexibleTaxonomy || this.pjson.oclif?.flexibleTaxonomy || false;
         this.moduleType = this.pjson.type === 'module' ? 'module' : 'commonjs';
         this.name = this.pjson.name;
         this.alias = this.options.name ?? this.pjson.name;
-        const pjsonPath = path.join(root, 'package.json');
+        const pjsonPath = (0, node_path_1.join)(root, 'package.json');
         if (!this.name)
-            throw new Error(`no name in ${pjsonPath}`);
-        if (!(0, util_4.isProd)() && !this.pjson.files)
+            throw new errors_1.CLIError(`no name in ${pjsonPath}`);
+        if (!(0, util_2.isProd)() && !this.pjson.files)
             this.warn(`files attribute must be specified in ${pjsonPath}`);
         // eslint-disable-next-line new-cap
-        this._debug = (0, util_2.Debug)(this.name);
+        this._debug = (0, util_1.Debug)(this.name);
         this.version = this.pjson.version;
         if (this.pjson.oclif) {
             this.valid = true;
@@ -132,10 +156,9 @@ class Plugin {
         else {
             this.pjson.oclif = this.pjson['cli-engine'] || {};
         }
-        this.hooks = (0, util_3.mapValues)(this.pjson.oclif.hooks || {}, i => Array.isArray(i) ? i : [i]);
-        this.manifest = await this._manifest(Boolean(this.options.ignoreManifest), Boolean(this.options.errorOnManifestCreate), isWritingManifest);
-        this.commands = Object
-            .entries(this.manifest.commands)
+        this.hooks = (0, util_2.mapValues)(this.pjson.oclif.hooks || {}, (i) => (Array.isArray(i) ? i : [i]));
+        this.manifest = await this._manifest();
+        this.commands = Object.entries(this.manifest.commands)
             .map(([id, c]) => ({
             ...c,
             pluginAlias: this.alias,
@@ -158,16 +181,12 @@ class Plugin {
             return [];
         const marker = performance_1.Performance.mark(`plugin.commandIDs#${this.name}`, { plugin: this.name });
         this._debug(`loading IDs from ${this.commandsDir}`);
-        const patterns = [
-            '**/*.+(js|cjs|mjs|ts|tsx)',
-            '!**/*.+(d.ts|test.ts|test.js|spec.ts|spec.js)?(x)',
-        ];
-        const ids = globby.sync(patterns, { cwd: this.commandsDir })
-            .map(file => {
-            const p = path.parse(file);
+        const patterns = ['**/*.+(js|cjs|mjs|ts|tsx)', '!**/*.+(d.ts|test.ts|test.js|spec.ts|spec.js)?(x)'];
+        const ids = (0, globby_1.sync)(patterns, { cwd: this.commandsDir }).map((file) => {
+            const p = (0, node_path_1.parse)(file);
             const topics = p.dir.split('/');
             const command = p.name !== 'index' && p.name;
-            const id = [...topics, command].filter(f => f).join(':');
+            const id = [...topics, command].filter(Boolean).join(':');
             return id === '' ? '.' : id;
         });
         this._debug('found commands', ids);
@@ -180,30 +199,28 @@ class Plugin {
         const fetch = async () => {
             if (!this.commandsDir)
                 return;
-            const search = (cmd) => {
-                if (typeof cmd.run === 'function')
-                    return cmd;
-                if (cmd.default && cmd.default.run)
-                    return cmd.default;
-                return Object.values(cmd).find((cmd) => typeof cmd.run === 'function');
-            };
-            let m;
+            let module;
+            let isESM;
+            let filePath;
             try {
-                const p = path.join(this.commandsDir ?? this.pjson.oclif.commands, ...id.split(':'));
-                const { isESM, module, filePath } = await module_loader_1.default.loadWithData(this, p);
+                ;
+                ({ isESM, module, filePath } = cachedCommandCanBeUsed(this.manifest, id)
+                    ? await (0, module_loader_1.loadWithDataFromManifest)(this.manifest.commands[id], this.root)
+                    : await (0, module_loader_1.loadWithData)(this, (0, node_path_1.join)(this.commandsDir ?? this.pjson.oclif.commands, ...id.split(':'))));
                 this._debug(isESM ? '(import)' : '(require)', filePath);
-                m = module;
             }
             catch (error) {
                 if (!opts.must && error.code === 'MODULE_NOT_FOUND')
                     return;
                 throw error;
             }
-            const cmd = search(m);
+            const cmd = search(module);
             if (!cmd)
                 return;
             cmd.id = id;
             cmd.plugin = this;
+            cmd.isESM = isESM;
+            cmd.relativePath = (0, node_path_1.relative)(this.root, filePath || '').split(node_path_1.sep);
             return cmd;
         };
         const cmd = await fetch();
@@ -212,11 +229,14 @@ class Plugin {
         marker?.stop();
         return cmd;
     }
-    async _manifest(ignoreManifest, errorOnManifestCreate = false, isWritingManifest = false) {
+    async _manifest() {
+        const ignoreManifest = Boolean(this.options.ignoreManifest);
+        const errorOnManifestCreate = Boolean(this.options.errorOnManifestCreate);
+        const respectNoCacheDefault = Boolean(this.options.respectNoCacheDefault);
         const readManifest = async (dotfile = false) => {
             try {
-                const p = path.join(this.root, `${dotfile ? '.' : ''}oclif.manifest.json`);
-                const manifest = await (0, util_3.loadJSON)(p);
+                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]) {
                     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.`);
                 }
@@ -249,16 +269,23 @@ class Plugin {
             version: this.version,
             commands: (await Promise.all(this.commandIDs.map(async (id) => {
                 try {
-                    return [id, await (0, config_1.toCached)(await this.findCommand(id, { must: true }), this, isWritingManifest)];
+                    const cached = await (0, cache_command_1.cacheCommand)(await this.findCommand(id, { must: true }), this, respectNoCacheDefault);
+                    if (this.flexibleTaxonomy) {
+                        const permutations = (0, util_1.getCommandIdPermutations)(id);
+                        const aliasPermutations = cached.aliases.flatMap((a) => (0, util_1.getCommandIdPermutations)(a));
+                        return [id, { ...cached, permutations, aliasPermutations }];
+                    }
+                    return [id, cached];
                 }
                 catch (error) {
-                    const scope = 'toCached';
+                    const scope = 'cacheCommand';
                     if (Boolean(errorOnManifestCreate) === false)
                         this.warn(error, scope);
                     else
                         throw this.addErrorScope(error, scope);
                 }
             })))
+                // eslint-disable-next-line unicorn/no-await-expression-member, unicorn/prefer-native-coercion-functions
                 .filter((f) => Boolean(f))
                 .reduce((commands, [id, c]) => {
                 commands[id] = c;
@@ -278,7 +305,14 @@ class Plugin {
     }
     addErrorScope(err, scope) {
         err.name = `${err.name} Plugin: ${this.name}`;
-        err.detail = (0, util_3.compact)([err.detail, `module: ${this._base}`, scope && `task: ${scope}`, `plugin: ${this.name}`, `root: ${this.root}`, 'See more details with DEBUG=*']).join('\n');
+        err.detail = (0, util_2.compact)([
+            err.detail,
+            `module: ${this._base}`,
+            scope && `task: ${scope}`,
+            `plugin: ${this.name}`,
+            `root: ${this.root}`,
+            'See more details with DEBUG=*',
+        ]).join('\n');
         return err;
     }
 }

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

@@ -1,4 +1,5 @@
-import { Plugin } from '../interfaces';
+import { Plugin, TSConfig } from '../interfaces';
+export declare const TS_CONFIGS: Record<string, TSConfig>;
 /**
  * Convert a path from the compiled ./lib files to the ./src typescript source
  * this is for developing typescript plugins/CLIs