syncpack 9.0.2 → 9.3.2

package/dist/get-context/get-config/schema/semver-group.d.ts

@@ -3,99 +3,117 @@ export declare const ignored: z.ZodObject<{
     isIgnored: z.ZodLiteral<true>;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     dependencies: string[];
-    isIgnored: true;
     dependencyTypes: string[];
+    label: string;
     packages: string[];
+    isIgnored: true;
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     dependencies: string[];
-    isIgnored: true;
     packages: string[];
+    isIgnored: true;
 }>;
 export declare const withRange: z.ZodObject<{
     range: z.ZodEnum<["*", "", ">", ">=", ".x", "<", "<=", "^", "~"]>;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     dependencies: string[];
+    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
     dependencyTypes: string[];
+    label: string;
     packages: string[];
-    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     dependencies: string[];
-    packages: string[];
     range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
+    packages: string[];
 }>;
 export declare const base: z.ZodObject<{
     range: z.ZodEnum<["*", "", ">", ">=", ".x", "<", "<=", "^", "~"]>;
     isDefault: z.ZodLiteral<true>;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     isDefault: true;
     dependencies: string[];
+    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
     dependencyTypes: string[];
+    label: string;
     packages: string[];
-    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     isDefault: true;
     dependencies: string[];
-    packages: string[];
     range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
+    packages: string[];
 }>;
 export declare const any: z.ZodUnion<[z.ZodObject<{
     isIgnored: z.ZodLiteral<true>;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     dependencies: string[];
-    isIgnored: true;
     dependencyTypes: string[];
+    label: string;
     packages: string[];
+    isIgnored: true;
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     dependencies: string[];
-    isIgnored: true;
     packages: string[];
+    isIgnored: true;
 }>, z.ZodObject<{
     range: z.ZodEnum<["*", "", ">", ">=", ".x", "<", "<=", "^", "~"]>;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     dependencies: string[];
+    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
     dependencyTypes: string[];
+    label: string;
     packages: string[];
-    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     dependencies: string[];
-    packages: string[];
     range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
+    packages: string[];
 }>, z.ZodObject<{
     range: z.ZodEnum<["*", "", ">", ">=", ".x", "<", "<=", "^", "~"]>;
     isDefault: z.ZodLiteral<true>;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     isDefault: true;
     dependencies: string[];
+    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
     dependencyTypes: string[];
+    label: string;
     packages: string[];
-    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     isDefault: true;
     dependencies: string[];
-    packages: string[];
     range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
+    packages: string[];
 }>]>;

package/dist/get-context/get-config/schema/version-group.d.ts

@@ -2,13 +2,16 @@ import { z } from 'zod';
 export declare const standard: z.ZodObject<{
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     dependencies: string[];
     dependencyTypes: string[];
+    label: string;
     packages: string[];
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     dependencies: string[];
     packages: string[];
 }>;
@@ -16,14 +19,17 @@ export declare const banned: z.ZodObject<{
     isBanned: z.ZodLiteral<true>;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     dependencies: string[];
     dependencyTypes: string[];
+    label: string;
     packages: string[];
     isBanned: true;
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     dependencies: string[];
     packages: string[];
     isBanned: true;
@@ -32,30 +38,36 @@ export declare const ignored: z.ZodObject<{
     isIgnored: z.ZodLiteral<true>;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     dependencies: string[];
-    isIgnored: true;
     dependencyTypes: string[];
+    label: string;
     packages: string[];
+    isIgnored: true;
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     dependencies: string[];
-    isIgnored: true;
     packages: string[];
+    isIgnored: true;
 }>;
 export declare const pinned: z.ZodObject<{
     pinVersion: z.ZodString;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     dependencies: string[];
     dependencyTypes: string[];
+    label: string;
     packages: string[];
     pinVersion: string;
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     dependencies: string[];
     packages: string[];
     pinVersion: string;
@@ -64,14 +76,17 @@ export declare const base: z.ZodObject<{
     isDefault: z.ZodLiteral<true>;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     isDefault: true;
     dependencies: string[];
     dependencyTypes: string[];
+    label: string;
     packages: string[];
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     isDefault: true;
     dependencies: string[];
     packages: string[];
@@ -79,27 +94,33 @@ export declare const base: z.ZodObject<{
 export declare const any: z.ZodUnion<[z.ZodObject<{
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     dependencies: string[];
     dependencyTypes: string[];
+    label: string;
     packages: string[];
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     dependencies: string[];
     packages: string[];
 }>, z.ZodObject<{
     isBanned: z.ZodLiteral<true>;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     dependencies: string[];
     dependencyTypes: string[];
+    label: string;
     packages: string[];
     isBanned: true;
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     dependencies: string[];
     packages: string[];
     isBanned: true;
@@ -107,29 +128,35 @@ export declare const any: z.ZodUnion<[z.ZodObject<{
     isIgnored: z.ZodLiteral<true>;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     dependencies: string[];
-    isIgnored: true;
     dependencyTypes: string[];
+    label: string;
     packages: string[];
+    isIgnored: true;
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     dependencies: string[];
-    isIgnored: true;
     packages: string[];
+    isIgnored: true;
 }>, z.ZodObject<{
     pinVersion: z.ZodString;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     dependencies: string[];
     dependencyTypes: string[];
+    label: string;
     packages: string[];
     pinVersion: string;
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     dependencies: string[];
     packages: string[];
     pinVersion: string;
@@ -137,14 +164,17 @@ export declare const any: z.ZodUnion<[z.ZodObject<{
     isDefault: z.ZodLiteral<true>;
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     isDefault: true;
     dependencies: string[];
     dependencyTypes: string[];
+    label: string;
     packages: string[];
 }, {
     dependencyTypes?: string[] | undefined;
+    label?: string | undefined;
     isDefault: true;
     dependencies: string[];
     packages: string[];

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;