@vltpkg/pick-manifest 1.0.0-rc.22 → 1.0.0-rc.24

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+import { Range, Version } from '@vltpkg/semver';
+import { Spec } from '@vltpkg/spec';
+import type { Manifest, Packument, RevDoc, RevDocEntry } from '@vltpkg/types';
+export type PickManifestOptions = {
+    tag?: string;
+    before?: Date | number | string;
+    'node-version'?: string;
+    os?: string;
+    arch?: string;
+    libc?: string;
+};
+export type Manifestish = Pick<Manifest, 'engines' | 'os' | 'cpu' | 'libc'> | Pick<RevDocEntry, 'engines' | 'os' | 'cpu' | 'libc'>;
+export type Packumentish = Packument | RevDoc;
+export type PickManifestish<T extends Packumentish> = T extends RevDoc ? RevDocEntry : Manifest;
+export type ManiCheck<T extends Packumentish> = {
+    version: Version;
+    deprecated: boolean;
+    platform: boolean;
+    prerelease: boolean;
+    mani: PickManifestish<T>;
+};
+/**
+ * Path to the ldd binary used for filesystem-based libc detection.
+ */
+export declare const LDD_PATH = "/usr/bin/ldd";
+/**
+ * Detect libc family by reading the /usr/bin/ldd file.
+ * Returns 'glibc', 'musl', null (detection ran but unknown)
+ * or undefined (file not readable).
+ */
+export declare const getFamilyFromFilesystem: () => string | null | undefined;
+/**
+ * Detect libc family by using process.report.getReport().
+ * Returns 'glibc', 'musl', or null if detection fails.
+ */
+export declare const getFamilyFromReport: () => string | null;
+/** Reset the cached libc detection result. For testing only. */
+export declare const resetLibcCache: () => void;
+/**
+ * Detect the libc family (glibc or musl) on Linux systems.
+ * First tries filesystem-based detection (/usr/bin/ldd),
+ * then falls back to process.report.
+ * Returns undefined on non-Linux platforms or if detection fails.
+ */
+export declare const detectLibc: () => string | undefined;
+/**
+ * Call with a manifest and the node version and process platform/arch/libc
+ * to check whether a version is suitable for the current platform.
+ */
+export declare const platformCheck: (mani: Manifestish, nodeVersion: Version | string, wantOs?: string, wantArch?: string, wantLibc?: string) => boolean;
+/**
+ * Choose the most appropriate manifest from a packument.
+ *
+ * If `before` is set in the options, then the packument MUST
+ * be a full non-minified Packument object. Otherwise, a minified packument
+ * is fine.
+ */
+export declare function pickManifest<T extends Packumentish>(packument: T, wanted: Range | Spec | string, opts?: PickManifestOptions): PickManifestish<T> | undefined;

package/dist/index.js

