@oclif/core 3.5.0 → 3.6.0

package/lib/config/plugin.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Plugin = void 0;
-/* eslint-disable no-await-in-loop */
 const globby_1 = require("globby");
 const node_path_1 = require("node:path");
 const node_util_1 = require("node:util");
@@ -9,6 +8,7 @@ const errors_1 = require("../errors");
 const module_loader_1 = require("../module-loader");
 const performance_1 = require("../performance");
 const cache_command_1 = require("../util/cache-command");
+const find_root_1 = require("../util/find-root");
 const fs_1 = require("../util/fs");
 const util_1 = require("../util/util");
 const ts_node_1 = require("./ts-node");
@@ -26,79 +26,6 @@ function topicsToArray(input, base) {
         return [{ ...input[k], name: `${base}${k}` }, ...topicsToArray(input[k].subtopics, `${base}${input[k].name}`)];
     });
 }
-// essentially just "cd .."
-function* up(from) {
-    while ((0, node_path_1.dirname)(from) !== from) {
-        yield from;
-        from = (0, node_path_1.dirname)(from);
-    }
-    yield from;
-}
-async function findSourcesRoot(root, name) {
-    // If we know the plugin name then we just need to traverse the file
-    // system until we find the directory that matches the plugin name.
-    if (name) {
-        for (const next of up(root)) {
-            if (next.endsWith((0, node_path_1.basename)(name)))
-                return next;
-        }
-    }
-    // If there's no plugin name (typically just the root plugin), then we need
-    // to traverse the file system until we find a directory with a package.json
-    for (const next of up(root)) {
-        // Skip the bin directory
-        if ((0, node_path_1.basename)((0, node_path_1.dirname)(next)) === 'bin' &&
-            ['dev', 'dev.cmd', 'dev.js', 'run', 'run.cmd', 'run.js'].includes((0, node_path_1.basename)(next))) {
-            continue;
-        }
-        try {
-            const cur = (0, node_path_1.join)(next, 'package.json');
-            if (await (0, fs_1.safeReadJson)(cur))
-                return (0, node_path_1.dirname)(cur);
-        }
-        catch { }
-    }
-}
-/**
- * Find package root for packages installed into node_modules. This will go up directories
- * until it finds a node_modules directory with the plugin installed into it
- *
- * This is needed because some oclif plugins do not declare the `main` field in their package.json
- * https://github.com/oclif/config/pull/289#issuecomment-983904051
- *
- * @returns string
- * @param name string
- * @param root string
- */
-async function findRootLegacy(name, root) {
-    for (const next of up(root)) {
-        let cur;
-        if (name) {
-            cur = (0, node_path_1.join)(next, 'node_modules', name, 'package.json');
-            if (await (0, fs_1.safeReadJson)(cur))
-                return (0, node_path_1.dirname)(cur);
-            const pkg = await (0, fs_1.safeReadJson)((0, node_path_1.join)(next, 'package.json'));
-            if (pkg?.name === name)
-                return next;
-        }
-        else {
-            cur = (0, node_path_1.join)(next, 'package.json');
-            if (await (0, fs_1.safeReadJson)(cur))
-                return (0, node_path_1.dirname)(cur);
-        }
-    }
-}
-async function findRoot(name, root) {
-    if (name) {
-        let pkgPath;
-        try {
-            pkgPath = (0, util_2.resolvePackage)(name, { paths: [root] });
-        }
-        catch { }
-        return pkgPath ? findSourcesRoot((0, node_path_1.dirname)(pkgPath), name) : 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')
@@ -212,7 +139,7 @@ class Plugin {
         // 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);
+        const root = this.type === 'link' && !this.parent ? this.options.root : await (0, find_root_1.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;

package/lib/config/ts-node.js

@@ -25,7 +25,7 @@ function loadTSConfig(root) {
     }
     catch {
         try {
-            typescript = require((0, node_path_1.join)(root, 'node_modules', 'typescript'));
+            typescript = require(require.resolve('typescript', { paths: [root, __dirname] }));
         }
         catch {
             debug(`Could not find typescript dependency. Skipping ts-node registration for ${root}.`);

package/lib/config/util.d.ts

@@ -1,6 +1,3 @@
-export declare function resolvePackage(id: string, paths: {
-    paths: string[];
-}): string;
 export declare function Debug(...scope: string[]): (..._: any) => void;
 export declare function getPermutations(arr: string[]): Array<string[]>;
 export declare function getCommandIdPermutations(commandId: string): string[];

package/lib/config/util.js

@@ -1,11 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectUsableIds = exports.getCommandIdPermutations = exports.getPermutations = exports.Debug = exports.resolvePackage = void 0;
+exports.collectUsableIds = exports.getCommandIdPermutations = exports.getPermutations = exports.Debug = void 0;
 const debug = require('debug');
-function resolvePackage(id, paths) {
-    return require.resolve(id, paths);
-}
-exports.resolvePackage = resolvePackage;
 function displayWarnings() {
     if (process.listenerCount('warning') > 1)
         return;

package/lib/util/find-root.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Returns the root directory of the plugin.
+ *
+ * It first attempts to use require.resolve to find the plugin root.
+ * If that returns a path, it will `cd` up the file system until if finds the package.json for the plugin
+ * Example: node_modules/@oclif/plugin-version/dist/index.js -> node_modules/@oclif/plugin-version
+ *
+ * If require.resolve throws an error, it will attempt to find the plugin root by traversing the file system.
+ * If we're in a PnP environment (determined by process.versions.pnp), it will use the pnpapi module to
+ * traverse the dependency tree. Otherwise, it will traverse the node_modules until it finds a package.json
+ * with a matching name.
+ *
+ * If no path is found, undefined is returned which will eventually result in a thrown Error from Plugin.
+ */
+export declare function findRoot(name: string | undefined, root: string): Promise<string | undefined>;

package/lib/util/find-root.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRoot = void 0;
+const node_path_1 = require("node:path");
+const fs_1 = require("./fs");
+// essentially just "cd .."
+function* up(from) {
+    while ((0, node_path_1.dirname)(from) !== from) {
+        yield from;
+        from = (0, node_path_1.dirname)(from);
+    }
+    yield from;
+}
+/**
+ * Return the plugin root directory from a given file. This will `cd` up the file system until it finds
+ * a package.json and then return the dirname of that path.
+ *
+ * Example: node_modules/@oclif/plugin-version/dist/index.js -> node_modules/@oclif/plugin-version
+ */
+async function findPluginRoot(root, name) {
+    // If we know the plugin name then we just need to traverse the file
+    // system until we find the directory that matches the plugin name.
+    if (name) {
+        for (const next of up(root)) {
+            if (next.endsWith((0, node_path_1.basename)(name)))
+                return next;
+        }
+    }
+    // If there's no plugin name (typically just the root plugin), then we need
+    // to traverse the file system until we find a directory with a package.json
+    for (const next of up(root)) {
+        // Skip the bin directory
+        if ((0, node_path_1.basename)((0, node_path_1.dirname)(next)) === 'bin' &&
+            ['dev', 'dev.cmd', 'dev.js', 'run', 'run.cmd', 'run.js'].includes((0, node_path_1.basename)(next))) {
+            continue;
+        }
+        try {
+            const cur = (0, node_path_1.join)(next, 'package.json');
+            if (await (0, fs_1.safeReadJson)(cur))
+                return (0, node_path_1.dirname)(cur);
+        }
+        catch { }
+    }
+}
+/**
+ * Find plugin root directory for plugins installed into node_modules that don't have a `main` or `export`.
+ * This will go up directories until it finds a directory with the plugin installed into it.
+ *
+ * See https://github.com/oclif/config/pull/289#issuecomment-983904051
+ */
+async function findRootLegacy(name, root) {
+    for (const next of up(root)) {
+        let cur;
+        if (name) {
+            cur = (0, node_path_1.join)(next, 'node_modules', name, 'package.json');
+            if (await (0, fs_1.safeReadJson)(cur))
+                return (0, node_path_1.dirname)(cur);
+            const pkg = await (0, fs_1.safeReadJson)((0, node_path_1.join)(next, 'package.json'));
+            if (pkg?.name === name)
+                return next;
+        }
+        else {
+            cur = (0, node_path_1.join)(next, 'package.json');
+            if (await (0, fs_1.safeReadJson)(cur))
+                return (0, node_path_1.dirname)(cur);
+        }
+    }
+}
+let pnp;
+/**
+ * The pnpapi module is only available if running in a pnp environment. Because of that
+ * we have to require it from the plugin.
+ *
+ * Solution taken from here: https://github.com/yarnpkg/berry/issues/1467#issuecomment-642869600
+ */
+function maybeRequirePnpApi(root) {
+    if (pnp)
+        return pnp;
+    try {
+        // eslint-disable-next-line node/no-missing-require
+        pnp = require(require.resolve('pnpapi', { paths: [root] }));
+        return pnp;
+    }
+    catch { }
+}
+const getKey = (locator) => JSON.stringify(locator);
+const isPeerDependency = (pkg, parentPkg, name) => getKey(pkg?.packageDependencies.get(name)) === getKey(parentPkg?.packageDependencies.get(name));
+/**
+ * Traverse PnP dependency tree to find plugin root directory.
+ *
+ * Implementation adapted from https://yarnpkg.com/advanced/pnpapi#traversing-the-dependency-tree
+ */
+function findPnpRoot(name, root) {
+    maybeRequirePnpApi(root);
+    if (!pnp)
+        return;
+    const seen = new Set();
+    const traverseDependencyTree = (locator, parentPkg) => {
+        // Prevent infinite recursion when A depends on B which depends on A
+        const key = getKey(locator);
+        if (seen.has(key))
+            return;
+        const pkg = pnp.getPackageInformation(locator);
+        if (locator.name === name) {
+            return pkg.packageLocation;
+        }
+        seen.add(key);
+        for (const [name, referencish] of pkg.packageDependencies) {
+            // Unmet peer dependencies
+            if (referencish === null)
+                continue;
+            // Avoid iterating on peer dependencies - very expensive
+            if (parentPkg !== null && isPeerDependency(pkg, parentPkg, name))
+                continue;
+            const childLocator = pnp.getLocator(name, referencish);
+            const foundSomething = traverseDependencyTree(childLocator, pkg);
+            if (foundSomething)
+                return foundSomething;
+        }
+        // Important: This `delete` here causes the traversal to go over nodes even
+        // if they have already been traversed in another branch. If you don't need
+        // that, remove this line for a hefty speed increase.
+        seen.delete(key);
+    };
+    // Iterate on each workspace
+    for (const locator of pnp.getDependencyTreeRoots()) {
+        const foundSomething = traverseDependencyTree(locator);
+        if (foundSomething)
+            return foundSomething;
+    }
+}
+/**
+ * Returns the root directory of the plugin.
+ *
+ * It first attempts to use require.resolve to find the plugin root.
+ * If that returns a path, it will `cd` up the file system until if finds the package.json for the plugin
+ * Example: node_modules/@oclif/plugin-version/dist/index.js -> node_modules/@oclif/plugin-version
+ *
+ * If require.resolve throws an error, it will attempt to find the plugin root by traversing the file system.
+ * If we're in a PnP environment (determined by process.versions.pnp), it will use the pnpapi module to
+ * traverse the dependency tree. Otherwise, it will traverse the node_modules until it finds a package.json
+ * with a matching name.
+ *
+ * If no path is found, undefined is returned which will eventually result in a thrown Error from Plugin.
+ */
+async function findRoot(name, root) {
+    if (name) {
+        let pkgPath;
+        try {
+            pkgPath = require.resolve(name, { paths: [root] });
+        }
+        catch { }
+        if (pkgPath)
+            return findPluginRoot((0, node_path_1.dirname)(pkgPath), name);
+        return process.versions.pnp ? findPnpRoot(name, root) : findRootLegacy(name, root);
+    }
+    return findPluginRoot(root);
+}
+exports.findRoot = findRoot;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {
@@ -49,6 +49,7 @@
     "@types/mocha": "^10.0.2",
     "@types/node": "^18",
     "@types/node-notifier": "^8.0.2",
+    "@types/pnpapi": "^0.0.4",
     "@types/slice-ansi": "^4.0.0",
     "@types/strip-ansi": "^5.2.1",
     "@types/supports-color": "^8.1.1",