@pnpm/deps.inspection.tree-builder 1001.1.3

package/lib/buildDependentsTree.js

@@ -0,0 +1,309 @@
+import path from 'node:path';
+import { normalizeRegistries } from '@pnpm/config.normalize-registries';
+import { readModulesManifest } from '@pnpm/installing.modules-yaml';
+import { getLockfileImporterId, } from '@pnpm/lockfile.fs';
+import { nameVerFromPkgSnapshot } from '@pnpm/lockfile.utils';
+import { StoreIndex } from '@pnpm/store.index';
+import { lexCompare } from '@pnpm/util.lex-comparator';
+import { realpathMissing } from 'realpath-missing';
+import semver from 'semver';
+import { buildDependencyGraph } from './buildDependencyGraph.js';
+import { createPackagesSearcher } from './createPackagesSearcher.js';
+import { getPkgInfo } from './getPkgInfo.js';
+import { peersSuffixHashFromDepPath } from './peersSuffixHash.js';
+export async function buildDependentsTree(packages, projectPaths, opts) {
+    const modulesDir = await realpathMissing(path.join(opts.lockfileDir, opts.modulesDir ?? 'node_modules'));
+    const modules = await readModulesManifest(modulesDir);
+    const registries = normalizeRegistries({
+        ...opts.registries,
+        ...modules?.registries,
+    });
+    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,
+    });
+    const reverseMap = invertGraph(graph);
+    const search = createPackagesSearcher(packages, opts.finders);
+    const currentPackages = opts.lockfile.packages ?? {};
+    // Pre-compute resolved filesystem paths for all package nodes by walking the
+    // 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,
+        modulesDir,
+        registries,
+        wantedPackages: currentPackages,
+        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 = {
+        reverseMap,
+        graph,
+        importers: opts.lockfile.importers,
+        currentPackages,
+        importerInfoMap: opts.importerInfoMap,
+        resolvedPackageNodes,
+        nameFormatter: opts.nameFormatter,
+        visited: new Set(),
+        expanded: new Set(),
+    };
+    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;
+        }
+        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 ?? '');
+    });
+    storeIndex?.close();
+    return trees;
+}
+function invertGraph(graph) {
+    const reverse = new Map();
+    for (const [parentSerialized, node] of graph.nodes) {
+        for (const edge of node.edges) {
+            if (edge.target == null)
+                continue;
+            const childSerialized = edge.target.id;
+            let entries = reverse.get(childSerialized);
+            if (entries == null) {
+                entries = [];
+                reverse.set(childSerialized, entries);
+            }
+            entries.push({
+                parentSerialized,
+                parentNodeId: node.nodeId,
+                alias: edge.alias,
+            });
+        }
+    }
+    return reverse;
+}
+/**
+ * Walks the dependency graph top-down from importer nodes and resolves the
+ * filesystem path for every package node.  This is necessary for global virtual
+ * store where the correct path can only be obtained by following symlinks
+ * through each parent's node_modules directory.
+ */
+function resolvePackageNodes(graph, currentPackages, opts) {
+    const resolved = new Map();
+    function walk(serialized, parentDir) {
+        const node = graph.nodes.get(serialized);
+        if (!node)
+            return;
+        for (const edge of node.edges) {
+            if (edge.target == null)
+                continue;
+            const childSerialized = edge.target.id;
+            if (resolved.has(childSerialized))
+                continue;
+            if (edge.target.nodeId.type !== 'package')
+                continue;
+            const { pkgInfo, readManifest } = getPkgInfo({
+                ...opts,
+                alias: edge.alias,
+                currentPackages,
+                depTypes: {},
+                linkedPathBaseDir: opts.modulesDir, // This might need adjustment for linked deps?
+                parentDir,
+                ref: edge.target.nodeId.depPath,
+                skipped: new Set(),
+            });
+            resolved.set(childSerialized, { path: pkgInfo.path, readManifest });
+            walk(childSerialized, pkgInfo.path);
+        }
+    }
+    for (const [serialized, node] of graph.nodes) {
+        if (node.nodeId.type === 'importer') {
+            walk(serialized, undefined);
+        }
+    }
+    return resolved;
+}
+function walkReverse(nodeId, ctx) {
+    const reverseEdges = ctx.reverseMap.get(nodeId);
+    if (reverseEdges == null || reverseEdges.length === 0)
+        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));
+        if (cmp !== 0)
+            return cmp;
+        return lexCompare(a.parentSerialized, b.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,
+            });
+        }
+    }
+    return dependents;
+}
+function resolveParentName(edge, ctx) {
+    const graphNode = ctx.graph.nodes.get(edge.parentSerialized);
+    if (graphNode == null)
+        return '';
+    if (graphNode.nodeId.type === 'importer') {
+        const info = ctx.importerInfoMap.get(graphNode.nodeId.importerId);
+        return info?.name ?? graphNode.nodeId.importerId;
+    }
+    const snapshot = ctx.currentPackages[graphNode.nodeId.depPath];
+    if (snapshot == null)
+        return '';
+    return nameVerFromPkgSnapshot(graphNode.nodeId.depPath, snapshot).name;
+}
+function resolveDisplayName(serialized, name, version, ctx) {
+    if (!ctx.nameFormatter)
+        return undefined;
+    const pkgNode = ctx.resolvedPackageNodes.get(serialized);
+    if (!pkgNode)
+        return undefined;
+    return ctx.nameFormatter({ name, version, manifest: pkgNode.readManifest() });
+}
+function getDepFieldForAlias(alias, importerSnapshot) {
+    if (importerSnapshot.devDependencies?.[alias] != null)
+        return 'devDependencies';
+    if (importerSnapshot.optionalDependencies?.[alias] != null)
+        return 'optionalDependencies';
+    if (importerSnapshot.dependencies?.[alias] != null)
+        return 'dependencies';
+    return undefined;
+}
+//# sourceMappingURL=buildDependentsTree.js.map

