@pnpm/deps.inspection.tree-builder 1101.0.6 → 1101.0.8

package/lib/buildDependentsTree.js

@@ -18,31 +18,7 @@ export async function buildDependentsTree(packages, projectPaths, opts) {
     const registriesByScope = normalizeRegistriesByScope(opts.registriesByScope);
     const storeDir = modules?.storeDir;
     const storeIndex = storeDir ? new StoreIndex(storeDir) : undefined;
-    const virtualStoreDir = modules?.virtualStoreDir ?? path.join(modulesDir, '.pnpm');
-    const virtualStoreDirMaxLength = modules?.virtualStoreDirMaxLength ?? 120;
-    const include = opts.include ?? {
-        dependencies: true,
-        devDependencies: true,
-        optionalDependencies: true,
-    };
-    // Build root IDs from the selected project paths (respects --filter / --recursive)
-    const allRootIds = [];
-    for (const projectPath of projectPaths) {
-        const importerId = getLockfileImporterId(opts.lockfileDir, projectPath);
-        if (opts.lockfile.importers[importerId]) {
-            allRootIds.push({ type: 'importer', importerId });
-        }
-    }
-    const graph = buildDependencyGraph(allRootIds, {
-        currentPackages: opts.lockfile.packages ?? {},
-        importers: opts.lockfile.importers,
-        include,
-        lockfileDir: opts.lockfileDir,
-        peerSatisfactionEdges: getPeerSatisfactionEdgesToSkip(opts.lockfile, {
-            include,
-            resolvePeersFromWorkspaceRoot: opts.resolvePeersFromWorkspaceRoot,
-        }),
-    });
+    const graph = buildSelectedProjectsGraph(projectPaths, opts);
     const reverseMap = invertGraph(graph);
     const search = createPackagesSearcher(packages, opts.finders);
     const currentPackages = opts.lockfile.packages ?? {};
@@ -50,8 +26,8 @@ export async function buildDependentsTree(packages, projectPaths, opts) {
     // graph top-down from importers.  This is needed for global virtual store
     // where symlinks must be resolved through each parent's node_modules.
     const resolvedPackageNodes = resolvePackageNodes(graph, currentPackages, {
-        virtualStoreDir,
-        virtualStoreDirMaxLength,
+        virtualStoreDir: modules?.virtualStoreDir ?? path.join(modulesDir, '.pnpm'),
+        virtualStoreDirMaxLength: modules?.virtualStoreDirMaxLength ?? 120,
         modulesDir,
         registriesByScope,
         registriesByPrefix: opts.registriesByPrefix,
@@ -59,13 +35,7 @@ export async function buildDependentsTree(packages, projectPaths, opts) {
         storeDir,
         storeIndex,
     });
-    // Scan all package nodes for matches.
-    // A package matches if any of the aliases used to refer to it (from incoming
-    // edges in the graph) or its canonical name match the search query.
-    // Each distinct depPath (i.e. different peer dep resolutions) is kept as a
-    // separate result so that peer variants are visible in the output.
-    const trees = [];
-    const ctx = {
+    const trees = collectMatchedTrees(search, {
         reverseMap,
         graph,
         importers: opts.lockfile.importers,
@@ -75,70 +45,111 @@ export async function buildDependentsTree(packages, projectPaths, opts) {
         nameFormatter: opts.nameFormatter,
         visited: new Set(),
         expanded: new Set(),
+    });
+    trees.sort(compareDependentsTrees);
+    storeIndex?.close();
+    return trees;
+}
+function buildSelectedProjectsGraph(projectPaths, opts) {
+    const include = opts.include ?? {
+        dependencies: true,
+        devDependencies: true,
+        optionalDependencies: true,
     };
-    for (const [serialized, node] of graph.nodes) {
-        if (node.nodeId.type !== 'package')
-            continue;
-        const depPath = node.nodeId.depPath;
-        const snapshot = currentPackages[depPath];
-        if (snapshot == null)
-            continue;
-        const { name, version } = nameVerFromPkgSnapshot(depPath, snapshot);
-        const pkgNode = resolvedPackageNodes.get(serialized);
-        if (!pkgNode)
-            continue;
-        const readManifest = pkgNode.readManifest;
-        // Check canonical name first
-        let matched = search({ alias: name, name, version, readManifest });
-        // Also check aliases from incoming edges (handles npm: protocol aliases)
-        if (!matched) {
-            const incomingEdges = reverseMap.get(serialized);
-            if (incomingEdges) {
-                for (const edge of incomingEdges) {
-                    if (edge.alias !== name) {
-                        matched = search({ alias: edge.alias, name, version, readManifest });
-                        if (matched)
-                            break;
-                    }
-                }
-            }
-        }
-        if (!matched)
-            continue;
-        ctx.visited = new Set([serialized]);
-        ctx.expanded = new Set();
-        const dependents = walkReverse(serialized, ctx);
-        const peersSuffixHash = peersSuffixHashFromDepPath(depPath);
-        const displayName = opts.nameFormatter
-            ? opts.nameFormatter({ name, version, manifest: readManifest() })
-            : undefined;
-        const tree = {
-            name,
-            displayName,
-            version,
-            path: pkgNode.path,
-            peersSuffixHash,
-            dependents,
-        };
-        if (typeof matched === 'string') {
-            tree.searchMessage = matched;
+    // Build root IDs from the selected project paths (respects --filter / --recursive)
+    const allRootIds = [];
+    for (const projectPath of projectPaths) {
+        const importerId = getLockfileImporterId(opts.lockfileDir, projectPath);
+        if (opts.lockfile.importers[importerId]) {
+            allRootIds.push({ type: 'importer', importerId });
         }
-        trees.push(tree);
     }
-    trees.sort((a, b) => {
-        const nameCmp = lexCompare(a.name, b.name);
-        if (nameCmp !== 0)
-            return nameCmp;
-        const versionCmp = semver.valid(a.version) && semver.valid(b.version)
-            ? semver.compare(a.version, b.version)
-            : lexCompare(a.version, b.version);
-        if (versionCmp !== 0)
-            return versionCmp;
-        return lexCompare(a.peersSuffixHash ?? '', b.peersSuffixHash ?? '');
+    return buildDependencyGraph(allRootIds, {
+        currentPackages: opts.lockfile.packages ?? {},
+        importers: opts.lockfile.importers,
+        include,
+        lockfileDir: opts.lockfileDir,
+        peerSatisfactionEdges: getPeerSatisfactionEdgesToSkip(opts.lockfile, {
+            include,
+            resolvePeersFromWorkspaceRoot: opts.resolvePeersFromWorkspaceRoot,
+        }),
     });
-    storeIndex?.close();
+}
+// Scan all package nodes for matches.
+// A package matches if any of the aliases used to refer to it (from incoming
+// edges in the graph) or its canonical name match the search query.
+// Each distinct depPath (i.e. different peer dep resolutions) is kept as a
+// separate result so that peer variants are visible in the output.
+function collectMatchedTrees(search, ctx) {
+    const trees = [];
+    for (const [serialized, node] of ctx.graph.nodes) {
+        if (node.nodeId.type !== 'package')
+            continue;
+        const tree = buildTreeIfMatched(search, { serialized, depPath: node.nodeId.depPath }, ctx);
+        if (tree != null)
+            trees.push(tree);
+    }
     return trees;
 }
+function buildTreeIfMatched(search, { serialized, depPath }, ctx) {
+    const snapshot = ctx.currentPackages[depPath];
+    if (snapshot == null)
+        return undefined;
+    const { name, version } = nameVerFromPkgSnapshot(depPath, snapshot);
+    const pkgNode = ctx.resolvedPackageNodes.get(serialized);
+    if (!pkgNode)
+        return undefined;
+    const readManifest = pkgNode.readManifest;
+    const matched = searchPackage(search, { serialized, name, version, readManifest }, ctx);
+    if (!matched)
+        return undefined;
+    ctx.visited = new Set([serialized]);
+    ctx.expanded = new Set();
+    const dependents = walkReverse(serialized, ctx);
+    const peersSuffixHash = peersSuffixHashFromDepPath(depPath);
+    const displayName = ctx.nameFormatter
+        ? ctx.nameFormatter({ name, version, manifest: readManifest() })
+        : undefined;
+    const tree = {
+        name,
+        displayName,
+        version,
+        path: pkgNode.path,
+        peersSuffixHash,
+        dependents,
+    };
+    if (typeof matched === 'string') {
+        tree.searchMessage = matched;
+    }
+    return tree;
+}
+function searchPackage(search, pkg, ctx) {
+    const { name, version, readManifest } = pkg;
+    // Check canonical name first
+    const matched = search({ alias: name, name, version, readManifest });
+    if (matched)
+        return matched;
+    // Also check aliases from incoming edges (handles npm: protocol aliases)
+    for (const edge of ctx.reverseMap.get(pkg.serialized) ?? []) {
+        if (edge.alias === name)
+            continue;
+        const aliasMatched = search({ alias: edge.alias, name, version, readManifest });
+        if (aliasMatched)
+            return aliasMatched;
+    }
+    return false;
+}
+function compareDependentsTrees(left, right) {
+    const nameCmp = lexCompare(left.name, right.name);
+    if (nameCmp !== 0)
+        return nameCmp;
+    const versionCmp = semver.valid(left.version) && semver.valid(right.version)
+        ? semver.compare(left.version, right.version)
+        : lexCompare(left.version, right.version);
+    if (versionCmp !== 0)
+        return versionCmp;
+    return lexCompare(left.peersSuffixHash ?? '', right.peersSuffixHash ?? '');
+}
 function invertGraph(graph) {
     const reverse = new Map();
     for (const [parentSerialized, node] of graph.nodes) {
@@ -207,78 +218,88 @@ function walkReverse(nodeId, ctx) {
         return [];
     // Sort edges by parent name (with serialized ID as tiebreaker) so that
     // deduplication is deterministic: the first parent always gets fully expanded.
-    const sortedEdges = [...reverseEdges].sort((a, b) => {
-        const cmp = lexCompare(resolveParentName(a, ctx), resolveParentName(b, ctx));
+    const sortedEdges = [...reverseEdges].sort((left, right) => {
+        const cmp = lexCompare(resolveParentName(left, ctx), resolveParentName(right, ctx));
         if (cmp !== 0)
             return cmp;
-        return lexCompare(a.parentSerialized, b.parentSerialized);
+        return lexCompare(left.parentSerialized, right.parentSerialized);
     });
     const dependents = [];
     for (const edge of sortedEdges) {
         // Cycle detection: this node is already on our current path
-        if (ctx.visited.has(edge.parentSerialized)) {
-            const parentNode = ctx.graph.nodes.get(edge.parentSerialized);
-            if (parentNode?.nodeId.type === 'importer') {
-                const info = ctx.importerInfoMap.get(parentNode.nodeId.importerId);
-                if (info) {
-                    dependents.push({
-                        name: info.name,
-                        version: info.version,
-                        circular: true,
-                    });
-                }
-            }
-            else if (parentNode?.nodeId.type === 'package') {
-                const snapshot = ctx.currentPackages[parentNode.nodeId.depPath];
-                if (snapshot) {
-                    const { name, version } = nameVerFromPkgSnapshot(parentNode.nodeId.depPath, snapshot);
-                    const displayName = resolveDisplayName(edge.parentSerialized, name, version, ctx);
-                    dependents.push({ name, displayName, version, circular: true });
-                }
-            }
-            continue;
-        }
-        const parentGraphNode = ctx.graph.nodes.get(edge.parentSerialized);
-        if (parentGraphNode == null)
-            continue;
-        if (parentGraphNode.nodeId.type === 'importer') {
-            const importerId = parentGraphNode.nodeId.importerId;
-            const info = ctx.importerInfoMap.get(importerId) ?? { name: importerId, version: '' };
-            const depField = getDepFieldForAlias(edge.alias, ctx.importers[importerId]);
-            dependents.push({
-                name: info.name,
-                version: info.version,
-                depField,
-            });
-        }
-        else if (parentGraphNode.nodeId.type === 'package') {
-            const snapshot = ctx.currentPackages[parentGraphNode.nodeId.depPath];
-            if (snapshot == null)
-                continue;
-            const { name, version } = nameVerFromPkgSnapshot(parentGraphNode.nodeId.depPath, snapshot);
-            const peersSuffixHash = peersSuffixHashFromDepPath(parentGraphNode.nodeId.depPath);
-            // Deduplication: if this package was already expanded elsewhere in the
-            // tree, show it as a leaf to keep the output bounded.
-            const displayName = resolveDisplayName(edge.parentSerialized, name, version, ctx);
-            if (ctx.expanded.has(edge.parentSerialized)) {
-                dependents.push({ name, displayName, version, peersSuffixHash, deduped: true });
-                continue;
-            }
-            ctx.visited.add(edge.parentSerialized);
-            ctx.expanded.add(edge.parentSerialized);
-            const childDependents = walkReverse(edge.parentSerialized, ctx);
-            ctx.visited.delete(edge.parentSerialized);
-            dependents.push({
-                name,
-                displayName,
-                version,
-                peersSuffixHash,
-                dependents: childDependents.length > 0 ? childDependents : undefined,
-            });
-        }
+        const dependent = ctx.visited.has(edge.parentSerialized)
+            ? createCircularDependent(edge, ctx)
+            : createDependent(edge, ctx);
+        if (dependent != null)
+            dependents.push(dependent);
     }
     return dependents;
 }
+function createCircularDependent(edge, ctx) {
+    const parentNode = ctx.graph.nodes.get(edge.parentSerialized);
+    if (parentNode?.nodeId.type === 'importer') {
+        const info = ctx.importerInfoMap.get(parentNode.nodeId.importerId);
+        if (!info)
+            return undefined;
+        return {
+            name: info.name,
+            version: info.version,
+            circular: true,
+        };
+    }
+    if (parentNode?.nodeId.type !== 'package')
+        return undefined;
+    const snapshot = ctx.currentPackages[parentNode.nodeId.depPath];
+    if (!snapshot)
+        return undefined;
+    const { name, version } = nameVerFromPkgSnapshot(parentNode.nodeId.depPath, snapshot);
+    const displayName = resolveDisplayName(edge.parentSerialized, name, version, ctx);
+    return { name, displayName, version, circular: true };
+}
+function createDependent(edge, ctx) {
+    const parentGraphNode = ctx.graph.nodes.get(edge.parentSerialized);
+    if (parentGraphNode == null)
+        return undefined;
+    const parentNodeId = parentGraphNode.nodeId;
+    if (parentNodeId.type === 'importer') {
+        const importerId = parentNodeId.importerId;
+        const info = ctx.importerInfoMap.get(importerId) ?? { name: importerId, version: '' };
+        const depField = getDepFieldForAlias(edge.alias, ctx.importers[importerId]);
+        return {
+            name: info.name,
+            version: info.version,
+            depField,
+        };
+    }
+    if (parentNodeId.type === 'package') {
+        return createPackageDependent(edge, parentNodeId.depPath, ctx);
+    }
+    return undefined;
+}
+function createPackageDependent(edge, depPath, ctx) {
+    const snapshot = ctx.currentPackages[depPath];
+    if (snapshot == null)
+        return undefined;
+    const { name, version } = nameVerFromPkgSnapshot(depPath, snapshot);
+    const peersSuffixHash = peersSuffixHashFromDepPath(depPath);
+    // Deduplication: if this package was already expanded elsewhere in the
+    // tree, show it as a leaf to keep the output bounded.
+    const displayName = resolveDisplayName(edge.parentSerialized, name, version, ctx);
+    if (ctx.expanded.has(edge.parentSerialized)) {
+        return { name, displayName, version, peersSuffixHash, deduped: true };
+    }
+    ctx.visited.add(edge.parentSerialized);
+    ctx.expanded.add(edge.parentSerialized);
+    const childDependents = walkReverse(edge.parentSerialized, ctx);
+    ctx.visited.delete(edge.parentSerialized);
+    return {
+        name,
+        displayName,
+        version,
+        peersSuffixHash,
+        dependents: childDependents.length > 0 ? childDependents : undefined,
+    };
+}
 function resolveParentName(edge, ctx) {
     const graphNode = ctx.graph.nodes.get(edge.parentSerialized);
     if (graphNode == null)
@@ -301,12 +322,15 @@ function resolveDisplayName(serialized, name, version, ctx) {
     return ctx.nameFormatter({ name, version, manifest: pkgNode.readManifest() });
 }
 function getDepFieldForAlias(alias, importerSnapshot) {
-    if (importerSnapshot.devDependencies?.[alias] != null)
+    if (hasDependency(importerSnapshot.devDependencies, alias))
         return 'devDependencies';
-    if (importerSnapshot.optionalDependencies?.[alias] != null)
+    if (hasDependency(importerSnapshot.optionalDependencies, alias))
         return 'optionalDependencies';
-    if (importerSnapshot.dependencies?.[alias] != null)
+    if (hasDependency(importerSnapshot.dependencies, alias))
         return 'dependencies';
     return undefined;
 }
+function hasDependency(dependencies, alias) {
+    return dependencies != null && Object.hasOwn(dependencies, alias) && dependencies[alias] != null;
+}
 //# sourceMappingURL=buildDependentsTree.js.map

package/lib/createPackagesSearcher.js

@@ -11,22 +11,25 @@ export function createPackagesSearcher(queries, finders) {
         }
         if (finders == null)
             return false;
-        const messages = [];
-        let found = false;
-        for (const finder of finders) {
-            const result = finder(pkg);
-            if (result) {
-                found = true;
-                if (typeof result === 'string') {
-                    messages.push(result);
-                }
-            }
-        }
-        if (messages.length)
-            return messages.join('\n');
-        return found;
+        return runFinders(finders, pkg);
     };
 }
+function runFinders(finders, pkg) {
+    const messages = [];
+    let found = false;
+    for (const finder of finders) {
+        const result = finder(pkg);
+        if (!result)
+            continue;
+        found = true;
+        if (typeof result === 'string') {
+            messages.push(result);
+        }
+    }
+    if (messages.length)
+        return messages.join('\n');
+    return found;
+}
 function search(packageSelector, { alias, name, version }) {
     const nameMatches = packageSelector.matchName(name) || packageSelector.matchName(alias);
     if (!nameMatches) {

package/lib/getPkgInfo.d.ts

@@ -17,7 +17,9 @@ export interface GetPkgInfoOpts {
     readonly virtualStoreDirMaxLength: number;
     readonly depTypes: DepTypes;
     /**
-     * The base dir if the `ref` argument is a `"link:"` relative path.
+     * The base dir if the `ref` argument is a `"link:"` relative path. An
+     * absolute `"link:"` path, such as one on another drive on Windows, is used
+     * as is.
      */
     readonly linkedPathBaseDir: string;
     /**

package/lib/getPkgInfo.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { refToRelative } from '@pnpm/deps.path';
+import { packageRootLinkTarget, refToRelative } from '@pnpm/deps.path';
 import { DepType } from '@pnpm/lockfile.detect-dep-types';
 import { nameVerFromPkgSnapshot, pkgSnapshotToResolution, } from '@pnpm/lockfile.utils';
 import { readPackageJsonFromDirSync } from '@pnpm/pkg-manifest.reader';
@@ -7,62 +7,11 @@ import normalizePath from 'normalize-path';
 import { readManifestFromCafs } from './readManifestFromCafs.js';
 import { resolvePackagePath } from './resolvePackagePath.js';
 export function getPkgInfo(opts) {
-    let name;
-    let version;
-    let resolved;
-    let depType;
-    let optional;
-    let isSkipped = false;
-    let isMissing = false;
-    let integrity;
     const depPath = refToRelative(opts.ref, opts.alias);
-    if (depPath) {
-        let pkgSnapshot;
-        if (opts.currentPackages[depPath]) {
-            pkgSnapshot = opts.currentPackages[depPath];
-            const parsed = nameVerFromPkgSnapshot(depPath, pkgSnapshot);
-            name = parsed.name;
-            version = parsed.version;
-        }
-        else {
-            pkgSnapshot = opts.wantedPackages[depPath];
-            if (pkgSnapshot) {
-                const parsed = nameVerFromPkgSnapshot(depPath, pkgSnapshot);
-                name = parsed.name;
-                version = parsed.version;
-            }
-            else {
-                name = opts.alias;
-                version = opts.ref;
-            }
-            isMissing = true;
-            isSkipped = opts.skipped.has(depPath);
-        }
-        if (pkgSnapshot) {
-            try {
-                resolved = pkgSnapshotToResolution(depPath, pkgSnapshot, { registriesByScope: opts.registriesByScope, registriesByPrefix: opts.registriesByPrefix }).tarball;
-            }
-            catch (err) {
-                // Inspection commands may run without the workspace's registriesByPrefix
-                // setting (registries come from .modules.yaml); a named-registry entry
-                // whose alias can't be resolved to a URL just has no tarball to show.
-                if (err.code !== 'ERR_PNPM_MISSING_NAMED_REGISTRY')
-                    throw err;
-            }
-            optional = pkgSnapshot.optional;
-            if ('integrity' in pkgSnapshot.resolution) {
-                integrity = pkgSnapshot.resolution.integrity;
-            }
-        }
-        depType = opts.depTypes[depPath];
-    }
-    else {
-        name = opts.alias;
-        version = opts.ref;
-    }
-    if (!version) {
-        version = opts.ref;
-    }
+    const lockedInfo = depPath
+        ? readLockedPackageInfo(depPath, opts)
+        : { name: opts.alias, version: opts.ref, isMissing: false, isSkipped: false };
+    const { name } = lockedInfo;
     const fullPackagePath = depPath
         ? resolvePackagePath({
             depPath,
@@ -73,41 +22,95 @@ export function getPkgInfo(opts) {
             modulesDir: opts.modulesDir,
             parentDir: opts.parentDir,
         })
-        : path.join(opts.linkedPathBaseDir, opts.ref.slice(5));
-    if (version.startsWith('link:') && opts.rewriteLinkVersionDir) {
-        version = `link:${normalizePath(path.relative(opts.rewriteLinkVersionDir, fullPackagePath))}`;
+        : resolveLinkedPath(opts);
+    const version = rewriteLinkVersion(lockedInfo.version || opts.ref, fullPackagePath, opts.rewriteLinkVersionDir);
+    const pkgInfo = createPackageInfo(opts, { ...lockedInfo, version, path: fullPackagePath });
+    return {
+        pkgInfo,
+        readManifest: () => readManifest(opts, { integrity: lockedInfo.integrity, name, version, path: fullPackagePath }),
+    };
+}
+function rewriteLinkVersion(version, fullPackagePath, rewriteLinkVersionDir) {
+    if (!version.startsWith('link:') || !rewriteLinkVersionDir)
+        return version;
+    return `link:${normalizePath(path.relative(rewriteLinkVersionDir, fullPackagePath))}`;
+}
+function readManifest(opts, pkg) {
+    if (pkg.integrity && opts.storeDir && opts.storeIndex) {
+        const manifest = readManifestFromCafs(opts.storeDir, opts.storeIndex, { integrity: pkg.integrity, name: pkg.name, version: pkg.version });
+        if (manifest)
+            return manifest;
+    }
+    return readPackageJsonFromDirSync(pkg.path);
+}
+function readLockedPackageInfo(depPath, opts) {
+    const { pkgSnapshot, ...identity } = findPackageSnapshot(depPath, opts);
+    return {
+        ...identity,
+        ...(pkgSnapshot && readSnapshotDetails(depPath, pkgSnapshot, opts)),
+        depType: opts.depTypes[depPath],
+    };
+}
+function findPackageSnapshot(depPath, opts) {
+    if (opts.currentPackages[depPath]) {
+        const pkgSnapshot = opts.currentPackages[depPath];
+        const { name, version } = nameVerFromPkgSnapshot(depPath, pkgSnapshot);
+        return { pkgSnapshot, name, version, isMissing: false, isSkipped: false };
+    }
+    const pkgSnapshot = opts.wantedPackages[depPath];
+    const { name, version } = pkgSnapshot
+        ? nameVerFromPkgSnapshot(depPath, pkgSnapshot)
+        : { name: opts.alias, version: opts.ref };
+    return { pkgSnapshot, name, version, isMissing: true, isSkipped: opts.skipped.has(depPath) };
+}
+function readSnapshotDetails(depPath, pkgSnapshot, opts) {
+    return {
+        resolved: readTarballUrl(depPath, pkgSnapshot, opts),
+        optional: pkgSnapshot.optional,
+        integrity: 'integrity' in pkgSnapshot.resolution ? pkgSnapshot.resolution.integrity : undefined,
+    };
+}
+function readTarballUrl(depPath, pkgSnapshot, opts) {
+    try {
+        return pkgSnapshotToResolution(depPath, pkgSnapshot, { registriesByScope: opts.registriesByScope, registriesByPrefix: opts.registriesByPrefix }).tarball;
     }
+    catch (err) {
+        // Inspection commands may run without the workspace's registriesByPrefix
+        // setting (registries come from .modules.yaml); a named-registry entry
+        // whose alias can't be resolved to a URL just has no tarball to show.
+        if (err.code !== 'ERR_PNPM_MISSING_NAMED_REGISTRY')
+            throw err;
+        return undefined;
+    }
+}
+function createPackageInfo(opts, info) {
     const packageInfo = {
         alias: opts.alias,
-        isMissing,
+        isMissing: info.isMissing,
         isPeer: Boolean(opts.peers?.has(opts.alias)),
-        isSkipped,
-        name,
-        path: fullPackagePath,
-        version,
+        isSkipped: info.isSkipped,
+        name: info.name,
+        path: info.path,
+        version: info.version,
     };
-    if (resolved) {
-        packageInfo.resolved = resolved;
+    if (info.resolved) {
+        packageInfo.resolved = info.resolved;
     }
-    if (optional === true) {
+    if (info.optional === true) {
         packageInfo.optional = true;
     }
-    if (depType === DepType.DevOnly) {
+    if (info.depType === DepType.DevOnly) {
         packageInfo.dev = true;
     }
-    else if (depType === DepType.ProdOnly) {
+    else if (info.depType === DepType.ProdOnly) {
         packageInfo.dev = false;
     }
-    return {
-        pkgInfo: packageInfo,
-        readManifest: () => {
-            if (integrity && opts.storeDir && opts.storeIndex) {
-                const manifest = readManifestFromCafs(opts.storeDir, opts.storeIndex, { integrity, name, version });
-                if (manifest)
-                    return manifest;
-            }
-            return readPackageJsonFromDirSync(fullPackagePath);
-        },
-    };
+    return packageInfo;
+}
+function resolveLinkedPath(opts) {
+    const target = packageRootLinkTarget(opts.ref);
+    return target != null && opts.parentDir != null
+        ? path.join(opts.parentDir, target)
+        : path.resolve(opts.linkedPathBaseDir, opts.ref.slice(5));
 }
 //# sourceMappingURL=getPkgInfo.js.map