syncpack 9.0.2 → 9.1.2

package/dist/bin-fix-mismatches/fix-mismatches.js

@@ -1,20 +1,4 @@
 "use strict";
-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;
 exports.fixMismatches = void 0;
 var expect_more_1 = require("expect-more");
@@ -26,32 +10,25 @@ function fixMismatches(ctx) {
             return;
         // Set the correct version on each instance.
         invalidGroups.forEach(function (instanceGroup) {
-            var nextVersion = instanceGroup.getExpectedVersion();
-            if (nextVersion === '')
-                console.trace(instanceGroup);
-            instanceGroup.instances.forEach(function (instance) {
-                return instance.setVersion(nextVersion);
-            });
+            if (!instanceGroup.hasUnsupportedVersion()) {
+                var nextVersion_1 = instanceGroup.getExpectedVersion();
+                instanceGroup.instances.forEach(function (instance) {
+                    return instance.setVersion(nextVersion_1);
+                });
+            }
         });
     });
-    ctx.packageJsonFiles.forEach(function (file) {
-        removeEmptyObjects(file.contents);
+    /** Remove eg `{"dependencies": {}, "devDependencies": {}}` */
+    ctx.packageJsonFiles.forEach(function (packageJsonFile) {
+        var contents = packageJsonFile.contents;
+        Object.keys(contents).forEach(function (key) {
+            var value = contents[key];
+            if ((0, expect_more_1.isObject)(value) &&
+                Object.values(value).every(expect_more_1.isUndefined)) {
+                delete contents[key];
+            }
+        });
     });
     return ctx;
-    /** Remove eg { "dependencies": {}, "devDependencies": {} }` */
-    function removeEmptyObjects(parent) {
-        if ((0, expect_more_1.isObject)(parent)) {
-            Object.entries(parent).forEach(function (_a) {
-                var _b = __read(_a, 2), key = _b[0], child = _b[1];
-                if ((0, expect_more_1.isObject)(child) &&
-                    ((0, expect_more_1.isEmptyObject)(child) || Object.values(child).every(expect_more_1.isUndefined))) {
-                    delete parent[key];
-                }
-                else {
-                    removeEmptyObjects(child);
-                }
-            });
-        }
-    }
 }
 exports.fixMismatches = fixMismatches;

package/dist/bin-lint-semver-ranges/lint-semver-ranges.js

@@ -50,7 +50,6 @@ exports.lintSemverRanges = void 0;
 var chalk_1 = __importDefault(require("chalk"));
 var constants_1 = require("../constants");
 var log = __importStar(require("../lib/log"));
-var set_semver_range_1 = require("../lib/set-semver-range");
 function lintSemverRanges(ctx) {
     ctx.semverGroups.reverse().forEach(function (semverGroup, i) {
         // Nothing to do if there are no mismatches
@@ -69,9 +68,7 @@ function lintSemverRanges(ctx) {
             log.invalid(name);
             // Log each of the dependencies mismatches
             mismatches.forEach(function (instance) {
-                if (!instance.hasRange(semverGroup.range)) {
-                    logSemverRangeMismatch(instance, semverGroup);
-                }
+                logSemverRangeMismatch(instance, semverGroup);
             });
         });
     });
@@ -82,7 +79,7 @@ function logSemverRangeMismatch(instance, semverGroup) {
     var path = instance.pathDef.path;
     var shortPath = instance.packageJsonFile.shortPath;
     var actual = instance.version;
-    var expected = (0, set_semver_range_1.setSemverRange)(semverGroup.range, actual);
+    var expected = semverGroup.getExpectedVersion(instance);
     console.log((0, chalk_1["default"])(templateObject_1 || (templateObject_1 = __makeTemplateObject(["  {red ", "} ", " {green ", "} {dim in ", " of ", "}"], ["  {red ", "} ", " {green ", "} {dim in ", " of ", "}"])), actual, constants_1.ICON.rightArrow, expected, path, shortPath));
 }
 var templateObject_1;

package/dist/bin-list/list.js

@@ -39,30 +39,36 @@ function list(ctx) {
         // Annotate user-defined version groups
         if (!versionGroup.isDefault)
             log.versionGroupHeader(i);
-        versionGroup.instanceGroups.forEach(function (instanceGroup) {
-            var expected = instanceGroup.getExpectedVersion();
-            var uniques = instanceGroup.uniques;
+        versionGroup.getAllInstanceGroups().forEach(function (instanceGroup) {
             // Record that this project has mismatches, so that eg. the CLI can exit
             // with the correct status code.
-            if (instanceGroup.isInvalid)
+            if (instanceGroup.isInvalid())
                 ctx.isInvalid = true;
-            versionGroup.isBanned
-                ? logBanned(instanceGroup)
-                : versionGroup.isIgnored
-                    ? logIgnored(instanceGroup)
-                    : instanceGroup.hasMismatches
-                        ? logVersionMismatch(instanceGroup, uniques, expected)
-                        : logVersionMatch(instanceGroup, uniques);
+            if (versionGroup.isBanned())
+                return logBanned(instanceGroup);
+            if (versionGroup.isIgnored())
+                return logIgnored(instanceGroup);
+            if (versionGroup.isUnpinned())
+                return logUnpinned(instanceGroup);
+            if (instanceGroup.hasMismatchingVersions()) {
+                return instanceGroup.hasUnsupportedVersion()
+                    ? logUnsupportedMismatches(instanceGroup)
+                    : logVersionMismatch(instanceGroup);
+            }
+            logVersionMatch(instanceGroup);
         });
     });
     return ctx;
-    function logVersionMatch(instanceGroup, uniques) {
-        console.log((0, chalk_1["default"])(templateObject_1 || (templateObject_1 = __makeTemplateObject(["{dim -} {white ", "} {dim ", "}"], ["{dim -} {white ", "} {dim ", "}"])), instanceGroup.name, uniques));
+    function logVersionMatch(instanceGroup) {
+        console.log((0, chalk_1["default"])(templateObject_1 || (templateObject_1 = __makeTemplateObject(["{dim -} {white ", "} {dim ", "}"], ["{dim -} {white ", "} {dim ", "}"])), instanceGroup.name, instanceGroup.getUniqueVersions()));
     }
-    function logVersionMismatch(instanceGroup, uniques, expected) {
-        console.log((0, chalk_1["default"])(templateObject_2 || (templateObject_2 = __makeTemplateObject(["{red ", " ", "} ", ""], ["{red ", " ", "} ", ""])), constants_1.ICON.cross, instanceGroup.name, uniques
+    function logVersionMismatch(instanceGroup) {
+        console.log((0, chalk_1["default"])(templateObject_2 || (templateObject_2 = __makeTemplateObject(["{red ", " ", "} ", ""], ["{red ", " ", "} ", ""])), constants_1.ICON.cross, instanceGroup.name, instanceGroup
+            .getUniqueVersions()
             .map(function (version) {
-            return version === expected ? chalk_1["default"].green(version) : chalk_1["default"].red(version);
+            return version === instanceGroup.getExpectedVersion()
+                ? chalk_1["default"].green(version)
+                : chalk_1["default"].red(version);
         })
             .join(chalk_1["default"].dim(', '))));
     }
@@ -72,6 +78,16 @@ function list(ctx) {
     function logBanned(instanceGroup) {
         console.log((0, chalk_1["default"])(templateObject_4 || (templateObject_4 = __makeTemplateObject(["{red ", " ", "} {dim.red is banned in this version group}"], ["{red ", " ", "} {dim.red is banned in this version group}"])), constants_1.ICON.cross, instanceGroup.name));
     }
+    function logUnpinned(instanceGroup) {
+        var pinVersion = instanceGroup.versionGroup.getPinnedVersion();
+        console.log((0, chalk_1["default"])(templateObject_5 || (templateObject_5 = __makeTemplateObject(["{red ", " ", "} {dim.red is pinned to ", " in this version group}"], ["{red ", " ", "} {dim.red is pinned to ", " in this version group}"])), constants_1.ICON.cross, instanceGroup.name, pinVersion));
+    }
+    function logUnsupportedMismatches(instanceGroup) {
+        console.log((0, chalk_1["default"])(templateObject_6 || (templateObject_6 = __makeTemplateObject(["{red ", " ", "} {dim.red has mismatched versions which syncpack cannot fix: ", "}"], ["{red ", " ", "} {dim.red has mismatched versions which syncpack cannot fix: ", "}"])), constants_1.ICON.cross, instanceGroup.name, instanceGroup
+            .getUniqueVersions()
+            .map(function (version) { return chalk_1["default"].yellow(version); })
+            .join(chalk_1["default"].dim(', '))));
+    }
 }
 exports.list = list;
-var templateObject_1, templateObject_2, templateObject_3, templateObject_4;
+var templateObject_1, templateObject_2, templateObject_3, templateObject_4, templateObject_5, templateObject_6;

package/dist/bin-list-mismatches/list-mismatches.js

@@ -47,46 +47,69 @@ function listMismatches(ctx) {
             log.versionGroupHeader(i);
         // Log the mismatches
         invalidGroups.forEach(function (instanceGroup) {
-            var name = instanceGroup.name;
-            var workspaceInstance = instanceGroup.getWorkspaceInstance();
-            var expected = instanceGroup.getExpectedVersion() || '';
-            var isBanned = versionGroup.isBanned;
-            var isUnpinned = instanceGroup.isUnpinned;
-            // Log the dependency name
-            if (isBanned) {
-                logBanned(name);
+            if (versionGroup.isBanned())
+                return logBanned(instanceGroup);
+            if (versionGroup.isUnpinned())
+                return logUnpinned(instanceGroup);
+            if (instanceGroup.hasUnsupportedVersion())
+                return logUnsupportedMismatches(instanceGroup);
+            if (instanceGroup.hasWorkspaceInstance()) {
+                return logWorkspaceMismatch(instanceGroup);
             }
-            else if (isUnpinned) {
-                logPinVersionMismatch(name, versionGroup);
-            }
-            else if (workspaceInstance) {
-                logWorkspaceMismatch(workspaceInstance, expected, name);
-            }
-            else {
-                logHighestVersionMismatch(expected, name);
-            }
-            // Log each of the dependencies mismatches
-            instanceGroup.instances.forEach(function (instance) {
-                if (instance.version !== expected) {
-                    logVersionMismatch(instance);
-                }
-            });
+            logHighestVersionMismatch(instanceGroup);
         });
     });
     return ctx;
-    function logBanned(name) {
+    function logBanned(instanceGroup) {
+        var name = instanceGroup.name;
         log.invalid(name, 'is banned in this version group');
+        // Log each of the dependencies mismatches
+        instanceGroup.instances.forEach(function (instance) {
+            logVersionMismatch(instance);
+        });
     }
-    function logPinVersionMismatch(name, versionGroup) {
-        var pinVersion = versionGroup.pinVersion;
+    function logUnsupportedMismatches(instanceGroup) {
+        var name = instanceGroup.name;
+        log.invalid(name, 'has mismatched versions which syncpack cannot fix');
+        // Log each of the dependencies mismatches
+        instanceGroup.instances.forEach(function (instance) {
+            logUnsupportedVersionMismatch(instance);
+        });
+    }
+    function logUnpinned(instanceGroup) {
+        var name = instanceGroup.name;
+        var pinVersion = instanceGroup.versionGroup.getPinnedVersion();
         log.invalid(name, (0, chalk_1["default"])(templateObject_1 || (templateObject_1 = __makeTemplateObject(["is pinned in this version group at {reset.green ", "}"], ["is pinned in this version group at {reset.green ", "}"])), pinVersion));
+        // Log each of the dependencies mismatches
+        instanceGroup.instances.forEach(function (instance) {
+            if (instance.version !== pinVersion) {
+                logVersionMismatch(instance);
+            }
+        });
     }
-    function logWorkspaceMismatch(workspaceInstance, expected, name) {
-        var shortPath = workspaceInstance.packageJsonFile.shortPath;
+    function logWorkspaceMismatch(instanceGroup) {
+        var name = instanceGroup.name;
+        var workspaceInstance = instanceGroup.getWorkspaceInstance();
+        var shortPath = workspaceInstance === null || workspaceInstance === void 0 ? void 0 : workspaceInstance.packageJsonFile.shortPath;
+        var expected = instanceGroup.getExpectedVersion();
         log.invalid(name, (0, chalk_1["default"])(templateObject_2 || (templateObject_2 = __makeTemplateObject(["{reset.green ", "} {dim is developed in this repo at ", "}"], ["{reset.green ", "} {dim is developed in this repo at ", "}"])), expected, shortPath));
+        // Log each of the dependencies mismatches
+        instanceGroup.instances.forEach(function (instance) {
+            if (instance.version !== expected) {
+                logVersionMismatch(instance);
+            }
+        });
     }
-    function logHighestVersionMismatch(expected, name) {
+    function logHighestVersionMismatch(instanceGroup) {
+        var name = instanceGroup.name;
+        var expected = instanceGroup.getExpectedVersion();
         log.invalid(name, (0, chalk_1["default"])(templateObject_3 || (templateObject_3 = __makeTemplateObject(["{reset.green ", "} {dim is the highest valid semver version in use}"], ["{reset.green ", "} {dim is the highest valid semver version in use}"])), expected));
+        // Log each of the dependencies mismatches
+        instanceGroup.instances.forEach(function (instance) {
+            if (instance.version !== expected) {
+                logVersionMismatch(instance);
+            }
+        });
     }
     function logVersionMismatch(instance) {
         var type = instance.pathDef.path;
@@ -94,6 +117,12 @@ function listMismatches(ctx) {
         var actual = instance.version;
         console.log((0, chalk_1["default"])(templateObject_4 || (templateObject_4 = __makeTemplateObject(["  {red ", "} {dim in ", " of ", "}"], ["  {red ", "} {dim in ", " of ", "}"])), actual, type, shortPath));
     }
+    function logUnsupportedVersionMismatch(instance) {
+        var type = instance.pathDef.path;
+        var shortPath = instance.packageJsonFile.shortPath;
+        var actual = instance.version;
+        console.log((0, chalk_1["default"])(templateObject_5 || (templateObject_5 = __makeTemplateObject(["  {yellow ", "} {dim in ", " of ", "}"], ["  {yellow ", "} {dim in ", " of ", "}"])), actual, type, shortPath));
+    }
 }
 exports.listMismatches = listMismatches;
-var templateObject_1, templateObject_2, templateObject_3, templateObject_4;
+var templateObject_1, templateObject_2, templateObject_3, templateObject_4, templateObject_5;

package/dist/bin-set-semver-ranges/set-semver-ranges.js

@@ -4,7 +4,7 @@ exports.setSemverRanges = void 0;
 var setSemverRanges = function (ctx) {
     ctx.semverGroups.reverse().forEach(function (semverGroup) {
         semverGroup.instances.forEach(function (instance) {
-            instance.setRange(semverGroup.range);
+            instance.setVersion(semverGroup.getExpectedVersion(instance));
         });
     });
     return ctx;

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

@@ -0,0 +1,19 @@
+import type { Syncpack } from '../../types';
+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 */
+    syncpackConfig: Syncpack.Config.Private;
+    /** The original config which created this `SemverGroup` */
+    groupConfig: T;
+    /** Instances which belong to this group */
+    instances: Instance[];
+    /** Instances which belong to this group, keyed by their .name property */
+    instancesByName: Record<string, Instance[]>;
+    /** Is this the catch-all group, not defined by the user? */
+    isDefault: boolean;
+    constructor(config: Syncpack.Config.Private, group: T);
+    /** Can this instance be added to this group? */
+    canAdd(instance: Instance): boolean;
+    /** Add this instance to this group */
+    add(instance: Instance): void;
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = 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) {
+        this.groupConfig = group;
+        this.instances = [];
+        this.instancesByName = {};
+        this.isDefault =
+            group === config.defaultSemverGroup ||
+                group === config.defaultVersionGroup;
+        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) ||
+            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); })));
+    };
+    /** Add this instance to this group */
+    BaseGroup.prototype.add = function (instance) {
+        var _a;
+        if (!this.instancesByName[instance.name]) {
+            this.instancesByName[instance.name] = [];
+        }
+        (_a = this.instancesByName[instance.name]) === null || _a === void 0 ? void 0 : _a.push(instance);
+        this.instances.push(instance);
+    };
+    return BaseGroup;
+}());
+exports.BaseGroup = BaseGroup;

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

@@ -0,0 +1,8 @@
+import type { Syncpack } from '../../types';
+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[]): {
+    semverGroups: SemverGroup[];
+    versionGroups: VersionGroup[];
+};

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

@@ -0,0 +1,47 @@
+"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;
+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); })
+    };
+    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);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            throw new Error("".concat(name, " in ").concat(pkgName, " did not match any ").concat(key));
+        });
+    });
+    return groupsByName;
+}
+exports.getGroups = getGroups;

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

