syncpack 9.3.2 → 9.8.4

package/dist/get-context/get-config/schema/version-group.js

@@ -1,31 +1,36 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-exports.__esModule = true;
-exports.any = exports.base = exports.pinned = exports.ignored = exports.banned = exports.standard = void 0;
-var zod_1 = require("zod");
-var base_group_1 = require("./base-group");
-var NonEmptyString = zod_1.z.string().trim().min(1);
-exports.standard = zod_1.z.object(base_group_1.baseGroupFields).strict();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.any = exports.defaultGroup = exports.snappedTo = exports.pinned = exports.ignored = exports.banned = exports.standard = void 0;
+const zod_1 = require("zod");
+const base_group_1 = require("./base-group");
+const non_empty_string_1 = require("./lib/non-empty-string");
+const preferVersion = zod_1.z
+    .enum(['highestSemver', 'lowestSemver'])
+    .optional()
+    .default('highestSemver');
+exports.standard = zod_1.z
+    .object({ ...base_group_1.baseGroupFields, preferVersion })
+    .strict();
 exports.banned = zod_1.z
-    .object(__assign(__assign({}, base_group_1.baseGroupFields), { isBanned: zod_1.z.literal(true) }))
+    .object({ ...base_group_1.baseGroupFields, isBanned: zod_1.z.literal(true) })
     .strict();
 exports.ignored = zod_1.z
-    .object(__assign(__assign({}, base_group_1.baseGroupFields), { isIgnored: zod_1.z.literal(true) }))
+    .object({ ...base_group_1.baseGroupFields, isIgnored: zod_1.z.literal(true) })
     .strict();
 exports.pinned = zod_1.z
-    .object(__assign(__assign({}, base_group_1.baseGroupFields), { pinVersion: NonEmptyString }))
+    .object({ ...base_group_1.baseGroupFields, pinVersion: non_empty_string_1.nonEmptyString })
+    .strict();
+exports.snappedTo = zod_1.z
+    .object({ ...base_group_1.baseGroupFields, snapTo: zod_1.z.array(non_empty_string_1.nonEmptyString) })
     .strict();
-exports.base = zod_1.z
-    .object(__assign(__assign({}, base_group_1.baseGroupFields), { isDefault: zod_1.z.literal(true) }))
+exports.defaultGroup = zod_1.z
+    .object({ ...base_group_1.baseGroupFields, isDefault: zod_1.z.literal(true), preferVersion })
     .strict();
-exports.any = zod_1.z.union([exports.standard, exports.banned, exports.ignored, exports.pinned, exports.base]);
+exports.any = zod_1.z.union([
+    exports.standard,
+    exports.banned,
+    exports.ignored,
+    exports.pinned,
+    exports.snappedTo,
+    exports.defaultGroup,
+]);

package/dist/get-context/get-groups/base-group.d.ts

@@ -1,4 +1,5 @@
 import type { Syncpack } from '../../types';
