syncpack 10.5.1 → 10.7.2

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

@@ -1,126 +1,198 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVersionGroups = void 0;
-const minimatch_1 = require("minimatch");
+exports.getVersionGroups = exports.VersionGroupConfigError = exports.VersionGroupReport = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Function_1 = require("@effect/data/Function");
+const Effect = __importStar(require("@effect/io/Effect"));
 const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
 const is_non_empty_array_1 = require("tightrope/guard/is-non-empty-array");
 const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
 const is_object_1 = require("tightrope/guard/is-object");
 const get_enabled_types_1 = require("../config/get-enabled-types");
+const can_add_to_group_1 = require("../guards/can-add-to-group");
+const sort_by_name_1 = require("../lib/sort-by-name");
 const banned_1 = require("./banned");
-const catch_all_1 = require("./catch-all");
 const filtered_out_1 = require("./filtered-out");
 const ignored_1 = require("./ignored");
 const pinned_1 = require("./pinned");
 const same_range_1 = require("./same-range");
 const snapped_to_1 = require("./snapped-to");
 const standard_1 = require("./standard");
+var VersionGroupReport;
+(function (VersionGroupReport) {
+    class Banned extends Data.TaggedClass('Banned') {
+    }
+    VersionGroupReport.Banned = Banned;
+    class FilteredOut extends Data.TaggedClass('FilteredOut') {
+    }
+    VersionGroupReport.FilteredOut = FilteredOut;
+    class HighestSemverMismatch extends Data.TaggedClass('HighestSemverMismatch') {
+    }
+    VersionGroupReport.HighestSemverMismatch = HighestSemverMismatch;
+    class Ignored extends Data.TaggedClass('Ignored') {
+    }
+    VersionGroupReport.Ignored = Ignored;
+    class LowestSemverMismatch extends Data.TaggedClass('LowestSemverMismatch') {
+    }
+    VersionGroupReport.LowestSemverMismatch = LowestSemverMismatch;
+    class PinnedMismatch extends Data.TaggedClass('PinnedMismatch') {
+    }
+    VersionGroupReport.PinnedMismatch = PinnedMismatch;
+    class SameRangeMismatch extends Data.TaggedClass('SameRangeMismatch') {
+    }
+    VersionGroupReport.SameRangeMismatch = SameRangeMismatch;
+    class SnappedToMismatch extends Data.TaggedClass('SnappedToMismatch') {
+    }
+    VersionGroupReport.SnappedToMismatch = SnappedToMismatch;
+    class UnsupportedMismatch extends Data.TaggedClass('UnsupportedMismatch') {
+    }
+    VersionGroupReport.UnsupportedMismatch = UnsupportedMismatch;
+    class Valid extends Data.TaggedClass('Valid') {
+    }
+    VersionGroupReport.Valid = Valid;
+    class WorkspaceMismatch extends Data.TaggedClass('WorkspaceMismatch') {
+    }
+    VersionGroupReport.WorkspaceMismatch = WorkspaceMismatch;
+})(VersionGroupReport || (exports.VersionGroupReport = VersionGroupReport = {}));
+class VersionGroupConfigError extends Data.TaggedClass('VersionGroupConfigError') {
+}
+exports.VersionGroupConfigError = VersionGroupConfigError;
 function getVersionGroups(ctx) {
-    const enabledTypes = (0, get_enabled_types_1.getEnabledTypes)(ctx.config);
-    const versionGroups = createVersionGroups(ctx);
-    ctx.packageJsonFiles.forEach((file) => {
-        file.getInstances(enabledTypes).forEach((instance) => {
-            const { name, pkgName } = instance;
-            for (const group of versionGroups) {
-                const { dependencies, dependencyTypes, packages } = group.config;
-                if (group.canAdd(instance) &&
-                    (!(0, is_non_empty_array_1.isNonEmptyArray)(dependencyTypes) ||
-                        dependencyTypes.includes(instance.strategy.name)) &&
-                    (!(0, is_non_empty_array_1.isNonEmptyArray)(packages) ||
-                        packages.some((pattern) => (0, minimatch_1.minimatch)(instance.pkgName, pattern))) &&
-                    (!(0, is_non_empty_array_1.isNonEmptyArray)(dependencies) ||
-                        dependencies.some((pattern) => (0, minimatch_1.minimatch)(instance.name, pattern)))) {
-                    group.instances.push(instance);
-                    return;
+    return (0, Function_1.pipe)(Effect.Do(), Effect.bind('enabledTypes', () => (0, get_enabled_types_1.getEnabledTypes)(ctx.config)), Effect.bind('versionGroups', () => createVersionGroups(ctx)), Effect.flatMap(({ enabledTypes, versionGroups }) => {
+        for (const file of ctx.packageJsonFiles) {
+            instances: for (const instance of file.getInstances(enabledTypes)) {
+                for (const group of versionGroups) {
+                    if ((0, can_add_to_group_1.canAddToGroup)(group, instance)) {
+                        group.instances.push(instance);
+                        continue instances;
+                    }
                 }
             }
-            throw new Error(`${name} in ${pkgName} did not match any version groups`);
-        });
-    });
-    return versionGroups.filter((group) => (0, is_non_empty_array_1.isNonEmptyArray)(group.instances));
+        }
+        return Effect.succeed(versionGroups.filter((group) => (0, is_non_empty_array_1.isNonEmptyArray)(group.instances.sort(sort_by_name_1.sortByName))));
+    }));
 }
 exports.getVersionGroups = getVersionGroups;
 function createVersionGroups(ctx) {
     const { rcFile } = ctx.config;
-    const versionGroups = [new filtered_out_1.FilteredOutVersionGroup(ctx)];
+    const versionGroups = [
+        Effect.succeed(new filtered_out_1.FilteredOutVersionGroup(ctx)),
+    ];
     if ((0, is_non_empty_array_1.isNonEmptyArray)(rcFile.versionGroups)) {
-        const ERR_OBJ = new Error('Invalid versionGroup');
-        const ERR_DEPS = new Error('Invalid versionGroup dependencies');
-        const ERR_PKGS = new Error('Invalid versionGroup packages');
         rcFile.versionGroups.forEach((config) => {
-            if (!(0, is_object_1.isObject)(config))
-                throw ERR_OBJ;
-            if (!(0, is_array_of_strings_1.isArrayOfStrings)(config.dependencies))
-                throw ERR_DEPS;
-            if (!(0, is_array_of_strings_1.isArrayOfStrings)(config.packages))
-                throw ERR_PKGS;
+            if (!(0, is_object_1.isObject)(config)) {
+                return versionGroups.push(Effect.fail(new VersionGroupConfigError({
+                    config,
+                    error: 'config is not an object',
+                })));
+            }
+            if (!(0, is_array_of_strings_1.isArrayOfStrings)(config.dependencies)) {
+                return versionGroups.push(Effect.fail(new VersionGroupConfigError({
+                    config,
+                    error: 'config.dependencies is not an array of strings',
+                })));
+            }
+            if (!(0, is_array_of_strings_1.isArrayOfStrings)(config.packages)) {
+                return versionGroups.push(Effect.fail(new VersionGroupConfigError({
+                    config,
+                    error: 'config.packages is not an array of strings',
+                })));
+            }
+            const mutuallyExclusiveProps = ['isBanned', 'isIgnored', 'pinVersion', 'snapTo', 'policy'].filter((prop) => Boolean(config[prop]));
+            if (mutuallyExclusiveProps.length > 1) {
+                return versionGroups.push(Effect.fail(new VersionGroupConfigError({
+                    config,
+                    error: `it's unclear what kind of version group you want, as it contains both ${mutuallyExclusiveProps.join(' and ')}`,
+                })));
+            }
             const { dependencies, packages } = config;
             const label = (0, is_non_empty_string_1.isNonEmptyString)(config.label) ? config.label : '';
             const dependencyTypes = (0, is_array_of_strings_1.isArrayOfStrings)(config.dependencyTypes)
                 ? config.dependencyTypes
                 : [];
             if (config.isBanned === true) {
-                versionGroups.push(new banned_1.BannedVersionGroup({
+                versionGroups.push(Effect.succeed(new banned_1.BannedVersionGroup({
                     dependencies,
                     dependencyTypes,
                     isBanned: true,
                     label,
                     packages,
-                }));
+                })));
             }
             else if (config.isIgnored === true) {
-                versionGroups.push(new ignored_1.IgnoredVersionGroup({
+                versionGroups.push(Effect.succeed(new ignored_1.IgnoredVersionGroup({
                     dependencies,
                     dependencyTypes,
                     isIgnored: true,
                     label,
                     packages,
-                }));
+                })));
             }
             else if ((0, is_non_empty_string_1.isNonEmptyString)(config.pinVersion)) {
-                versionGroups.push(new pinned_1.PinnedVersionGroup({
+                versionGroups.push(Effect.succeed(new pinned_1.PinnedVersionGroup({
                     dependencies,
                     dependencyTypes,
                     label,
                     packages,
                     pinVersion: config.pinVersion,
-                }));
+                })));
             }
             else if ((0, is_array_of_strings_1.isArrayOfStrings)(config.snapTo)) {
-                versionGroups.push(new snapped_to_1.SnappedToVersionGroup({
+                versionGroups.push(Effect.succeed(new snapped_to_1.SnappedToVersionGroup({
                     dependencies,
                     dependencyTypes,
                     label,
                     packages,
                     snapTo: config.snapTo,
-                }));
+                })));
             }
             else if (config.policy === 'sameRange') {
-                versionGroups.push(new same_range_1.SameRangeVersionGroup({
+                versionGroups.push(Effect.succeed(new same_range_1.SameRangeVersionGroup({
                     dependencies,
                     dependencyTypes,
                     label,
                     packages,
                     policy: config.policy,
-                }));
+                })));
             }
             else {
-                versionGroups.push(new standard_1.StandardVersionGroup({
+                versionGroups.push(Effect.succeed(new standard_1.StandardVersionGroup(false, {
                     dependencies,
                     dependencyTypes,
                     label,
                     packages,
-                    preferVersion: config.preferVersion === 'lowestSemver'
-                        ? 'lowestSemver'
-                        : 'highestSemver',
-                }));
+                    preferVersion: config.preferVersion === 'lowestSemver' ? 'lowestSemver' : 'highestSemver',
+                })));
             }
         });
     }
-    versionGroups.push(new catch_all_1.CatchAllVersionGroup({
+    versionGroups.push(Effect.succeed(new standard_1.StandardVersionGroup(true, {
         dependencies: ['**'],
         packages: ['**'],
         preferVersion: 'highestSemver',
-    }));
-    return versionGroups;
+    })));
+    return Effect.all(versionGroups);
 }

package/dist/get-version-groups/lib/get-highest-version.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHighestVersion = void 0;
-const pipe_1 = require("tightrope/fn/pipe");
+const Function_1 = require("@effect/data/Function");
 const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
 const filter_1 = require("tightrope/result/filter");
 const from_try_1 = require("tightrope/result/from-try");
 const map_1 = require("tightrope/result/map");
 const sort_1 = require("./sort");
 function getHighestVersion(versions) {
-    return (0, pipe_1.pipe)((0, from_try_1.fromTry)(() => [...versions].sort(sort_1.compareSemver)), (0, map_1.map)((sorted) => sorted[sorted.length - 1]), (0, filter_1.filter)(is_non_empty_string_1.isNonEmptyString, 'getHighestVersion(): did not return a version'));
+    return (0, Function_1.pipe)((0, from_try_1.fromTry)(() => [...versions].sort(sort_1.compareSemver)), (0, map_1.map)((sorted) => sorted[sorted.length - 1]), (0, filter_1.filter)(is_non_empty_string_1.isNonEmptyString, 'getHighestVersion(): did not return a version'));
 }
 exports.getHighestVersion = getHighestVersion;

package/dist/get-version-groups/lib/get-lowest-version.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLowestVersion = void 0;
-const pipe_1 = require("tightrope/fn/pipe");
+const Function_1 = require("@effect/data/Function");
 const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
 const filter_1 = require("tightrope/result/filter");
 const from_try_1 = require("tightrope/result/from-try");
 const map_1 = require("tightrope/result/map");
 const sort_1 = require("./sort");
 function getLowestVersion(versions) {
-    return (0, pipe_1.pipe)((0, from_try_1.fromTry)(() => [...versions].sort(sort_1.compareSemver)), (0, map_1.map)(([lowest]) => lowest), (0, filter_1.filter)(is_non_empty_string_1.isNonEmptyString, 'getLowestVersion(): did not return a version'));
+    return (0, Function_1.pipe)((0, from_try_1.fromTry)(() => [...versions].sort(sort_1.compareSemver)), (0, map_1.map)(([lowest]) => lowest), (0, filter_1.filter)(is_non_empty_string_1.isNonEmptyString, 'getLowestVersion(): did not return a version'));
 }
 exports.getLowestVersion = getLowestVersion;

package/dist/get-version-groups/lib/get-range-score.js

@@ -16,9 +16,7 @@ const scoresByRange = {
 };
 /** Rank a Semver Range according to its greediness */
 function getRangeScore(version) {
-    const range = version.indexOf('.x') !== -1
-        ? constants_1.RANGE.LOOSE
-        : version.slice(0, version.search(/[0-9]/));
+    const range = version.indexOf('.x') !== -1 ? constants_1.RANGE.LOOSE : version.slice(0, version.search(/[0-9]/));
     return scoresByRange[range] || 0;
 }
 exports.getRangeScore = getRangeScore;

package/dist/get-version-groups/lib/sort.js

@@ -6,16 +6,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.compareSemver = void 0;
 const gt_1 = __importDefault(require("semver/functions/gt"));
 const lt_1 = __importDefault(require("semver/functions/lt"));
-const is_semver_1 = require("../../lib/is-semver");
+const is_supported_1 = require("../../guards/is-supported");
 const clean_1 = require("./clean");
 const get_range_score_1 = require("./get-range-score");
 const EQ = 0;
 const LT = -1;
 const GT = 1;
 function compareSemver(a, b) {
-    if (!(0, is_semver_1.isSupported)(a))
+    if (!(0, is_supported_1.isSupported)(a))
         throw new Error(`"${a}" is not supported`);
-    if (!(0, is_semver_1.isSupported)(b))
+    if (!(0, is_supported_1.isSupported)(b))
         throw new Error(`"${b}" is not supported`);
     if (a.startsWith('workspace:'))
         return LT;

package/dist/get-version-groups/pinned.d.ts

@@ -1,11 +1,17 @@
-import type { VersionGroupReport } from '.';
+import * as Data from '@effect/data/Data';
+import * as Effect from '@effect/io/Effect';
+import { VersionGroupReport } from '.';
 import type { VersionGroupConfig } from '../config/types';
 import type { Instance } from '../get-package-json-files/instance';
-export declare class PinnedVersionGroup {
-    _tag: string;
+declare const PinnedVersionGroup_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "Pinned";
+}>;
+export declare class PinnedVersionGroup extends PinnedVersionGroup_base<{
     config: VersionGroupConfig.Pinned;
     instances: Instance[];
+}> {
     constructor(config: VersionGroupConfig.Pinned);
     canAdd(_: Instance): boolean;
-    inspect(): VersionGroupReport[];
+    inspect(): Effect.Effect<never, VersionGroupReport.PinnedMismatch, VersionGroupReport.Valid>[];
 }
+export {};

package/dist/get-version-groups/pinned.js

@@ -1,40 +1,63 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PinnedVersionGroup = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Effect = __importStar(require("@effect/io/Effect"));
+const _1 = require(".");
 const group_by_1 = require("./lib/group-by");
-class PinnedVersionGroup {
+class PinnedVersionGroup extends Data.TaggedClass('Pinned') {
     constructor(config) {
-        this._tag = 'Pinned';
-        this.config = config;
-        this.instances = [];
+        super({
+            config,
+            instances: [],
+        });
     }
     canAdd(_) {
         return true;
     }
     inspect() {
-        const report = [];
         const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
         const expectedVersion = this.config.pinVersion;
-        Object.entries(instancesByName).forEach(([name, instances]) => {
+        return Object.entries(instancesByName).map(([name, instances]) => {
             if (hasMismatch(expectedVersion, instances)) {
-                report.push({
-                    expectedVersion,
+                return Effect.fail(new _1.VersionGroupReport.PinnedMismatch({
+                    name,
                     instances,
                     isValid: false,
-                    name,
-                    status: 'PINNED_MISMATCH',
-                });
+                    expectedVersion,
+                }));
             }
             else {
-                report.push({
+                return Effect.succeed(new _1.VersionGroupReport.Valid({
+                    name,
                     instances,
                     isValid: true,
-                    name,
-                    status: 'VALID',
-                });
+                }));
             }
         });
-        return report;
     }
 }
 exports.PinnedVersionGroup = PinnedVersionGroup;

package/dist/get-version-groups/same-range.d.ts

@@ -1,11 +1,17 @@
-import type { VersionGroupReport } from '.';
+import * as Data from '@effect/data/Data';
+import * as Effect from '@effect/io/Effect';
+import { VersionGroupReport } from '.';
 import type { VersionGroupConfig } from '../config/types';
 import type { Instance } from '../get-package-json-files/instance';
-export declare class SameRangeVersionGroup {
-    _tag: string;
+declare const SameRangeVersionGroup_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "SameRange";
+}>;
+export declare class SameRangeVersionGroup extends SameRangeVersionGroup_base<{
     config: VersionGroupConfig.SameRange;
     instances: Instance[];
+}> {
     constructor(config: VersionGroupConfig.SameRange);
     canAdd(_: Instance): boolean;
-    inspect(): VersionGroupReport[];
+    inspect(): Effect.Effect<never, VersionGroupReport.SameRangeMismatch, VersionGroupReport.Valid>[];
 }
+export {};

package/dist/get-version-groups/same-range.js

@@ -1,42 +1,65 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SameRangeVersionGroup = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Effect = __importStar(require("@effect/io/Effect"));
 const intersects_1 = __importDefault(require("semver/ranges/intersects"));
+const _1 = require(".");
 const group_by_1 = require("./lib/group-by");
-class SameRangeVersionGroup {
+class SameRangeVersionGroup extends Data.TaggedClass('SameRange') {
     constructor(config) {
-        this._tag = 'SameRange';
-        this.config = config;
-        this.instances = [];
+        super({
+            config,
+            instances: [],
+        });
     }
     canAdd(_) {
         return true;
     }
     inspect() {
-        const report = [];
         const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
-        Object.entries(instancesByName).forEach(([name, instances]) => {
+        return Object.entries(instancesByName).map(([name, instances]) => {
             if (hasMismatch(instances)) {
-                report.push({
+                return Effect.fail(new _1.VersionGroupReport.SameRangeMismatch({
+                    name,
                     instances,
                     isValid: false,
-                    name,
-                    status: 'SAME_RANGE_MISMATCH',
-                });
+                }));
             }
             else {
-                report.push({
+                return Effect.succeed(new _1.VersionGroupReport.Valid({
+                    name,
                     instances,
                     isValid: true,
-                    name,
-                    status: 'VALID',
-                });
+                }));
             }
         });
-        return report;
     }
 }
 exports.SameRangeVersionGroup = SameRangeVersionGroup;

package/dist/get-version-groups/snapped-to.d.ts

@@ -1,11 +1,17 @@
-import type { VersionGroupReport } from '.';
+import * as Data from '@effect/data/Data';
+import * as Effect from '@effect/io/Effect';
+import { VersionGroupReport } from '.';
 import type { VersionGroupConfig } from '../config/types';
 import type { Instance } from '../get-package-json-files/instance';
-export declare class SnappedToVersionGroup {
-    _tag: string;
+declare const SnappedToVersionGroup_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "SnappedTo";
+}>;
+export declare class SnappedToVersionGroup extends SnappedToVersionGroup_base<{
     config: VersionGroupConfig.SnappedTo;
     instances: Instance[];
+}> {
     constructor(config: VersionGroupConfig.SnappedTo);
     canAdd(_: Instance): boolean;
-    inspect(): VersionGroupReport[];
+    inspect(): Effect.Effect<never, VersionGroupReport.SnappedToMismatch, VersionGroupReport.Valid>[];
 }
+export {};

package/dist/get-version-groups/snapped-to.js

@@ -1,41 +1,65 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SnappedToVersionGroup = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Effect = __importStar(require("@effect/io/Effect"));
+const _1 = require(".");
 const group_by_1 = require("./lib/group-by");
-class SnappedToVersionGroup {
+class SnappedToVersionGroup extends Data.TaggedClass('SnappedTo') {
     constructor(config) {
-        this._tag = 'SnappedTo';
-        this.config = config;
-        this.instances = [];
+        super({
+            config,
+            instances: [],
+        });
     }
     canAdd(_) {
         return true;
     }
     inspect() {
-        const report = [];
         const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
-        Object.entries(instancesByName).forEach(([name, instances]) => {
+        return Object.entries(instancesByName).map(([name, instances]) => {
             const snapTo = this.config.snapTo;
             const expectedVersion = getExpectedVersion(snapTo, instances);
             if (hasMismatch(expectedVersion, instances)) {
-                report.push({
-                    expectedVersion,
+                return Effect.fail(new _1.VersionGroupReport.SnappedToMismatch({
+                    name,
                     instances,
                     isValid: false,
-                    name,
-                    status: 'SNAPPED_TO_MISMATCH',
-                });
+                    expectedVersion,
+                    snapTo,
+                }));
             }
             else {
-                report.push({
+                return Effect.succeed(new _1.VersionGroupReport.Valid({
+                    name,
                     instances,
                     isValid: true,
-                    name,
-                    status: 'VALID',
-                });
+                }));
             }
         });
-        return report;
     }
 }
 exports.SnappedToVersionGroup = SnappedToVersionGroup;
@@ -45,6 +69,7 @@ function getExpectedVersion(snapTo, instances) {
         .find((i) => i.version)?.version;
     if (expectedVersion)
         return expectedVersion;
+    // @FIXME: create tagged error for this
     throw new Error('versionGroup.snapTo does not match any package versions');
 }
 function hasMismatch(expectedVersion, instances) {