syncpack 11.2.1 → 12.0.0-alpha.1

package/dist/strategy/name-and-version-props.js

@@ -1,49 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NameAndVersionPropsStrategy = void 0;
-const Function_1 = require("@effect/data/Function");
-const get_1 = require("tightrope/fn/get");
-const and_then_1 = require("tightrope/result/and-then");
-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_object_1 = require("tightrope/guard/is-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 getOptionOfObject = effect_1.Option.liftPredicate((is_object_1.isObject));
 class NameAndVersionPropsStrategy {
+    _tag = 'name~version';
+    name;
+    path;
+    namePath;
     constructor(name, path, namePath) {
-        this._tag = 'name~version';
         this.name = name;
         this.path = path;
         this.namePath = namePath;
     }
     read(file) {
-        const path = this.path;
-        const namePath = this.namePath;
-        return (0, Function_1.pipe)(
-        // get name prop
-        (0, get_non_empty_string_prop_1.getNonEmptyStringProp)(namePath, file), 
+        return (0, effect_1.pipe)(effect_1.Effect.Do, 
+        // get the name prop
+        effect_1.Effect.bind('name', () => (0, get_non_empty_string_prop_1.getNonEmptyStringProp)(this.namePath, file)), 
         // add the version prop
-        (0, and_then_1.andThen)((name) => (0, Function_1.pipe)((0, get_non_empty_string_prop_1.getNonEmptyStringProp)(path, file), (0, map_1.map)((version) => ({ name, version })))), 
+        effect_1.Effect.bind('version', () => (0, effect_1.pipe)((0, get_non_empty_string_prop_1.getNonEmptyStringProp)(this.path, file), 
+        /**
+         * In order to report an `InstanceReport.MissingLocalVersion`, we need
+         * to ensure that a value is returned for `local` package .version
+         * properties so we can know that `this.name` is a package developed
+         * in this repo but that its version is missing.
+         *
+         * Not doing this results in the invalid local package being ignored
+         * and each installation of it being checked for mismatches amongst
+         * themselves.
+         */
+        this.name === 'local'
+            ? effect_1.Effect.catchAll(() => effect_1.Effect.succeed('PACKAGE_JSON_HAS_NO_VERSION'))
+            : effect_1.Effect.map(effect_1.identity))), 
         // if both are non empty strings, we can return them
-        (0, map_1.map)(({ name, version }) => [[name, version]]));
+        effect_1.Effect.map(({ name, version }) => [[name, version]]), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`NameAndVersionPropsStrategy#${this.name} found nothing at <${file.jsonFile.shortPath}>.${this.path} & .${this.namePath}`)), 
+        // if either are invalid, default to empty
+        effect_1.Effect.catchAll(() => effect_1.Effect.succeed([])));
     }
     write(file, [, version]) {
         const path = this.path;
-        const { contents } = file;
+        const { contents } = file.jsonFile;
         const isNestedPath = path.includes('.');
         const nextValue = version === delete_1.DELETE ? undefined : version;
         if (isNestedPath) {
             const fullPath = 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) => {
-                parent[key] = version;
-            }), (0, map_1.map)(() => file));
+            return (0, effect_1.pipe)((0, get_1.get)(contents, ...pathToParent.split('.')), effect_1.Effect.flatMap(getOptionOfObject), effect_1.Effect.flatMap((parent) => effect_1.Effect.try(() => {
+                parent[key] = 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));
         }
         else {
-            return (0, Function_1.pipe)((0, from_try_1.fromTry)(() => {
-                contents[path] = nextValue;
-            }), (0, map_1.map)(() => file));
+            return (0, effect_1.pipe)(getOptionOfObject(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/named-version-string.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 NamedVersionStringStrategy {
     _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/named-version-string.js

@@ -1,52 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NamedVersionStringStrategy = 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 is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
-const result_1 = require("tightrope/result");
-const and_then_1 = require("tightrope/result/and-then");
-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 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 getOptionOfNonEmptyString = effect_1.Option.liftPredicate(is_non_empty_string_1.isNonEmptyString);
+const getOptionOfNonEmptyObject = effect_1.Option.liftPredicate((is_non_empty_object_1.isNonEmptyObject));
 class NamedVersionStringStrategy {
+    _tag = 'name@version';
+    name;
+    path;
     constructor(name, path) {
-        this._tag = 'name@version';
         this.name = name;
         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), 
         // if it is a non empty string, we can read it
-        (0, and_then_1.andThen)((value) => {
-            const [name, version] = value.split(/@(.*)/);
-            return (0, is_non_empty_string_1.isNonEmptyString)(name) && (0, is_non_empty_string_1.isNonEmptyString)(version)
-                ? new result_1.Ok([[name, version]])
-                : new result_1.Err(new Error(`Strategy<name@version> failed to get ${path} in ${file.shortPath}`));
-        }));
+        effect_1.Effect.map((value) => value.split(/@(.*)/)), 
+        // check the string was properly formed
+        effect_1.Effect.flatMap(([name, version]) => effect_1.Effect.all([getOptionOfNonEmptyString(name), getOptionOfNonEmptyString(version)])), 
+        // return an array of one entry if valid
+        effect_1.Effect.map(([name, version]) => [[name, version]]), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`NamedVersionStringStrategy#${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 { contents } = file;
-        const path = this.path;
-        const isNestedPath = path.includes('.');
+        const { contents } = file.jsonFile;
+        const isNestedPath = this.path.includes('.');
         const nextValue = version === delete_1.DELETE ? undefined : `${name}@${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/unnamed-version-string.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 UnnamedVersionStringStrategy {
     _tag: string;
     name: string;
     path: string;
     constructor(name: string, path: string);
-    read(file: PackageJsonFile): Result<[string, string][]>;
-    write(file: PackageJsonFile, [, version]: [string, string | Delete]): Result<PackageJsonFile>;
+    read(file: PackageJsonFile): Effect.Effect<never, never, [string, string][]>;
+    write(file: PackageJsonFile, [, version]: [string, string | Delete]): Effect.Effect<never, never, PackageJsonFile>;
 }

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

@@ -1,47 +1,48 @@
 "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 {
+    _tag = 'version';
+    name;
+    path;
     constructor(name, path) {
-        this._tag = 'version';
         this.name = name;
         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,29 +1,29 @@
 "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 {
+    _tag = 'versionsByName';
+    name;
+    path;
     constructor(name, path) {
-        this._tag = 'versionsByName';
         this.name = name;
         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/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<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') {
+    groupType = 'versionGroup';
+    constructor(config) {
+        super({
+            config,
+            instances: [],
+        });
+    }
+    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/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<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') {
+    groupType = 'versionGroup';
+    constructor(ctx) {
+        super({
+            config: {
+                dependencies: ['**'],
+                dependencyTypes: ['**'],
+                label: 'Filtered out',
+                packages: ['**'],
+            },
+            filter: (0, get_filter_1.getFilter)(ctx.config),
+            instances: [],
+        });
+    }
+    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/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<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') {
+    groupType = 'versionGroup';
+    constructor(config) {
+        super({
+            config,
+            instances: [],
+        });
+    }
+    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/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
+        readonly _tag: "VersionGroupConfigError";
+    }>;
+    export class ConfigError extends ConfigError_base<{
+        readonly config: unknown;
+        readonly error: string;
+    }> {
+    }
+    export {};
+}