@pnpm/config.package-is-installable 1100.0.9 → 1100.0.10

package/lib/index.d.ts

@@ -3,6 +3,7 @@ import { UnsupportedEngineError, type WantedEngine } from './checkEngine.js';
 import { UnsupportedPlatformError } from './checkPlatform.js';
 export type { Engine } from './checkEngine.js';
 export type { Platform, WantedPlatform } from './checkPlatform.js';
+export { inferPlatformFromPackageName } from './inferPlatformFromPackageName.js';
 export { UnsupportedEngineError, UnsupportedPlatformError, type WantedEngine, };
 export declare function packageIsInstallable(pkgId: string, pkg: {
     name: string;

package/lib/index.js

@@ -2,9 +2,11 @@ import { installCheckLogger, skippedOptionalDependencyLogger, } from '@pnpm/core
 import { getSystemNodeVersion } from '@pnpm/engine.runtime.system-version';
 import { checkEngine, UnsupportedEngineError } from './checkEngine.js';
 import { checkPlatform, UnsupportedPlatformError } from './checkPlatform.js';
+import { inferPlatformFromPackageName } from './inferPlatformFromPackageName.js';
+export { inferPlatformFromPackageName } from './inferPlatformFromPackageName.js';
 export { UnsupportedEngineError, UnsupportedPlatformError, };
 export function packageIsInstallable(pkgId, pkg, options) {
-    const warn = checkPackage(pkgId, pkg, options);
+    const warn = checkPackage(pkgId, { engines: pkg.engines, ...effectivePlatform(pkg, options.optional) }, options);
     if (warn == null)
         return true;
     installCheckLogger.warn({
@@ -28,6 +30,32 @@ export function packageIsInstallable(pkgId, pkg, options) {
         throw warn;
     return null;
 }
+/**
+ * The platform fields of an optional dependency may be incomplete: some
+ * registries strip os/cpu/libc (or just libc) from the metadata they serve,
+ * and lockfile entries written from such metadata lack them too. For a
+ * platform-specific binary the package name carries the same information, so
+ * each missing field is filled from the name's tokens. A package that
+ * declares no platform fields at all is treated as platform-specific only
+ * when an operating system is recognized in its name — a generic name
+ * segment (e.g. `arm` on its own) never marks it as such.
+ * https://github.com/pnpm/pnpm/issues/11702
+ */
+function effectivePlatform(pkg, optional) {
+    if (!optional || (pkg.os != null && pkg.cpu != null && pkg.libc != null))
+        return pkg;
+    const inferred = inferPlatformFromPackageName(pkg.name);
+    if (inferred == null)
+        return pkg;
+    const pkgDeclaresPlatform = pkg.os != null || pkg.cpu != null || pkg.libc != null;
+    if (!pkgDeclaresPlatform && inferred.os == null)
+        return pkg;
+    return {
+        os: pkg.os ?? inferred.os,
+        cpu: pkg.cpu ?? inferred.cpu,
+        libc: pkg.libc ?? inferred.libc,
+    };
+}
 export function checkPackage(pkgId, manifest, options) {
     return checkPlatform(pkgId, {
         cpu: manifest.cpu ?? ['any'],

package/lib/inferPlatformFromPackageName.d.ts

@@ -0,0 +1,13 @@
+export interface PlatformInferredFromPackageName {
+    os?: string[];
+    cpu?: string[];
+    libc?: string[];
+}
+/**
+ * Infers the supported platforms of a package from the tokens of its name,
+ * e.g. `@nx/nx-win32-arm64-msvc` → `{ os: ['win32'], cpu: ['arm64'] }`.
+ * Platform-specific binary packages follow this naming convention, which is
+ * the only platform signal left when their os/cpu/libc manifest fields are
+ * absent. Returns null when no platform token is recognized in the name.
+ */
+export declare function inferPlatformFromPackageName(name: string): PlatformInferredFromPackageName | null;

package/lib/inferPlatformFromPackageName.js

@@ -0,0 +1,71 @@
+const OS_BY_TOKEN = new Map([
+    ['aix', 'aix'],
+    ['android', 'android'],
+    ['darwin', 'darwin'],
+    ['macos', 'darwin'],
+    ['osx', 'darwin'],
+    ['freebsd', 'freebsd'],
+    ['linux', 'linux'],
+    ['netbsd', 'netbsd'],
+    ['openbsd', 'openbsd'],
+    ['openharmony', 'openharmony'],
+    ['sunos', 'sunos'],
+    ['win32', 'win32'],
+    ['windows', 'win32'],
+]);
+const CPU_BY_TOKEN = new Map([
+    ['arm', 'arm'],
+    ['armv6', 'arm'],
+    ['armv7', 'arm'],
+    ['arm64', 'arm64'],
+    ['aarch64', 'arm64'],
+    ['ia32', 'ia32'],
+    ['loong64', 'loong64'],
+    ['mips64el', 'mips64el'],
+    ['ppc64', 'ppc64'],
+    ['ppc64le', 'ppc64'],
+    ['riscv64', 'riscv64'],
+    ['s390x', 's390x'],
+    ['x64', 'x64'],
+    ['amd64', 'x64'],
+    ['wasm32', 'wasm32'],
+]);
+const LIBC_BY_TOKEN = new Map([
+    ['glibc', 'glibc'],
+    ['gnu', 'glibc'],
+    ['gnueabihf', 'glibc'],
+    ['musl', 'musl'],
+    ['musleabihf', 'musl'],
+]);
+/**
+ * Infers the supported platforms of a package from the tokens of its name,
+ * e.g. `@nx/nx-win32-arm64-msvc` → `{ os: ['win32'], cpu: ['arm64'] }`.
+ * Platform-specific binary packages follow this naming convention, which is
+ * the only platform signal left when their os/cpu/libc manifest fields are
+ * absent. Returns null when no platform token is recognized in the name.
+ */
+export function inferPlatformFromPackageName(name) {
+    const nameWithoutScope = name.includes('/') ? name.slice(name.indexOf('/') + 1) : name;
+    const tokens = nameWithoutScope.toLowerCase().split(/[-_.]/);
+    const os = pickTokenValues(tokens, OS_BY_TOKEN);
+    const cpu = pickTokenValues(tokens, CPU_BY_TOKEN);
+    const libc = pickTokenValues(tokens, LIBC_BY_TOKEN);
+    if (os == null && cpu == null && libc == null)
+        return null;
+    return {
+        ...(os != null ? { os } : {}),
+        ...(cpu != null ? { cpu } : {}),
+        ...(libc != null ? { libc } : {}),
+    };
+}
+function pickTokenValues(tokens, valueByToken) {
+    const values = new Set();
+    for (const token of tokens) {
+        const value = valueByToken.get(token);
+        if (value != null) {
+            values.add(value);
+        }
+    }
+    return values.size > 0 ? Array.from(values) : undefined;
+}
+//# sourceMappingURL=inferPlatformFromPackageName.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/config.package-is-installable",
-  "version": "1100.0.9",
+  "version": "1100.0.10",
   "description": "Checks if a package is installable on the current system",
   "keywords": [
     "pnpm",
@@ -31,11 +31,11 @@
     "execa": "npm:safe-execa@0.3.0",
     "memoize": "^10.2.0",
     "semver": "^7.8.1",
-    "@pnpm/core-loggers": "1100.1.4",
-    "@pnpm/error": "1100.0.0",
-    "@pnpm/types": "1101.3.1",
     "@pnpm/cli.meta": "1100.0.7",
-    "@pnpm/engine.runtime.system-version": "1100.0.2"
+    "@pnpm/core-loggers": "1100.2.0",
+    "@pnpm/engine.runtime.system-version": "1100.0.2",
+    "@pnpm/types": "1101.3.1",
+    "@pnpm/error": "1100.0.0"
   },
   "peerDependencies": {
     "@pnpm/logger": "^1001.0.1"
@@ -43,7 +43,7 @@
   "devDependencies": {
     "@jest/globals": "30.3.0",
     "@types/semver": "7.7.1",
-    "@pnpm/config.package-is-installable": "1100.0.9",
+    "@pnpm/config.package-is-installable": "1100.0.10",
     "@pnpm/logger": "1100.0.0"
   },
   "engines": {