@pnpm/config.package-is-installable 1000.0.15

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# @pnpm/package-is-installable
+
+> Checks if a package is installable on the current system
+
+## Install
+
+```
+pnpm install @pnpm/package-is-installable
+```
+
+## License
+
+MIT

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;
+    let blc = 0;
+    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;
+                }
+                ++blc;
+            }
+            else {
+                match = match || tmp === value;
+            }
+        }
+    }
+    return match || blc === list.length;
+}
+function dedupeCurrent(current, supported) {
+    return supported.map((supported) => supported === 'current' ? current : supported);
+}
+//# sourceMappingURL=checkPlatform.js.map

package/lib/index.d.ts

@@ -0,0 +1,31 @@
+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 { UnsupportedEngineError, UnsupportedPlatformError, type WantedEngine, };
+export declare function packageIsInstallable(pkgId: string, pkg: {
+    name: string;
+    version: string;
+    engines?: WantedEngine;
+    cpu?: string[];
+    os?: string[];
+    libc?: string[];
+}, 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

@@ -0,0 +1,43 @@
+import { installCheckLogger, skippedOptionalDependencyLogger, } from '@pnpm/core-loggers';
+import { getSystemNodeVersion } from '@pnpm/engine.runtime.system-node-version';
+import { checkEngine, UnsupportedEngineError } from './checkEngine.js';
+import { checkPlatform, UnsupportedPlatformError } from './checkPlatform.js';
+export { UnsupportedEngineError, UnsupportedPlatformError, };
+export function packageIsInstallable(pkgId, pkg, options) {
+    const warn = checkPackage(pkgId, pkg, options);
+    if (warn == null)
+        return true;
+    installCheckLogger.warn({
+        message: warn.message,
+        prefix: options.lockfileDir,
+    });
+    if (options.optional) {
+        skippedOptionalDependencyLogger.debug({
+            details: warn.toString(),
+            package: {
+                id: pkgId,
+                name: pkg.name,
+                version: pkg.version,
+            },
+            prefix: options.lockfileDir,
+            reason: warn.code === 'ERR_PNPM_UNSUPPORTED_ENGINE' ? 'unsupported_engine' : 'unsupported_platform',
+        });
+        return false;
+    }
+    if (options.engineStrict)
+        throw warn;
+    return null;
+}
+export function checkPackage(pkgId, manifest, options) {
+    return checkPlatform(pkgId, {
+        cpu: manifest.cpu ?? ['any'],
+        os: manifest.os ?? ['any'],
+        libc: manifest.libc ?? ['any'],
+    }, options.supportedArchitectures) ?? ((manifest.engines == null)
+        ? null
+        : checkEngine(pkgId, manifest.engines, {
+            node: options.nodeVersion ?? getSystemNodeVersion() ?? process.version,
+            pnpm: options.pnpmVersion,
+        }));
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@pnpm/config.package-is-installable",
+  "version": "1000.0.15",
+  "description": "Checks if a package is installable on the current system",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/config/package-is-installable",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/config/package-is-installable#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "detect-libc": "^2.0.3",
+    "execa": "npm:safe-execa@0.3.0",
+    "memoize": "^10.2.0",
+    "semver": "^7.7.2",
+    "@pnpm/engine.runtime.system-node-version": "1000.0.11",
+    "@pnpm/core-loggers": "1001.0.4",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/cli.meta": "1000.0.11"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "30.0.5",
+    "@types/semver": "7.7.1",
+    "@pnpm/logger": "1001.0.1",
+    "@pnpm/config.package-is-installable": "1000.0.15"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "start": "tsgo --watch",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
+    "test": "pnpm run compile && pnpm run _test",
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}