@agentxm/extension-model 0.28.8 → 0.28.10

package/dist/src/unstable/version-constraints/version-constraints.js

@@ -82,22 +82,69 @@ export const parseVersionRange = (sourceString) => {
 export const isValidVersionRange = (range) => semver.validRange(range) !== null;
 /** Return one range representing the complete intersection, or undefined when unsatisfiable. */
 export const intersectVersionConstraints = (constraints) => {
-    let intersections = [""];
+    // A comparator conjunction admits a prerelease when *any* comparator names
+    // its version tuple. Intersection instead requires *every contributor* to
+    // admit that tuple, so preserve this information before flattening the sets.
+    let intersections = [{ comparators: [], prereleaseBases: undefined }];
     for (const constraint of constraints) {
         const validRange = semver.validRange(constraint);
         if (validRange === null)
             return undefined;
         const range = new semver.Range(validRange);
         intersections = intersections.flatMap((current) => range.set.flatMap((comparators) => {
-            const candidate = [current, ...comparators.map((comparator) => comparator.value)]
-                .filter((part) => part.length > 0)
+            const combined = [...current.comparators, ...comparators];
+            const candidate = combined
+                .map((comparator) => comparator.value)
+                .filter((value) => value.length > 0)
                 .join(" ");
-            return semver.minVersion(candidate) === null ? [] : [candidate];
+            if (semver.minVersion(candidate) === null)
+                return [];
+            const bases = new Set(comparators.flatMap((comparator) => comparator.value !== "" && comparator.semver.prerelease.length > 0
+                ? [`${comparator.semver.major}.${comparator.semver.minor}.${comparator.semver.patch}`]
+                : []));
+            return [
+                {
+                    comparators: combined,
+                    prereleaseBases: current.prereleaseBases === undefined
+                        ? bases
+                        : new Set([...current.prereleaseBases].filter((base) => bases.has(base))),
+                },
+            ];
         }));
         if (intersections.length === 0)
             return undefined;
     }
-    return intersections.join(" || ");
+    const ranges = intersections.flatMap(({ comparators, prereleaseBases }) => {
+        const original = comparators
+            .map((comparator) => comparator.value)
+            .filter((value) => value.length > 0)
+            .join(" ");
+        const stable = comparators
+            .map((comparator) => {
+            if (comparator.value === "" || comparator.semver.prerelease.length === 0)
+                return comparator.value;
+            const base = `${comparator.semver.major}.${comparator.semver.minor}.${comparator.semver.patch}`;
+            switch (comparator.operator) {
+                case ">":
+                case ">=":
+                    return `>=${base}`;
+                case "<":
+                case "<=":
+                    return `<${base}`;
+                // An exact prerelease admits no stable version.
+                default:
+                    return "<0.0.0-0";
+            }
+        })
+            .filter((value) => value.length > 0)
+            .join(" ") || "*";
+        const candidates = [
+            stable,
+            ...[...(prereleaseBases ?? [])].map((base) => `${original} >=${base}-0 <${base}`),
+        ];
+        return candidates.filter((candidate) => semver.minVersion(candidate) !== null);
+    });
+    return ranges.length === 0 ? undefined : [...new Set(ranges)].join(" || ");
 };
 /**
  * Check whether moving from `previousVersion` to `currentVersion` includes at

package/package.json

@@ -333,5 +333,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.28.8"
+  "version": "0.28.10"
 }