@yarnpkg/nm 3.0.1-rc.9 → 4.0.0-rc.2

package/lib/buildNodeModulesTree.js

@@ -202,7 +202,7 @@ const buildPackageTree = (pnp, options) => {
         reference: topLocator.reference,
         peerNames: topPkg.packagePeers,
         dependencies: new Set(),
-        isWorkspace: true,
+        dependencyKind: hoist_1.HoisterDependencyKind.WORKSPACE,
     };
     const nodes = new Map();
     const getNodeKey = (name, locator) => `${stringifyLocator(locator)}:${name}`;
@@ -217,7 +217,11 @@ const buildPackageTree = (pnp, options) => {
         }
         const isExternalSoftLinkPackage = isExternalSoftLink(pkg, locator, pnp, topPkgPortableLocation);
         if (!node) {
-            const isWorkspace = pkg.linkType === LinkType.SOFT && locator.name.endsWith(WORKSPACE_NAME_SUFFIX);
+            let dependencyKind = hoist_1.HoisterDependencyKind.REGULAR;
+            if (isExternalSoftLinkPackage)
+                dependencyKind = hoist_1.HoisterDependencyKind.EXTERNAL_SOFT_LINK;
+            else if (pkg.linkType === LinkType.SOFT && locator.name.endsWith(WORKSPACE_NAME_SUFFIX))
+                dependencyKind = hoist_1.HoisterDependencyKind.WORKSPACE;
             node = {
                 name,
                 identName: locator.name,
@@ -225,8 +229,8 @@ const buildPackageTree = (pnp, options) => {
                 dependencies: new Set(),
                 // View peer dependencies as regular dependencies for workspaces
                 // (meeting workspace peer dependency constraints is sometimes hard, sometimes impossible for the nm linker)
-                peerNames: isWorkspace ? new Set() : pkg.packagePeers,
-                isWorkspace,
+                peerNames: dependencyKind === hoist_1.HoisterDependencyKind.WORKSPACE ? new Set() : pkg.packagePeers,
+                dependencyKind,
             };
             nodes.set(nodeKey, node);
         }
@@ -269,7 +273,7 @@ const buildPackageTree = (pnp, options) => {
                 allDependencies.set(`${workspaceLocator.name}${WORKSPACE_NAME_SUFFIX}`, workspaceLocator.reference);
             }
         }
