syncpack 10.5.1 → 10.6.1

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

@@ -1,55 +1,139 @@
-import type { Context } from '../get-context';
+import * as Data from '@effect/data/Data';
+import * as Effect from '@effect/io/Effect';
+import type { Union } from 'ts-toolbelt';
+import type { DeprecatedTypesError } from '../config/get-enabled-types';
+import type { Ctx } from '../get-context';
 import type { Instance } from '../get-package-json-files/instance';
 import { BannedVersionGroup } from './banned';
-import { CatchAllVersionGroup } from './catch-all';
 import { FilteredOutVersionGroup } from './filtered-out';
 import { IgnoredVersionGroup } from './ignored';
 import { PinnedVersionGroup } from './pinned';
 import { SameRangeVersionGroup } from './same-range';
 import { SnappedToVersionGroup } from './snapped-to';
 import { StandardVersionGroup } from './standard';
-export type AnyVersionGroup = BannedVersionGroup | CatchAllVersionGroup | FilteredOutVersionGroup | IgnoredVersionGroup | PinnedVersionGroup | SameRangeVersionGroup | SnappedToVersionGroup | StandardVersionGroup;
-export type VersionGroupReport = {
-    name: string;
-    instances: Instance[];
-} & ({
-    status: 'BANNED';
-    isValid: false;
-} | {
-    status: 'FILTERED_OUT';
-    isValid: true;
-} | {
-    status: 'HIGHEST_SEMVER_MISMATCH';
-    isValid: false;
-    expectedVersion: string;
-} | {
-    status: 'IGNORED';
-    isValid: true;
-} | {
-    status: 'LOWEST_SEMVER_MISMATCH';
-    isValid: false;
-    expectedVersion: string;
-} | {
-    status: 'PINNED_MISMATCH';
-    isValid: false;
-    expectedVersion: string;
-} | {
-    status: 'SAME_RANGE_MISMATCH';
-    isValid: false;
-} | {
-    status: 'SNAPPED_TO_MISMATCH';
-    isValid: false;
-    expectedVersion: string;
-} | {
-    status: 'UNSUPPORTED_MISMATCH';
-    isValid: false;
-} | {
-    status: 'VALID';
-    isValid: true;
-} | {
-    status: 'WORKSPACE_MISMATCH';
-    isValid: false;
-    expectedVersion: string;
-    workspaceInstance: Instance;
-});
-export declare function getVersionGroups(ctx: Context): AnyVersionGroup[];
+export type AnyVersionGroup = Union.Strict<BannedVersionGroup | FilteredOutVersionGroup | IgnoredVersionGroup | PinnedVersionGroup | SameRangeVersionGroup | SnappedToVersionGroup | StandardVersionGroup>;
+export declare namespace VersionGroupReport {
+    const Banned_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: "Banned";
+    }>;
+    export class Banned extends Banned_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+    }> {
+    }
+    const FilteredOut_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: "FilteredOut";
+    }>;
+    export class FilteredOut extends FilteredOut_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: true;
+    }> {
+    }
+    const HighestSemverMismatch_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: "HighestSemverMismatch";
+    }>;
+    export class HighestSemverMismatch extends HighestSemverMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+        readonly expectedVersion: string;
+    }> {
+    }
+    const Ignored_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: "Ignored";
+    }>;
+    export class Ignored extends Ignored_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: true;
+    }> {
+    }
+    const LowestSemverMismatch_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: "LowestSemverMismatch";
+    }>;
+    export class LowestSemverMismatch extends LowestSemverMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+        readonly expectedVersion: string;
+    }> {
+    }
+    const PinnedMismatch_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: "PinnedMismatch";
+    }>;
+    export class PinnedMismatch extends PinnedMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+        readonly expectedVersion: string;
+    }> {
+    }
+    const SameRangeMismatch_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: "SameRangeMismatch";
+    }>;
+    export class SameRangeMismatch extends SameRangeMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+    }> {
+    }
+    const SnappedToMismatch_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: "SnappedToMismatch";
+    }>;
+    export class SnappedToMismatch extends SnappedToMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+        readonly expectedVersion: string;
+        readonly snapTo: string[];
+    }> {
+    }
+    const UnsupportedMismatch_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: "UnsupportedMismatch";
+    }>;
+    export class UnsupportedMismatch extends UnsupportedMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+    }> {
+    }
+    const Valid_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: "Valid";
+    }>;
+    export class Valid extends Valid_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: true;
+    }> {
+    }
+    const WorkspaceMismatch_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: "WorkspaceMismatch";
+    }>;
+    export class WorkspaceMismatch extends WorkspaceMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+        readonly expectedVersion: string;
+        readonly workspaceInstance: Instance;
+    }> {
+    }
+    export type ValidCases = Union.Strict<FilteredOut | Ignored | Valid>;
+    export type InvalidCases = Union.Strict<Banned | HighestSemverMismatch | LowestSemverMismatch | PinnedMismatch | SameRangeMismatch | SnappedToMismatch | UnsupportedMismatch | WorkspaceMismatch>;
+    export type FixableCases = Union.Strict<HighestSemverMismatch | LowestSemverMismatch | PinnedMismatch | SnappedToMismatch | WorkspaceMismatch>;
+    export type UnfixableCases = Union.Strict<SameRangeMismatch | UnsupportedMismatch | WorkspaceMismatch>;
+    export type HighLowSemverMismatch = VersionGroupReport.HighestSemverMismatch | VersionGroupReport.LowestSemverMismatch;
+    export type Any = Union.Strict<ValidCases | InvalidCases>;
+    export {};
+}
+declare const VersionGroupConfigError_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: "VersionGroupConfigError";
+}>;
+export declare class VersionGroupConfigError extends VersionGroupConfigError_base<{
+    readonly config: unknown;
+    readonly error: string;
+}> {
+}
+export declare function getVersionGroups(ctx: Ctx): Effect.Effect<never, VersionGroupConfigError | DeprecatedTypesError, AnyVersionGroup[]>;
+export {};

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 {};