@yarnpkg/nm 3.0.1 → 4.0.0-rc.3

package/lib/buildNodeModulesTree.js

@@ -273,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) {
@@ -356,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
@@ -449,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);
@@ -465,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.js

@@ -281,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;
@@ -316,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;
@@ -334,8 +345,8 @@ const getNodeHoistInfo = (rootNode, rootNodePathLocators, nodePath, node, usedDe
             reason = `- workspace`;
         }
     }
-    if (isHoistable) {
-        isHoistable = node.dependencyKind !== HoisterDependencyKind.EXTERNAL_SOFT_LINK || node.dependencies.size === 0;
+    if (isHoistable && node.dependencyKind === HoisterDependencyKind.EXTERNAL_SOFT_LINK) {
+        isHoistable = !hasUnhoistedDependencies(node);
         if (outputReason && !isHoistable) {
             reason = `- external soft link with unhoisted dependencies`;
         }
@@ -427,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)
@@ -443,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.
  *
@@ -457,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)) {
@@ -487,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);
@@ -522,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) {
@@ -535,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);
                 }
             }
@@ -546,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();
@@ -553,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 };
@@ -828,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",
+  "version": "4.0.0-rc.3",
   "license": "BSD-2-Clause",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "sideEffects": false,
   "dependencies": {
-    "@yarnpkg/core": "^3.2.0",
-    "@yarnpkg/fslib": "^2.6.1"
+    "@yarnpkg/core": "^4.0.0-rc.3",
+    "@yarnpkg/fslib": "^3.0.0-rc.3"
   },
   "devDependencies": {
-    "@yarnpkg/pnp": "^3.2.0"
+    "@yarnpkg/pnp": "^4.0.0-rc.3"
   },
   "scripts": {
     "postpack": "rm -rf lib",
@@ -31,6 +31,7 @@
     "directory": "packages/yarnpkg-nm"
   },
   "engines": {
-    "node": ">=12 <14 || 14.2 - 14.9 || >14.10.0"
-  }
+    "node": ">=14.15.0"
+  },
+  "stableVersion": "3.0.1"
 }