@@ -0,0 +1,16 @@
+import type { Syncpack } from '../../types';
+import type { Instance } from '../get-package-json-files/package-json-file/instance';
+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;
+    /** 1+ `Instance` has a version which does not follow the rules */
+    hasMismatches(): boolean;
+    isIgnored(): boolean;
+    /** Get every `Instance` with a version which does not follow the rules */
+    getMismatches(): MismatchesByName[];
+}
+export {};

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

@@ -0,0 +1,89 @@
+"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;
+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;
+        // leave ignored versions alone
+        if (this.isIgnored())
+            return version;
+        // leave unsupported versions alone
+        if (!(0, is_semver_1.isSemver)(version))
+            return version;
+        // version property of package.json must always be exact
+        if (instance.isWorkspace())
+            return (0, set_semver_range_1.setSemverRange)('', version);
+        // otherwise we can change it
+        var 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) {
+        return instance.version !== this.getExpectedVersion(instance);
+    };
+    /** 1+ `Instance` has a version which does not follow the rules */
+    SemverGroup.prototype.hasMismatches = function () {
+        return this.getMismatches().length > 0;
+    };
+    SemverGroup.prototype.isIgnored = function () {
+        return this.groupConfig.isIgnored === true;
+    };
+    /** Get every `Instance` with a version which does not follow the rules */
+    SemverGroup.prototype.getMismatches = function () {
+        var _this = this;
+        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));
+exports.SemverGroup = SemverGroup;

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

