@pnpm/installing.deps-installer 1012.0.1

package/lib/install/link.d.ts

@@ -0,0 +1,51 @@
+import { type DepsStateCache } from '@pnpm/deps.graph-hasher';
+import type { DependenciesGraph, LinkedDependency } from '@pnpm/installing.deps-resolver';
+import type { InstallationResultStats } from '@pnpm/installing.deps-restorer';
+import type { IncludedDependencies } from '@pnpm/installing.modules-yaml';
+import type { LockfileObject } from '@pnpm/lockfile.fs';
+import type { StoreController } from '@pnpm/store.controller-types';
+import type { AllowBuild, DepPath, HoistedDependencies, Registries } from '@pnpm/types';
+import type { ImporterToUpdate } from './index.js';
+export interface LinkPackagesOptions {
+    allowBuild?: AllowBuild;
+    currentLockfile: LockfileObject;
+    dedupeDirectDeps: boolean;
+    dependenciesByProjectId: Record<string, Map<string, DepPath>>;
+    disableRelinkLocalDirDeps?: boolean;
+    force: boolean;
+    depsStateCache: DepsStateCache;
+    enableGlobalVirtualStore: boolean;
+    extraNodePaths: string[];
+    hoistedDependencies: HoistedDependencies;
+    hoistedModulesDir: string;
+    hoistPattern?: string[];
+    ignoreScripts: boolean;
+    publicHoistPattern?: string[];
+    include: IncludedDependencies;
+    linkedDependenciesByProjectId: Record<string, LinkedDependency[]>;
+    lockfileDir: string;
+    makePartialCurrentLockfile: boolean;
+    outdatedDependencies: Record<string, string>;
+    pruneStore: boolean;
+    pruneVirtualStore: boolean;
+    registries: Registries;
+    rootModulesDir: string;
+    sideEffectsCacheRead: boolean;
+    symlink: boolean;
+    skipped: Set<DepPath>;
+    storeController: StoreController;
+    virtualStoreDir: string;
+    virtualStoreDirMaxLength: number;
+    wantedLockfile: LockfileObject;
+    wantedToBeSkippedPackageIds: Set<string>;
+    hoistWorkspacePackages?: boolean;
+    virtualStoreOnly: boolean;
+}
+export interface LinkPackagesResult {
+    currentLockfile: LockfileObject;
+    newDepPaths: DepPath[];
+    newHoistedDependencies: HoistedDependencies;
+    removedDepPaths: Set<string>;
+    stats: InstallationResultStats;
+}
+export declare function linkPackages(projects: ImporterToUpdate[], depGraph: DependenciesGraph, opts: LinkPackagesOptions): Promise<LinkPackagesResult>;

package/lib/install/link.js