package/lib/createPackagesSearcher.d.ts

@@ -0,0 +1,2 @@
+import type { Finder } from '@pnpm/types';
+export declare function createPackagesSearcher(queries: string[], finders?: Finder[]): Finder;

package/lib/createPackagesSearcher.js

@@ -0,0 +1,53 @@
+import { createMatcher } from '@pnpm/config.matcher';
+import npa from '@pnpm/npm-package-arg';
+import semver from 'semver';
+export function createPackagesSearcher(queries, finders) {
+    const searchers = queries
+        .map(parseSearchQuery)
+        .map((packageSelector) => search.bind(null, packageSelector));
+    return (pkg) => {
+        if (searchers.length > 0 && searchers.some((search) => search(pkg))) {
+            return true;
+        }
+        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;
+    };
+}
+function search(packageSelector, { alias, name, version }) {
+    const nameMatches = packageSelector.matchName(name) || packageSelector.matchName(alias);
+    if (!nameMatches) {
+        return false;
+    }
+    if (packageSelector.matchVersion == null) {
+        return true;
+    }
+    return !version.startsWith('link:') && packageSelector.matchVersion(version);
+}
+function parseSearchQuery(query) {
+    const parsed = npa(query);
+    if (parsed.raw === parsed.name) {
+        return { matchName: createMatcher(parsed.name) };
+    }
+    if (parsed.type !== 'version' && parsed.type !== 'range') {
+        throw new Error(`Invalid query - ${query}. List can search only by version or range`);
+    }
+    return {
+        matchName: createMatcher(parsed.name),
+        matchVersion: (version) => semver.satisfies(version, parsed.fetchSpec),
+    };
+}
+//# sourceMappingURL=createPackagesSearcher.js.map

package/lib/getPkgInfo.d.ts

@@ -0,0 +1,58 @@
+import { type DepTypes } from '@pnpm/lockfile.detect-dep-types';
+import type { PackageSnapshots } from '@pnpm/lockfile.fs';
+import type { StoreIndex } from '@pnpm/store.index';
+import type { DependencyManifest, Registries } from '@pnpm/types';
+export interface GetPkgInfoOpts {
+    readonly alias: string;
+    readonly ref: string;
+    readonly currentPackages: PackageSnapshots;
+    readonly peers?: Set<string>;
+    readonly registries: Registries;
+    readonly skipped: Set<string>;
+    readonly storeDir?: string;
+    readonly storeIndex?: StoreIndex;
+    readonly wantedPackages: PackageSnapshots;
+    readonly virtualStoreDir?: string;
+    readonly virtualStoreDirMaxLength: number;
+    readonly depTypes: DepTypes;
+    /**
+     * The base dir if the `ref` argument is a `"link:"` relative path.
+     */
+    readonly linkedPathBaseDir: string;
+    /**
+     * If the `ref` argument is a `"link:"` relative path, the ref is reused for
+     * the version field. (Since the true semver may not be known.)
+     *
+     * Optionally rewrite this relative path to a base dir before writing it to
+     * version.
+     */
+    readonly rewriteLinkVersionDir?: string;
+    /**
+     * The node_modules directory to resolve symlinks from when using global virtual store.
+     * This is used for top-level dependencies.
+     */
+    readonly modulesDir?: string;
+    /**
+     * The resolved path of the parent package. When provided, the symlink resolution
+     * will use the parent's node_modules directory instead of the top-level modulesDir.
+     * This is needed for subdependencies when using global virtual store.
+     */
+    readonly parentDir?: string;
+}
+export declare function getPkgInfo(opts: GetPkgInfoOpts): {
+    pkgInfo: PackageInfo;
+    readManifest: () => DependencyManifest;
+};
+interface PackageInfo {
+    alias: string;
+    isMissing: boolean;
+    isPeer: boolean;
+    isSkipped: boolean;
+    name: string;
+    path: string;
+    version: string;
+    resolved?: string;
+    optional?: true;
+    dev?: boolean;
+}
+export {};