+import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
 import type { Instance } from '../get-package-json-files/package-json-file/instance';
 export declare class BaseGroup<T extends Syncpack.Config.SemverGroup.Any | Syncpack.Config.VersionGroup.Any> {
     /** Full config for this run of syncpack */
@@ -11,7 +12,9 @@ export declare class BaseGroup<T extends Syncpack.Config.SemverGroup.Any | Syncp
     instancesByName: Record<string, Instance[]>;
     /** Is this the catch-all group, not defined by the user? */
     isDefault: boolean;
-    constructor(config: Syncpack.Config.Private, group: T);
+    /** All package.json files */
+    packageJsonFiles: PackageJsonFile[];
+    constructor(config: Syncpack.Config.Private, group: T, packageJsonFiles: PackageJsonFile[]);
     /** Can this instance be added to this group? */
     canAdd(instance: Instance): boolean;
     /** Add this instance to this group */

package/dist/get-context/get-groups/base-group.js

@@ -2,39 +2,38 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseGroup = void 0;
-var expect_more_1 = require("expect-more");
-var minimatch_1 = __importDefault(require("minimatch"));
-var BaseGroup = /** @class */ (function () {
-    function BaseGroup(config, group) {
+const is_non_empty_array_1 = require("expect-more/dist/is-non-empty-array");
+const minimatch_1 = __importDefault(require("minimatch"));
+class BaseGroup {
+    constructor(config, group, packageJsonFiles) {
         this.groupConfig = group;
         this.instances = [];
         this.instancesByName = {};
         this.isDefault =
             group === config.defaultSemverGroup ||
                 group === config.defaultVersionGroup;
+        this.packageJsonFiles = packageJsonFiles;
         this.syncpackConfig = config;
     }
     /** Can this instance be added to this group? */
-    BaseGroup.prototype.canAdd = function (instance) {
-        var _a = this.groupConfig, dependencies = _a.dependencies, dependencyTypes = _a.dependencyTypes, packages = _a.packages;
-        return ((!(0, expect_more_1.isNonEmptyArray)(dependencyTypes) ||
+    canAdd(instance) {
+        const { dependencies, dependencyTypes, packages } = this.groupConfig;
+        return ((!(0, is_non_empty_array_1.isNonEmptyArray)(dependencyTypes) ||
             dependencyTypes.includes(instance.pathDef.name)) &&
-            (!(0, expect_more_1.isNonEmptyArray)(packages) ||
-                packages.some(function (pattern) { return (0, minimatch_1["default"])(instance.pkgName, pattern); })) &&
-            (!(0, expect_more_1.isNonEmptyArray)(dependencies) ||
-                dependencies.some(function (pattern) { return (0, minimatch_1["default"])(instance.name, pattern); })));
-    };
+            (!(0, is_non_empty_array_1.isNonEmptyArray)(packages) ||
+                packages.some((pattern) => (0, minimatch_1.default)(instance.pkgName, pattern))) &&
+            (!(0, is_non_empty_array_1.isNonEmptyArray)(dependencies) ||
+                dependencies.some((pattern) => (0, minimatch_1.default)(instance.name, pattern))));
+    }
     /** Add this instance to this group */
-    BaseGroup.prototype.add = function (instance) {
-        var _a;
+    add(instance) {
         if (!this.instancesByName[instance.name]) {
             this.instancesByName[instance.name] = [];
         }
-        (_a = this.instancesByName[instance.name]) === null || _a === void 0 ? void 0 : _a.push(instance);
+        this.instancesByName[instance.name]?.push(instance);
         this.instances.push(instance);
-    };
-    return BaseGroup;
-}());
+    }
+}
 exports.BaseGroup = BaseGroup;

package/dist/get-context/get-groups/index.d.ts

@@ -1,8 +1,12 @@
+import { R } from '@mobily/ts-belt';
+import { BaseError } from '../../lib/error';
 import type { Syncpack } from '../../types';
-import type { Instance } from '../get-package-json-files/package-json-file/instance';
+import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
 import { SemverGroup } from './semver-group';
 import { VersionGroup } from './version-group';
-export declare function getGroups(config: Syncpack.Config.Private, instances: Instance[]): {
+interface GroupsByPropName {
     semverGroups: SemverGroup[];
     versionGroups: VersionGroup[];
-};
+}
+export declare function getGroups(config: Syncpack.Config.Private, packageJsonFiles: PackageJsonFile[]): R.Result<GroupsByPropName, BaseError>;
+export {};

package/dist/get-context/get-groups/index.js

@@ -1,47 +1,51 @@
 "use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGroups = void 0;
-var semver_group_1 = require("./semver-group");
-var version_group_1 = require("./version-group");
-function getGroups(config, instances) {
-    var groupsByName = {
-        semverGroups: config.semverGroups.map(function (group) { return new semver_group_1.SemverGroup(config, group); }),
-        versionGroups: config.versionGroups.map(function (group) { return new version_group_1.VersionGroup(config, group); })
+const ts_belt_1 = require("@mobily/ts-belt");
+const error_1 = require("../../lib/error");
+const log_1 = require("../../lib/log");
+const sort_by_name_1 = require("../../lib/sort-by-name");
+const semver_group_1 = require("./semver-group");
+const version_group_1 = require("./version-group");
+function getGroups(config, packageJsonFiles) {
+    const ERR_CREATING_GROUPS = 'Error creating semver and version groups';
+    return (0, ts_belt_1.pipe)(ts_belt_1.R.fromExecution(() => unsafeGetGroups(config, packageJsonFiles)), ts_belt_1.R.mapError(error_1.BaseError.map(ERR_CREATING_GROUPS)));
+}
+exports.getGroups = getGroups;
+function unsafeGetGroups(config, packageJsonFiles) {
+    const groupsByName = {
+        semverGroups: config.semverGroups.map((group) => new semver_group_1.SemverGroup(config, group, packageJsonFiles)),
+        versionGroups: config.versionGroups.map((group) => new version_group_1.VersionGroup(config, group, packageJsonFiles)),
     };
-    instances.forEach(function (instance) {
-        var name = instance.name, pkgName = instance.pkgName;
-        Object.keys(groupsByName).forEach(function (key) {
-            var e_1, _a;
-            try {
-                for (var _b = __values(groupsByName[key]), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var group = _c.value;
-                    if (group.canAdd(instance)) {
-                        group.add(instance);
-                        return;
-                    }
+    const groupNames = Object.keys(groupsByName);
+    const instances = packageJsonFiles
+        .flatMap((pkg) => pkg.getInstances())
+        .sort(sort_by_name_1.sortByName);
+    instances.forEach((instance) => {
+        const { name, pkgName } = instance;
+        groupNames.forEach((key) => {
+            for (const group of groupsByName[key]) {
+                if (group.canAdd(instance)) {
+                    group.add(instance);
+                    return;
                 }
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            throw new Error("".concat(name, " in ").concat(pkgName, " did not match any ").concat(key));
+            throw new Error(`${name} in ${pkgName} did not match any ${key}`);
         });
     });
+    /* istanbul ignore if */
+    if (process.env.SYNCPACK_VERBOSE) {
+        groupNames.forEach((key) => {
+            groupsByName[key].forEach((group, i) => {
+                const size = group.instances.length;
+                const ref = `${key}[${group.isDefault ? 'default' : i}]`;
+                (0, log_1.verbose)(`${ref} has ${size} instances`);
+                group.instances.forEach(({ name, pathDef, version, packageJsonFile }) => {
+                    const shortPath = packageJsonFile.shortPath;
+                    (0, log_1.verbose)(`${ref} ← ${name}@${version} in ${pathDef.path} of ${shortPath}`);
+                });
+            });
+        });
+    }
     return groupsByName;
 }
-exports.getGroups = getGroups;

package/dist/get-context/get-groups/semver-group.d.ts

@@ -3,7 +3,6 @@ import type { Instance } from '../get-package-json-files/package-json-file/insta
 import { BaseGroup } from './base-group';
 type MismatchesByName = [string, Instance[]];
 export declare class SemverGroup extends BaseGroup<Syncpack.Config.SemverGroup.Any> {
-    constructor(config: Syncpack.Config.Private, semverGroup: Syncpack.Config.SemverGroup.Any);
     getExpectedVersion(instance: Instance): string;
     /** Does this `Instance` have a version which does not follow the rules? */
     isMismatch(instance: Instance): boolean;

package/dist/get-context/get-groups/semver-group.js

@@ -1,47 +1,12 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.SemverGroup = void 0;
-var is_semver_1 = require("../../lib/is-semver");
-var set_semver_range_1 = require("../../lib/set-semver-range");
-var base_group_1 = require("./base-group");
-var SemverGroup = /** @class */ (function (_super) {
-    __extends(SemverGroup, _super);
-    function SemverGroup(config, semverGroup) {
-        return _super.call(this, config, semverGroup) || this;
-    }
-    SemverGroup.prototype.getExpectedVersion = function (instance) {
-        var version = instance.version;
+const is_semver_1 = require("../../lib/is-semver");
+const set_semver_range_1 = require("../../lib/set-semver-range");
+const base_group_1 = require("./base-group");
+class SemverGroup extends base_group_1.BaseGroup {
+    getExpectedVersion(instance) {
+        const version = instance.version;
         // leave ignored versions alone
         if (this.isIgnored())
             return version;
@@ -52,38 +17,30 @@ var SemverGroup = /** @class */ (function (_super) {
         if (instance.isWorkspace())
             return (0, set_semver_range_1.setSemverRange)('', version);
         // otherwise we can change it
-        var range = this.groupConfig.range;
+        const range = this.groupConfig.range;
         return (0, set_semver_range_1.setSemverRange)(range, version);
-    };
+    }
     /** Does this `Instance` have a version which does not follow the rules? */
-    SemverGroup.prototype.isMismatch = function (instance) {
+    isMismatch(instance) {
         return instance.version !== this.getExpectedVersion(instance);
-    };
+    }
     /** 1+ `Instance` has a version which does not follow the rules */
-    SemverGroup.prototype.hasMismatches = function () {
+    hasMismatches() {
         return this.getMismatches().length > 0;
-    };
-    SemverGroup.prototype.isIgnored = function () {
+    }
+    isIgnored() {
         return this.groupConfig.isIgnored === true;
-    };
+    }
     /** Get every `Instance` with a version which does not follow the rules */
-    SemverGroup.prototype.getMismatches = function () {
-        var _this = this;
+    getMismatches() {
         return this.isIgnored()
             ? []
             : Object.entries(this.instancesByName)
-                .map(function (_a) {
-                var _b = __read(_a, 2), name = _b[0], instances = _b[1];
-                return [
-                    name,
-                    instances.filter(function (instance) { return _this.isMismatch(instance); }),
-                ];
-            })
-                .filter(function (_a) {
-                var _b = __read(_a, 2), arr = _b[1];
-                return arr.length > 0;
-            });
-    };
-    return SemverGroup;
-}(base_group_1.BaseGroup));
+                .map(([name, instances]) => [
+                name,
+                instances.filter((instance) => this.isMismatch(instance)),
+            ])
+                .filter(([, arr]) => arr.length > 0);
+    }
+}
 exports.SemverGroup = SemverGroup;

package/dist/get-context/get-groups/version-group/index.d.ts

@@ -1,12 +1,15 @@
+import { O } from '@mobily/ts-belt';
 import type { Syncpack } from '../../../types';
 import { BaseGroup } from '../base-group';
 import { InstanceGroup } from './instance-group';
 export declare class VersionGroup extends BaseGroup<Syncpack.Config.VersionGroup.Any> {
-    getAllInstanceGroups(): InstanceGroup[];
-    getInvalidInstanceGroups(): InstanceGroup[];
     isBanned(): boolean;
     isIgnored(): boolean;
-    hasPinnedVersion(): boolean;
-    getPinnedVersion(): string;
+    hasSnappedToPackages(): boolean;
+    getSnappedToPackages(): O.Option<string[]>;
+    getAllInstanceGroups(): InstanceGroup[];
+    getInvalidInstanceGroups(): InstanceGroup[];
+    getPinnedVersion(): O.Option<string>;
+    /** Is `pinVersion` defined and this group does not match that version? */
     isUnpinned(): boolean;
 }

package/dist/get-context/get-groups/version-group/index.js

@@ -1,75 +1,36 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.VersionGroup = void 0;
-var expect_more_1 = require("expect-more");
-var base_group_1 = require("../base-group");
-var instance_group_1 = require("./instance-group");
-var VersionGroup = /** @class */ (function (_super) {
-    __extends(VersionGroup, _super);
-    function VersionGroup() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    VersionGroup.prototype.getAllInstanceGroups = function () {
-        var _this = this;
-        return Object.entries(this.instancesByName).map(function (_a) {
-            var _b = __read(_a, 2), name = _b[0], instances = _b[1];
-            return new instance_group_1.InstanceGroup(_this, name, instances);
-        });
-    };
-    VersionGroup.prototype.getInvalidInstanceGroups = function () {
-        return this.getAllInstanceGroups().filter(function (group) { return group.isInvalid(); });
-    };
-    VersionGroup.prototype.isBanned = function () {
+const ts_belt_1 = require("@mobily/ts-belt");
+const expect_more_1 = require("expect-more");
+const is_non_empty_string_1 = require("expect-more/dist/is-non-empty-string");
+const base_group_1 = require("../base-group");
+const instance_group_1 = require("./instance-group");
+class VersionGroup extends base_group_1.BaseGroup {
+    isBanned() {
         return this.groupConfig.isBanned === true;
-    };
-    VersionGroup.prototype.isIgnored = function () {
+    }
+    isIgnored() {
         return this.groupConfig.isIgnored === true;
-    };
-    VersionGroup.prototype.hasPinnedVersion = function () {
-        return (0, expect_more_1.isNonEmptyString)(this.getPinnedVersion());
-    };
-    VersionGroup.prototype.getPinnedVersion = function () {
-        return this.groupConfig.pinVersion;
-    };
-    VersionGroup.prototype.isUnpinned = function () {
-        var pinVersion = this.groupConfig.pinVersion;
-        return ((0, expect_more_1.isNonEmptyString)(pinVersion) &&
-            this.instances.some(function (_a) {
-                var version = _a.version;
-                return version !== pinVersion;
-            }));
-    };
-    return VersionGroup;
-}(base_group_1.BaseGroup));
+    }
+    hasSnappedToPackages() {
+        return ts_belt_1.O.isSome(this.getSnappedToPackages());
+    }
+    getSnappedToPackages() {
+        return ts_belt_1.O.fromPredicate(this.groupConfig.snapTo, expect_more_1.isArrayOfStrings);
+    }
+    getAllInstanceGroups() {
+        return Object.entries(this.instancesByName).map(([name, instances]) => new instance_group_1.InstanceGroup(this, name, instances));
+    }
+    getInvalidInstanceGroups() {
+        return this.getAllInstanceGroups().filter((group) => group.isInvalid());
+    }
+    getPinnedVersion() {
+        return ts_belt_1.O.fromPredicate(this.groupConfig.pinVersion, is_non_empty_string_1.isNonEmptyString);
+    }
+    /** Is `pinVersion` defined and this group does not match that version? */
+    isUnpinned() {
+        return (0, ts_belt_1.pipe)(this.getPinnedVersion(), ts_belt_1.O.map((pinVersion) => this.instances.some((o) => o.version !== pinVersion)), ts_belt_1.O.getWithDefault(false));
+    }
+}
 exports.VersionGroup = VersionGroup;

package/dist/get-context/get-groups/version-group/instance-group/get-highest-version.d.ts

@@ -1 +1,3 @@
-export declare function getHighestVersion(versions: string[]): string;
+import { R } from '@mobily/ts-belt';
+import { BaseError } from '../../../../lib/error';
+export declare function getHighestVersion(versions: string[]): R.Result<string, BaseError>;

package/dist/get-context/get-groups/version-group/instance-group/get-highest-version.js

@@ -1,51 +1,42 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHighestVersion = void 0;
-var semver_1 = require("semver");
-var constants_1 = require("../../../../constants");
-var is_semver_1 = require("../../../../lib/is-semver");
+const ts_belt_1 = require("@mobily/ts-belt");
+const error_1 = require("../../../../lib/error");
+const clean_1 = require("./lib/clean");
+const compare_semver_1 = require("./lib/compare-semver");
+const get_range_score_1 = require("./lib/get-range-score");
 function getHighestVersion(versions) {
-    return versions.reduce(function (rawHighest, raw) {
-        var version = (0, semver_1.valid)((0, semver_1.coerce)(raw)) || '';
-        var highest = (0, semver_1.valid)((0, semver_1.coerce)(rawHighest)) || '';
-        if (raw === '*' || rawHighest === '*')
-            return '*';
-        if (!(0, is_semver_1.isSemver)(raw) || version === '')
-            return rawHighest;
-        if (highest === '')
-            return raw;
-        if ((0, semver_1.gt)(version, highest))
-            return raw;
-        if ((0, semver_1.eq)(version, highest) && getRangeScore(raw) > getRangeScore(rawHighest))
-            return raw;
-        return rawHighest;
-    }, '');
+    let highest;
+    for (const withRange of versions) {
+        switch ((0, compare_semver_1.compareGt)(withRange, highest?.semver)) {
+            // highest possible, quit early
+            case '*': {
+                return ts_belt_1.R.Ok(withRange);
+            }
+            // impossible to know how the user wants to resolve unsupported versions
+            case 'invalid': {
+                return ts_belt_1.R.Error(new error_1.BaseError(`"${withRange}" is not supported`));
+            }
+            // we found a new highest version
+            case 'gt': {
+                highest = newHighestVersion(withRange);
+                continue;
+            }
+            // versions are the same, but one range might be greedier than another
+            case 'eq': {
+                const score = (0, get_range_score_1.getRangeScore)(withRange);
+                const highestScore = (0, get_range_score_1.getRangeScore)(`${highest?.withRange}`);
+                if (score > highestScore)
+                    highest = newHighestVersion(withRange);
+            }
+        }
+    }
+    return highest && highest.withRange
+        ? ts_belt_1.R.Ok(highest.withRange)
+        : ts_belt_1.R.Error(new error_1.BaseError(`getHighestVersion(): did not return a version`));
 }
 exports.getHighestVersion = getHighestVersion;
-function getRangeScore(version) {
-    if (version === '')
-        return 0;
-    if (version === constants_1.RANGE.ANY)
-        return 8;
-    var range = getRange(version);
-    if (range === constants_1.RANGE.GT)
-        return 7;
-    if (range === constants_1.RANGE.GTE)
-        return 6;
-    if (range === constants_1.RANGE.MINOR)
-        return 5;
-    if (version.indexOf('.x') !== -1)
-        return 4;
-    if (range === constants_1.RANGE.PATCH)
-        return 3;
-    if (range === constants_1.RANGE.EXACT)
-        return 2;
-    if (range === constants_1.RANGE.LTE)
-        return 1;
-    if (range === constants_1.RANGE.LT)
-        return 0;
-    return 0;
-}
-function getRange(version) {
-    return version.slice(0, version.search(/[0-9]/));
+function newHighestVersion(withRange) {
+    return { withRange, semver: (0, clean_1.clean)(withRange) };
 }

package/dist/get-context/get-groups/version-group/instance-group/get-lowest-version.d.ts

@@ -0,0 +1,3 @@
+import { R } from '@mobily/ts-belt';
+import { BaseError } from '../../../../lib/error';
+export declare function getLowestVersion(versions: string[]): R.Result<string, BaseError>;

package/dist/get-context/get-groups/version-group/instance-group/get-lowest-version.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLowestVersion = void 0;
+const ts_belt_1 = require("@mobily/ts-belt");
+const error_1 = require("../../../../lib/error");
+const clean_1 = require("./lib/clean");
+const compare_semver_1 = require("./lib/compare-semver");
+const get_range_score_1 = require("./lib/get-range-score");
+function getLowestVersion(versions) {
+    let lowest;
+    for (const withRange of versions) {
+        switch ((0, compare_semver_1.compareLt)(withRange, lowest?.semver)) {
+            // lowest possible, quit early
+            case '*': {
+                if (!lowest)
+                    lowest = { withRange: '*', semver: '*' };
+                continue;
+            }
+            // impossible to know how the user wants to resolve unsupported versions
+            case 'invalid': {
+                return ts_belt_1.R.Error(new error_1.BaseError(`"${withRange}" is not supported`));
+            }
+            // we found a new lowest version
+            case 'lt': {
+                lowest = newLowestVersion(withRange);
+                continue;
+            }
+            // versions are the same, but one range might be greedier than another
+            case 'eq': {
+                const score = (0, get_range_score_1.getRangeScore)(withRange);
+                const lowestScore = (0, get_range_score_1.getRangeScore)(`${lowest?.withRange}`);
+                if (score < lowestScore)
+                    lowest = newLowestVersion(withRange);
+            }
+        }
+    }
+    return lowest && lowest.withRange
+        ? ts_belt_1.R.Ok(lowest.withRange)
+        : ts_belt_1.R.Error(new error_1.BaseError(`getLowestVersion(): did not return a version`));
+}
+exports.getLowestVersion = getLowestVersion;
+function newLowestVersion(withRange) {
+    return { withRange, semver: (0, clean_1.clean)(withRange) };
+}