@pnpm/installing.deps-resolver 1008.3.1

package/lib/resolvePeers.js

@@ -0,0 +1,702 @@
+import path from 'node:path';
+import { createPeerDepGraphHash, depPathToFilename } from '@pnpm/deps.path';
+import * as semverUtils from '@yarnpkg/core/semverUtils';
+import filenamify from 'filenamify';
+import { analyzeGraph } from 'graph-cycles';
+import pDefer, {} from 'p-defer';
+import { partition, pick } from 'ramda';
+import semver from 'semver';
+import { dedupeInjectedDeps } from './dedupeInjectedDeps.js';
+import { mergePeers } from './mergePeers.js';
+export async function resolvePeers(opts) {
+    const depGraph = {};
+    const pathsByNodeId = new Map();
+    const pathsByNodeIdPromises = new Map();
+    const depPathsByPkgId = new Map();
+    const _createPkgsByName = createPkgsByName.bind(null, opts.dependenciesTree);
+    const rootPkgsByName = opts.resolvePeersFromWorkspaceRoot ? getRootPkgsByName(opts.dependenciesTree, opts.projects) : {};
+    const peerDependencyIssuesByProjects = {};
+    const finishingList = [];
+    const peersCache = new Map();
+    const purePkgs = new Set();
+    for (const { directNodeIdsByAlias, topParents, rootDir, id } of opts.projects) {
+        const peerDependencyIssues = { bad: {}, missing: {} };
+        const pkgsByName = Object.fromEntries(Object.entries({
+            ...rootPkgsByName,
+            ..._createPkgsByName({ directNodeIdsByAlias, topParents }),
+        }).filter(([peerName]) => opts.allPeerDepNames.has(peerName)));
+        for (const { nodeId } of Object.values(pkgsByName)) {
+            if (nodeId && !pathsByNodeIdPromises.has(nodeId)) {
+                pathsByNodeIdPromises.set(nodeId, pDefer());
+            }
+        }
+        // eslint-disable-next-line no-await-in-loop
+        const { finishing } = await resolvePeersOfChildren(Object.fromEntries(directNodeIdsByAlias.entries()), pkgsByName, {
+            allPeerDepNames: opts.allPeerDepNames,
+            parentPkgsOfNode: new Map(),
+            dependenciesTree: opts.dependenciesTree,
+            depGraph,
+            lockfileDir: opts.lockfileDir,
+            parentNodeIds: [],
+            parentDepPathsChain: [],
+            pathsByNodeId,
+            pathsByNodeIdPromises,
+            depPathsByPkgId,
+            peersCache,
+            peerDependencyIssues,
+            purePkgs,
+            peersSuffixMaxLength: opts.peersSuffixMaxLength,
+            rootDir,
+            virtualStoreDir: opts.virtualStoreDir,
+            virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
+        });
+        if (finishing) {
+            finishingList.push(finishing);
+        }
+        if (Object.keys(peerDependencyIssues.bad).length > 0 || Object.keys(peerDependencyIssues.missing).length > 0) {
+            peerDependencyIssuesByProjects[id] = {
+                ...peerDependencyIssues,
+                ...mergePeers(peerDependencyIssues.missing),
+            };
+        }
+    }
+    await Promise.all(finishingList);
+    const depGraphWithResolvedChildren = resolveChildren(depGraph);
+    function resolveChildren(depGraph) {
+        for (const node of Object.values(depGraph)) {
+            node.children = {};
+            for (const [alias, childNodeId] of Object.entries(node.childrenNodeIds)) {
+                node.children[alias] = pathsByNodeId.get(childNodeId) ?? childNodeId;
+            }
+            delete node.childrenNodeIds;
+        }
+        return depGraph;
+    }
+    const dependenciesByProjectId = {};
+    for (const { directNodeIdsByAlias, id } of opts.projects) {
+        dependenciesByProjectId[id] = new Map();
+        for (const [alias, nodeId] of directNodeIdsByAlias.entries()) {
+            dependenciesByProjectId[id].set(alias, pathsByNodeId.get(nodeId));
+        }
+    }
+    if (opts.dedupeInjectedDeps) {
+        dedupeInjectedDeps({
+            dependenciesByProjectId,
+            projects: opts.projects,
+            depGraph: depGraphWithResolvedChildren,
+            pathsByNodeId,
+            lockfileDir: opts.lockfileDir,
+            resolvedImporters: opts.resolvedImporters,
+            workspaceProjectIds: opts.workspaceProjectIds,
+        });
+    }
+    if (opts.dedupePeerDependents) {
+        const duplicates = Array.from(depPathsByPkgId.values()).filter((item) => item.size > 1);
+        const allDepPathsMap = deduplicateAll(depGraphWithResolvedChildren, duplicates);
+        for (const { id } of opts.projects) {
+            for (const [alias, depPath] of dependenciesByProjectId[id].entries()) {
+                dependenciesByProjectId[id].set(alias, allDepPathsMap[depPath] ?? depPath);
+            }
+        }
+    }
+    return {
+        dependenciesGraph: depGraphWithResolvedChildren,
+        dependenciesByProjectId,
+        peerDependencyIssuesByProjects,
+    };
+}
+function nodeDepsCount(node) {
+    return Object.keys(node.children).length + node.resolvedPeerNames.size;
+}
+function deduplicateAll(depGraph, duplicates) {
+    const { depPathsMap, remainingDuplicates } = deduplicateDepPaths(duplicates, depGraph);
+    if (remainingDuplicates.length === duplicates.length) {
+        return depPathsMap;
+    }
+    for (const node of Object.values(depGraph)) {
+        for (const [alias, childDepPath] of Object.entries(node.children)) {
+            if (depPathsMap[childDepPath]) {
+                node.children[alias] = depPathsMap[childDepPath];
+            }
+        }
+    }
+    if (Object.keys(depPathsMap).length > 0) {
+        return {
+            ...depPathsMap,
+            ...deduplicateAll(depGraph, remainingDuplicates),
+        };
+    }
+    return depPathsMap;
+}
+function deduplicateDepPaths(duplicates, depGraph) {
+    const depCountSorter = (depPath1, depPath2) => nodeDepsCount(depGraph[depPath1]) - nodeDepsCount(depGraph[depPath2]);
+    const depPathsMap = {};
+    const remainingDuplicates = [];
+    for (const depPaths of duplicates) {
+        const unresolvedDepPaths = new Set(depPaths.values());
+        let currentDepPaths = [...depPaths].sort(depCountSorter);
+        while (currentDepPaths.length) {
+            const depPath1 = currentDepPaths.pop();
+            const nextDepPaths = [];
+            while (currentDepPaths.length) {
+                const depPath2 = currentDepPaths.pop();
+                if (isCompatibleAndHasMoreDeps(depGraph, depPath1, depPath2)) {
+                    depPathsMap[depPath2] = depPath1;
+                    unresolvedDepPaths.delete(depPath1);
+                    unresolvedDepPaths.delete(depPath2);
+                }
+                else {
+                    nextDepPaths.push(depPath2);
+                }
+            }
+            nextDepPaths.push(...currentDepPaths);
+            currentDepPaths = nextDepPaths.sort(depCountSorter);
+        }
+        if (unresolvedDepPaths.size) {
+            remainingDuplicates.push(unresolvedDepPaths);
+        }
+    }
+    return {
+        depPathsMap,
+        remainingDuplicates,
+    };
+}
+function isCompatibleAndHasMoreDeps(depGraph, depPath1, depPath2) {
+    const node1 = depGraph[depPath1];
+    const node2 = depGraph[depPath2];
+    if (nodeDepsCount(node1) < nodeDepsCount(node2))
+        return false;
+    const node1DepPathsSet = new Set(Object.values(node1.children));
+    const node2DepPaths = Object.values(node2.children);
+    if (!node2DepPaths.every((depPath) => node1DepPathsSet.has(depPath)))
+        return false;
+    for (const depPath of node2.resolvedPeerNames) {
+        if (!node1.resolvedPeerNames.has(depPath))
+            return false;
+    }
+    return true;
+}
+function getRootPkgsByName(dependenciesTree, projects) {
+    const rootProject = projects.length > 1 ? projects.find(({ id }) => id === '.') : null;
+    return rootProject == null ? {} : createPkgsByName(dependenciesTree, rootProject);
+}
+function createPkgsByName(dependenciesTree, { directNodeIdsByAlias, topParents }) {
+    const parentRefs = toPkgByName(Array.from(directNodeIdsByAlias.entries())
+        .map(([alias, nodeId]) => ({
+        alias,
+        node: dependenciesTree.get(nodeId),
+        nodeId,
+        parentNodeIds: [],
+    })));
+    const _updateParentRefs = updateParentRefs.bind(null, parentRefs);
+    for (const { name, version, alias, linkedDir } of topParents) {
+        const pkg = {
+            occurrence: 0,
+            alias,
+            depth: 0,
+            version,
+            nodeId: linkedDir,
+            parentNodeIds: [],
+        };
+        _updateParentRefs(name, pkg);
+        if (alias && alias !== name) {
+            _updateParentRefs(alias, pkg);
+        }
+    }
+    return parentRefs;
+}
+async function resolvePeersOfNode(currentAlias, nodeId, parentParentPkgs, ctx) {
+    const node = ctx.dependenciesTree.get(nodeId);
+    if (node.depth === -1)
+        return { resolvedPeers: new Map(), missingPeers: new Map() };
+    const resolvedPackage = node.resolvedPackage;
+    if (ctx.purePkgs.has(resolvedPackage.pkgIdWithPatchHash) &&
+        ctx.depGraph[resolvedPackage.pkgIdWithPatchHash].depth <= node.depth &&
+        Object.keys(resolvedPackage.peerDependencies).length === 0) {
+        ctx.pathsByNodeId.set(nodeId, resolvedPackage.pkgIdWithPatchHash);
+        ctx.pathsByNodeIdPromises.get(nodeId).resolve(resolvedPackage.pkgIdWithPatchHash);
+        return { resolvedPeers: new Map(), missingPeers: new Map() };
+    }
+    if (typeof node.children === 'function') {
+        node.children = node.children();
+    }
+    const parentNodeIds = [...ctx.parentNodeIds, nodeId];
+    const children = node.children;
+    let parentPkgs;
+    if (Object.keys(children).length === 0) {
+        parentPkgs = parentParentPkgs;
+    }
+    else {
+        parentPkgs = { ...parentParentPkgs };
+        const parentPkgNodes = [];
+        for (const [alias, nodeId] of Object.entries(children)) {
+            if (ctx.allPeerDepNames.has(alias)) {
+                parentPkgNodes.push({
+                    alias,
+                    node: ctx.dependenciesTree.get(nodeId),
+                    nodeId,
+                    parentNodeIds,
+                });
+            }
+        }
+        const newParentPkgs = toPkgByName(parentPkgNodes);
+        const _parentPkgsMatch = parentPkgsMatch.bind(null, ctx.dependenciesTree);
+        for (const [newParentPkgName, newParentPkg] of Object.entries(newParentPkgs)) {
+            if (parentPkgs[newParentPkgName]) {
+                if (!_parentPkgsMatch(parentPkgs[newParentPkgName], newParentPkg)) {
+                    newParentPkg.occurrence = parentPkgs[newParentPkgName].occurrence + 1;
+                    parentPkgs[newParentPkgName] = newParentPkg;
+                }
+            }
+            else {
+                parentPkgs[newParentPkgName] = newParentPkg;
+            }
+        }
+    }
+    const hit = findHit(ctx, parentPkgs, resolvedPackage.pkgIdWithPatchHash);
+    if (hit != null) {
+        for (const [peerName, { range: wantedRange, optional }] of hit.missingPeers.entries()) {
+            if (ctx.peerDependencyIssues.missing[peerName] == null) {
+                ctx.peerDependencyIssues.missing[peerName] = [];
+            }
+            const { parents } = getLocationFromParentNodeIds({
+                dependenciesTree: ctx.dependenciesTree,
+                parentNodeIds,
+            });
+            ctx.peerDependencyIssues.missing[peerName].push({
+                optional,
+                parents,
+                wantedRange,
+            });
+        }
+        return {
+            missingPeers: hit.missingPeers,
+            finishing: (async () => {
+                const depPath = await hit.depPath.promise;
+                ctx.pathsByNodeId.set(nodeId, depPath);
+                ctx.depGraph[depPath].depth = Math.min(ctx.depGraph[depPath].depth, node.depth);
+                ctx.pathsByNodeIdPromises.get(nodeId).resolve(depPath);
+            })(),
+            resolvedPeers: hit.resolvedPeers,
+        };
+    }
+    const { resolvedPeers: unknownResolvedPeersOfChildren, missingPeers: missingPeersOfChildren, finishing, } = await resolvePeersOfChildren(children, parentPkgs, {
+        ...ctx,
+        parentNodeIds,
+        parentDepPathsChain: ctx.parentDepPathsChain.includes(resolvedPackage.pkgIdWithPatchHash) ? ctx.parentDepPathsChain : [...ctx.parentDepPathsChain, resolvedPackage.pkgIdWithPatchHash],
+    });
+    const { resolvedPeers, missingPeers } = Object.keys(resolvedPackage.peerDependencies).length === 0
+        ? { resolvedPeers: new Map(), missingPeers: new Map() }
+        : _resolvePeers({
+            currentDepth: node.depth,
+            dependenciesTree: ctx.dependenciesTree,
+            lockfileDir: ctx.lockfileDir,
+            nodeId,
+            parentPkgs,
+            peerDependencyIssues: ctx.peerDependencyIssues,
+            resolvedPackage,
+            rootDir: ctx.rootDir,
+            parentNodeIds,
+        });
+    const allResolvedPeers = unknownResolvedPeersOfChildren;
+    for (const [k, v] of resolvedPeers) {
+        allResolvedPeers.set(k, v);
+    }
+    allResolvedPeers.delete(node.resolvedPackage.name);
+    const allMissingPeers = new Map();
+    for (const [peer, range] of missingPeersOfChildren.entries()) {
+        allMissingPeers.set(peer, range);
+    }
+    for (const [peer, range] of missingPeers.entries()) {
+        allMissingPeers.set(peer, range);
+    }
+    let cache;
+    const isPure = allResolvedPeers.size === 0 && allMissingPeers.size === 0;
+    if (isPure) {
+        ctx.purePkgs.add(resolvedPackage.pkgIdWithPatchHash);
+    }
+    else {
+        cache = {
+            missingPeers: allMissingPeers,
+            depPath: pDefer(),
+            resolvedPeers: allResolvedPeers,
+        };
+        if (ctx.peersCache.has(resolvedPackage.pkgIdWithPatchHash)) {
+            ctx.peersCache.get(resolvedPackage.pkgIdWithPatchHash).push(cache);
+        }
+        else {
+            ctx.peersCache.set(resolvedPackage.pkgIdWithPatchHash, [cache]);
+        }
+    }
+    let calculateDepPathIfNeeded;
+    if (allResolvedPeers.size === 0) {
+        addDepPathToGraph(resolvedPackage.pkgIdWithPatchHash);
+    }
+    else {
+        const peerIds = [];
+        const pendingPeers = [];
+        for (const [alias, peerNodeId] of allResolvedPeers.entries()) {
+            if (typeof peerNodeId === 'string' && peerNodeId.startsWith('link:')) {
+                const linkedDir = peerNodeId.slice(5);
+                peerIds.push({
+                    name: alias,
+                    version: filenamify(linkedDir, { replacement: '+' }),
+                });
+                continue;
+            }
+            const peerDepPath = ctx.pathsByNodeId.get(peerNodeId);
+            if (peerDepPath) {
+                peerIds.push(peerDepPath);
+                continue;
+            }
+            pendingPeers.push({ alias, nodeId: peerNodeId });
+        }
+        if (pendingPeers.length === 0) {
+            const peerDepGraphHash = createPeerDepGraphHash(peerIds, ctx.peersSuffixMaxLength);
+            addDepPathToGraph(`${resolvedPackage.pkgIdWithPatchHash}${peerDepGraphHash}`);
+        }
+        else {
+            calculateDepPathIfNeeded = calculateDepPath.bind(null, peerIds, pendingPeers);
+        }
+    }
+    return {
+        resolvedPeers: allResolvedPeers,
+        missingPeers: allMissingPeers,
+        calculateDepPath: calculateDepPathIfNeeded,
+        finishing,
+    };
+    async function calculateDepPath(peerIds, pendingPeerNodes, cycles) {
+        const cyclicPeerAliases = new Set();
+        for (const cycle of cycles) {
+            if (cycle.includes(currentAlias)) {
+                for (const peerAlias of cycle) {
+                    cyclicPeerAliases.add(peerAlias);
+                }
+            }
+        }
+        const peerDepGraphHash = createPeerDepGraphHash([
+            ...peerIds,
+            ...await Promise.all(pendingPeerNodes
+                .map(async (pendingPeer) => {
+                if (cyclicPeerAliases.has(pendingPeer.alias)) {
+                    const { name, version } = ctx.dependenciesTree.get(pendingPeer.nodeId)?.resolvedPackage;
+                    const id = `${name}@${version}`;
+                    ctx.pathsByNodeIdPromises.get(pendingPeer.nodeId)?.resolve(id);
+                    return id;
+                }
+                return ctx.pathsByNodeIdPromises.get(pendingPeer.nodeId).promise;
+            })),
+        ], ctx.peersSuffixMaxLength);
+        addDepPathToGraph(`${resolvedPackage.pkgIdWithPatchHash}${peerDepGraphHash}`);
+    }
+    function addDepPathToGraph(depPath) {
+        cache?.depPath.resolve(depPath);
+        ctx.pathsByNodeId.set(nodeId, depPath);
+        ctx.pathsByNodeIdPromises.get(nodeId).resolve(depPath);
+        if (ctx.depPathsByPkgId != null) {
+            if (!ctx.depPathsByPkgId.has(resolvedPackage.pkgIdWithPatchHash)) {
+                ctx.depPathsByPkgId.set(resolvedPackage.pkgIdWithPatchHash, new Set([depPath]));
+            }
+            else {
+                ctx.depPathsByPkgId.get(resolvedPackage.pkgIdWithPatchHash).add(depPath);
+            }
+        }
+        const peerDependencies = { ...resolvedPackage.peerDependencies };
+        if (!ctx.depGraph[depPath] || ctx.depGraph[depPath].depth > node.depth) {
+            const modules = path.join(ctx.virtualStoreDir, depPathToFilename(depPath, ctx.virtualStoreDirMaxLength), 'node_modules');
+            const dir = path.join(modules, resolvedPackage.name);
+            const transitivePeerDependencies = new Set();
+            for (const unknownPeer of allResolvedPeers.keys()) {
+                if (!peerDependencies[unknownPeer]) {
+                    transitivePeerDependencies.add(unknownPeer);
+                }
+            }
+            for (const unknownPeer of missingPeersOfChildren.keys()) {
+                if (!peerDependencies[unknownPeer]) {
+                    transitivePeerDependencies.add(unknownPeer);
+                }
+            }
+            ctx.depGraph[depPath] = {
+                ...node.resolvedPackage,
+                childrenNodeIds: Object.assign(getPreviouslyResolvedChildren(ctx, node.resolvedPackage.pkgIdWithPatchHash), children, Object.fromEntries(resolvedPeers.entries())),
+                depPath,
+                depth: node.depth,
+                dir,
+                installable: node.installable,
+                isPure,
+                modules,
+                peerDependencies,
+                transitivePeerDependencies,
+                resolvedPeerNames: new Set(allResolvedPeers.keys()),
+            };
+        }
+    }
+}
+function parentPkgsMatch(dependenciesTree, currentParentPkg, newParentPkg) {
+    if (currentParentPkg.version !== newParentPkg.version ||
+        currentParentPkg.alias !== newParentPkg.alias) {
+        return false;
+    }
+    const currentParentResolvedPkg = currentParentPkg.nodeId && dependenciesTree.get(currentParentPkg.nodeId)?.resolvedPackage;
+    if (currentParentResolvedPkg == null)
+        return true;
+    const newParentResolvedPkg = newParentPkg.nodeId && dependenciesTree.get(newParentPkg.nodeId)?.resolvedPackage;
+    if (newParentResolvedPkg == null)
+        return true;
+    return currentParentResolvedPkg.name === newParentResolvedPkg.name;
+}
+function findHit(ctx, parentPkgs, pkgIdWithPatchHash) {
+    const cacheItems = ctx.peersCache.get(pkgIdWithPatchHash);
+    if (!cacheItems)
+        return undefined;
+    return cacheItems.find((cache) => {
+        for (const [name, cachedNodeId] of cache.resolvedPeers) {
+            const parentPkgNodeId = parentPkgs[name]?.nodeId;
+            if (Boolean(parentPkgNodeId) !== Boolean(cachedNodeId))
+                return false;
+            if (parentPkgNodeId === cachedNodeId)
+                continue;
+            if (!parentPkgNodeId)
+                return false;
+            if (ctx.pathsByNodeId.has(cachedNodeId) &&
+                ctx.pathsByNodeId.get(cachedNodeId) === ctx.pathsByNodeId.get(parentPkgNodeId))
+                continue;
+            if (!ctx.dependenciesTree.has(parentPkgNodeId) && typeof parentPkgNodeId === 'string' && parentPkgNodeId.startsWith('link:')) {
+                return false;
+            }
+            const parentPkgId = ctx.dependenciesTree.get(parentPkgNodeId).resolvedPackage.pkgIdWithPatchHash;
+            const cachedPkgId = ctx.dependenciesTree.get(cachedNodeId).resolvedPackage.pkgIdWithPatchHash;
+            if (parentPkgId !== cachedPkgId) {
+                return false;
+            }
+            if (!ctx.purePkgs.has(parentPkgId) &&
+                !parentPackagesMatch(ctx, cachedNodeId, parentPkgNodeId)) {
+                return false;
+            }
+        }
+        for (const missingPeer of cache.missingPeers.keys()) {
+            if (parentPkgs[missingPeer])
+                return false;
+        }
+        return true;
+    });
+}
+function parentPackagesMatch(ctx, cachedNodeId, checkedNodeId) {
+    const cachedParentPkgs = ctx.parentPkgsOfNode.get(cachedNodeId);
+    if (!cachedParentPkgs)
+        return false;
+    const checkedParentPkgs = ctx.parentPkgsOfNode.get(checkedNodeId);
+    if (!checkedParentPkgs)
+        return false;
+    if (Object.keys(cachedParentPkgs).length !== Object.keys(checkedParentPkgs).length)
+        return false;
+    const maxDepth = Object.values(checkedParentPkgs)
+        .reduce((maxDepth, { depth }) => Math.max(depth ?? 0, maxDepth), 0);
+    const peerDepsAreNotShadowed = parentPkgsHaveSingleOccurrence(cachedParentPkgs) &&
+        parentPkgsHaveSingleOccurrence(checkedParentPkgs);
+    return (Object.entries(cachedParentPkgs).every(([name, { version, pkgIdWithPatchHash }]) => {
+        if (checkedParentPkgs[name] == null)
+            return false;
+        if (version && checkedParentPkgs[name].version) {
+            return version === checkedParentPkgs[name].version;
+        }
+        return pkgIdWithPatchHash != null &&
+            (pkgIdWithPatchHash === checkedParentPkgs[name].pkgIdWithPatchHash) &&
+            (peerDepsAreNotShadowed ||
+                // Peer dependencies that appear last we can consider valid.
+                // If they do depend on other peer dependencies then they must be those that we will check further.
+                checkedParentPkgs[name].depth === maxDepth ||
+                ctx.purePkgs.has(pkgIdWithPatchHash));
+    }));
+}
+function parentPkgsHaveSingleOccurrence(parentPkgs) {
+    return Object.values(parentPkgs).every(({ occurrence }) => occurrence === 0 || occurrence == null);
+}
+// When a package has itself in the subdependencies, so there's a cycle,
+// pnpm will break the cycle, when it first repeats itself.
+// However, when the cycle is broken up, the last repeated package is removed
+// from the dependencies of the parent package.
+// So we need to merge all the children of all the parent packages with same ID as the resolved package.
+// This way we get all the children that were removed, when ending cycles.
+function getPreviouslyResolvedChildren({ parentNodeIds, parentDepPathsChain, dependenciesTree, }, currentDepPath) {
+    const allChildren = {};
+    if (!currentDepPath || !parentDepPathsChain.includes(currentDepPath))
+        return allChildren;
+    for (let i = parentNodeIds.length - 1; i >= 0; i--) {
+        const parentNode = dependenciesTree.get(parentNodeIds[i]);
+        if (parentNode.resolvedPackage.pkgIdWithPatchHash === currentDepPath) {
+            if (typeof parentNode.children === 'function') {
+                parentNode.children = parentNode.children();
+            }
+            Object.assign(allChildren, parentNode.children);
+        }
+    }
+    return allChildren;
+}
+async function resolvePeersOfChildren(children, parentPkgs, ctx) {
+    const allResolvedPeers = new Map();
+    const allMissingPeers = new Map();
+    // Partition children based on whether they're repeated in parentPkgs.
+    // This impacts the efficiency of graph traversal and prevents potential out-of-memory errors.
+    // We check repeated first as the peers resolution of those probably are cached already.
+    const [repeated, notRepeated] = partition(([alias]) => parentPkgs[alias] != null, Object.entries(children));
+    const nodeIds = Array.from(new Set([...repeated, ...notRepeated].map(([, nodeId]) => nodeId)));
+    const aliasByNodeId = Object.fromEntries(Object.entries(children).map(([alias, nodeId]) => [nodeId, alias]));
+    for (const nodeId of nodeIds) {
+        if (!ctx.pathsByNodeIdPromises.has(nodeId)) {
+            ctx.pathsByNodeIdPromises.set(nodeId, pDefer());
+        }
+    }
+    // Resolving non-repeated nodes before repeated nodes proved to be slightly faster.
+    const calculateDepPaths = [];
+    const graph = new Map();
+    const finishingList = [];
+    const parentDepPaths = {};
+    for (const [name, parentPkg] of Object.entries(parentPkgs)) {
+        if (!ctx.allPeerDepNames.has(name))
+            continue;
+        if (parentPkg.nodeId && (typeof parentPkg.nodeId === 'number' || !parentPkg.nodeId.startsWith('link:'))) {
+            parentDepPaths[name] = {
+                pkgIdWithPatchHash: ctx.dependenciesTree.get(parentPkg.nodeId).resolvedPackage.pkgIdWithPatchHash,
+                depth: parentPkg.depth,
+                occurrence: parentPkg.occurrence,
+            };
+        }
+        else {
+            parentDepPaths[name] = { version: parentPkg.version };
+        }
+    }
+    for (const childNodeId of nodeIds) {
+        ctx.parentPkgsOfNode.set(childNodeId, parentDepPaths);
+    }
+    for (const childNodeId of nodeIds) {
+        const currentAlias = aliasByNodeId[childNodeId];
+        const { resolvedPeers, missingPeers, calculateDepPath, finishing, } = await resolvePeersOfNode(currentAlias, childNodeId, parentPkgs, ctx); // eslint-disable-line no-await-in-loop
+        if (finishing) {
+            finishingList.push(finishing);
+        }
+        if (calculateDepPath) {
+            calculateDepPaths.push(calculateDepPath);
+        }
+        const edges = [];
+        for (const [peerName, peerNodeId] of resolvedPeers) {
+            allResolvedPeers.set(peerName, peerNodeId);
+            edges.push(peerName);
+        }
+        addEdgesToGraph(currentAlias, edges);
+        const node = ctx.dependenciesTree.get(childNodeId);
+        // We resolve peer dependencies via both the alias and the real name of the package.
+        // That's why we need to detect circular graphs via both the alias and the real name.
+        if (currentAlias !== node.resolvedPackage.name) {
+            addEdgesToGraph(node.resolvedPackage.name, edges);
+        }
+        for (const [missingPeer, range] of missingPeers.entries()) {
+            allMissingPeers.set(missingPeer, range);
+        }
+    }
+    function addEdgesToGraph(pkgName, edges) {
+        const existingEdges = graph.get(pkgName);
+        if (existingEdges == null) {
+            graph.set(pkgName, edges);
+        }
+        else {
+            existingEdges.push(...edges);
+        }
+    }
+    if (calculateDepPaths.length) {
+        const { cycles } = analyzeGraph(Array.from(graph.entries()));
+        finishingList.push(...calculateDepPaths.map((calculateDepPath) => calculateDepPath(cycles)));
+    }
+    const finishing = Promise.all(finishingList).then(() => { });
+    const unknownResolvedPeersOfChildren = new Map();
+    for (const [alias, v] of allResolvedPeers) {
+        if (!children[alias]) {
+            unknownResolvedPeersOfChildren.set(alias, v);
+        }
+    }
+    return { resolvedPeers: unknownResolvedPeersOfChildren, missingPeers: allMissingPeers, finishing };
+}
+function _resolvePeers(ctx) {
+    const resolvedPeers = new Map();
+    const missingPeers = new Map();
+    for (const [peerName, { version, optional }] of Object.entries(ctx.resolvedPackage.peerDependencies)) {
+        const peerVersionRange = version.replace(/^workspace:/, '');
+        const resolved = ctx.parentPkgs[peerName];
+        const optionalPeer = optional === true;
+        if (!resolved) {
+            missingPeers.set(peerName, { range: version, optional: optionalPeer });
+            const location = getLocationFromParentNodeIds(ctx);
+            if (!ctx.peerDependencyIssues.missing[peerName]) {
+                ctx.peerDependencyIssues.missing[peerName] = [];
+            }
+            ctx.peerDependencyIssues.missing[peerName].push({
+                parents: location.parents,
+                optional: optionalPeer,
+                wantedRange: peerVersionRange,
+            });
+            continue;
+        }
+        if (!semverUtils.satisfiesWithPrereleases(resolved.version, peerVersionRange, true)) {
+            const location = getLocationFromParentNodeIds(ctx);
+            if (!ctx.peerDependencyIssues.bad[peerName]) {
+                ctx.peerDependencyIssues.bad[peerName] = [];
+            }
+            const peerLocation = resolved.nodeId == null
+                ? []
+                : getLocationFromParentNodeIds({
+                    dependenciesTree: ctx.dependenciesTree,
+                    parentNodeIds: resolved.parentNodeIds,
+                }).parents;
+            ctx.peerDependencyIssues.bad[peerName].push({
+                foundVersion: resolved.version,
+                resolvedFrom: peerLocation,
+                parents: location.parents,
+                optional: optionalPeer,
+                wantedRange: peerVersionRange,
+            });
+        }
+        if (resolved?.nodeId)
+            resolvedPeers.set(peerName, resolved.nodeId);
+    }
+    return { resolvedPeers, missingPeers };
+}
+function getLocationFromParentNodeIds({ dependenciesTree, parentNodeIds, }) {
+    const parents = parentNodeIds
+        .map((nid) => pick(['name', 'version'], dependenciesTree.get(nid).resolvedPackage));
+    return {
+        projectId: '.',
+        parents,
+    };
+}
+function toPkgByName(nodes) {
+    const pkgsByName = {};
+    const _updateParentRefs = updateParentRefs.bind(null, pkgsByName);
+    for (const { alias, node, nodeId, parentNodeIds } of nodes) {
+        const pkg = {
+            alias,
+            depth: node.depth,
+            nodeId,
+            version: node.resolvedPackage.version,
+            occurrence: 0,
+            parentNodeIds,
+        };
+        _updateParentRefs(alias, pkg);
+        if (alias !== node.resolvedPackage.name) {
+            _updateParentRefs(node.resolvedPackage.name, pkg);
+        }
+    }
+    return pkgsByName;
+}
+function updateParentRefs(parentRefs, newAlias, pkg) {
+    const existing = parentRefs[newAlias];
+    if (existing) {
+        const existingHasAlias = existing.alias != null && existing.alias !== newAlias;
+        if (!existingHasAlias)
+            return;
+        const newHasAlias = pkg.alias != null && pkg.alias !== newAlias;
+        if (newHasAlias && semver.gte(existing.version, pkg.version))
+            return;
+    }
+    parentRefs[newAlias] = pkg;
+}
+//# sourceMappingURL=resolvePeers.js.map