-        if (pkg !== parentPkg || pkg.linkType !== LinkType.SOFT || !options.selfReferencesByCwd || options.selfReferencesByCwd.get(parentRelativeCwd))
+        if (pkg !== parentPkg || pkg.linkType !== LinkType.SOFT || (!isExternalSoftLinkPackage && (!options.selfReferencesByCwd || options.selfReferencesByCwd.get(parentRelativeCwd))))
             parent.dependencies.add(node);
         const isWorkspaceDependency = locator !== topLocator && pkg.linkType === LinkType.SOFT && !locator.name.endsWith(WORKSPACE_NAME_SUFFIX) && !isExternalSoftLinkPackage;
         if (!isSeen && !isWorkspaceDependency) {
@@ -352,22 +356,14 @@ function getTargetLocatorPath(locator, pnp, options) {
     const info = pnp.getPackageInformation(pkgLocator);
     if (info === null)
         throw new Error(`Assertion failed: Expected the package to be registered`);
-    let linkType;
-    let target;
-    if (options.pnpifyFs) {
+    return options.pnpifyFs
         // In case of pnpifyFs we represent modules as symlinks to archives in NodeModulesFS
         // `/home/user/project/foo` is a symlink to `/home/user/project/.yarn/.cache/foo.zip/node_modules/foo`
         // To make this fs layout work with legacy tools we make
         // `/home/user/project/.yarn/.cache/foo.zip/node_modules/foo/node_modules` (which normally does not exist inside archive) a symlink to:
         // `/home/user/project/node_modules/foo/node_modules`, so that the tools were able to access it
-        target = fslib_1.npath.toPortablePath(info.packageLocation);
-        linkType = LinkType.SOFT;
-    }
-    else {
-        target = getRealPackageLocation(info, locator, pnp);
-        linkType = info.linkType;
-    }
-    return { linkType, target };
+        ? { linkType: LinkType.SOFT, target: fslib_1.npath.toPortablePath(info.packageLocation) }
+        : { linkType: info.linkType, target: getRealPackageLocation(info, locator, pnp) };
 }
 /**
  * Converts hoisted tree to node modules map
@@ -445,8 +441,7 @@ const populateNodeModulesTree = (pnp, hoistedTree, options) => {
                 tree.set(nodeModulesLocation, leafNode);
                 const segments = nodeModulesLocation.split(`/`);
                 const nodeModulesIdx = segments.indexOf(NODE_MODULES);
-                let segCount = segments.length - 1;
-                while (nodeModulesIdx >= 0 && segCount > nodeModulesIdx) {
+                for (let segCount = segments.length - 1; nodeModulesIdx >= 0 && segCount > nodeModulesIdx; segCount--) {
                     const dirPath = fslib_1.npath.toPortablePath(segments.slice(0, segCount).join(fslib_1.ppath.sep));
                     const targetDir = (0, fslib_1.toFilename)(segments[segCount]);
                     const subdirs = tree.get(dirPath);
@@ -461,7 +456,6 @@ const populateNodeModulesTree = (pnp, hoistedTree, options) => {
                             subdirs.dirList.add(targetDir);
                         }
                     }
-                    segCount--;
                 }
             }
             buildTree(dep, leafNode.linkType === LinkType.SOFT ? leafNode.target : nodeModulesLocation, nodePath);

package/lib/hoist.d.ts

@@ -46,6 +46,11 @@
  * until you run out of candidates for current tree root.
  */
 declare type PackageName = string;
+export declare enum HoisterDependencyKind {
+    REGULAR = 0,
+    WORKSPACE = 1,
+    EXTERNAL_SOFT_LINK = 2
+}
 export declare type HoisterTree = {
     name: PackageName;
     identName: PackageName;
@@ -53,7 +58,7 @@ export declare type HoisterTree = {
     dependencies: Set<HoisterTree>;
     peerNames: Set<PackageName>;
     hoistPriority?: number;
-    isWorkspace?: boolean;
+    dependencyKind?: HoisterDependencyKind;
 };
 export declare type HoisterResult = {
     name: PackageName;

package/lib/hoist.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hoist = void 0;
+exports.hoist = exports.HoisterDependencyKind = void 0;
+var HoisterDependencyKind;
+(function (HoisterDependencyKind) {
+    HoisterDependencyKind[HoisterDependencyKind["REGULAR"] = 0] = "REGULAR";
+    HoisterDependencyKind[HoisterDependencyKind["WORKSPACE"] = 1] = "WORKSPACE";
+    HoisterDependencyKind[HoisterDependencyKind["EXTERNAL_SOFT_LINK"] = 2] = "EXTERNAL_SOFT_LINK";
+})(HoisterDependencyKind = exports.HoisterDependencyKind || (exports.HoisterDependencyKind = {}));
 var Hoistable;
 (function (Hoistable) {
     Hoistable[Hoistable["YES"] = 0] = "YES";
@@ -134,7 +140,7 @@ const getUsedDependencies = (rootNodePath) => {
 const decoupleGraphNode = (parent, node) => {
     if (node.decoupled)
         return node;
-    const { name, references, ident, locator, dependencies, originalDependencies, hoistedDependencies, peerNames, reasons, isHoistBorder, hoistPriority, isWorkspace, hoistedFrom, hoistedTo } = node;
+    const { name, references, ident, locator, dependencies, originalDependencies, hoistedDependencies, peerNames, reasons, isHoistBorder, hoistPriority, dependencyKind, hoistedFrom, hoistedTo } = node;
     // To perform node hoisting from parent node we must clone parent nodes up to the root node,
     // because some other package in the tree might depend on the parent package where hoisting
     // cannot be performed
@@ -151,7 +157,7 @@ const decoupleGraphNode = (parent, node) => {
         decoupled: true,
         isHoistBorder,
         hoistPriority,
-        isWorkspace,
+        dependencyKind,
         hoistedFrom: new Map(hoistedFrom),
         hoistedTo: new Map(hoistedTo),
     };
@@ -275,7 +281,10 @@ const hoistTo = (tree, rootNodePath, rootNodePathLocators, parentShadowedNodes,
     seenNodes.add(rootNode);
     const preferenceMap = buildPreferenceMap(rootNode);
     const hoistIdentMap = getHoistIdentMap(rootNode, preferenceMap);
-    const usedDependencies = tree == rootNode ? new Map() : (options.fastLookupPossible ? getZeroRoundUsedDependencies(rootNodePath) : getUsedDependencies(rootNodePath));
+    const usedDependencies = tree == rootNode ? new Map() :
+        (options.fastLookupPossible
+            ? getZeroRoundUsedDependencies(rootNodePath)
+            : getUsedDependencies(rootNodePath));
     let wasStateChanged;
     let anotherRoundNeeded = false;
     let isGraphChanged = false;
@@ -310,6 +319,14 @@ const hoistTo = (tree, rootNodePath, rootNodePathLocators, parentShadowedNodes,
     }
     return { anotherRoundNeeded, isGraphChanged };
 };
+const hasUnhoistedDependencies = (node) => {
+    for (const [subName, subDependency] of node.dependencies) {
+        if (!node.peerNames.has(subName) && subDependency.ident !== node.ident) {
+            return true;
+        }
+    }
+    return false;
+};
 const getNodeHoistInfo = (rootNode, rootNodePathLocators, nodePath, node, usedDependencies, hoistIdents, hoistIdentMap, shadowedNodes, { outputReason, fastLookupPossible }) => {
     let reasonRoot;
     let reason = null;
@@ -323,11 +340,17 @@ const getNodeHoistInfo = (rootNode, rootNodePathLocators, nodePath, node, usedDe
     if (outputReason && !isHoistable)
         reason = `- self-reference`;
     if (isHoistable) {
-        isHoistable = !node.isWorkspace;
+        isHoistable = node.dependencyKind !== HoisterDependencyKind.WORKSPACE;
         if (outputReason && !isHoistable) {
             reason = `- workspace`;
         }
     }
+    if (isHoistable && node.dependencyKind === HoisterDependencyKind.EXTERNAL_SOFT_LINK) {
+        isHoistable = !hasUnhoistedDependencies(node);
+        if (outputReason && !isHoistable) {
+            reason = `- external soft link with unhoisted dependencies`;
+        }
+    }
     if (isHoistable) {
         // Direct workspace dependencies must be hoisted to any common ancestor workspace of all the
         // graph paths that include the dependency, because otherwise running app with
@@ -340,7 +363,7 @@ const getNodeHoistInfo = (rootNode, rootNodePathLocators, nodePath, node, usedDe
         // It is difficult to find all common ancestors, but there is one easy to find common ancestor -
         // the root workspace, so, for now, we either hoist direct dependencies into the root workspace, or we keep them
         // unhoisted, thus we are safe from various pathological cases with `--preserve-symlinks`
-        isHoistable = !parentNode.isWorkspace || parentNode.hoistedFrom.has(node.name) || rootNodePathLocators.size === 1;
+        isHoistable = parentNode.dependencyKind !== HoisterDependencyKind.WORKSPACE || parentNode.hoistedFrom.has(node.name) || rootNodePathLocators.size === 1;
         if (outputReason && !isHoistable) {
             reason = parentNode.reasons.get(node.name);
         }
@@ -415,7 +438,7 @@ const getNodeHoistInfo = (rootNode, rootNodePathLocators, nodePath, node, usedDe
     }
     if (isHoistable && !fastLookupPossible) {
         for (const origDep of node.hoistedDependencies.values()) {
-            const usedDep = usedDependencies.get(origDep.name);
+            const usedDep = usedDependencies.get(origDep.name) || rootNode.dependencies.get(origDep.name);
             if (!usedDep || origDep.ident !== usedDep.ident) {
                 isHoistable = false;
                 if (outputReason)
@@ -431,6 +454,7 @@ const getNodeHoistInfo = (rootNode, rootNodePathLocators, nodePath, node, usedDe
         return { isHoistable: isHoistable ? Hoistable.YES : Hoistable.NO, reason };
     }
 };
+const getAliasedLocator = (node) => `${node.name}@${node.locator}`;
 /**
  * Performs actual graph transformation, by hoisting packages to the root node.
  *
@@ -445,10 +469,11 @@ const hoistGraph = (tree, rootNodePath, rootNodePathLocators, usedDependencies,
     const seenNodes = new Set();
     let anotherRoundNeeded = false;
     let isGraphChanged = false;
-    const hoistNodeDependencies = (nodePath, locatorPath, parentNode, newNodes) => {
+    const hoistNodeDependencies = (nodePath, locatorPath, aliasedLocatorPath, parentNode, newNodes) => {
         if (seenNodes.has(parentNode))
             return;
-        const nextLocatorPath = [...locatorPath, parentNode.locator];
+        const nextLocatorPath = [...locatorPath, getAliasedLocator(parentNode)];
+        const nextAliasedLocatorPath = [...aliasedLocatorPath, getAliasedLocator(parentNode)];
         const dependantTree = new Map();
         const hoistInfos = new Map();
         for (const subDependency of getSortedRegularDependencies(parentNode)) {
@@ -475,12 +500,14 @@ const hoistGraph = (tree, rootNodePath, rootNodePathLocators, usedDependencies,
         for (const [node, hoistInfo] of hoistInfos)
             if (hoistInfo.isHoistable === Hoistable.NO)
                 addUnhoistableNode(node, hoistInfo, hoistInfo.reason);
+        let wereNodesHoisted = false;
         for (const node of hoistInfos.keys()) {
             if (!unhoistableNodes.has(node)) {
                 isGraphChanged = true;
                 const shadowedNames = parentShadowedNodes.get(parentNode);
                 if (shadowedNames && shadowedNames.has(node.name))
                     anotherRoundNeeded = true;
+                wereNodesHoisted = true;
                 parentNode.dependencies.delete(node.name);
                 parentNode.hoistedDependencies.set(node.name, node);
                 parentNode.reasons.delete(node.name);
@@ -510,6 +537,8 @@ const hoistGraph = (tree, rootNodePath, rootNodePathLocators, usedDependencies,
                 }
             }
         }
+        if (parentNode.dependencyKind === HoisterDependencyKind.EXTERNAL_SOFT_LINK && wereNodesHoisted)
+            anotherRoundNeeded = true;
         if (options.check) {
             const checkLog = selfCheck(tree);
             if (checkLog) {
@@ -523,10 +552,10 @@ const hoistGraph = (tree, rootNodePath, rootNodePathLocators, usedDependencies,
                 const hoistableIdent = hoistIdents.get(node.name);
                 if ((hoistableIdent === node.ident || !parentNode.reasons.has(node.name)) && hoistInfo.isHoistable !== Hoistable.YES)
                     parentNode.reasons.set(node.name, hoistInfo.reason);
-                if (!node.isHoistBorder && nextLocatorPath.indexOf(node.locator) < 0) {
+                if (!node.isHoistBorder && nextAliasedLocatorPath.indexOf(getAliasedLocator(node)) < 0) {
                     seenNodes.add(parentNode);
                     const decoupledNode = decoupleGraphNode(parentNode, node);
-                    hoistNodeDependencies([...nodePath, parentNode], [...locatorPath, parentNode.locator], decoupledNode, nextNewNodes);
+                    hoistNodeDependencies([...nodePath, parentNode], nextLocatorPath, nextAliasedLocatorPath, decoupledNode, nextNewNodes);
                     seenNodes.delete(parentNode);
                 }
             }
@@ -534,6 +563,7 @@ const hoistGraph = (tree, rootNodePath, rootNodePathLocators, usedDependencies,
     };
     let newNodes;
     let nextNewNodes = new Set(getSortedRegularDependencies(rootNode));
+    const aliasedRootNodePathLocators = Array.from(rootNodePath).map(x => getAliasedLocator(x));
     do {
         newNodes = nextNewNodes;
         nextNewNodes = new Set();
@@ -541,7 +571,7 @@ const hoistGraph = (tree, rootNodePath, rootNodePathLocators, usedDependencies,
             if (dep.locator === rootNode.locator || dep.isHoistBorder)
                 continue;
             const decoupledDependency = decoupleGraphNode(rootNode, dep);
-            hoistNodeDependencies([], Array.from(rootNodePathLocators), decoupledDependency, nextNewNodes);
+            hoistNodeDependencies([], Array.from(rootNodePathLocators), aliasedRootNodePathLocators, decoupledDependency, nextNewNodes);
         }
     } while (nextNewNodes.size > 0);
     return { anotherRoundNeeded, isGraphChanged };
@@ -614,7 +644,7 @@ const cloneTree = (tree, options) => {
         decoupled: true,
         isHoistBorder: true,
         hoistPriority: 0,
-        isWorkspace: true,
+        dependencyKind: HoisterDependencyKind.WORKSPACE,
         hoistedFrom: new Map(),
         hoistedTo: new Map(),
     };
@@ -623,7 +653,7 @@ const cloneTree = (tree, options) => {
         let workNode = seenNodes.get(node);
         const isSeen = !!workNode;
         if (!workNode) {
-            const { name, identName, reference, peerNames, hoistPriority, isWorkspace } = node;
+            const { name, identName, reference, peerNames, hoistPriority, dependencyKind } = node;
             const dependenciesNmHoistingLimits = options.hoistingLimits.get(parentNode.locator);
             workNode = {
                 name,
@@ -638,7 +668,7 @@ const cloneTree = (tree, options) => {
                 decoupled: true,
                 isHoistBorder: dependenciesNmHoistingLimits ? dependenciesNmHoistingLimits.has(name) : false,
                 hoistPriority: hoistPriority || 0,
-                isWorkspace: isWorkspace || false,
+                dependencyKind: dependencyKind || HoisterDependencyKind.REGULAR,
                 hoistedFrom: new Map(),
                 hoistedTo: new Map(),
             };
@@ -816,8 +846,7 @@ const dumpDepTree = (tree) => {
             if (!pkg.peerNames.has(dep.name) && dep !== pkg) {
                 const reason = pkg.reasons.get(dep.name);
                 const identName = getIdentName(dep.locator);
-                const hoistedFrom = pkg.hoistedFrom.get(dep.name) || [];
-                str += `${prefix}${idx < dependencies.length - 1 ? `├─` : `└─`}${(parents.has(dep) ? `>` : ``) + (identName !== dep.name ? `a:${dep.name}:` : ``) + prettyPrintLocator(dep.locator) + (reason ? ` ${reason}` : ``) + (dep !== pkg && hoistedFrom.length > 0 ? `, hoisted from: ${hoistedFrom.join(`, `)}` : ``)}\n`;
+                str += `${prefix}${idx < dependencies.length - 1 ? `├─` : `└─`}${(parents.has(dep) ? `>` : ``) + (identName !== dep.name ? `a:${dep.name}:` : ``) + prettyPrintLocator(dep.locator) + (reason ? ` ${reason}` : ``)}\n`;
                 str += dumpPackage(dep, parents, `${prefix}${idx < dependencies.length - 1 ? `│ ` : `  `}`);
             }
         }

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@yarnpkg/nm",
-  "version": "3.0.1-rc.9",
+  "version": "4.0.0-rc.2",
   "license": "BSD-2-Clause",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "sideEffects": false,
   "dependencies": {
-    "@yarnpkg/core": "^3.2.0-rc.9",
-    "@yarnpkg/fslib": "^2.6.1-rc.4"
+    "@yarnpkg/core": "^4.0.0-rc.2",
+    "@yarnpkg/fslib": "^3.0.0-rc.2"
   },
   "devDependencies": {
-    "@yarnpkg/pnp": "^3.1.1-rc.9"
+    "@yarnpkg/pnp": "^4.0.0-rc.2"
   },
   "scripts": {
     "postpack": "rm -rf lib",
@@ -31,7 +31,7 @@
     "directory": "packages/yarnpkg-nm"
   },
   "engines": {
-    "node": ">=12 <14 || 14.2 - 14.9 || >14.10.0"
+    "node": ">=14.15.0"
   },
-  "stableVersion": "3.0.0"
+  "stableVersion": "3.0.1"
 }