@@ -0,0 +1,306 @@
+import { error } from '@vltpkg/error-cause';
+import { parse, Range, satisfies, Version, isRange, } from '@vltpkg/semver';
+import { Spec } from '@vltpkg/spec';
+import { isSpec } from '@vltpkg/spec/browser';
+import { readFileSync } from 'node:fs';
+const parsedNodeVersion = Version.parse(process.version);
+const isBefore = (version, before, verTimes) => {
+    if (!verTimes || !version || !before)
+        return true;
+    const time = version && verTimes[version];
+    return !!time && Date.parse(time) <= before;
+};
+const checkList = (value, list) => {
+    if (typeof list === 'string') {
+        list = [list];
+    }
+    // invalid list is equivalent to 'any'
+    if (!Array.isArray(list))
+        return true;
+    if (list.length === 1 && list[0] === 'any') {
+        return true;
+    }
+    // match none of the negated values, and at least one of the
+    // non-negated values, if any are present.
+    let negated = 0;
+    let match = false;
+    for (const entry of list) {
+        const negate = entry.startsWith('!');
+        const test = negate ? entry.slice(1) : entry;
+        if (negate) {
+            negated++;
+            if (value === test) {
+                return false;
+            }
+        }
+        else {
+            match = match || value === test;
+        }
+    }
+    return match || negated === list.length;
+};
+/* c8 ignore start - Linux-only helper */
+const isMusl = (file) => file.includes('libc.musl-') || file.includes('ld-musl-');
+/* c8 ignore stop */
+/**
+ * Path to the ldd binary used for filesystem-based libc detection.
+ */
+export const LDD_PATH = '/usr/bin/ldd';
+/**
+ * Detect libc family by reading the /usr/bin/ldd file.
+ * Returns 'glibc', 'musl', null (detection ran but unknown)
+ * or undefined (file not readable).
+ */
+export const getFamilyFromFilesystem = () => {
+    /* c8 ignore start - Linux-only detection */
+    try {
+        const content = readFileSync(LDD_PATH, 'utf-8');
+        if (content.includes('musl')) {
+            return 'musl';
+        }
+        if (content.includes('GNU C Library')) {
+            return 'glibc';
+        }
+        // File exists but content unrecognized
+        return null;
+    }
+    catch {
+        // File not readable, return undefined to signal fallback needed
+        return undefined;
+    }
+    /* c8 ignore stop */
+};
+/**
+ * Detect libc family by using process.report.getReport().
+ * Returns 'glibc', 'musl', or null if detection fails.
+ */
+export const getFamilyFromReport = () => {
+    /* c8 ignore start - Linux-only detection */
+    try {
+        const processReport = process.report;
+        const originalExclude = processReport.excludeNetwork === true;
+        processReport.excludeNetwork = true;
+        const report = processReport.getReport();
+        processReport.excludeNetwork = originalExclude;
+        if (report?.header?.glibcRuntimeVersion) {
+            return 'glibc';
+        }
+        if (Array.isArray(report?.sharedObjects) &&
+            report.sharedObjects.some(isMusl)) {
+            return 'musl';
+        }
+    }
+    catch {
+        // detection failed
+    }
+    return null;
+    /* c8 ignore stop */
+};
+/**
+ * Cached libc family detection result.
+ * null means detection ran but couldn't determine, undefined means not cached yet.
+ */
+let cachedLibcFamily = undefined;
+/* c8 ignore start - test helper */
+/** Reset the cached libc detection result. For testing only. */
+export const resetLibcCache = () => {
+    cachedLibcFamily = undefined;
+};
+/* c8 ignore stop */
+/**
+ * Detect the libc family (glibc or musl) on Linux systems.
+ * First tries filesystem-based detection (/usr/bin/ldd),
+ * then falls back to process.report.
+ * Returns undefined on non-Linux platforms or if detection fails.
+ */
+export const detectLibc = () => {
+    /* c8 ignore start - Linux-only detection */
+    // Return cached result if available (null means detection ran but failed)
+    if (cachedLibcFamily !== undefined) {
+        return cachedLibcFamily ?? undefined;
+    }
+    // libc checks only work on linux
+    if (process.platform !== 'linux') {
+        cachedLibcFamily = null;
+        return undefined;
+    }
+    // Try filesystem detection first
+    let family = getFamilyFromFilesystem();
+    // If filesystem detection didn't work, fall back to process.report
+    if (!family) {
+        family = getFamilyFromReport();
+    }
+    cachedLibcFamily = family;
+    return family ?? undefined;
+    /* c8 ignore stop */
+};
+/**
+ * Call with a manifest and the node version and process platform/arch/libc
+ * to check whether a version is suitable for the current platform.
+ */
+export const platformCheck = (mani, nodeVersion, wantOs, wantArch, wantLibc) => {
+    const { engines, os, cpu, libc } = mani;
+    if (engines) {
+        const { node } = engines;
+        if (node && !satisfies(nodeVersion, node, true)) {
+            return false;
+        }
+    }
+    if (wantOs && !checkList(wantOs, os))
+        return false;
+    if (wantArch && !checkList(wantArch, cpu))
+        return false;
+    // libc checks only apply when the package specifies libc requirements
+    if (libc) {
+        /* c8 ignore start - system specific */
+        // if wantLibc is not provided, detect it
+        const libcFamily = wantLibc ?? detectLibc();
+        // if libc can't be determined, fail the check (can't install libc-specific packages)
+        if (!libcFamily)
+            return false;
+        if (!checkList(libcFamily, libc))
+            return false;
+        /* c8 ignore stop */
+    }
+    return true;
+};
+const versionOk = (packument, version, nodeVersion, os, arch, libc, before) => {
+    const mani = packument.versions[version];
+    /* c8 ignore next */
+    if (!mani)
+        return false;
+    const { time } = packument;
+    return (isBefore(version, before, time) &&
+        platformCheck(mani, nodeVersion, os, arch, libc));
+};
+/**
+ * Choose the most appropriate manifest from a packument.
+ *
+ * If `before` is set in the options, then the packument MUST
+ * be a full non-minified Packument object. Otherwise, a minified packument
+ * is fine.
+ */
+export function pickManifest(packument, wanted, opts = {}) {
+    const { tag = 'latest', before, 'node-version': nodeVersion, os = process.platform, arch = process.arch, libc, } = opts;
+    const nv = !nodeVersion ? parsedNodeVersion : Version.parse(nodeVersion);
+    // detect libc if not provided
+    const libcFamily = libc ?? detectLibc();
+    // cast since 'time' might not be present on minified packuments
+    const { name, time: verTimes, versions, 'dist-tags': distTags, } = packument;
+    const time = before && verTimes ? +new Date(before) : Infinity;
+    let range = undefined;
+    let spec = undefined;
+    if (typeof wanted === 'object') {
+        if (isSpec(wanted)) {
+            const f = wanted.final;
+            range = f.range;
+            spec = f;
+        }
+        else if (isRange(wanted)) {
+            range = wanted;
+        }
+    }
+    else {
+        spec = Spec.parse(`${name}@${wanted}`).final;
+        range = spec.range;
+    }
+    if (!range) {
+        if (!spec?.distTag) {
+            throw error('Only dist-tag or semver range specs are supported', { spec });
+        }
+        // if there is an explicit dist tag, we must get that version.
+        const ver = distTags[spec.distTag];
+        if (!ver)
+            return undefined;
+        // if the version in the dist-tags is before the before date, then
+        // we use that.  Otherwise, we get the highest precedence version
+        // prior to the dist-tag.
+        const mani = versions[ver];
+        if (mani &&
+            versionOk(packument, ver, nv, os, arch, libcFamily, time)) {
+            return mani;
+        }
+        else {
+            range = new Range(`<=${ver}`);
+        }
+    }
+    if (range.isAny)
+        range = new Range('*', true);
+    // if the range is *, then we prefer the 'latest' if available
+    // but skip this if it should be avoided, in that case we have
+    // to try a little harder.
+    const defaultVer = distTags[tag];
+    const defTagVersion = defaultVer ? Version.parse(defaultVer) : undefined;
+    if (defaultVer &&
+        (range.isAny || defTagVersion?.satisfies(range)) &&
+        versionOk(packument, defaultVer, nv, os, arch, libcFamily, time)) {
+        return versions[defaultVer];
+    }
+    // ok, actually have to scan the list
+    const entries = Object.entries(versions);
+    if (!entries.length) {
+        return undefined;
+    }
+    let found = undefined;
+    let foundIsDefTag = false;
+    for (const [ver, mani] of entries) {
+        if (time && verTimes && !isBefore(ver, time, verTimes)) {
+            continue;
+        }
+        const version = parse(ver);
+        if (!version?.satisfies(range)) {
+            continue;
+        }
+        const mc = {
+            version,
+            deprecated: !!mani.deprecated,
+            platform: platformCheck(mani, nv, os, arch, libcFamily),
+            prerelease: !!version.prerelease?.length,
+            mani,
+        };
+        if (!found) {
+            found = mc;
+            if (defTagVersion?.equals(found.version)) {
+                foundIsDefTag = true;
+            }
+            continue;
+        }
+        const mok = !mc.deprecated && mc.platform;
+        const fok = !found.deprecated && found.platform;
+        if (mok !== fok) {
+            if (mok) {
+                found = mc;
+                foundIsDefTag = !!defTagVersion?.equals(mc.version);
+            }
+        }
+        else if (mc.platform !== found.platform) {
+            if (mc.platform) {
+                found = mc;
+                foundIsDefTag = !!defTagVersion?.equals(mc.version);
+            }
+        }
+        else if (mc.deprecated !== found.deprecated) {
+            if (!mc.deprecated) {
+                found = mc;
+                /* c8 ignore next */
+                foundIsDefTag = !!defTagVersion?.equals(mc.version);
+            }
+        }
+        else if (found.prerelease !== mc.prerelease) {
+            if (!mc.prerelease) {
+                found = mc;
+                /* c8 ignore next */
+                foundIsDefTag = !!defTagVersion?.equals(mc.version);
+            }
+        }
+        else if (defTagVersion?.equals(mc.version)) {
+            found = mc;
+            foundIsDefTag = true;
+        }
+        else if (mc.version.greaterThan(found.version) &&
+            !foundIsDefTag) {
+            found = mc;
+        }
+    }
+    return found?.mani;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vltpkg/pick-manifest",
   "description": "Choose a manifest from a packument",
-  "version": "1.0.0-rc.22",
+  "version": "1.0.0-rc.24",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vltpkg/vltpkg.git",
@@ -12,10 +12,10 @@
     "email": "support@vlt.sh"
   },
   "dependencies": {
-    "@vltpkg/error-cause": "1.0.0-rc.22",
-    "@vltpkg/semver": "1.0.0-rc.22",
-    "@vltpkg/spec": "1.0.0-rc.22",
-    "@vltpkg/types": "1.0.0-rc.22"
+    "@vltpkg/error-cause": "1.0.0-rc.24",
+    "@vltpkg/semver": "1.0.0-rc.24",
+    "@vltpkg/spec": "1.0.0-rc.24",
+    "@vltpkg/types": "1.0.0-rc.24"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
@@ -49,13 +49,13 @@
     "extends": "../../tap-config.yaml"
   },
   "prettier": "../../.prettierrc.js",
-  "module": "./src/index.ts",
+  "module": "./dist/index.js",
   "type": "module",
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "import": {
-        "default": "./src/index.ts"
+        "default": "./dist/index.js"
       }
     }
   },