syncpack 10.9.3 → 12.0.0-alpha.0

package/dist/strategy/unnamed-version-string.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnnamedVersionStringStrategy = void 0;
-const Function_1 = require("@effect/data/Function");
-const get_1 = require("tightrope/fn/get");
-const from_try_1 = require("tightrope/result/from-try");
-const map_1 = require("tightrope/result/map");
-const tap_1 = require("tightrope/result/tap");
-const delete_1 = require("../get-version-groups/lib/delete");
+const effect_1 = require("effect");
+const is_non_empty_object_1 = require("tightrope/guard/is-non-empty-object");
+const get_1 = require("../lib/get");
+const delete_1 = require("../version-group/lib/delete");
 const get_non_empty_string_prop_1 = require("./lib/get-non-empty-string-prop");
+const getOptionOfNonEmptyObject = effect_1.Option.liftPredicate((is_non_empty_object_1.isNonEmptyObject));
 class UnnamedVersionStringStrategy {
     constructor(name, path) {
         this._tag = 'version';
@@ -15,33 +14,33 @@ class UnnamedVersionStringStrategy {
         this.path = path;
     }
     read(file) {
-        const path = this.path;
-        return (0, Function_1.pipe)(
+        return (0, effect_1.pipe)(
         // get version prop
-        (0, get_non_empty_string_prop_1.getNonEmptyStringProp)(path, file), 
+        (0, get_non_empty_string_prop_1.getNonEmptyStringProp)(this.path, file), 
         // if it is a non empty string, we can read it
-        (0, map_1.map)((version) => {
-            const name = path.split('.').slice(-1).join('');
+        effect_1.Effect.map((version) => {
+            const name = this.path.split('.').slice(-1).join('');
             return [[name, version]];
-        }));
+        }), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`UnnamedVersionStringStrategy#${this.name} found nothing at <${file.jsonFile.shortPath}>.${this.path}`)), 
+        // if value is invalid, default to empty
+        effect_1.Effect.catchAll(() => effect_1.Effect.succeed([])));
     }
     write(file, [, version]) {
-        const path = this.path;
-        const { contents } = file;
-        const isNestedPath = path.includes('.');
+        const { contents } = file.jsonFile;
+        const isNestedPath = this.path.includes('.');
         const nextValue = version === delete_1.DELETE ? undefined : version;
         if (isNestedPath) {
-            const fullPath = path.split('.');
+            const fullPath = this.path.split('.');
             const pathToParent = fullPath.slice(0, fullPath.length - 1).join('.');
             const key = fullPath.slice(-1).join('');
-            return (0, Function_1.pipe)((0, get_1.get)(contents, ...pathToParent.split('.')), (0, tap_1.tap)((parent) => {
+            return (0, effect_1.pipe)((0, get_1.get)(contents, ...pathToParent.split('.')), effect_1.Effect.flatMap(getOptionOfNonEmptyObject), effect_1.Effect.flatMap((parent) => effect_1.Effect.try(() => {
                 parent[key] = nextValue;
-            }), (0, map_1.map)(() => file));
+            })), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), effect_1.Effect.catchAll(() => effect_1.Effect.succeed(file)), effect_1.Effect.map(() => file));
         }
         else {
-            return (0, Function_1.pipe)((0, from_try_1.fromTry)(() => {
-                contents[path] = nextValue;
-            }), (0, map_1.map)(() => file));
+            return (0, effect_1.pipe)(getOptionOfNonEmptyObject(contents), effect_1.Effect.flatMap((parent) => effect_1.Effect.try(() => {
+                parent[this.path] = nextValue;
+            })), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), effect_1.Effect.catchAll(() => effect_1.Effect.succeed(file)), effect_1.Effect.map(() => file));
         }
     }
 }

package/dist/strategy/versions-by-name.d.ts

@@ -1,11 +1,11 @@
-import type { Result } from 'tightrope/result';
+import { Effect } from 'effect';
 import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
