@vltpkg/semver 1.0.0-rc.31 → 1.0.0-rc.32

package/dist/index.d.ts

@@ -201,3 +201,8 @@ export declare const stable: <T extends Version | string = string | Version>(ver
  * Returns true if any version would satisfy both ranges.
  */
 export declare const intersects: (r1: Range | string, r2: Range | string, includePrerelease?: boolean) => boolean;
+/**
+ * Check if range r1 is a subset of range r2.
+ * Returns true if every version that satisfies r1 also satisfies r2.
+ */
+export declare const subset: (r1: Range | string, r2: Range | string, includePrerelease?: boolean) => boolean;

package/dist/index.js

@@ -364,6 +364,149 @@ export const intersects = (r1, r2, includePrerelease) => {
     // Check if any set from range1 intersects with any set from range2
     return range1.set.some(set1 => range2.set.some(set2 => intersectComparators(set1, set2)));
 };
+/**
+ * Check if range r1 is a subset of range r2.
+ * Returns true if every version that satisfies r1 also satisfies r2.
+ */
+export const subset = (r1, r2, includePrerelease) => {
+    const range1 = typeof r1 === 'string' ? parseRange(r1, includePrerelease) : r1;
+    const range2 = typeof r2 === 'string' ? parseRange(r2, includePrerelease) : r2;
+    if (!range1 || !range2)
+        return false;
+    // Any range is only a subset of another 'any' range
+    if (range2.isAny)
+        return true;
+    if (range1.isAny)
+        return false;
+    // Every comparator set in r1 must be a subset of at least one
+    // comparator set in r2
+    return range1.set.every(set1 => range2.set.some(set2 => comparatorSubset(set1, set2)));
+};
+/**
+ * Check if comparator comp1 is a subset of comparator comp2.
+ * Every version satisfying comp1 must also satisfy comp2.
+ */
+const comparatorSubset = (comp1, comp2) => {
+    const tuples1 = comp1.tuples.filter((t) => Array.isArray(t));
+    const tuples2 = comp2.tuples.filter((t) => Array.isArray(t));
+    // comp1 must be satisfiable
+    if (!satisfiableRange(tuples1))
+        return true;
+    const bounds1 = getBounds(tuples1);
+    const bounds2 = getBounds(tuples2);
+    // If comp2 has an exact match, comp1 must only match that exact version
+    if (bounds2.hasExact) {
+        if (bounds1.hasExact) {
+            return eq(bounds1.hasExact, bounds2.hasExact);
+        }
+        // bounds1 must collapse to exactly that version
+        if (!bounds1.lowerBound ||
+            !bounds1.upperBound ||
+            !eq(bounds1.lowerBound, bounds2.hasExact) ||
+            !eq(bounds1.upperBound, bounds2.hasExact) ||
+            !bounds1.lowerInclusive ||
+            !bounds1.upperInclusive) {
+            return false;
+        }
+        return true;
+    }
+    // If comp1 has an exact match, check it satisfies comp2's bounds
+    if (bounds1.hasExact) {
+        if (bounds2.lowerBound) {
+            if (bounds2.lowerInclusive ?
+                lt(bounds1.hasExact, bounds2.lowerBound)
+                : lte(bounds1.hasExact, bounds2.lowerBound)) {
+                return false;
+            }
+        }
+        if (bounds2.upperBound) {
+            if (bounds2.upperInclusive ?
+                gt(bounds1.hasExact, bounds2.upperBound)
+                : gte(bounds1.hasExact, bounds2.upperBound)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // comp1's lower bound must be >= comp2's lower bound
+    if (bounds2.lowerBound) {
+        if (!bounds1.lowerBound)
+            return false;
+        const cmp = compare(bounds1.lowerBound, bounds2.lowerBound);
+        if (cmp < 0)
+            return false;
+        if (cmp === 0 &&
+            !bounds2.lowerInclusive &&
+            bounds1.lowerInclusive)
+            return false;
+    }
+    // comp1's upper bound must be <= comp2's upper bound
+    if (bounds2.upperBound) {
+        if (!bounds1.upperBound)
+            return false;
+        const cmp = compare(bounds1.upperBound, bounds2.upperBound);
+        if (cmp > 0)
+            return false;
+        if (cmp === 0 &&
+            !bounds2.upperInclusive &&
+            bounds1.upperInclusive)
+            return false;
+    }
+    return true;
+};
+const getBounds = (tuples) => {
+    let lowerBound = null;
+    let lowerInclusive = false;
+    let upperBound = null;
+    let upperInclusive = false;
+    let hasExact = null;
+    for (const [op, ver] of tuples) {
+        switch (op) {
+            case '':
+                hasExact = ver;
+                break;
+            case '>=':
+                /* c8 ignore start */
+                if (!lowerBound ||
+                    gt(ver, lowerBound) ||
+                    (eq(ver, lowerBound) && !lowerInclusive)) {
+                    lowerBound = ver;
+                    lowerInclusive = true;
+                }
+                /* c8 ignore stop */
+                break;
+            case '>':
+                if (!lowerBound || gt(ver, lowerBound)) {
+                    lowerBound = ver;
+                    lowerInclusive = false;
+                }
+                break;
+            case '<=':
+                /* c8 ignore start */
+                if (!upperBound ||
+                    lt(ver, upperBound) ||
+                    (eq(ver, upperBound) && !upperInclusive)) {
+                    upperBound = ver;
+                    upperInclusive = true;
+                }
+                /* c8 ignore stop */
+                break;
+            case '<':
+                if (!upperBound || lt(ver, upperBound)) {
+                    upperBound = ver;
+                    upperInclusive = false;
+                }
+                break;
+        }
+    }
+    return {
+        lowerBound,
+        lowerInclusive,
+        upperBound,
+        upperInclusive,
+        hasExact,
+    };
+};
 /**
  * Check if two comparators can be satisfied simultaneously
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vltpkg/semver",
   "description": "The semantic version parser used by vlt",
-  "version": "1.0.0-rc.31",
+  "version": "1.0.0-rc.32",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vltpkg/vltpkg.git",
@@ -13,9 +13,9 @@
     "url": "http://vlt.sh"
   },
   "dependencies": {
-    "@vltpkg/error-cause": "1.0.0-rc.31",
-    "@vltpkg/fast-split": "1.0.0-rc.31",
-    "@vltpkg/types": "1.0.0-rc.31"
+    "@vltpkg/error-cause": "1.0.0-rc.32",
+    "@vltpkg/fast-split": "1.0.0-rc.32",
+    "@vltpkg/types": "1.0.0-rc.32"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",