syncpack 9.3.2 → 9.7.4

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,9 @@
 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';
 import { SemverGroup } from './semver-group';
 import { VersionGroup } from './version-group';
-export declare function getGroups(config: Syncpack.Config.Private, instances: Instance[]): {
+export declare function getGroups(config: Syncpack.Config.Private, instances: Instance[], packageJsonFiles: PackageJsonFile[]): {
     semverGroups: SemverGroup[];
     versionGroups: VersionGroup[];
 };

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

@@ -1,47 +1,41 @@
 "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 log_1 = require("../../lib/log");
+const semver_group_1 = require("./semver-group");
+const version_group_1 = require("./version-group");
+function getGroups(config, instances, 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;
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
+    const groupNames = Object.keys(groupsByName);
+    instances.forEach((instance) => {
+        const { name, pkgName } = instance;
+        groupNames.forEach((key) => {
+            for (const group of groupsByName[key]) {
+                if (group.canAdd(instance)) {
+                    group.add(instance);
+                    return;
                 }
-                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

@@ -6,7 +6,8 @@ export declare class VersionGroup extends BaseGroup<Syncpack.Config.VersionGroup
     getInvalidInstanceGroups(): InstanceGroup[];
     isBanned(): boolean;
     isIgnored(): boolean;
-    hasPinnedVersion(): boolean;
+    hasSnappedToPackages(): boolean;
+    getSnappedToPackages(): string[];
     getPinnedVersion(): string;
     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;
+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 {
+    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());
     }
-    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 () {
+    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 () {
+    }
+    hasSnappedToPackages() {
+        return (0, expect_more_1.isArrayOfStrings)(this.groupConfig.snapTo);
+    }
+    getSnappedToPackages() {
+        return this.groupConfig.snapTo;
+    }
+    getPinnedVersion() {
         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));
+    }
+    isUnpinned() {
+        const { pinVersion } = this.groupConfig;
+        return ((0, is_non_empty_string_1.isNonEmptyString)(pinVersion) &&
+            this.instances.some(({ version }) => version !== pinVersion));
+    }
+}
 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.compareSemver)(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/index.d.ts

@@ -15,7 +15,8 @@ export declare class InstanceGroup {
     isInvalid(): boolean;
     getExpectedVersion(): string | undefined;
     getHighestVersion(): string;
-    isUnpinned(): boolean;
+    getSnappedVersion(): string;
+    isUnsnapped(): boolean;
     /** Get version of dependency which is developed in this monorepo */
     getWorkspaceVersion(): string | undefined;
     /** Find instance of this dependency which is developed in this monorepo */

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

@@ -1,76 +1,84 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstanceGroup = void 0;
-var error_1 = require("../../../../lib/error");
-var is_semver_1 = require("../../../../lib/is-semver");
-var print_strings_1 = require("../../../../lib/print-strings");
-var get_highest_version_1 = require("./get-highest-version");
+const ts_belt_1 = require("@mobily/ts-belt");
+const error_1 = require("../../../../lib/error");
+const is_semver_1 = require("../../../../lib/is-semver");
+const print_strings_1 = require("../../../../lib/print-strings");
+const get_highest_version_1 = require("./get-highest-version");
 /** Every `Instance` of eg `"lodash"` for a given `VersionGroup` */
-var InstanceGroup = /** @class */ (function () {
-    function InstanceGroup(versionGroup, name, instances) {
+class InstanceGroup {
+    constructor(versionGroup, name, instances) {
         this.instances = instances;
         this.name = name;
         this.versionGroup = versionGroup;
     }
-    InstanceGroup.prototype.hasUnsupportedVersion = function () {
-        return this.instances.some(function (obj) { return !(0, is_semver_1.isSemver)(obj.version); });
-    };
-    InstanceGroup.prototype.getUniqueVersions = function () {
-        return Array.from(new Set(this.instances.map(function (obj) { return obj.version; }))).sort();
-    };
-    InstanceGroup.prototype.hasMismatchingVersions = function () {
+    hasUnsupportedVersion() {
+        return this.instances.some((obj) => !(0, is_semver_1.isSemver)(obj.version));
+    }
+    getUniqueVersions() {
+        return Array.from(new Set(this.instances.map((obj) => obj.version))).sort();
+    }
+    hasMismatchingVersions() {
         return this.getUniqueVersions().length > 1;
-    };
-    InstanceGroup.prototype.isInvalid = function () {
+    }
+    isInvalid() {
         return this.versionGroup.isIgnored()
             ? false
             : this.versionGroup.isBanned() ||
                 this.versionGroup.isUnpinned() ||
                 this.hasMismatchingVersions();
-    };
-    InstanceGroup.prototype.getExpectedVersion = function () {
-        var versionGroup = this.versionGroup;
-        var REMOVE_DEPENDENCY = undefined;
+    }
+    getExpectedVersion() {
+        const versionGroup = this.versionGroup;
+        const REMOVE_DEPENDENCY = undefined;
         if (versionGroup.isBanned())
             return REMOVE_DEPENDENCY;
         if (versionGroup.isUnpinned())
             return versionGroup.getPinnedVersion();
+        if (this.isUnsnapped())
+            return this.getSnappedVersion();
         if (this.hasWorkspaceInstance())
             return this.getWorkspaceVersion();
         if (this.hasUnsupportedVersion()) {
-            throw new error_1.BaseError("".concat(this.name, " contains unsupported versions: ").concat((0, print_strings_1.printStrings)(this.getUniqueVersions())));
+            throw new error_1.BaseError(`${this.name} contains unsupported versions: ${(0, print_strings_1.printStrings)(this.getUniqueVersions())}`);
         }
         return this.getHighestVersion();
-    };
-    InstanceGroup.prototype.getHighestVersion = function () {
-        return (0, get_highest_version_1.getHighestVersion)(this.getUniqueVersions());
-    };
-    InstanceGroup.prototype.isUnpinned = function () {
-        var _this = this;
-        return (this.versionGroup.hasPinnedVersion() &&
-            this.instances.some(function (_a) {
-                var version = _a.version;
-                return version !== _this.versionGroup.getPinnedVersion();
-            }));
-    };
+    }
+    getHighestVersion() {
+        return (0, ts_belt_1.pipe)((0, get_highest_version_1.getHighestVersion)(this.getUniqueVersions()), ts_belt_1.R.getExn);
+    }
+    getSnappedVersion() {
+        const snapTo = this.versionGroup.getSnappedToPackages();
+        const version = this.instances
+            .filter(({ pkgName }) => snapTo.includes(pkgName))
+            .map((instance) => instance.version)
+            .find(Boolean);
+        if (!version) {
+            const pkgNames = (0, print_strings_1.printStrings)(snapTo);
+            throw new error_1.BaseError(`${this.name} is in a versionGroup with snapTo:[${pkgNames}], but ${this.name} was not found in those packages`);
+        }
+        return version;
+    }
+    isUnsnapped() {
+        if (!this.versionGroup.hasSnappedToPackages())
+            return false;
+        const targetVersion = this.getSnappedVersion();
+        return this.instances.some(({ version }) => version !== targetVersion);
+    }
     /** Get version of dependency which is developed in this monorepo */
-    InstanceGroup.prototype.getWorkspaceVersion = function () {
-        var _a;
+    getWorkspaceVersion() {
         if (this.hasWorkspaceInstance()) {
-            return (_a = this.getWorkspaceInstance()) === null || _a === void 0 ? void 0 : _a.packageJsonFile.contents.version;
+            return this.getWorkspaceInstance()?.packageJsonFile.contents.version;
         }
         throw new error_1.BaseError('getWorkspaceVersion invoked when there is none');
-    };
+    }
     /** Find instance of this dependency which is developed in this monorepo */
-    InstanceGroup.prototype.getWorkspaceInstance = function () {
-        return this.instances.find(function (_a) {
-            var pathDef = _a.pathDef;
-            return pathDef.name === 'workspace';
-        });
-    };
-    InstanceGroup.prototype.hasWorkspaceInstance = function () {
+    getWorkspaceInstance() {
+        return this.instances.find(({ pathDef }) => pathDef.name === 'workspace');
+    }
+    hasWorkspaceInstance() {
         return this.getWorkspaceInstance() !== undefined;
-    };
-    return InstanceGroup;
-}());
+    }
+}
 exports.InstanceGroup = InstanceGroup;

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

@@ -0,0 +1,2 @@
+/** Convert eg "1" to "1.0.0" which the semver lib does not understand */
+export declare function clean(v: string): string;

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

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clean = void 0;
+const coerce_1 = __importDefault(require("semver/functions/coerce"));
+const valid_1 = __importDefault(require("semver/functions/valid"));
+/** Convert eg "1" to "1.0.0" which the semver lib does not understand */
+function clean(v) {
+    return (0, valid_1.default)((0, coerce_1.default)(v)) || '';
+}
+exports.clean = clean;