-import type { Delete } from '../get-version-groups/lib/delete';
+import type { Delete } from '../version-group/lib/delete';
 export declare class VersionsByNameStrategy {
     _tag: string;
     name: string;
     path: string;
     constructor(name: string, path: string);
-    read(file: PackageJsonFile): Result<[string, string][]>;
-    write(file: PackageJsonFile, [name, version]: [string, string | Delete]): Result<PackageJsonFile>;
+    read(file: PackageJsonFile): Effect.Effect<never, never, [string, string][]>;
+    write(file: PackageJsonFile, [name, version]: [string, string | Delete]): Effect.Effect<never, never, PackageJsonFile>;
 }

package/dist/strategy/versions-by-name.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VersionsByNameStrategy = void 0;
-const Function_1 = require("@effect/data/Function");
-const get_1 = require("tightrope/fn/get");
+const effect_1 = require("effect");
 const is_non_empty_object_1 = require("tightrope/guard/is-non-empty-object");
-const filter_1 = require("tightrope/result/filter");
-const map_1 = require("tightrope/result/map");
-const tap_1 = require("tightrope/result/tap");
-const delete_1 = require("../get-version-groups/lib/delete");
+const get_1 = require("../lib/get");
+const delete_1 = require("../version-group/lib/delete");
+const getOptionOfNonEmptyObject = effect_1.Option.liftPredicate((is_non_empty_object_1.isNonEmptyObject));
 class VersionsByNameStrategy {
     constructor(name, path) {
         this._tag = 'versionsByName';
@@ -15,15 +13,15 @@ class VersionsByNameStrategy {
         this.path = path;
     }
     read(file) {
-        const path = this.path;
-        return (0, Function_1.pipe)((0, get_1.get)(file.contents, ...path.split('.')), (0, filter_1.filter)((is_non_empty_object_1.isNonEmptyObject), ''), (0, map_1.map)((Object.entries)));
+        return (0, effect_1.pipe)((0, get_1.get)(file.jsonFile.contents, ...this.path.split('.')), effect_1.Effect.flatMap((value) => getOptionOfNonEmptyObject(value)), effect_1.Effect.map((obj) => Object.entries(obj)), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`VersionsByNameStrategy#${this.name} found nothing at <${file.jsonFile.shortPath}>.${this.path}`)), 
+        // if value is invalid, default to empty
+        effect_1.Effect.catchAll(() => effect_1.Effect.succeed([])));
     }
     write(file, [name, version]) {
-        const path = this.path;
         const nextValue = version === delete_1.DELETE ? undefined : version;
-        return (0, Function_1.pipe)((0, get_1.get)(file.contents, ...path.split('.')), (0, tap_1.tap)((parent) => {
+        return (0, effect_1.pipe)((0, get_1.get)(file.jsonFile.contents, ...this.path.split('.')), effect_1.Effect.flatMap(getOptionOfNonEmptyObject), effect_1.Effect.flatMap((parent) => effect_1.Effect.try(() => {
             parent[name] = nextValue;
-        }), (0, map_1.map)(() => file));
+        })), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}.${name}`)), effect_1.Effect.catchAll(() => effect_1.Effect.succeed(file)), effect_1.Effect.map(() => file));
     }
 }
 exports.VersionsByNameStrategy = VersionsByNameStrategy;

package/dist/version-group/banned.d.ts

@@ -0,0 +1,17 @@
+import { Data, Effect } from 'effect';
+import type { VersionGroupConfig } from '../config/types';
+import type { Instance } from '../get-instances/instance';
+import { Report } from '../report';
+declare const BannedVersionGroup_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "Banned";
+}>;
+export declare class BannedVersionGroup extends BannedVersionGroup_base<{
+    config: VersionGroupConfig.Banned;
+    instances: Instance[];
+}> {
+    groupType: string;
+    constructor(config: VersionGroupConfig.Banned);
+    canAdd(_: Instance): boolean;
+    inspectAll(): Effect.Effect<never, never, Report.Version.Group[]>;
+}
+export {};

package/dist/version-group/banned.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BannedVersionGroup = void 0;
+const effect_1 = require("effect");
+const report_1 = require("../report");
+const specifier_1 = require("../specifier");
+const delete_1 = require("./lib/delete");
+const group_by_1 = require("./lib/group-by");
+class BannedVersionGroup extends effect_1.Data.TaggedClass('Banned') {
+    constructor(config) {
+        super({
+            config,
+            instances: [],
+        });
+        this.groupType = 'versionGroup';
+    }
+    canAdd(_) {
+        return true;
+    }
+    inspectAll() {
+        return effect_1.Effect.succeed(Object.entries((0, group_by_1.groupBy)('name', this.instances)).map(([name, instances]) => ({
+            name,
+            reports: instances.map((instance) => 
+            // ✘ package should not be used
+            // ✓ is a mismatch we can auto-fix
+            new report_1.Report.Banned({
+                fixable: specifier_1.Specifier.create(instance, delete_1.DELETE),
+            })),
+        })));
+    }
+}
+exports.BannedVersionGroup = BannedVersionGroup;

package/dist/version-group/create-version-groups.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from 'effect';
+import { VersionGroup } from '.';
+import type { Ctx } from '../get-context';
+export declare function createVersionGroups(ctx: Ctx): Effect.Effect<never, VersionGroup.ConfigError, VersionGroup.Any[]>;

package/dist/version-group/create-version-groups.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVersionGroups = void 0;
+const effect_1 = require("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 _1 = require(".");
+const banned_1 = require("./banned");
+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");
+function createVersionGroups(ctx) {
+    const { rcFile } = ctx.config;
+    const versionGroups = [
+        effect_1.Effect.succeed(new filtered_out_1.FilteredOutVersionGroup(ctx)),
+    ];
+    if ((0, is_non_empty_array_1.isNonEmptyArray)(rcFile.versionGroups)) {
+        rcFile.versionGroups.forEach((config) => {
+            if (!(0, is_object_1.isObject)(config)) {
+                return versionGroups.push(effect_1.Effect.fail(new _1.VersionGroup.ConfigError({
+                    config,
+                    error: 'config is not an object',
+                })));
+            }
+            const mutuallyExclusiveProps = ['isBanned', 'isIgnored', 'pinVersion', 'snapTo', 'policy'].filter((prop) => Boolean(config[prop]));
+            if (mutuallyExclusiveProps.length > 1) {
+                return versionGroups.push(effect_1.Effect.fail(new _1.VersionGroup.ConfigError({
+                    config,
+                    error: `it's unclear what kind of version group you want, as it contains both ${mutuallyExclusiveProps.join(' and ')}`,
+                })));
+            }
+            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
+                : ['**'];
+            const dependencies = (0, is_array_of_strings_1.isArrayOfStrings)(config.dependencies) ? config.dependencies : ['**'];
+            const packages = (0, is_array_of_strings_1.isArrayOfStrings)(config.packages) ? config.packages : ['**'];
+            if (config.isBanned === true) {
+                versionGroups.push(effect_1.Effect.succeed(new banned_1.BannedVersionGroup({
+                    dependencies,
+                    dependencyTypes,
+                    isBanned: true,
+                    label,
+                    packages,
+                })));
+            }
+            else if (config.isIgnored === true) {
+                versionGroups.push(effect_1.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(effect_1.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(effect_1.Effect.succeed(new snapped_to_1.SnappedToVersionGroup({
+                    dependencies,
+                    dependencyTypes,
+                    label,
+                    packages,
+                    snapTo: config.snapTo,
+                })));
+            }
+            else if (config.policy === 'sameRange') {
+                versionGroups.push(effect_1.Effect.succeed(new same_range_1.SameRangeVersionGroup(ctx, {
+                    dependencies,
+                    dependencyTypes,
+                    label,
+                    packages,
+                    policy: config.policy,
+                })));
+            }
+            else {
+                versionGroups.push(effect_1.Effect.succeed(new standard_1.StandardVersionGroup(false, {
+                    dependencies,
+                    dependencyTypes,
+                    label,
+                    packages,
+                    preferVersion: config.preferVersion === 'lowestSemver' ? 'lowestSemver' : 'highestSemver',
+                })));
+            }
+        });
+    }
+    versionGroups.push(effect_1.Effect.succeed(new standard_1.StandardVersionGroup(true, {
+        dependencies: ['**'],
+        label: 'Default Version Group',
+        packages: ['**'],
+        preferVersion: 'highestSemver',
+    })));
+    return effect_1.Effect.all(versionGroups);
+}
+exports.createVersionGroups = createVersionGroups;

