@pnpm/config.package-is-installable 1100.0.15 → 1100.1.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @pnpm/package-is-installable
 
+## 1100.1.0
+
+### Minor Changes
+
+- Fixed an installed optional dependency being left without one of its own required dependencies. When a package reached through `optionalDependencies` is installable on the current system but one of its regular `dependencies` is not, a lockfile-based install skipped that dependency and installed the parent anyway, so importing the parent failed with `MODULE_NOT_FOUND`. The dependency is now installed, and an install-check warning reports the incompatibility. A dependency is still only skipped when every path to it is optional, or when the package that pulls it in was itself skipped [#13286](https://github.com/pnpm/pnpm/issues/13286).
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/cli.meta@1100.0.12
+  - @pnpm/core-loggers@1100.3.0
+  - @pnpm/engine.runtime.system-version@1100.0.7
+  - @pnpm/types@1101.7.0
+
+## 1100.0.16
+
+### 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/cli.meta@1100.0.11
+  - @pnpm/core-loggers@1100.2.5
+  - @pnpm/engine.runtime.system-version@1100.0.6
+  - @pnpm/error@1100.1.0
+  - @pnpm/types@1101.6.0
+
 ## 1100.0.15
 
 ### Patch Changes

package/lib/checkEngine.d.ts

@@ -0,0 +1,13 @@
+import { PnpmError } from '@pnpm/error';
+export declare class UnsupportedEngineError extends PnpmError {
+    wanted: WantedEngine;
+    current: Engine;
+    packageId: string;
+    constructor(packageId: string, wanted: WantedEngine, current: Engine);
+}
+export declare function checkEngine(packageId: string, wantedEngine: WantedEngine, currentEngine: Engine): UnsupportedEngineError | null;
+export interface Engine {
+    node: string;
+    pnpm?: string;
+}
+export type WantedEngine = Partial<Engine>;

package/lib/checkEngine.js

@@ -0,0 +1,32 @@
+import { PnpmError } from '@pnpm/error';
+import semver from 'semver';
+export class UnsupportedEngineError extends PnpmError {
+    wanted;
+    current;
+    packageId;
+    constructor(packageId, wanted, current) {
+        super('UNSUPPORTED_ENGINE', `Unsupported engine for ${packageId}: wanted: ${JSON.stringify(wanted)} (current: ${JSON.stringify(current)})`);
+        this.packageId = packageId;
+        this.wanted = wanted;
+        this.current = current;
+    }
+}
+export function checkEngine(packageId, wantedEngine, currentEngine) {
+    if (!wantedEngine)
+        return null;
+    const unsatisfiedWanted = {};
+    if (wantedEngine.node && !semver.satisfies(currentEngine.node, wantedEngine.node, { includePrerelease: true })) {
+        if (!semver.valid(currentEngine.node)) {
+            throw new PnpmError('INVALID_NODE_VERSION', `The nodeVersion setting is "${currentEngine.node}", which is not exact semver version`);
+        }
+        unsatisfiedWanted.node = wantedEngine.node;
+    }
+    if (currentEngine.pnpm && wantedEngine.pnpm && !semver.satisfies(currentEngine.pnpm, wantedEngine.pnpm, { includePrerelease: true })) {
+        unsatisfiedWanted.pnpm = wantedEngine.pnpm;
+    }
+    if (Object.keys(unsatisfiedWanted).length > 0) {
+        return new UnsupportedEngineError(packageId, unsatisfiedWanted, currentEngine);
+    }
+    return null;
+}
+//# sourceMappingURL=checkEngine.js.map

package/lib/checkPlatform.d.ts

@@ -0,0 +1,14 @@
+import { PnpmError } from '@pnpm/error';
+import type { SupportedArchitectures } from '@pnpm/types';
+export declare class UnsupportedPlatformError extends PnpmError {
+    wanted: WantedPlatform;
+    current: Platform;
+    constructor(packageId: string, wanted: WantedPlatform, current: Platform);
+}
+export declare function checkPlatform(packageId: string, wantedPlatform: WantedPlatform, supportedArchitectures?: SupportedArchitectures): UnsupportedPlatformError | null;
+export interface Platform {
+    cpu: string | string[];
+    os: string | string[];
+    libc: string | string[];
+}
+export type WantedPlatform = Partial<Platform>;

package/lib/checkPlatform.js

@@ -0,0 +1,69 @@
+import { PnpmError } from '@pnpm/error';
+import { familySync as getLibcFamilySync } from 'detect-libc';
+const currentLibc = getLibcFamilySync() ?? 'unknown';
+export class UnsupportedPlatformError extends PnpmError {
+    wanted;
+    current;
+    constructor(packageId, wanted, current) {
+        super('UNSUPPORTED_PLATFORM', `Unsupported platform for ${packageId}: wanted ${JSON.stringify(wanted)} (current: ${JSON.stringify(current)})`);
+        this.wanted = wanted;
+        this.current = current;
+    }
+}
+export function checkPlatform(packageId, wantedPlatform, supportedArchitectures) {
+    const current = {
+        os: dedupeCurrent(process.platform, supportedArchitectures?.os ?? ['current']),
+        cpu: dedupeCurrent(process.arch, supportedArchitectures?.cpu ?? ['current']),
+        libc: dedupeCurrent(currentLibc, supportedArchitectures?.libc ?? ['current']),
+    };
+    const { platform, arch } = process;
+    let osOk = true;
+    let cpuOk = true;
+    let libcOk = true;
+    if (wantedPlatform.os) {
+        osOk = checkList(current.os, wantedPlatform.os);
+    }
+    if (wantedPlatform.cpu) {
+        cpuOk = checkList(current.cpu, wantedPlatform.cpu);
+    }
+    if (wantedPlatform.libc && currentLibc !== 'unknown') {
+        libcOk = checkList(current.libc, wantedPlatform.libc);
+    }
+    if (!osOk || !cpuOk || !libcOk) {
+        return new UnsupportedPlatformError(packageId, wantedPlatform, { os: platform, cpu: arch, libc: currentLibc });
+    }
+    return null;
+}
+function checkList(value, list) {
+    let tmp;
+    let match = false;
+    if (typeof list === 'string') {
+        list = [list];
+    }
+    list = list.filter((value) => typeof value === 'string');
+    if (list.length === 1 && list[0] === 'any') {
+        return true;
+    }
+    const values = Array.isArray(value) ? value : [value];
+    for (const value of values) {
+        for (let i = 0; i < list.length; ++i) {
+            tmp = list[i];
+            if (tmp[0] === '!') {
+                tmp = tmp.slice(1);
+                if (tmp === value) {
+                    return false;
+                }
+            }
+            else {
+                match = match || tmp === value;
+            }
+        }
+    }
+    // No negation rejected any value. Accept if a positive entry matched, or if the list
+    // contains only negations (no positive constraints to satisfy).
+    return match || list.every(entry => entry[0] === '!');
+}
+function dedupeCurrent(current, supported) {
+    return supported.map((supported) => supported === 'current' ? current : supported);
+}
+//# sourceMappingURL=checkPlatform.js.map

package/lib/index.d.ts

@@ -0,0 +1,46 @@
+import type { SupportedArchitectures } from '@pnpm/types';
+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 interface InstallabilityManifest {
+    name: string;
+    version: string;
+    engines?: WantedEngine;
+    cpu?: string[];
+    os?: string[];
+    libc?: string[];
+}
+/**
+ * The installability verdict on its own — `null` when the package is
+ * installable — without the logging and the `engineStrict` throw that
+ * [packageIsInstallable] wraps around it. Callers that have to classify a
+ * package before they know how to report it use this, so the report is
+ * emitted exactly once.
+ */
+export declare function checkPackageInstallability(pkgId: string, pkg: InstallabilityManifest, options: {
+    nodeVersion?: string;
+    optional: boolean;
+    pnpmVersion?: string;
+    supportedArchitectures?: SupportedArchitectures;
+}): null | UnsupportedEngineError | UnsupportedPlatformError;
+export declare function packageIsInstallable(pkgId: string, pkg: InstallabilityManifest, options: {
+    engineStrict?: boolean;
+    nodeVersion?: string;
+    optional: boolean;
+    pnpmVersion?: string;
+    lockfileDir: string;
+    supportedArchitectures?: SupportedArchitectures;
+}): boolean | null;
+export declare function checkPackage(pkgId: string, manifest: {
+    engines?: WantedEngine;
+    cpu?: string[];
+    os?: string[];
+    libc?: string[];
+}, options: {
+    nodeVersion?: string;
+    pnpmVersion?: string;
+    supportedArchitectures?: SupportedArchitectures;
+}): null | UnsupportedEngineError | UnsupportedPlatformError;

package/lib/index.js

@@ -5,8 +5,18 @@ import { checkPlatform, UnsupportedPlatformError } from './checkPlatform.js';
 import { inferPlatformFromPackageName } from './inferPlatformFromPackageName.js';
 export { inferPlatformFromPackageName } from './inferPlatformFromPackageName.js';
 export { UnsupportedEngineError, UnsupportedPlatformError, };
+/**
+ * The installability verdict on its own — `null` when the package is
+ * installable — without the logging and the `engineStrict` throw that
+ * [packageIsInstallable] wraps around it. Callers that have to classify a
+ * package before they know how to report it use this, so the report is
+ * emitted exactly once.
+ */
+export function checkPackageInstallability(pkgId, pkg, options) {
+    return checkPackage(pkgId, { engines: pkg.engines, ...effectivePlatform(pkg, options.optional) }, options);
+}
 export function packageIsInstallable(pkgId, pkg, options) {
-    const warn = checkPackage(pkgId, { engines: pkg.engines, ...effectivePlatform(pkg, options.optional) }, options);
+    const warn = checkPackageInstallability(pkgId, pkg, options);
     if (warn == null)
         return true;
     installCheckLogger.warn({

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.15",
+  "version": "1100.1.0",
   "description": "Checks if a package is installable on the current system",
   "keywords": [
     "pnpm",
@@ -27,22 +27,22 @@
     "!*.map"
   ],
   "dependencies": {
-    "@pnpm/cli.meta": "1100.0.10",
-    "@pnpm/core-loggers": "1100.2.4",
-    "@pnpm/engine.runtime.system-version": "1100.0.5",
-    "@pnpm/error": "1100.0.1",
-    "@pnpm/types": "1101.5.0",
+    "@pnpm/cli.meta": "1100.0.12",
+    "@pnpm/core-loggers": "1100.3.0",
+    "@pnpm/engine.runtime.system-version": "1100.0.7",
+    "@pnpm/error": "1100.1.0",
+    "@pnpm/types": "1101.7.0",
     "detect-libc": "^2.1.2",
     "execa": "npm:safe-execa@0.3.0",
     "memoize": "^11.0.0",
-    "semver": "^7.8.4"
+    "semver": "^7.8.5"
   },
   "peerDependencies": {
     "@pnpm/logger": "^1100.0.0"
   },
   "devDependencies": {
     "@jest/globals": "30.4.1",
-    "@pnpm/config.package-is-installable": "1100.0.15",
+    "@pnpm/config.package-is-installable": "1100.1.0",
     "@pnpm/logger": "1100.0.0",
     "@types/semver": "7.7.1"
   },