@oclif/core 3.0.0-beta.8 → 3.0.0

package/lib/config/plugin.js

@@ -1,44 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Plugin = void 0;
+const globby_1 = require("globby");
+const node_path_1 = require("node:path");
+const node_util_1 = require("node:util");
 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 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 fs_1 = require("../util/fs");
+const util_1 = require("../util/util");
+const ts_node_1 = require("./ts-node");
+const util_2 = require("./util");
+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,131 +80,48 @@ async function findRoot(name, root) {
     if (name) {
         let pkgPath;
         try {
-            pkgPath = (0, util_3.resolvePackage)(name, { paths: [root] });
+            pkgPath = (0, util_2.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}`;
+    _commandsDir;
+    // eslint-disable-next-line new-cap
+    _debug = (0, util_2.Debug)();
+    flexibleTaxonomy;
+    alias;
+    alreadyLoaded = false;
+    children = [];
+    commands;
+    hasManifest = false;
+    hooks;
+    isRoot = false;
+    manifest;
+    moduleType;
+    name;
+    parent;
+    pjson;
+    root;
+    tag;
+    type;
+    valid = false;
+    version;
+    warned = false;
     constructor(options) {
         this.options = options;
-        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;
-    }
-    async load() {
-        this.type = this.options.type || 'core';
-        this.tag = this.options.tag;
-        const root = await findRoot(this.options.name, this.options.root);
-        if (!root)
-            throw new errors_1.CLIError(`could not find package.json with ${(0, 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.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');
-        if (!this.name)
-            throw new errors_1.CLIError(`no name in ${pjsonPath}`);
-        if (!(0, util_4.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.version = this.pjson.version;
-        if (this.pjson.oclif) {
-            this.valid = true;
-        }
-        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();
-        this.commands = Object
-            .entries(this.manifest.commands)
-            .map(([id, c]) => ({
-            ...c,
-            pluginAlias: this.alias,
-            pluginType: c.pluginType === 'jit' ? 'jit' : this.type,
-            load: async () => this.findCommand(id, { must: true }),
-        }))
-            .sort((a, b) => a.id.localeCompare(b.id));
-    }
-    get topics() {
-        return topicsToArray(this.pjson.oclif.topics || {});
-    }
-    get commandsDir() {
-        if (this._commandsDir)
-            return this._commandsDir;
-        this._commandsDir = (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands, this);
-        return this._commandsDir;
-    }
-    get commandIDs() {
-        if (!this.commandsDir)
-            return [];
-        const marker = performance_1.default.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 topics = p.dir.split('/');
-            const command = p.name !== 'index' && p.name;
-            const id = [...topics, command].filter(f => f).join(':');
-            return id === '' ? '.' : id;
-        });
-        this._debug('found commands', ids);
-        marker?.addDetails({ count: ids.length });
-        marker?.stop();
-        return ids;
-    }
-    async findCommand(id, opts = {}) {
-        const marker = performance_1.default.mark(`plugin.findCommand#${this.name}.${id}`, { id, plugin: this.name });
-        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;
-            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);
-                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);
-            if (!cmd)
-                return;
-            cmd.id = id;
-            cmd.plugin = this;
-            return cmd;
-        };
-        const cmd = await fetch();
-        if (!cmd && opts.must)
-            (0, errors_1.error)(`command ${id} not found`);
-        marker?.stop();
-        return cmd;
     }
     async _manifest() {
         const ignoreManifest = Boolean(this.options.ignoreManifest);
@@ -212,8 +129,8 @@ class Plugin {
         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.`);
                 }
@@ -233,45 +150,58 @@ class Plugin {
                 }
             }
         };
-        const marker = performance_1.default.mark(`plugin.manifest#${this.name}`, { plugin: this.name });
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.manifest#${this.name}`, { plugin: this.name });
         if (!ignoreManifest) {
             const manifest = await readManifest();
             if (manifest) {
-                marker?.addDetails({ fromCache: true, commandCount: Object.keys(manifest.commands).length });
+                marker?.addDetails({ commandCount: Object.keys(manifest.commands).length, fromCache: true });
                 marker?.stop();
                 return manifest;
             }
         }
         const manifest = {
-            version: this.version,
             commands: (await Promise.all(this.commandIDs.map(async (id) => {
                 try {
-                    const cached = await (0, config_1.toCached)(await this.findCommand(id, { must: true }), this, respectNoCacheDefault);
+                    const cached = await (0, cache_command_1.cacheCommand)(await this.findCommand(id, { must: true }), this, respectNoCacheDefault);
                     if (this.flexibleTaxonomy) {
                         const permutations = (0, util_2.getCommandIdPermutations)(id);
-                        const aliasPermutations = cached.aliases.flatMap(a => (0, util_2.getCommandIdPermutations)(a));
-                        return [id, { ...cached, permutations, aliasPermutations }];
+                        const aliasPermutations = cached.aliases.flatMap((a) => (0, util_2.getCommandIdPermutations)(a));
+                        return [id, { ...cached, aliasPermutations, permutations }];
                     }
                     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;
                 return commands;
             }, {}),
+            version: this.version,
         };
-        marker?.addDetails({ fromCache: false, commandCount: Object.keys(manifest.commands).length });
+        marker?.addDetails({ commandCount: Object.keys(manifest.commands).length, fromCache: false });
         marker?.stop();
         return manifest;
     }
+    addErrorScope(err, scope) {
+        err.name = `${err.name} Plugin: ${this.name}`;
+        err.detail = (0, util_1.compact)([
+            err.detail,
+            `module: ${this._base}`,
+            scope && `task: ${scope}`,
+            `plugin: ${this.name}`,
+            `root: ${this.root}`,
+            'See more details with DEBUG=*',
+        ]).join('\n');
+        return err;
+    }
     warn(err, scope) {
         if (this.warned)
             return;
@@ -279,10 +209,114 @@ class Plugin {
             err = new Error(err);
         process.emitWarning(this.addErrorScope(err, scope));
     }
-    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');
-        return err;
+    async findCommand(id, opts = {}) {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.findCommand#${this.name}.${id}`, {
+            id,
+            plugin: this.name,
+        });
+        const fetch = async () => {
+            if (!this.commandsDir)
+                return;
+            let module;
+            let isESM;
+            let filePath;
+            try {
+                ;
+                ({ filePath, isESM, module } = 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);
+            }
+            catch (error) {
+                if (!opts.must && error.code === 'MODULE_NOT_FOUND')
+                    return;
+                throw error;
+            }
+            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();
+        if (!cmd && opts.must)
+            (0, errors_1.error)(`command ${id} not found`);
+        marker?.stop();
+        return cmd;
+    }
+    async load() {
+        this.type = this.options.type || 'core';
+        this.tag = this.options.tag;
+        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 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, 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 = (0, node_path_1.join)(root, 'package.json');
+        if (!this.name)
+            throw new errors_1.CLIError(`no name in ${pjsonPath}`);
+        if (!(0, util_1.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.version = this.pjson.version;
+        if (this.pjson.oclif) {
+            this.valid = true;
+        }
+        else {
+            this.pjson.oclif = this.pjson['cli-engine'] || {};
+        }
+        this.hooks = (0, util_1.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,
+            load: async () => this.findCommand(id, { must: true }),
+            pluginAlias: this.alias,
+            pluginType: c.pluginType === 'jit' ? 'jit' : this.type,
+        }))
+            .sort((a, b) => a.id.localeCompare(b.id));
+    }
+    get commandIDs() {
+        if (!this.commandsDir)
+            return [];
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `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 = (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(Boolean).join(':');
+            return id === '' ? '.' : id;
+        });
+        this._debug('found commands', ids);
+        marker?.addDetails({ count: ids.length });
+        marker?.stop();
+        return ids;
+    }
+    get commandsDir() {
+        if (this._commandsDir)
+            return this._commandsDir;
+        this._commandsDir = (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands, this);
+        return this._commandsDir;
+    }
+    get topics() {
+        return topicsToArray(this.pjson.oclif.topics || {});
     }
 }
 exports.Plugin = Plugin;

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