package/dist/version-group/filtered-out.d.ts

@@ -0,0 +1,19 @@
+import { Data, Effect } from 'effect';
+import type { GroupConfig } from '../config/types';
+import type { Ctx } from '../get-context';
+import type { Instance } from '../get-instances/instance';
+import { Report } from '../report';
+declare const FilteredOutVersionGroup_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "FilteredOut";
+}>;
+export declare class FilteredOutVersionGroup extends FilteredOutVersionGroup_base<{
+    config: GroupConfig;
+    filter: string;
+    instances: Instance[];
+}> {
+    groupType: string;
+    constructor(ctx: Ctx);
+    canAdd(instance: Instance): boolean;
+    inspectAll(): Effect.Effect<never, never, Report.Version.Group[]>;
+}
+export {};

package/dist/version-group/filtered-out.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilteredOutVersionGroup = void 0;
+const effect_1 = require("effect");
+const get_filter_1 = require("../config/get-filter");
+const report_1 = require("../report");
+const group_by_1 = require("./lib/group-by");
+class FilteredOutVersionGroup extends effect_1.Data.TaggedClass('FilteredOut') {
+    constructor(ctx) {
+        super({
+            config: {
+                dependencies: ['**'],
+                dependencyTypes: ['**'],
+                label: 'Filtered out',
+                packages: ['**'],
+            },
+            filter: (0, get_filter_1.getFilter)(ctx.config),
+            instances: [],
+        });
+        this.groupType = 'versionGroup';
+    }
+    canAdd(instance) {
+        return instance.name.search(new RegExp(this.filter)) === -1;
+    }
+    inspectAll() {
+        return effect_1.Effect.succeed(Object.entries((0, group_by_1.groupBy)('name', this.instances)).map(([name, instances]) => ({
+            name,
+            reports: instances.map((instance) => 
+            // ✓ is ignored and dismissed as valid
+            new report_1.Report.FilteredOut({ instance })),
+        })));
+    }
+}
+exports.FilteredOutVersionGroup = FilteredOutVersionGroup;

