@pnpm/resolving.resolver-base 1100.0.1 → 1100.1.0

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import type { DependencyManifest, PackageVersionPolicy, PinnedVersion, PkgResolutionId, ProjectRootDir, TrustPolicy } from '@pnpm/types';
+import type { DependencyManifest, PackageVersionPolicy, PinnedVersion, PkgResolutionId, ProjectRootDir, SupportedArchitectures, TrustPolicy } from '@pnpm/types';
 export { type PkgResolutionId };
 /**
  * tarball hosted remotely
@@ -49,6 +49,34 @@ export interface VariationsResolution {
     variants: PlatformAssetResolution[];
 }
 export type Resolution = AtomicResolution | VariationsResolution;
+/** Concrete platform selector used when picking a variant from a VariationsResolution. */
+export interface PlatformSelector {
+    os: string;
+    cpu: string;
+    /** Name of the libc family requested. Omit (or leave `null`) for the default (glibc on Linux, n/a elsewhere). */
+    libc?: string | null;
+}
+/**
+ * Resolve a {@link PlatformSelector} from the user's supportedArchitectures config
+ * and the host's own platform/arch/libc. When `supportedArchitectures.xxx` is set
+ * and its first entry is not `"current"`, that entry wins; otherwise the host's
+ * value is used. Additional entries beyond the first are ignored — variant
+ * selection picks exactly one (os, cpu, libc) triplet per install.
+ */
+export declare function resolvePlatformSelector(supportedArchitectures: SupportedArchitectures | undefined, host: {
+    platform: string;
+    arch: string;
+    libc: string | null | undefined;
+}): PlatformSelector;
+/**
+ * Pick the variant whose target matches the given selector, or `undefined` if
+ * none does. A variant with no `libc` represents the "default" build — glibc on
+ * Linux, irrelevant on macOS/Windows. A non-default libc (e.g. `musl`) is a
+ * separate, non-interchangeable artifact; an exact libc match is required in
+ * that case so the glibc/default variant doesn't silently win (its `target.libc`
+ * is nullish).
+ */
+export declare function selectPlatformVariant(variants: PlatformAssetResolution[], selector: PlatformSelector): PlatformAssetResolution | undefined;
 export interface ResolveResult {
     id: PkgResolutionId;
     latest?: string;

package/lib/index.js

@@ -1,4 +1,43 @@
 export {};
+/**
+ * Resolve a {@link PlatformSelector} from the user's supportedArchitectures config
+ * and the host's own platform/arch/libc. When `supportedArchitectures.xxx` is set
+ * and its first entry is not `"current"`, that entry wins; otherwise the host's
+ * value is used. Additional entries beyond the first are ignored — variant
+ * selection picks exactly one (os, cpu, libc) triplet per install.
+ */
+export function resolvePlatformSelector(supportedArchitectures, host) {
+    return {
+        os: pickFirstNonCurrent(supportedArchitectures?.os) ?? host.platform,
+        cpu: pickFirstNonCurrent(supportedArchitectures?.cpu) ?? host.arch,
+        libc: pickFirstNonCurrent(supportedArchitectures?.libc) ?? host.libc,
+    };
+}
+/**
+ * Pick the variant whose target matches the given selector, or `undefined` if
+ * none does. A variant with no `libc` represents the "default" build — glibc on
+ * Linux, irrelevant on macOS/Windows. A non-default libc (e.g. `musl`) is a
+ * separate, non-interchangeable artifact; an exact libc match is required in
+ * that case so the glibc/default variant doesn't silently win (its `target.libc`
+ * is nullish).
+ */
+export function selectPlatformVariant(variants, selector) {
+    return variants.find((variant) => variant.targets.some((target) => target.os === selector.os &&
+        target.cpu === selector.cpu &&
+        libcMatches(target.libc, selector.libc)));
+}
+function libcMatches(variantLibc, requestedLibc) {
+    if (requestedLibc == null || requestedLibc === 'glibc') {
+        return variantLibc == null;
+    }
+    return variantLibc === requestedLibc;
+}
+function pickFirstNonCurrent(requirements) {
+    if (requirements?.length && requirements[0] !== 'current') {
+        return requirements[0];
+    }
+    return undefined;
+}
 // This weight is set for selectors that are used on direct dependencies.
 // It is important to give a bigger weight to direct dependencies.
 export const DIRECT_DEP_SELECTOR_WEIGHT = 1000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/resolving.resolver-base",
-  "version": "1100.0.1",
+  "version": "1100.1.0",
   "description": "Types for pnpm-compatible resolvers",
   "keywords": [
     "pnpm",
@@ -28,7 +28,7 @@
     "@pnpm/types": "1101.0.0"
   },
   "devDependencies": {
-    "@pnpm/resolving.resolver-base": "1100.0.1"
+    "@pnpm/resolving.resolver-base": "1100.1.0"
   },
   "engines": {
     "node": ">=22.13"