@@ -0,0 +1,382 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { progressLogger, stageLogger, statsLogger, } from '@pnpm/core-loggers';
+import { calcDepState } from '@pnpm/deps.graph-hasher';
+import { symlinkDependency } from '@pnpm/fs.symlink-dependency';
+import { linkDirectDeps } from '@pnpm/installing.linking.direct-dep-linker';
+import { hoist } from '@pnpm/installing.linking.hoist';
+import { prune } from '@pnpm/installing.linking.modules-cleaner';
+import { filterLockfileByImporters, } from '@pnpm/lockfile.filtering';
+import { logger } from '@pnpm/logger';
+import { symlinkAllModules } from '@pnpm/worker';
+import pLimit from 'p-limit';
+import { pathExists } from 'path-exists';
+import { difference, equals, isEmpty, pick, pickBy, props } from 'ramda';
+const brokenModulesLogger = logger('_broken_node_modules');
+export async function linkPackages(projects, depGraph, opts) {
+    let depNodes = Object.values(depGraph).filter(({ depPath, id }) => {
+        if (((opts.wantedLockfile.packages?.[depPath]) != null) && !opts.wantedLockfile.packages[depPath].optional) {
+            opts.skipped.delete(depPath);
+            return true;
+        }
+        if (opts.wantedToBeSkippedPackageIds.has(id)) {
+            opts.skipped.add(depPath);
+            return false;
+        }
+        opts.skipped.delete(depPath);
+        return true;
+    });
+    if (!opts.include.dependencies) {
+        depNodes = depNodes.filter(({ dev, optional }) => dev || optional);
+    }
+    if (!opts.include.devDependencies) {
+        depNodes = depNodes.filter(({ optional, prod }) => prod || optional);
+    }
+    if (!opts.include.optionalDependencies) {
+        depNodes = depNodes.filter(({ optional }) => !optional);
+    }
+    depGraph = Object.fromEntries(depNodes.map((depNode) => [depNode.depPath, depNode]));
+    const removedDepPaths = await prune(projects, {
+        currentLockfile: opts.currentLockfile,
+        dedupeDirectDeps: opts.dedupeDirectDeps,
+        hoistedDependencies: opts.hoistedDependencies,
+        hoistedModulesDir: (opts.hoistPattern != null) ? opts.hoistedModulesDir : undefined,
+        include: opts.include,
+        lockfileDir: opts.lockfileDir,
+        pruneStore: opts.pruneStore,
+        pruneVirtualStore: opts.pruneVirtualStore,
+        publicHoistedModulesDir: (opts.publicHoistPattern != null) ? opts.rootModulesDir : undefined,
+        skipped: opts.skipped,
+        storeController: opts.storeController,
+        virtualStoreDir: opts.virtualStoreDir,
+        virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
+        wantedLockfile: opts.wantedLockfile,
+    });
+    stageLogger.debug({
+        prefix: opts.lockfileDir,
+        stage: 'importing_started',
+    });
+    const projectIds = projects.map(({ id }) => id);
+    const filterOpts = {
+        include: opts.include,
+        registries: opts.registries,
+        skipped: opts.skipped,
+    };
+    const newCurrentLockfile = filterLockfileByImporters(opts.wantedLockfile, projectIds, {
+        ...filterOpts,
+        failOnMissingDependencies: true,
+        skipped: new Set(),
+    });
+    const { newDepPaths, added } = await linkNewPackages(filterLockfileByImporters(opts.currentLockfile, projectIds, {
+        ...filterOpts,
+        failOnMissingDependencies: false,
+    }), newCurrentLockfile, depGraph, {
+        allowBuild: opts.allowBuild,
+        disableRelinkLocalDirDeps: opts.disableRelinkLocalDirDeps,
+        enableGlobalVirtualStore: opts.enableGlobalVirtualStore,
+        force: opts.force,
+        depsStateCache: opts.depsStateCache,
+        ignoreScripts: opts.ignoreScripts,
+        lockfileDir: opts.lockfileDir,
+        optional: opts.include.optionalDependencies,
+        sideEffectsCacheRead: opts.sideEffectsCacheRead,
+        symlink: opts.symlink,
+        skipped: opts.skipped,
+        storeController: opts.storeController,
+        virtualStoreDir: opts.virtualStoreDir,
+    });
+    stageLogger.debug({
+        prefix: opts.lockfileDir,
+        stage: 'importing_done',
+    });
+    let currentLockfile;
+    const allImportersIncluded = equals(projectIds.sort(), Object.keys(opts.wantedLockfile.importers).sort());
+    if (opts.makePartialCurrentLockfile ||
+        !allImportersIncluded) {
+        const packages = opts.currentLockfile.packages ?? {};
+        if (opts.wantedLockfile.packages != null) {
+            for (const depPath in opts.wantedLockfile.packages) { // eslint-disable-line:forin
+                if (depGraph[depPath]) {
+                    packages[depPath] = opts.wantedLockfile.packages[depPath];
+                }
+            }
+        }
+        const projects = {
+            ...opts.currentLockfile.importers,
+            ...pick(projectIds, opts.wantedLockfile.importers),
+        };
+        currentLockfile = filterLockfileByImporters({
+            ...opts.wantedLockfile,
+            importers: projects,
+            packages,
+        }, Object.keys(projects), {
+            ...filterOpts,
+            failOnMissingDependencies: false,
+            skipped: new Set(),
+        });
+    }
+    else if (opts.include.dependencies &&
+        opts.include.devDependencies &&
+        opts.include.optionalDependencies &&
+        opts.skipped.size === 0) {
+        currentLockfile = opts.wantedLockfile;
+    }
+    else {
+        currentLockfile = newCurrentLockfile;
+    }
+    let newHoistedDependencies;
+    if (opts.virtualStoreOnly || (opts.hoistPattern == null && opts.publicHoistPattern == null)) {
+        newHoistedDependencies = {};
+    }
+    else if (newDepPaths.length > 0 || removedDepPaths.size > 0) {
+        newHoistedDependencies = {
+            ...opts.hoistedDependencies,
+            ...await hoist({
+                extraNodePath: opts.extraNodePaths,
+                graph: depGraph,
+                directDepsByImporterId: {
+                    ...opts.dependenciesByProjectId,
+                    '.': new Map(Array.from(opts.dependenciesByProjectId['.']?.entries() ?? []).filter(([alias]) => {
+                        return newCurrentLockfile.importers['.'].specifiers[alias];
+                    })),
+                },
+                importerIds: projectIds,
+                privateHoistedModulesDir: opts.hoistedModulesDir,
+                privateHoistPattern: opts.hoistPattern ?? [],
+                publicHoistedModulesDir: opts.rootModulesDir,
+                publicHoistPattern: opts.publicHoistPattern ?? [],
+                virtualStoreDir: opts.virtualStoreDir,
+                virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
+                hoistedWorkspacePackages: opts.hoistWorkspacePackages
+                    ? projects.reduce((hoistedWorkspacePackages, project) => {
+                        if (project.manifest.name && project.id !== '.') {
+                            hoistedWorkspacePackages[project.id] = {
+                                dir: project.rootDir,
+                                name: project.manifest.name,
+                            };
+                        }
+                        return hoistedWorkspacePackages;
+                    }, {})
+                    : undefined,
+                skipped: opts.skipped,
+            }),
+        };
+    }
+    else {
+        newHoistedDependencies = opts.hoistedDependencies;
+    }
+    let linkedToRoot = 0;
+    if (opts.symlink && !opts.virtualStoreOnly) {
+        const projectsToLink = Object.fromEntries(await Promise.all(projects.map(async ({ id, manifest, modulesDir, rootDir }) => {
+            const deps = opts.dependenciesByProjectId[id];
+            const importerFromLockfile = newCurrentLockfile.importers[id];
+            return [id, {
+                    dir: rootDir,
+                    modulesDir,
+                    dependencies: await Promise.all([
+                        ...Array.from(deps.entries())
+                            .filter(([rootAlias]) => importerFromLockfile.specifiers[rootAlias])
+                            .map(([rootAlias, depPath]) => ({ rootAlias, depGraphNode: depGraph[depPath] }))
+                            .filter(({ depGraphNode }) => depGraphNode)
+                            .map(async ({ rootAlias, depGraphNode }) => {
+                            const isDev = Boolean(manifest.devDependencies?.[depGraphNode.name]);
+                            const isOptional = Boolean(manifest.optionalDependencies?.[depGraphNode.name]);
+                            return {
+                                alias: rootAlias,
+                                name: depGraphNode.name,
+                                version: depGraphNode.version,
+                                dir: depGraphNode.dir,
+                                id: depGraphNode.id,
+                                dependencyType: (isDev && 'dev' || isOptional && 'optional' || 'prod'),
+                                latest: opts.outdatedDependencies[depGraphNode.id],
+                                isExternalLink: false,
+                            };
+                        }),
+                        ...opts.linkedDependenciesByProjectId[id].map(async (linkedDependency) => {
+                            const dir = resolvePath(rootDir, linkedDependency.resolution.directory);
+                            return {
+                                alias: linkedDependency.alias,
+                                name: linkedDependency.name,
+                                version: linkedDependency.version,
+                                dir,
+                                id: linkedDependency.resolution.directory,
+                                dependencyType: (linkedDependency.dev && 'dev' || linkedDependency.optional && 'optional' || 'prod'),
+                                isExternalLink: true,
+                            };
+                        }),
+                    ]),
+                }];
+        })));
+        linkedToRoot = await linkDirectDeps(projectsToLink, { dedupe: opts.dedupeDirectDeps });
+    }
+    return {
+        currentLockfile,
+        newDepPaths,
+        newHoistedDependencies,
+        removedDepPaths,
+        stats: {
+            added,
+            removed: removedDepPaths.size,
+            linkedToRoot,
+        },
+    };
+}
+const isAbsolutePath = /^\/|^[A-Z]:/i;
+// This function is copied from @pnpm/resolving.local-resolver
+function resolvePath(where, spec) {
+    if (isAbsolutePath.test(spec))
+        return spec;
+    return path.resolve(where, spec);
+}
+async function linkNewPackages(currentLockfile, wantedLockfile, depGraph, opts) {
+    const wantedRelDepPaths = difference(Object.keys(wantedLockfile.packages ?? {}), Array.from(opts.skipped));
+    let newDepPathsSet;
+    if (opts.force) {
+        newDepPathsSet = new Set(wantedRelDepPaths
+            // when installing a new package, not all the nodes are analyzed
+            // just skip the ones that are in the lockfile but were not analyzed
+            .filter((depPath) => depGraph[depPath]));
+    }
+    else {
+        newDepPathsSet = await selectNewFromWantedDeps(wantedRelDepPaths, currentLockfile, depGraph);
+    }
+    const added = newDepPathsSet.size;
+    statsLogger.debug({
+        added,
+        prefix: opts.lockfileDir,
+    });
+    const existingWithUpdatedDeps = [];
+    if (!opts.force && (currentLockfile.packages != null) && (wantedLockfile.packages != null)) {
+        // add subdependencies that have been updated
+        // TODO: no need to relink everything. Can be relinked only what was changed
+        for (const depPath of wantedRelDepPaths) {
+            if (currentLockfile.packages[depPath] &&
+                (!equals(currentLockfile.packages[depPath].dependencies, wantedLockfile.packages[depPath].dependencies) ||
+                    !isEmpty(currentLockfile.packages[depPath].optionalDependencies ?? {}) ||
+                    !isEmpty(wantedLockfile.packages[depPath].optionalDependencies ?? {}))) {
+                // TODO: come up with a test that triggers the usecase of depGraph[depPath] undefined
+                // see related issue: https://github.com/pnpm/pnpm/issues/870
+                if (depGraph[depPath] && !newDepPathsSet.has(depPath)) {
+                    existingWithUpdatedDeps.push(depGraph[depPath]);
+                }
+            }
+        }
+    }
+    if (!newDepPathsSet.size && (existingWithUpdatedDeps.length === 0))
+        return { newDepPaths: [], added };
+    const newDepPaths = Array.from(newDepPathsSet);
+    const newPkgs = props(newDepPaths, depGraph);
+    await Promise.all(newPkgs.map(async (depNode) => fs.mkdir(depNode.modules, { recursive: true })));
+    await Promise.all([
+        !opts.symlink
+            ? Promise.resolve()
+            : linkAllModules([...newPkgs, ...existingWithUpdatedDeps], depGraph, {
+                lockfileDir: opts.lockfileDir,
+                optional: opts.optional,
+            }),
+        linkAllPkgs(opts.storeController, newPkgs, {
+            allowBuild: opts.allowBuild,
+            depGraph,
+            depsStateCache: opts.depsStateCache,
+            disableRelinkLocalDirDeps: opts.disableRelinkLocalDirDeps,
+            enableGlobalVirtualStore: opts.enableGlobalVirtualStore,
+            force: opts.force,
+            ignoreScripts: opts.ignoreScripts,
+            lockfileDir: opts.lockfileDir,
+            sideEffectsCacheRead: opts.sideEffectsCacheRead,
+        }),
+    ]);
+    return { newDepPaths, added };
+}
+async function selectNewFromWantedDeps(wantedRelDepPaths, currentLockfile, depGraph) {
+    const newDeps = new Set();
+    const prevDeps = currentLockfile.packages ?? {};
+    await Promise.all(wantedRelDepPaths.map(async (depPath) => {
+        const depNode = depGraph[depPath];
+        if (!depNode)
+            return;
+        const prevDep = prevDeps[depPath];
+        if (prevDep &&
+            // Local file should always be treated as a new dependency
+            // https://github.com/pnpm/pnpm/issues/5381
+            depNode.resolution.type !== 'directory' &&
+            depNode.resolution.integrity === prevDep.resolution.integrity) {
+            if (await pathExists(depNode.dir)) {
+                return;
+            }
+            brokenModulesLogger.debug({
+                missing: depNode.dir,
+            });
+        }
+        newDeps.add(depPath);
+    }));
+    return newDeps;
+}
+const limitLinking = pLimit(16);
+async function linkAllPkgs(storeController, depNodes, opts) {
+    await Promise.all(depNodes.map(async (depNode) => {
+        const { files } = await depNode.fetching();
+        depNode.requiresBuild = files.requiresBuild;
+        let sideEffectsCacheKey;
+        if (opts.sideEffectsCacheRead && files.sideEffectsMaps && !isEmpty(files.sideEffectsMaps)) {
+            if (opts?.allowBuild?.(depNode.name, depNode.version) !== false) {
+                sideEffectsCacheKey = calcDepState(opts.depGraph, opts.depsStateCache, depNode.depPath, {
+                    includeDepGraphHash: !opts.ignoreScripts && depNode.requiresBuild, // true when is built
+                    patchFileHash: depNode.patch?.hash,
+                });
+            }
+        }
+        const { importMethod, isBuilt } = await storeController.importPackage(depNode.dir, {
+            disableRelinkLocalDirDeps: opts.disableRelinkLocalDirDeps,
+            filesResponse: files,
+            force: opts.force,
+            safeToSkip: opts.enableGlobalVirtualStore,
+            sideEffectsCacheKey,
+            requiresBuild: depNode.patch != null || depNode.requiresBuild,
+        });
+        if (importMethod) {
+            progressLogger.debug({
+                method: importMethod,
+                requester: opts.lockfileDir,
+                status: 'imported',
+                to: depNode.dir,
+            });
+        }
+        depNode.isBuilt = isBuilt;
+        const selfDep = depNode.children[depNode.name];
+        if (selfDep) {
+            const pkg = opts.depGraph[selfDep];
+            if (!pkg || !pkg.installable && pkg.optional)
+                return;
+            const targetModulesDir = path.join(depNode.modules, depNode.name, 'node_modules');
+            await limitLinking(async () => symlinkDependency(pkg.dir, targetModulesDir, depNode.name));
+        }
+    }));
+}
+async function linkAllModules(depNodes, depGraph, opts) {
+    await symlinkAllModules({
+        deps: depNodes.map((depNode) => {
+            const children = opts.optional
+                ? depNode.children
+                : pickBy((_, childAlias) => !depNode.optionalDependencies.has(childAlias), depNode.children);
+            const childrenPaths = {};
+            for (const [alias, childDepPath] of Object.entries(children ?? {})) {
+                if (childDepPath.startsWith('link:')) {
+                    childrenPaths[alias] = path.resolve(opts.lockfileDir, childDepPath.slice(5));
+                }
+                else {
+                    const pkg = depGraph[childDepPath];
+                    if (!pkg || !pkg.installable && pkg.optional || alias === depNode.name)
+                        continue;
+                    childrenPaths[alias] = pkg.dir;
+                }
+            }
+            return {
+                children: childrenPaths,
+                modules: depNode.modules,
+                name: depNode.name,
+            };
+        }),
+    });
+}
+//# sourceMappingURL=link.js.map