package/dist/version-group/ignored.d.ts

@@ -0,0 +1,17 @@
+import { Data, Effect } from 'effect';
+import type { VersionGroupConfig } from '../config/types';
+import type { Instance } from '../get-instances/instance';
+import { Report } from '../report';
+declare const IgnoredVersionGroup_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "Ignored";
+}>;
+export declare class IgnoredVersionGroup extends IgnoredVersionGroup_base<{
+    config: VersionGroupConfig.Ignored;
+    instances: Instance[];
+}> {
+    groupType: string;
+    constructor(config: VersionGroupConfig.Ignored);
+    canAdd(_: Instance): boolean;
+    inspectAll(): Effect.Effect<never, never, Report.Version.Group[]>;
+}
+export {};

package/dist/version-group/ignored.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IgnoredVersionGroup = void 0;
+const effect_1 = require("effect");
+const report_1 = require("../report");
+const group_by_1 = require("./lib/group-by");
+class IgnoredVersionGroup extends effect_1.Data.TaggedClass('Ignored') {
+    constructor(config) {
+        super({
+            config,
+            instances: [],
+        });
+        this.groupType = 'versionGroup';
+    }
+    canAdd(_) {
+        return true;
+    }
+    inspectAll() {
+        return effect_1.Effect.succeed(Object.entries((0, group_by_1.groupBy)('name', this.instances)).map(([name, instances]) => ({
+            name,
+            reports: instances.map((instance) => 
+            // ✓ is ignored and dismissed as valid
+            new report_1.Report.Ignored({ instance })),
+        })));
+    }
+}
+exports.IgnoredVersionGroup = IgnoredVersionGroup;

package/dist/version-group/index.d.ts