@@ -1,29 +1,12 @@
 import type { Syncpack } from '../../../types';
-import type { Instance } from '../../get-package-json-files/package-json-file/instance';
-import type { InstanceGroup } from './instance-group';
-export declare class VersionGroup {
-    /** */
-    dependencies: string[];
-    /** Optionally limit this group to dependencies at these named paths */
-    dependencyTypes: Syncpack.TypeName[];
-    /** */
-    input: Syncpack.Config.Private;
-    /** */
-    instanceGroups: InstanceGroup[];
-    /** */
-    instances: Instance[];
-    /** */
-    instancesByName: Record<string, Instance[]>;
-    /** */
-    isBanned: boolean;
-    /** */
-    isDefault: boolean;
-    /** */
-    isIgnored: boolean;
-    /** */
-    packages: string[];
-    /** Optionally force all dependencies in this group to have this version */
-    pinVersion?: string;
-    constructor(input: Syncpack.Config.Private, versionGroup: Syncpack.Config.VersionGroup.Any);
+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;
+    isUnpinned(): boolean;
 }

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

@@ -1,23 +1,75 @@
 "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;
 exports.VersionGroup = void 0;
-var VersionGroup = /** @class */ (function () {
-    function VersionGroup(input, versionGroup) {
-        this.dependencies = versionGroup.dependencies;
-        this.dependencyTypes = versionGroup.dependencyTypes;
-        this.input = input;
-        this.instanceGroups = [];
-        this.instances = [];
-        this.instancesByName = {};
-        this.isBanned = versionGroup.isBanned === true;
-        this.isDefault = versionGroup === input.defaultVersionGroup;
-        this.isIgnored = versionGroup.isIgnored === true;
-        this.packages = versionGroup.packages;
-        this.pinVersion = versionGroup.pinVersion;
+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.instanceGroups.filter(function (group) { return group.isInvalid; });
+        return this.getAllInstanceGroups().filter(function (group) { return group.isInvalid(); });
+    };
+    VersionGroup.prototype.isBanned = function () {
+        return this.groupConfig.isBanned === true;
+    };
+    VersionGroup.prototype.isIgnored = function () {
+        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));
 exports.VersionGroup = VersionGroup;