package/lib/install/reportPeerDependencyIssues.d.ts

@@ -0,0 +1,12 @@
+import { PnpmError } from '@pnpm/error';
+import type { PeerDependencyIssuesByProjects, PeerDependencyRules } from '@pnpm/types';
+export declare function reportPeerDependencyIssues(peerDependencyIssuesByProjects: PeerDependencyIssuesByProjects, opts: {
+    lockfileDir: string;
+    rules?: PeerDependencyRules;
+    strictPeerDependencies: boolean;
+}): void;
+export declare function filterPeerDependencyIssues(peerDependencyIssuesByProjects: PeerDependencyIssuesByProjects, rules?: PeerDependencyRules): PeerDependencyIssuesByProjects;
+export declare class PeerDependencyIssuesError extends PnpmError {
+    issuesByProjects: PeerDependencyIssuesByProjects;
+    constructor(issues: PeerDependencyIssuesByProjects);
+}

package/lib/install/reportPeerDependencyIssues.js

@@ -0,0 +1,116 @@
+import { createMatcher } from '@pnpm/config.matcher';
+import { parseOverrides } from '@pnpm/config.parse-overrides';
+import { peerDependencyIssuesLogger } from '@pnpm/core-loggers';
+import { PnpmError } from '@pnpm/error';
+import { isEmpty } from 'ramda';
+import semver from 'semver';
+export function reportPeerDependencyIssues(peerDependencyIssuesByProjects, opts) {
+    const newPeerDependencyIssuesByProjects = filterPeerDependencyIssues(peerDependencyIssuesByProjects, opts.rules);
+    if (Object.values(newPeerDependencyIssuesByProjects).every((peerIssuesOfProject) => isEmpty(peerIssuesOfProject.bad) && (isEmpty(peerIssuesOfProject.missing) ||
+        peerIssuesOfProject.conflicts.length === 0 && Object.keys(peerIssuesOfProject.intersections).length === 0)))
+        return;
+    if (opts.strictPeerDependencies) {
+        throw new PeerDependencyIssuesError(newPeerDependencyIssuesByProjects);
+    }
+    peerDependencyIssuesLogger.debug({
+        issuesByProjects: newPeerDependencyIssuesByProjects,
+    });
+}
+export function filterPeerDependencyIssues(peerDependencyIssuesByProjects, rules) {
+    if (!rules)
+        return peerDependencyIssuesByProjects;
+    const ignoreMissingPatterns = [...new Set(rules?.ignoreMissing ?? [])];
+    const ignoreMissingMatcher = createMatcher(ignoreMissingPatterns);
+    const allowAnyPatterns = [...new Set(rules?.allowAny ?? [])];
+    const allowAnyMatcher = createMatcher(allowAnyPatterns);
+    const { allowedVersionsMatchAll, allowedVersionsByParentPkgName } = parseAllowedVersions(rules?.allowedVersions ?? {});
+    const newPeerDependencyIssuesByProjects = {};
+    for (const [projectId, { bad, missing, conflicts, intersections }] of Object.entries(peerDependencyIssuesByProjects)) {
+        newPeerDependencyIssuesByProjects[projectId] = { bad: {}, missing: {}, conflicts, intersections };
+        for (const [peerName, issues] of Object.entries(missing)) {
+            if (ignoreMissingMatcher(peerName) || issues.every(({ optional }) => optional)) {
+                continue;
+            }
+            newPeerDependencyIssuesByProjects[projectId].missing[peerName] = issues;
+        }
+        for (const [peerName, issues] of Object.entries(bad)) {
+            if (allowAnyMatcher(peerName))
+                continue;
+            const filteredIssues = [];
+            for (const issue of issues) {
+                if (allowedVersionsMatchAll[peerName]?.some((range) => semver.satisfies(issue.foundVersion, range)))
+                    continue;
+                const currentParentPkg = issue.parents.at(-1);
+                if (currentParentPkg && allowedVersionsByParentPkgName[peerName]?.[currentParentPkg.name]) {
+                    const allowedVersionsByParent = {};
+                    for (const { targetPkg, parentPkg, ranges } of allowedVersionsByParentPkgName[peerName][currentParentPkg.name]) {
+                        if (!parentPkg.bareSpecifier || currentParentPkg.version &&
+                            (isSubRange(parentPkg.bareSpecifier, currentParentPkg.version) || semver.satisfies(currentParentPkg.version, parentPkg.bareSpecifier))) {
+                            allowedVersionsByParent[targetPkg.name] = ranges;
+                        }
+                    }
+                    if (allowedVersionsByParent[peerName]?.some((range) => semver.satisfies(issue.foundVersion, range)))
+                        continue;
+                }
+                filteredIssues.push(issue);
+            }
+            if (filteredIssues.length) {
+                newPeerDependencyIssuesByProjects[projectId].bad[peerName] = filteredIssues;
+            }
+        }
+    }
+    return newPeerDependencyIssuesByProjects;
+}
+function isSubRange(superRange, subRange) {
+    return !superRange ||
+        subRange === superRange ||
+        semver.validRange(subRange) != null &&
+            semver.validRange(superRange) != null &&
+            semver.subset(subRange, superRange);
+}
+function tryParseAllowedVersions(allowedVersions) {
+    try {
+        return parseOverrides(allowedVersions ?? {});
+    }
+    catch (err) {
+        throw new PnpmError('INVALID_ALLOWED_VERSION_SELECTOR', `${err.message} in pnpm.peerDependencyRules.allowedVersions`);
+    }
+}
+function parseAllowedVersions(allowedVersions) {
+    const overrides = tryParseAllowedVersions(allowedVersions);
+    const allowedVersionsMatchAll = {};
+    const allowedVersionsByParentPkgName = {};
+    for (const { parentPkg, targetPkg, newBareSpecifier } of overrides) {
+        const ranges = parseVersions(newBareSpecifier);
+        if (!parentPkg) {
+            allowedVersionsMatchAll[targetPkg.name] = ranges;
+            continue;
+        }
+        if (!allowedVersionsByParentPkgName[targetPkg.name]) {
+            allowedVersionsByParentPkgName[targetPkg.name] = {};
+        }
+        if (!allowedVersionsByParentPkgName[targetPkg.name][parentPkg.name]) {
+            allowedVersionsByParentPkgName[targetPkg.name][parentPkg.name] = [];
+        }
+        allowedVersionsByParentPkgName[targetPkg.name][parentPkg.name].push({
+            parentPkg,
+            targetPkg,
+            ranges,
+        });
+    }
+    return {
+        allowedVersionsMatchAll,
+        allowedVersionsByParentPkgName,
+    };
+}
+function parseVersions(versions) {
+    return versions.split('||').map(v => v.trim());
+}
+export class PeerDependencyIssuesError extends PnpmError {
+    issuesByProjects;
+    constructor(issues) {
+        super('PEER_DEP_ISSUES', 'Unmet peer dependencies');
+        this.issuesByProjects = issues;
+    }
+}
+//# sourceMappingURL=reportPeerDependencyIssues.js.map

package/lib/install/validateModules.d.ts

@@ -0,0 +1,26 @@
+import type { IncludedDependencies, Modules } from '@pnpm/installing.modules-yaml';
+import { type ProjectRootDir, type Registries } from '@pnpm/types';
+export declare function validateModules(modules: Modules, projects: Array<{
+    modulesDir: string;
+    id: string;
+    rootDir: ProjectRootDir;
+}>, opts: {
+    currentHoistPattern?: string[];
+    currentPublicHoistPattern?: string[];
+    forceNewModules: boolean;
+    include?: IncludedDependencies;
+    lockfileDir: string;
+    modulesDir: string;
+    registries: Registries;
+    storeDir: string;
+    virtualStoreDir: string;
+    virtualStoreDirMaxLength: number;
+    confirmModulesPurge?: boolean;
+    hoistPattern?: string[] | undefined;
+    forceHoistPattern?: boolean;
+    publicHoistPattern?: string[] | undefined;
+    forcePublicHoistPattern?: boolean;
+    global?: boolean;
+}): Promise<{
+    purged: boolean;
+}>;