@pnpm/deps.inspection.tree-builder 1101.0.7 → 1101.0.9

package/lib/getTree.js

@@ -12,11 +12,6 @@ export function getTree(opts, parentId) {
         ancestors,
     };
     const result = materializeChildren(ctx, parentId, opts.maxDepth, opts.parentDir);
-    // Mark circular back-edges.  materializeChildren truncates dependencies
-    // at cycle boundaries but does not set the `circular` flag, so that cached
-    // subtrees stay context-independent.  fixCircularRefs walks the final tree
-    // and adds `circular: true` wherever a node's path matches an ancestor.
-    //
     // Seed the ancestors with parentDir (the filesystem path of parentId) so
     // that back-edges to the root of this subtree are detected — the root
     // itself does not appear as a node in the tree, only its children do.
@@ -54,14 +49,21 @@ function materializeChildren(ctx, parentId, maxDepth, parentDir) {
     if (!graphNode) {
         throw new Error(`Node ${parentSerialized} not found in the dependency graph`);
     }
-    const childTreeMaxDepth = maxDepth - 1;
-    const linkedPathBaseDir = parentId.type === 'importer'
-        ? path.join(ctx.lockfileDir, parentId.importerId)
-        : ctx.lockfileDir;
-    const resultDependencies = [];
-    let resultCount = 0;
-    let resultHasSearchMatch = false;
-    const resultSearchMessages = ctx.showDedupedSearchMatches ? [] : undefined;
+    const parent = {
+        id: parentId,
+        dir: parentDir,
+        peers: graphNode.peers,
+        childTreeMaxDepth: maxDepth - 1,
+        linkedPathBaseDir: parentId.type === 'importer'
+            ? path.join(ctx.lockfileDir, parentId.importerId)
+            : ctx.lockfileDir,
+    };
+    const result = {
+        nodes: [],
+        count: 0,
+        hasSearchMatch: false,
+        searchMessages: ctx.showDedupedSearchMatches ? [] : undefined,
+    };
     // Sort edges by alias so that deduplication is deterministic:
     // the alphabetically-first dependency always gets fully expanded.
     const sortedEdges = [...graphNode.edges].sort((a, b) => lexCompare(a.alias, b.alias));
@@ -69,132 +71,146 @@ function materializeChildren(ctx, parentId, maxDepth, parentDir) {
         if (ctx.onlyProjects && !isProjectEdge(parentId, edge)) {
             continue;
         }
-        const { pkgInfo: packageInfo, readManifest } = getPkgInfo({
-            ...ctx,
-            alias: edge.alias,
-            ref: edge.ref,
-            peers: graphNode.peers,
-            linkedPathBaseDir,
-            parentDir,
-        });
-        // A project linked through its publish directory is listed at its own
-        // directory.
-        if (ctx.onlyProjects && edge.target?.nodeId.type === 'importer') {
-            packageInfo.path = path.join(ctx.lockfileDir, edge.target.nodeId.importerId);
-        }
-        const searchMatch = ctx.search?.({
-            alias: edge.alias,
-            name: packageInfo.name,
-            version: packageInfo.version,
-            readManifest,
-        });
-        let newEntry = null;
-        let childCount = 0;
-        let dedupedHasSearchMatch = false;
-        let dedupedSearchMessages = [];
-        if (edge.target == null) {
-            // External link or unresolvable — no traversal possible. With
-            // onlyProjects, this is a link to a project outside the lockfile, which
-            // buildDependenciesTree walks and prunes for the search afterwards.
-            if (ctx.search == null || searchMatch || ctx.onlyProjects) {
-                newEntry = packageInfo;
-            }
-            else {
-                continue;
-            }
-        }
-        else {
-            let dependencies;
-            let childHasSearchMatch = false;
-            let childSearchMessages = [];
-            let dedupedCount;
-            const circular = ctx.ancestors.has(edge.target.id);
-            if (circular) {
-                dependencies = [];
-            }
-            else {
-                const cacheKey = materializeCacheKey(edge.target.id, childTreeMaxDepth);
-                const cached = ctx.materializationCache.get(cacheKey);
-                if (cached !== undefined) {
-                    // This subtree was already returned to a parent elsewhere in
-                    // the output tree — elide it to avoid repeating the same nodes.
-                    dependencies = [];
-                    if (cached.count > 0) {
-                        dedupedCount = cached.count;
-                    }
-                    if (ctx.showDedupedSearchMatches) {
-                        dedupedHasSearchMatch = cached.hasSearchMatch;
-                        dedupedSearchMessages = cached.searchMessages;
-                    }
-                }
-                else {
-                    ctx.ancestors.add(edge.target.id);
-                    const childResult = materializeChildren(ctx, edge.target.nodeId, childTreeMaxDepth, packageInfo.path);
-                    ctx.ancestors.delete(edge.target.id);
-                    dependencies = childResult.nodes;
-                    childCount = childResult.count;
-                    childHasSearchMatch = childResult.hasSearchMatch;
-                    childSearchMessages = childResult.searchMessages;
-                    // Always cache — even results with circular truncations.
-                    ctx.materializationCache.set(cacheKey, {
-                        count: childCount,
-                        hasSearchMatch: childHasSearchMatch,
-                        searchMessages: childSearchMessages,
-                    });
-                }
-                if (childHasSearchMatch || dedupedHasSearchMatch) {
-                    resultHasSearchMatch = true;
-                }
-                resultSearchMessages?.push(...childSearchMessages, ...dedupedSearchMessages);
-            }
-            if (dependencies.length > 0) {
-                newEntry = {
-                    ...packageInfo,
-                    dependencies,
-                };
-            }
-            else if (ctx.search == null || searchMatch || dedupedHasSearchMatch) {
-                newEntry = packageInfo;
-            }
-            else {
-                continue;
-            }
-            if (dedupedCount != null) {
-                newEntry.deduped = true;
-                newEntry.dedupedDependenciesCount = dedupedCount;
-            }
-            if (edge.target.nodeId.type === 'package') {
-                const peerHash = peersSuffixHashFromDepPath(edge.target.nodeId.depPath);
-                if (peerHash != null) {
-                    newEntry.peersSuffixHash = peerHash;
-                }
-            }
-        }
-        if (searchMatch) {
-            newEntry.searched = true;
-            resultHasSearchMatch = true;
-            if (typeof searchMatch === 'string') {
-                newEntry.searchMessage = searchMatch;
-                resultSearchMessages?.push(searchMatch);
-            }
+        materializeEdge(ctx, { parent, edge, result });
+    }
+    return {
+        count: result.count,
+        hasSearchMatch: result.hasSearchMatch,
+        nodes: result.nodes,
+        searchMessages: result.searchMessages ?? [],
+    };
+}
+function materializeEdge(ctx, { parent, edge, result }) {
+    const { pkgInfo: packageInfo, readManifest } = getPkgInfo({
+        ...ctx,
+        alias: edge.alias,
+        ref: edge.ref,
+        peers: parent.peers,
+        linkedPathBaseDir: parent.linkedPathBaseDir,
+        parentDir: parent.dir,
+    });
+    // A project linked through its publish directory is listed at its own
+    // directory.
+    if (ctx.onlyProjects && edge.target?.nodeId.type === 'importer') {
+        packageInfo.path = path.join(ctx.lockfileDir, edge.target.nodeId.importerId);
+    }
+    const searchMatch = ctx.search?.({
+        alias: edge.alias,
+        name: packageInfo.name,
+        version: packageInfo.version,
+        readManifest,
+    });
+    const subtree = edge.target == null
+        ? createEmptySubtree()
+        : materializeTarget(ctx, { target: edge.target, maxDepth: parent.childTreeMaxDepth, dir: packageInfo.path });
+    collectSubtreeSearchMatches(result, subtree);
+    const newEntry = edge.target == null
+        ? selectUnresolvedEntry(ctx, packageInfo, searchMatch)
+        : selectTargetEntry(ctx, { packageInfo, searchMatch, subtree, target: edge.target });
+    if (newEntry == null)
+        return;
+    markSearchMatch(newEntry, { searchMatch, subtree, result });
+    if (!newEntry.isPeer || !ctx.excludePeerDependencies || newEntry.dependencies?.length) {
+        result.nodes.push(newEntry);
+        result.count += 1 + (newEntry.dependencies?.length ? subtree.count : 0);
+    }
+}
+function collectSubtreeSearchMatches(result, subtree) {
+    if (subtree.hasSearchMatch || subtree.dedupedHasSearchMatch) {
+        result.hasSearchMatch = true;
+    }
+    result.searchMessages?.push(...subtree.searchMessages, ...subtree.dedupedSearchMessages);
+}
+function createEmptySubtree() {
+    return {
+        dependencies: [],
+        count: 0,
+        hasSearchMatch: false,
+        searchMessages: [],
+        dedupedHasSearchMatch: false,
+        dedupedSearchMessages: [],
+    };
+}
+function materializeTarget(ctx, { target, maxDepth, dir }) {
+    if (ctx.ancestors.has(target.id))
+        return createEmptySubtree();
+    const cacheKey = materializeCacheKey(target.id, maxDepth);
+    const cached = ctx.materializationCache.get(cacheKey);
+    if (cached !== undefined) {
+        // This subtree was already returned to a parent elsewhere in
+        // the output tree — elide it to avoid repeating the same nodes.
+        return {
+            ...createEmptySubtree(),
+            dedupedCount: cached.count > 0 ? cached.count : undefined,
+            dedupedHasSearchMatch: ctx.showDedupedSearchMatches ? cached.hasSearchMatch : false,
+            dedupedSearchMessages: ctx.showDedupedSearchMatches ? cached.searchMessages : [],
+        };
+    }
+    ctx.ancestors.add(target.id);
+    const childResult = materializeChildren(ctx, target.nodeId, maxDepth, dir);
+    ctx.ancestors.delete(target.id);
+    ctx.materializationCache.set(cacheKey, {
+        count: childResult.count,
+        hasSearchMatch: childResult.hasSearchMatch,
+        searchMessages: childResult.searchMessages,
+    });
+    return {
+        dependencies: childResult.nodes,
+        count: childResult.count,
+        hasSearchMatch: childResult.hasSearchMatch,
+        searchMessages: childResult.searchMessages,
+        dedupedHasSearchMatch: false,
+        dedupedSearchMessages: [],
+    };
+}
+// External link or unresolvable — no traversal possible. With
+// onlyProjects, this is a link to a project outside the lockfile, which
+// buildDependenciesTree walks and prunes for the search afterwards.
+function selectUnresolvedEntry(ctx, packageInfo, searchMatch) {
+    return ctx.search == null || searchMatch || ctx.onlyProjects ? packageInfo : undefined;
+}
+function selectTargetEntry(ctx, { packageInfo, searchMatch, subtree, target }) {
+    let newEntry;
+    if (subtree.dependencies.length > 0) {
+        newEntry = {
+            ...packageInfo,
+            dependencies: subtree.dependencies,
+        };
+    }
+    else if (ctx.search == null || searchMatch || subtree.dedupedHasSearchMatch) {
+        newEntry = packageInfo;
+    }
+    else {
+        return undefined;
+    }
+    if (subtree.dedupedCount != null) {
+        newEntry.deduped = true;
+        newEntry.dedupedDependenciesCount = subtree.dedupedCount;
+    }
+    if (target.nodeId.type === 'package') {
+        const peerHash = peersSuffixHashFromDepPath(target.nodeId.depPath);
+        if (peerHash != null) {
+            newEntry.peersSuffixHash = peerHash;
         }
-        else if (dedupedHasSearchMatch) {
-            newEntry.searched = true;
-            if (dedupedSearchMessages.length > 0) {
-                newEntry.searchMessage = dedupedSearchMessages.join('\n');
-            }
+    }
+    return newEntry;
+}
+function markSearchMatch(newEntry, { searchMatch, subtree, result }) {
+    if (searchMatch) {
+        newEntry.searched = true;
+        result.hasSearchMatch = true;
+        if (typeof searchMatch === 'string') {
+            newEntry.searchMessage = searchMatch;
+            result.searchMessages?.push(searchMatch);
         }
-        if (!newEntry.isPeer || !ctx.excludePeerDependencies || newEntry.dependencies?.length) {
-            resultDependencies.push(newEntry);
-            resultCount += 1 + (newEntry.dependencies?.length ? childCount : 0);
+        return;
+    }
+    if (subtree.dedupedHasSearchMatch) {
+        newEntry.searched = true;
+        if (subtree.dedupedSearchMessages.length > 0) {
+            newEntry.searchMessage = subtree.dedupedSearchMessages.join('\n');
         }
     }
-    return {
-        count: resultCount,
-        hasSearchMatch: resultHasSearchMatch,
-        nodes: resultDependencies,
-        searchMessages: resultSearchMessages ?? [],
-    };
 }
 /**
  * Walks the materialized DependencyNode[] tree and marks circular back-edges.
@@ -206,7 +222,6 @@ function materializeChildren(ctx, parentId, maxDepth, parentDir) {
 function fixCircularRefs(nodes, ancestors) {
     let changed = false;
     const result = nodes.map(node => {
-        // A node whose path matches an ancestor is a circular back-edge.
         if (node.path && ancestors.has(node.path)) {
             changed = true;
             const { dependencies: _, deduped: _d, dedupedDependenciesCount: _c, ...rest } = node;

package/lib/resolvePackagePath.js

@@ -9,39 +9,41 @@ import { depPathToFilename } from '@pnpm/deps.path';
  * symlinks are resolved to find the actual store location.
  */
 export function resolvePackagePath(opts) {
-    let fullPackagePath = path.join(opts.virtualStoreDir, depPathToFilename(opts.depPath, opts.virtualStoreDirMaxLength), 'node_modules', opts.name);
+    const fullPackagePath = path.join(opts.virtualStoreDir, depPathToFilename(opts.depPath, opts.virtualStoreDirMaxLength), 'node_modules', opts.name);
     // Resolve symlink for global virtual store.
-    // Global virtual store is detected when virtualStoreDir is outside the project's node_modules.
-    const resolvedVirtualStoreDir = path.resolve(opts.virtualStoreDir);
-    const resolvedModulesDir = opts.modulesDir ? path.resolve(opts.modulesDir) : undefined;
-    const isGlobalVirtualStore = resolvedModulesDir &&
-        !resolvedVirtualStoreDir.startsWith(resolvedModulesDir + path.sep) &&
-        resolvedVirtualStoreDir !== resolvedModulesDir;
-    if (isGlobalVirtualStore) {
-        try {
-            let nodeModulesDir;
-            if (opts.parentDir) {
-                // parentDir example: /store/.../node_modules/express
-                //                    /store/.../node_modules/@scope/pkg
-                // We need the node_modules directory to find sibling packages
-                nodeModulesDir = path.dirname(opts.parentDir);
-                // For scoped packages (@org/pkg), go up one more level
-                if (path.basename(nodeModulesDir).startsWith('@')) {
-                    nodeModulesDir = path.dirname(nodeModulesDir);
-                }
-            }
-            else if (opts.modulesDir) {
-                nodeModulesDir = opts.modulesDir;
-            }
-            else {
-                return fullPackagePath;
-            }
-            fullPackagePath = fs.realpathSync(path.join(nodeModulesDir, opts.alias));
-        }
-        catch {
-            // Fallback to constructed path if symlink doesn't exist
-        }
+    if (!isGlobalVirtualStore(opts.virtualStoreDir, opts.modulesDir))
+        return fullPackagePath;
+    const nodeModulesDir = getSymlinkNodeModulesDir(opts);
+    if (nodeModulesDir == null)
+        return fullPackagePath;
+    try {
+        return fs.realpathSync(path.join(nodeModulesDir, opts.alias));
+    }
+    catch {
+        // Fallback to constructed path if symlink doesn't exist
+        return fullPackagePath;
     }
-    return fullPackagePath;
+}
+/**
+ * Global virtual store is detected when virtualStoreDir is outside the project's node_modules.
+ */
+function isGlobalVirtualStore(virtualStoreDir, modulesDir) {
+    const resolvedVirtualStoreDir = path.resolve(virtualStoreDir);
+    const resolvedModulesDir = modulesDir ? path.resolve(modulesDir) : undefined;
+    return Boolean(resolvedModulesDir &&
+        !resolvedVirtualStoreDir.startsWith(resolvedModulesDir + path.sep) &&
+        resolvedVirtualStoreDir !== resolvedModulesDir);
+}
+function getSymlinkNodeModulesDir(opts) {
+    if (!opts.parentDir)
+        return opts.modulesDir || undefined;
+    // parentDir example: /store/.../node_modules/express
+    //                    /store/.../node_modules/@scope/pkg
+    // We need the node_modules directory to find sibling packages
+    const nodeModulesDir = path.dirname(opts.parentDir);
+    // For scoped packages (@org/pkg), go up one more level
+    return path.basename(nodeModulesDir).startsWith('@')
+        ? path.dirname(nodeModulesDir)
+        : nodeModulesDir;
 }
 //# sourceMappingURL=resolvePackagePath.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/deps.inspection.tree-builder",
-  "version": "1101.0.7",
+  "version": "1101.0.9",
   "description": "Creates a dependencies hierarchy for a symlinked `node_modules`",
   "keywords": [
     "pnpm",
@@ -30,19 +30,19 @@
     "!*.map"
   ],
   "dependencies": {
-    "@pnpm/config.matcher": "1100.0.2",
+    "@pnpm/config.matcher": "1100.0.3",
     "@pnpm/config.normalize-registries": "1101.0.2",
     "@pnpm/deps.path": "1101.0.5",
     "@pnpm/fs.read-modules-dir": "1100.0.3",
     "@pnpm/installing.modules-yaml": "1101.0.5",
     "@pnpm/lockfile.detect-dep-types": "1100.0.26",
-    "@pnpm/lockfile.fs": "1100.2.10",
+    "@pnpm/lockfile.fs": "1100.2.12",
     "@pnpm/lockfile.peer-edges": "1100.0.1",
     "@pnpm/lockfile.utils": "1102.1.5",
     "@pnpm/npm-package-arg": "^2.0.0",
     "@pnpm/pkg-manifest.reader": "1100.0.21",
-    "@pnpm/store.cafs": "1100.3.5",
-    "@pnpm/store.index": "1100.3.3",
+    "@pnpm/store.cafs": "1100.3.6",
+    "@pnpm/store.index": "1101.0.0",
     "@pnpm/text.ordinal-comparator": "1100.0.0",
     "@pnpm/types": "1102.1.1",
     "load-json-file": "^7.0.1",
@@ -56,7 +56,7 @@
   "devDependencies": {
     "@jest/globals": "30.4.1",
     "@pnpm/constants": "1102.0.0",
-    "@pnpm/deps.inspection.tree-builder": "1101.0.7",
+    "@pnpm/deps.inspection.tree-builder": "1101.0.9",
     "@pnpm/test-fixtures": "1100.0.1",
     "@types/normalize-path": "^3.0.2",
     "@types/semver": "7.8.0"