@@ -0,0 +1,28 @@
+import { Data } from 'effect';
+import type { Union } from 'ts-toolbelt';
+import type { BannedVersionGroup } from './banned';
+import type { FilteredOutVersionGroup } from './filtered-out';
+import type { IgnoredVersionGroup } from './ignored';
+import type { PinnedVersionGroup } from './pinned';
+import type { SameRangeVersionGroup } from './same-range';
+import type { SnappedToVersionGroup } from './snapped-to';
+import type { StandardVersionGroup } from './standard';
+export declare namespace VersionGroup {
+    export type Banned = BannedVersionGroup;
+    export type FilteredOut = FilteredOutVersionGroup;
+    export type Ignored = IgnoredVersionGroup;
+    export type Pinned = PinnedVersionGroup;
+    export type SameRange = SameRangeVersionGroup;
+    export type SnappedTo = SnappedToVersionGroup;
+    export type Standard = StandardVersionGroup;
+    export type Any = Union.Strict<Banned | FilteredOut | Ignored | Pinned | SameRange | SnappedTo | Standard>;
+    const ConfigError_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "VersionGroupConfigError";
+    }>;
+    export class ConfigError extends ConfigError_base<{
+        readonly config: unknown;
+        readonly error: string;
+    }> {
+    }
+    export {};
+}

package/dist/version-group/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionGroup = void 0;
+const effect_1 = require("effect");
+var VersionGroup;
+(function (VersionGroup) {
+    class ConfigError extends effect_1.Data.TaggedClass('VersionGroupConfigError') {
+    }
+    VersionGroup.ConfigError = ConfigError;
+})(VersionGroup || (exports.VersionGroup = VersionGroup = {}));

package/dist/version-group/lib/get-highest-version.d.ts

@@ -0,0 +1,6 @@
+import type { Specifier } from '../../specifier';
+/**
+ * From an array of instances where every instance contains a valid semver
+ * version, return the highest version number
+ */
+export declare function getHighestVersion(specifiers: Specifier.Any[]): import("effect/Effect").Effect<never, import("../../specifier/lib/non-semver-error").NonSemverError, Specifier.Any>;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHighestVersion = void 0;
+const get_preferred_version_1 = require("./get-preferred-version");
+/**
+ * From an array of instances where every instance contains a valid semver
+ * version, return the highest version number
+ */
+function getHighestVersion(specifiers) {
+    return (0, get_preferred_version_1.getPreferredVersion)('highestSemver', specifiers);
+}
+exports.getHighestVersion = getHighestVersion;

package/dist/version-group/lib/get-lowest-version.d.ts

@@ -0,0 +1,6 @@
+import type { Specifier } from '../../specifier';
+/**
+ * From an array of instances where every instance contains a valid semver
+ * version, return the lowest version number
+ */
+export declare function getLowestVersion(specifiers: Specifier.Any[]): import("effect/Effect").Effect<never, import("../../specifier/lib/non-semver-error").NonSemverError, Specifier.Any>;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLowestVersion = void 0;
+const get_preferred_version_1 = require("./get-preferred-version");
+/**
+ * From an array of instances where every instance contains a valid semver
+ * version, return the lowest version number
+ */
+function getLowestVersion(specifiers) {
+    return (0, get_preferred_version_1.getPreferredVersion)('lowestSemver', specifiers);
+}
+exports.getLowestVersion = getLowestVersion;

package/dist/version-group/lib/get-preferred-version.d.ts

@@ -0,0 +1,5 @@
+import { Effect } from 'effect';
+import type { VersionGroupConfig } from '../../config/types';
+import type { Specifier } from '../../specifier';
+import type { NonSemverError } from '../../specifier/lib/non-semver-error';
+export declare function getPreferredVersion(preferVersion: VersionGroupConfig.Standard['preferVersion'], specifiers: Specifier.Any[]): Effect.Effect<never, NonSemverError, Specifier.Any>;

package/dist/{get-version-groups/lib/compare-semver.js → version-group/lib/get-preferred-version.js}

@@ -3,11 +3,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareSemver = void 0;
+exports.getPreferredVersion = void 0;
+const effect_1 = require("effect");
 const gt_1 = __importDefault(require("semver/functions/gt"));
 const lt_1 = __importDefault(require("semver/functions/lt"));
 const clean_1 = require("./clean");
 const get_range_score_1 = require("./get-range-score");
+function getPreferredVersion(preferVersion, specifiers) {
+    return (0, effect_1.pipe)(
+    // every instance must have a semver version
+    effect_1.Effect.all(specifiers.map((specifier) => (0, effect_1.pipe)(specifier.getSemver(), effect_1.Effect.map((semver) => ({ semver, specifier }))))), 
+    // comparing semver can error on some loose ranges, all must succeed
+    effect_1.Effect.map((semvers) => semvers.sort((a, b) => compareSemver(a.semver, b.semver))), 
+    // get the preferred value from the list
+    effect_1.Effect.map((sorted) => sorted[preferVersion === 'lowestSemver' ? 0 : sorted.length - 1]), 
+    // return just the specifier
+    effect_1.Effect.map((preferred) => preferred?.specifier));
+}
+exports.getPreferredVersion = getPreferredVersion;
 const EQ = 0;
 const LT = -1;
 const GT = 1;
