@pnpm/deps.inspection.peers-checker 1100.0.21 → 1100.0.23

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @pnpm/deps.inspection.peers-checker
 
+## 1100.0.23
+
+### Patch Changes
+
+- Republished every package: the tarballs published by the v11.13.1 through v11.16.0 releases were missing most of their compiled files due to a packing bug [#13164](https://github.com/pnpm/pnpm/issues/13164).
+
+- Updated dependencies:
+  - @pnpm/config.matcher@1100.0.2
+  - @pnpm/config.parse-overrides@1100.1.1
+  - @pnpm/deps.path@1100.0.11
+  - @pnpm/deps.peer-range@1100.1.1
+  - @pnpm/error@1100.1.0
+  - @pnpm/lockfile.fs@1100.1.14
+  - @pnpm/lockfile.walker@1100.0.16
+  - @pnpm/types@1101.6.0
+
+## 1100.0.22
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/deps.path@1100.0.10
+  - @pnpm/lockfile.fs@1100.1.13
+  - @pnpm/lockfile.walker@1100.0.15
+  - @pnpm/types@1101.5.0
+
 ## 1100.0.21
 
 ### Patch Changes

package/lib/checkPeerDependencies.d.ts

@@ -0,0 +1,7 @@
+import type { PeerDependencyIssuesByProjects, PeerDependencyRules } from '@pnpm/types';
+export declare function checkPeerDependencies(projectPaths: string[], opts: {
+    lockfileDir: string;
+    checkWantedLockfileOnly?: boolean;
+    modulesDir?: string;
+    peerDependencyRules?: PeerDependencyRules;
+}): Promise<PeerDependencyIssuesByProjects>;

package/lib/checkPeerDependencies.js

@@ -0,0 +1,197 @@
+import path from 'node:path';
+import { createMatcher } from '@pnpm/config.matcher';
+import { parseOverrides } from '@pnpm/config.parse-overrides';
+import { parse as parseDependencyPath, refToRelative } from '@pnpm/deps.path';
+import { getPeerVersionRange } from '@pnpm/deps.peer-range';
+import { PnpmError } from '@pnpm/error';
+import { getLockfileImporterId, readCurrentLockfile, readWantedLockfile, } from '@pnpm/lockfile.fs';
+import { lockfileWalkerGroupImporterSteps } from '@pnpm/lockfile.walker';
+import semver from 'semver';
+import { intersect } from 'semver-range-intersect';
+export async function checkPeerDependencies(projectPaths, opts) {
+    const modulesDir = opts.modulesDir ?? 'node_modules';
+    const lockfile = opts.checkWantedLockfileOnly
+        ? await readWantedLockfile(opts.lockfileDir, { ignoreIncompatible: false })
+        : await readCurrentLockfile(path.join(opts.lockfileDir, modulesDir, '.pnpm'), { ignoreIncompatible: false })
+            ?? await readWantedLockfile(opts.lockfileDir, { ignoreIncompatible: false });
+    if (!lockfile)
+        return {};
+    const issues = checkPeerDependenciesFromLockfile(projectPaths, lockfile, opts.lockfileDir);
+    if (opts.peerDependencyRules) {
+        return filterPeerDependencyIssues(issues, opts.peerDependencyRules);
+    }
+    return issues;
+}
+function checkPeerDependenciesFromLockfile(projectPaths, lockfile, lockfileDir) {
+    const packages = lockfile.packages ?? {};
+    const importerIds = projectPaths.map((p) => getLockfileImporterId(lockfileDir, p));
+    const walkerSteps = lockfileWalkerGroupImporterSteps(lockfile, importerIds);
+    const result = {};
+    for (const { importerId, step } of walkerSteps) {
+        const projectIssues = {
+            bad: {},
+            missing: {},
+            conflicts: [],
+            intersections: {},
+        };
+        walkStep(step, packages, [], projectIssues);
+        const merged = mergePeers(projectIssues.missing);
+        projectIssues.conflicts = merged.conflicts;
+        projectIssues.intersections = merged.intersections;
+        result[importerId] = projectIssues;
+    }
+    return result;
+}
+function walkStep(step, packages, parents, issues) {
+    for (const { depPath, pkgSnapshot, next } of step.dependencies) {
+        const parsed = parseDependencyPath(depPath);
+        const pkgName = parsed.name ?? depPath;
+        const pkgVersion = pkgSnapshot.version ?? parsed.version ?? '';
+        const currentParents = [...parents, { name: pkgName, version: pkgVersion }];
+        if (pkgSnapshot.peerDependencies) {
+            for (const [peerName, rawPeerRange] of Object.entries(pkgSnapshot.peerDependencies)) {
+                const peerRange = getPeerVersionRange(rawPeerRange);
+                const isOptional = pkgSnapshot.peerDependenciesMeta?.[peerName]?.optional === true;
+                const resolvedPeerRef = pkgSnapshot.dependencies?.[peerName] ?? pkgSnapshot.optionalDependencies?.[peerName];
+                if (!resolvedPeerRef) {
+                    if (!isOptional) {
+                        if (!issues.missing[peerName])
+                            issues.missing[peerName] = [];
+                        issues.missing[peerName].push({
+                            parents: currentParents,
+                            optional: isOptional,
+                            wantedRange: peerRange,
+                        });
+                    }
+                }
+                else {
+                    const peerVersion = extractVersion(resolvedPeerRef, peerName, packages);
+                    if (peerVersion && !satisfies(peerVersion, peerRange)) {
+                        if (!issues.bad[peerName])
+                            issues.bad[peerName] = [];
+                        issues.bad[peerName].push({
+                            parents: currentParents,
+                            optional: isOptional,
+                            wantedRange: peerRange,
+                            foundVersion: peerVersion,
+                            resolvedFrom: [],
+                        });
+                    }
+                }
+            }
+        }
+        walkStep(next(), packages, currentParents, issues);
+    }
+}
+function extractVersion(ref, alias, packages) {
+    const depPath = refToRelative(ref, alias);
+    if (depPath && packages[depPath]) {
+        const parsed = parseDependencyPath(depPath);
+        return packages[depPath].version ?? parsed.version;
+    }
+    const parsed = parseDependencyPath(`${alias}@${ref}`);
+    return parsed.version;
+}
+function satisfies(version, range) {
+    if (range === '*')
+        return true;
+    return semver.satisfies(version, range, { includePrerelease: true, loose: true });
+}
+function filterPeerDependencyIssues(peerDependencyIssuesByProjects, rules) {
+    const ignoreMissingMatcher = createMatcher([...new Set(rules.ignoreMissing ?? [])]);
+    const allowAnyMatcher = createMatcher([...new Set(rules.allowAny ?? [])]);
+    const { matchAll: allowedVersionsMatchAll, byParent: allowedVersionsByParent } = parseAllowedVersions(rules.allowedVersions ?? {});
+    const result = {};
+    for (const [projectId, { bad, missing, conflicts, intersections }] of Object.entries(peerDependencyIssuesByProjects)) {
+        const filteredMissing = {};
+        const filteredBad = {};
+        const filteredIntersections = {};
+        for (const [peerName, issues] of Object.entries(missing)) {
+            if (ignoreMissingMatcher(peerName) || issues.every(({ optional }) => optional))
+                continue;
+            filteredMissing[peerName] = issues;
+            if (intersections[peerName]) {
+                filteredIntersections[peerName] = intersections[peerName];
+            }
+        }
+        for (const [peerName, issues] of Object.entries(bad)) {
+            if (allowAnyMatcher(peerName))
+                continue;
+            const remaining = issues.filter((issue) => {
+                if (allowedVersionsMatchAll[peerName]?.some((range) => semver.satisfies(issue.foundVersion, range)))
+                    return false;
+                const declaringParent = issue.parents.at(-1);
+                if (declaringParent && allowedVersionsByParent[declaringParent.name]?.[peerName]?.some((range) => semver.satisfies(issue.foundVersion, range)))
+                    return false;
+                return true;
+            });
+            if (remaining.length > 0) {
+                filteredBad[peerName] = remaining;
+            }
+        }
+        result[projectId] = {
+            bad: filteredBad,
+            missing: filteredMissing,
+            conflicts: conflicts.filter((peerName) => filteredMissing[peerName] != null),
+            intersections: filteredIntersections,
+        };
+    }
+    return result;
+}
+function parseAllowedVersions(allowedVersions) {
+    let overrides;
+    try {
+        overrides = parseOverrides(allowedVersions);
+    }
+    catch (err) {
+        throw new PnpmError('INVALID_ALLOWED_VERSION_SELECTOR', `${err.message} in pnpm.peerDependencyRules.allowedVersions`);
+    }
+    const matchAll = {};
+    const byParent = {};
+    for (const { parentPkg, targetPkg, newBareSpecifier } of overrides) {
+        const ranges = newBareSpecifier.split('||').map((v) => v.trim());
+        if (parentPkg) {
+            if (!byParent[parentPkg.name])
+                byParent[parentPkg.name] = {};
+            byParent[parentPkg.name][targetPkg.name] = ranges;
+        }
+        else {
+            matchAll[targetPkg.name] = ranges;
+        }
+    }
+    return { matchAll, byParent };
+}
+function mergePeers(missingPeers) {
+    const conflicts = [];
+    const intersections = {};
+    for (const [peerName, issues] of Object.entries(missingPeers)) {
+        if (issues.every(({ optional }) => optional))
+            continue;
+        if (issues.length === 1) {
+            intersections[peerName] = issues[0].wantedRange;
+            continue;
+        }
+        const ranges = [...new Set(issues.map(({ wantedRange }) => wantedRange))];
+        if (ranges.length === 1) {
+            intersections[peerName] = ranges[0];
+            continue;
+        }
+        const intersection = safeIntersect(ranges);
+        if (intersection === null) {
+            conflicts.push(peerName);
+        }
+        else {
+            intersections[peerName] = intersection;
+        }
+    }
+    return { conflicts, intersections };
+}
+function safeIntersect(ranges) {
+    try {
+        return intersect(...ranges);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=checkPeerDependencies.js.map

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { checkPeerDependencies } from './checkPeerDependencies.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/deps.inspection.peers-checker",
-  "version": "1100.0.21",
+  "version": "1100.0.23",
   "description": "Check for unmet and missing peer dependency issues from the lockfile",
   "keywords": [
     "pnpm",
@@ -28,21 +28,21 @@
     "!*.map"
   ],
   "dependencies": {
-    "@pnpm/config.matcher": "1100.0.1",
-    "@pnpm/config.parse-overrides": "1100.1.0",
-    "@pnpm/deps.path": "1100.0.9",
-    "@pnpm/deps.peer-range": "1100.1.0",
-    "@pnpm/error": "1100.0.1",
-    "@pnpm/lockfile.fs": "1100.1.12",
-    "@pnpm/lockfile.walker": "1100.0.14",
-    "@pnpm/types": "1101.4.0",
+    "@pnpm/config.matcher": "1100.0.2",
+    "@pnpm/config.parse-overrides": "1100.1.1",
+    "@pnpm/deps.path": "1100.0.11",
+    "@pnpm/deps.peer-range": "1100.1.1",
+    "@pnpm/error": "1100.1.0",
+    "@pnpm/lockfile.fs": "1100.1.14",
+    "@pnpm/lockfile.walker": "1100.0.16",
+    "@pnpm/types": "1101.6.0",
     "semver": "^7.8.4",
     "semver-range-intersect": "^0.3.1"
   },
   "devDependencies": {
     "@jest/globals": "30.4.1",
-    "@pnpm/deps.inspection.peers-checker": "1100.0.21",
-    "@pnpm/test-fixtures": "1100.0.0",
+    "@pnpm/deps.inspection.peers-checker": "1100.0.23",
+    "@pnpm/test-fixtures": "1100.0.1",
     "@types/semver": "7.7.1"
   },
   "engines": {