package/lib/getPkgInfo.js

@@ -0,0 +1,104 @@
+import path from 'node:path';
+import { 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';
+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) {
+            resolved = pkgSnapshotToResolution(depPath, pkgSnapshot, opts.registries).tarball;
+            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 fullPackagePath = depPath
+        ? resolvePackagePath({
+            depPath,
+            name,
+            alias: opts.alias,
+            virtualStoreDir: opts.virtualStoreDir ?? '.pnpm',
+            virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
+            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))}`;
+    }
+    const packageInfo = {
+        alias: opts.alias,
+        isMissing,
+        isPeer: Boolean(opts.peers?.has(opts.alias)),
+        isSkipped,
+        name,
+        path: fullPackagePath,
+        version,
+    };
+    if (resolved) {
+        packageInfo.resolved = resolved;
+    }
+    if (optional === true) {
+        packageInfo.optional = true;
+    }
+    if (depType === DepType.DevOnly) {
+        packageInfo.dev = true;
+    }
+    else if (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);
+        },
+    };
+}
+//# sourceMappingURL=getPkgInfo.js.map

package/lib/getTree.d.ts

@@ -0,0 +1,53 @@
+import type { DepTypes } from '@pnpm/lockfile.detect-dep-types';
+import type { PackageSnapshots, ProjectSnapshot } from '@pnpm/lockfile.fs';
+import type { StoreIndex } from '@pnpm/store.index';
+import type { Finder, Registries } from '@pnpm/types';
+import type { DependencyGraph } from './buildDependencyGraph.js';
+import type { DependencyNode } from './DependencyNode.js';
+import { type TreeNodeId } from './TreeNodeId.js';
+export interface BaseTreeOpts {
+    include: {
+        dependencies?: boolean;
+        devDependencies?: boolean;
+        optionalDependencies?: boolean;
+    };
+    excludePeerDependencies?: boolean;
+    lockfileDir: string;
+    onlyProjects?: boolean;
+    search?: Finder;
+    skipped: Set<string>;
+    registries: Registries;
+    depTypes: DepTypes;
+    storeDir?: string;
+    storeIndex?: StoreIndex;
+    virtualStoreDir?: string;
+    virtualStoreDirMaxLength: number;
+    modulesDir?: string;
+    showDedupedSearchMatches?: boolean;
+    graph: DependencyGraph;
+    materializationCache: MaterializationCache;
+}
+interface GetTreeOpts extends BaseTreeOpts {
+    maxDepth: number;
+    rewriteLinkVersionDir: string;
+    importers: Record<string, ProjectSnapshot>;
+    currentPackages: PackageSnapshots;
+    wantedPackages: PackageSnapshots;
+    parentDir?: string;
+}
+interface CachedSubtree {
+    /** Total number of DependencyNode objects in the subtree (recursive). */
+    count: number;
+    /** Whether any node in this subtree matched the search. */
+    hasSearchMatch: boolean;
+    /** Search match messages (string-typed matches) found in this subtree. */
+    searchMessages: string[];
+}
+/**
+ * Caches already-materialized subtrees.  When a subtree is encountered a
+ * second time (cache hit), an empty array is returned and the node is marked
+ * as deduped — bounding the total output to O(N) nodes.
+ */
+export type MaterializationCache = Map<string, CachedSubtree>;
+export declare function getTree(opts: GetTreeOpts, parentId: TreeNodeId): DependencyNode[];
+export {};