@@ -36,4 +49,3 @@ function compareSemver(a, b) {
         return GT;
     return EQ;
 }
-exports.compareSemver = compareSemver;

package/dist/version-group/lib/group-by.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert an array of objects to an object, where each property of the new
+ * object is an array whose members share the same value for the given key.
+ */
+export declare function groupBy<A extends any[]>(key: string, array: A): Record<string, A>;

package/dist/{get-version-groups → version-group}/lib/group-by.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.groupBy = void 0;
+/**
+ * Convert an array of objects to an object, where each property of the new
+ * object is an array whose members share the same value for the given key.
+ */
 function groupBy(key, array) {
     return array.reduce((objectsByKeyValue, obj) => {
         const value = obj[key];

package/dist/version-group/pinned.d.ts

@@ -0,0 +1,17 @@
+import { Data, Effect } from 'effect';
+import type { VersionGroupConfig } from '../config/types';
+import type { Instance } from '../get-instances/instance';
+import { Report } from '../report';
+declare const PinnedVersionGroup_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "Pinned";
+}>;
+export declare class PinnedVersionGroup extends PinnedVersionGroup_base<{
+    config: VersionGroupConfig.Pinned;
+    instances: Instance[];
+}> {
+    groupType: string;
+    constructor(config: VersionGroupConfig.Pinned);
+    canAdd(_: Instance): boolean;
+    inspectAll(): Effect.Effect<never, never, Report.Version.Group[]>;
+}
+export {};

package/dist/version-group/pinned.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinnedVersionGroup = void 0;
+const effect_1 = require("effect");
+const report_1 = require("../report");
+const specifier_1 = require("../specifier");
+const group_by_1 = require("./lib/group-by");
+class PinnedVersionGroup extends effect_1.Data.TaggedClass('Pinned') {
+    constructor(config) {
+        super({
+            config,
+            instances: [],
+        });
+        this.groupType = 'versionGroup';
+    }
+    canAdd(_) {
+        return true;
+    }
+    inspectAll() {
+        return effect_1.Effect.all(Object.entries((0, group_by_1.groupBy)('name', this.instances)).map(([name, instances]) => (0, effect_1.pipe)(instances, effect_1.Effect.forEach((instance) => (0, effect_1.pipe)(effect_1.Effect.succeed(specifier_1.Specifier.create(instance, this.config.pinVersion)), effect_1.Effect.map((expected) => instance.rawSpecifier === expected.raw
+            ? // ✓ pinned takes precedence over any semver group
+                // ✓ current version matches expected
+                new report_1.Report.Valid({ specifier: expected })
+            : // ✓ pinned takes precedence over any semver group
+                // ✘ current version mismatches expected
+                // ✓ is a mismatch we can auto-fix
+                new report_1.Report.PinnedMismatch({ fixable: expected })))), effect_1.Effect.map((reports) => ({ name, reports })))));
+    }
+}
+exports.PinnedVersionGroup = PinnedVersionGroup;

package/dist/version-group/same-range.d.ts

@@ -0,0 +1,19 @@
+import { Data, Effect } from 'effect';
+import type { VersionGroupConfig } from '../config/types';
+import type { Ctx } from '../get-context';
+import type { Instance } from '../get-instances/instance';
+import { Report } from '../report';
+declare const SameRangeVersionGroup_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "SameRange";
+}>;
+export declare class SameRangeVersionGroup extends SameRangeVersionGroup_base<{
+    ctx: Ctx;
+    config: VersionGroupConfig.SameRange;
+    instances: Instance[];
+}> {
+    groupType: string;
+    constructor(ctx: Ctx, config: VersionGroupConfig.SameRange);
+    canAdd(_: Instance): boolean;
+    inspectAll(): Effect.Effect<never, never, Report.Version.Group[]>;
+}
+export {};