syncpack 11.2.1 → 12.0.0-alpha.1

package/dist/report.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Report = void 0;
+const effect_1 = require("effect");
+var Report;
+(function (Report) {
+    /** Semver Groups are disabled by default */
+    class Disabled extends effect_1.Data.TaggedClass('Disabled') {
+    }
+    Report.Disabled = Disabled;
+    /** Has a name which does not match the `--filter` RegExp */
+    class FilteredOut extends effect_1.Data.TaggedClass('FilteredOut') {
+    }
+    Report.FilteredOut = FilteredOut;
+    /** Is in an ignored version group */
+    class Ignored extends effect_1.Data.TaggedClass('Ignored') {
+    }
+    Report.Ignored = Ignored;
+    /** Version satisfies the rules of its version group */
+    class Valid extends effect_1.Data.TaggedClass('Valid') {
+    }
+    Report.Valid = Valid;
+    /** Must be removed */
+    class Banned extends effect_1.Data.TaggedClass('Banned') {
+    }
+    Report.Banned = Banned;
+    /** Version mismatches and should use a higher version found on another */
+    class HighestSemverMismatch extends effect_1.Data.TaggedClass('HighestSemverMismatch') {
+    }
+    Report.HighestSemverMismatch = HighestSemverMismatch;
+    /** Version mismatches the `.version` of the package developed in this repo */
+    class LocalPackageMismatch extends effect_1.Data.TaggedClass('LocalPackageMismatch') {
+    }
+    Report.LocalPackageMismatch = LocalPackageMismatch;
+    /** Version mismatches and should use a lower version found on another */
+    class LowestSemverMismatch extends effect_1.Data.TaggedClass('LowestSemverMismatch') {
+    }
+    Report.LowestSemverMismatch = LowestSemverMismatch;
+    /** Version is not identical to the `pinVersion` of its Pinned version group */
+    class PinnedMismatch extends effect_1.Data.TaggedClass('PinnedMismatch') {
+    }
+    Report.PinnedMismatch = PinnedMismatch;
+    /** Version is identical but the semver range does not match its semver group */
+    class SemverRangeMismatch extends effect_1.Data.TaggedClass('SemverRangeMismatch') {
+    }
+    Report.SemverRangeMismatch = SemverRangeMismatch;
+    /** Version mismatches the version used by the packages in the `snapTo` array */
+    class SnappedToMismatch extends effect_1.Data.TaggedClass('SnappedToMismatch') {
+    }
+    Report.SnappedToMismatch = SnappedToMismatch;
+    /** Dependency should match a local package.json which is missing a .version */
+    class MissingLocalVersion extends effect_1.Data.TaggedClass('MissingLocalVersion') {
+    }
+    Report.MissingLocalVersion = MissingLocalVersion;
+    /** Dependency is not present in any of the packages in the `snapTo` array */
+    class MissingSnappedToMismatch extends effect_1.Data.TaggedClass('MissingSnappedToMismatch') {
+    }
+    Report.MissingSnappedToMismatch = MissingSnappedToMismatch;
+    /** Specifier does not cover the specifiers of every other instance in this group */
+    class SameRangeMismatch extends effect_1.Data.TaggedClass('SameRangeMismatch') {
+    }
+    Report.SameRangeMismatch = SameRangeMismatch;
+    /** Version mismatches and is not semver, syncpack cannot guess what to do */
+    class UnsupportedMismatch extends effect_1.Data.TaggedClass('UnsupportedMismatch') {
+    }
+    Report.UnsupportedMismatch = UnsupportedMismatch;
+})(Report || (exports.Report = Report = {}));

package/dist/schema.json

@@ -9,16 +9,19 @@
         "SemverGroupConfig.Any": {
             "anyOf": [
                 {
-                    "$ref": "#/definitions/{isIgnored:true;dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];range?:never;}"
+                    "$ref": "#/definitions/{isDisabled:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;range?:never;}"
                 },
                 {
-                    "$ref": "#/definitions/{range:SemverRange;dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isIgnored?:never;}"
+                    "$ref": "#/definitions/{isIgnored:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isDisabled?:never;range?:never;}"
+                },
+                {
+                    "$ref": "#/definitions/{range:SemverRange;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isDisabled?:never;isIgnored?:never;}"
                 }
             ]
         },
         "SemverRange": {
             "default": "",
-            "description": "Aliases for semver range formats supported by syncpack\n\nDefaults to `\"\"` to ensure that exact dependency versions are used\ninstead of loose ranges, but this can be overridden in your config file\nor via the `--semver-range` command line option.\n\n| Supported Range |   Example |\n| --------------- | --------: |\n| `\"<\"`           |  `<1.4.2` |\n| `\"<=\"`          | `<=1.4.2` |\n| `\"\"`            |   `1.4.2` |\n| `\"~\"`           |  `~1.4.2` |\n| `\"^\"`           |  `^1.4.2` |\n| `\">=\"`          | `>=1.4.2` |\n| `\">\"`           |  `>1.4.2` |\n| `\"*\"`           |       `*` |",
+            "description": "Aliases for semver range formats supported by syncpack\n\nDefaults to `\"\"` to ensure that exact dependency versions are used instead of\nloose ranges, but this can be overridden in your config file.\n\n| Supported Range |   Example |\n| --------------- | --------: |\n| `\"<\"`           |  `<1.4.2` |\n| `\"<=\"`          | `<=1.4.2` |\n| `\"\"`            |   `1.4.2` |\n| `\"~\"`           |  `~1.4.2` |\n| `\"^\"`           |  `^1.4.2` |\n| `\">=\"`          | `>=1.4.2` |\n| `\">\"`           |  `>1.4.2` |\n| `\"*\"`           |       `*` |",
             "enum": [
                 "",
                 "*",
@@ -35,26 +38,26 @@
         "VersionGroupConfig.Any": {
             "anyOf": [
                 {
-                    "$ref": "#/definitions/{isBanned:true;dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isIgnored?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}"
+                    "$ref": "#/definitions/{isBanned:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}"
                 },
                 {
-                    "$ref": "#/definitions/{isIgnored:true;dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}"
+                    "$ref": "#/definitions/{isIgnored:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}"
                 },
                 {
-                    "$ref": "#/definitions/{pinVersion:string;dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isIgnored?:never;isBanned?:never;snapTo?:never;policy?:never;preferVersion?:never;}"
+                    "$ref": "#/definitions/{pinVersion:string;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;snapTo?:never;policy?:never;preferVersion?:never;}"
                 },
                 {
-                    "$ref": "#/definitions/{snapTo:string[];dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;policy?:never;preferVersion?:never;}"
+                    "$ref": "#/definitions/{snapTo:string[];dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;policy?:never;preferVersion?:never;}"
                 },
                 {
-                    "$ref": "#/definitions/{policy:\"sameRange\";dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;preferVersion?:never;}"
+                    "$ref": "#/definitions/{policy:\"sameRange\";dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;preferVersion?:never;}"
                 },
                 {
-                    "$ref": "#/definitions/{preferVersion?:\"highestSemver\"|\"lowestSemver\";dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;}"
+                    "$ref": "#/definitions/{preferVersion?:\"highestSemver\"|\"lowestSemver\";dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;}"
                 }
             ]
         },
-        "{isBanned:true;dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isIgnored?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}": {
+        "{isBanned:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -85,7 +88,38 @@
             },
             "type": "object"
         },
-        "{isIgnored:true;dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}": {
+        "{isDisabled:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;range?:never;}": {
+            "additionalProperties": false,
+            "properties": {
+                "dependencies": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "dependencyTypes": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "isDisabled": {
+                    "const": true,
+                    "type": "boolean"
+                },
+                "label": {
+                    "type": "string"
+                },
+                "packages": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "{isIgnored:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -116,7 +150,7 @@
             },
             "type": "object"
         },
-        "{isIgnored:true;dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];range?:never;}": {
+        "{isIgnored:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isDisabled?:never;range?:never;}": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -147,7 +181,7 @@
             },
             "type": "object"
         },
-        "{pinVersion:string;dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isIgnored?:never;isBanned?:never;snapTo?:never;policy?:never;preferVersion?:never;}": {
+        "{pinVersion:string;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;snapTo?:never;policy?:never;preferVersion?:never;}": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -177,7 +211,7 @@
             },
             "type": "object"
         },
-        "{policy:\"sameRange\";dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;preferVersion?:never;}": {
+        "{policy:\"sameRange\";dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;preferVersion?:never;}": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -208,7 +242,7 @@
             },
             "type": "object"
         },
-        "{preferVersion?:\"highestSemver\"|\"lowestSemver\";dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;}": {
+        "{preferVersion?:\"highestSemver\"|\"lowestSemver\";dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;}": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -242,7 +276,7 @@
             },
             "type": "object"
         },
-        "{range:SemverRange;dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isIgnored?:never;}": {
+        "{range:SemverRange;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isDisabled?:never;isIgnored?:never;}": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -272,7 +306,7 @@
             },
             "type": "object"
         },
-        "{snapTo:string[];dependencies:string[];dependencyTypes?:string[];label?:string;packages:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;policy?:never;preferVersion?:never;}": {
+        "{snapTo:string[];dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;policy?:never;preferVersion?:never;}": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -328,9 +362,6 @@
             },
             "type": "array"
         },
-        "semverRange": {
-            "$ref": "#/definitions/SemverRange"
-        },
         "sortAz": {
             "items": {
                 "type": "string"

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

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

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSemverGroups = 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 is_valid_semver_range_1 = require("../guards/is-valid-semver-range");
+const disabled_1 = require("./disabled");
+const filtered_out_1 = require("./filtered-out");
+const ignored_1 = require("./ignored");
+const with_range_1 = require("./with-range");
+function createSemverGroups(ctx) {
+    const { rcFile } = ctx.config;
+    const semverGroups = [
+        effect_1.Effect.succeed(new filtered_out_1.FilteredOutSemverGroup(ctx)),
+        effect_1.Effect.succeed(new with_range_1.WithRangeSemverGroup(false, {
+            dependencies: ['**'],
+            dependencyTypes: ['local'],
+            label: 'the version property of package.json files must always be exact',
+            packages: ['**'],
+            range: '',
+        })),
+    ];
+    if ((0, is_non_empty_array_1.isNonEmptyArray)(rcFile.semverGroups)) {
+        rcFile.semverGroups.forEach((config) => {
+            if (!(0, is_object_1.isObject)(config)) {
+                return semverGroups.push(effect_1.Effect.fail(new _1.SemverGroup.ConfigError({
+                    config,
+                    error: 'config is not an object',
+                })));
+            }
+            const mutuallyExclusiveProps = ['isIgnored', 'range'].filter((prop) => Boolean(config[prop]));
+            if (mutuallyExclusiveProps.length > 1) {
+                return semverGroups.push(effect_1.Effect.fail(new _1.SemverGroup.ConfigError({
+                    config,
+                    error: `it's unclear what kind of semver 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.isIgnored === true) {
+                semverGroups.push(effect_1.Effect.succeed(new ignored_1.IgnoredSemverGroup({
+                    dependencies,
+                    dependencyTypes,
+                    isIgnored: true,
+                    label,
+                    packages,
+                })));
+            }
+            else if ((0, is_valid_semver_range_1.isValidSemverRange)(config.range)) {
+                semverGroups.push(effect_1.Effect.succeed(new with_range_1.WithRangeSemverGroup(false, {
+                    dependencies,
+                    dependencyTypes,
+                    label,
+                    packages,
+                    range: config.range,
+                })));
+            }
+        });
+    }
+    semverGroups.push(effect_1.Effect.succeed(new disabled_1.DisabledSemverGroup(true, {
+        dependencies: ['**'],
+        dependencyTypes: ['**'],
+        label: 'Default Semver Group',
+        packages: ['**'],
+        isDisabled: true,
+    })));
+    return effect_1.Effect.all(semverGroups);
+}
+exports.createSemverGroups = createSemverGroups;

package/dist/semver-group/disabled.d.ts

@@ -0,0 +1,26 @@
+import { Data, Effect } from 'effect';
+import type { SemverGroupConfig } from '../config/types';
+import type { Instance } from '../get-instances/instance';
+import { Report } from '../report';
+import type { Specifier } from '../specifier';
+import type { NonSemverError } from '../specifier/lib/non-semver-error';
+declare const DisabledSemverGroup_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: "Disabled";
+}>;
+/**
+ * Semver groups are disabled by default and, when that's the case, every
+ * instance is assigned to this group. This group will allow anything.
+ */
+export declare class DisabledSemverGroup extends DisabledSemverGroup_base<{
+    config: SemverGroupConfig.Disabled;
+    instances: Instance[];
+    isCatchAll: boolean;
+}> {
+    groupType: string;
+    constructor(isCatchAll: boolean, config: SemverGroupConfig.Disabled);
+    canAdd(_: Instance): boolean;
+    getFixed(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, Specifier.Any>;
+    inspectAll(): Effect.Effect<never, never, Report.Disabled[]>;
+    inspect(instance: Instance): Effect.Effect<never, never, Report.Disabled>;
+}
+export {};

package/dist/semver-group/disabled.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisabledSemverGroup = void 0;
+const effect_1 = require("effect");
+const report_1 = require("../report");
+/**
+ * Semver groups are disabled by default and, when that's the case, every
+ * instance is assigned to this group. This group will allow anything.
+ */
+class DisabledSemverGroup extends effect_1.Data.TaggedClass('Disabled') {
+    groupType = 'semverGroup';
+    constructor(isCatchAll, config) {
+        super({
+            config,
+            instances: [],
+            isCatchAll,
+        });
+    }
+    canAdd(_) {
+        return true;
+    }
+    getFixed(specifier) {
+        return effect_1.Effect.succeed(specifier);
+    }
+    inspectAll() {
+        return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
+    }
+    inspect(instance) {
+        return effect_1.Effect.succeed(new report_1.Report.Disabled({
+            instance,
+        }));
+    }
+}
+exports.DisabledSemverGroup = DisabledSemverGroup;

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

@@ -0,0 +1,27 @@
+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';
+import type { Specifier } from '../specifier';
+import type { NonSemverError } from '../specifier/lib/non-semver-error';
+declare const FilteredOutSemverGroup_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";
+}>;
+/**
+ * Instances which do not match a given `--filter` option are assigned to this
+ * group and nothing will be changed.
+ */
+export declare class FilteredOutSemverGroup extends FilteredOutSemverGroup_base<{
+    config: GroupConfig;
+    filter: string;
+    instances: Instance[];
+}> {
+    groupType: string;
+    constructor(ctx: Ctx);
+    canAdd(instance: Instance): boolean;
+    getFixed(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, Specifier.Any>;
+    inspectAll(): Effect.Effect<never, never, Report.FilteredOut[]>;
+    inspect(instance: Instance): Effect.Effect<never, never, Report.FilteredOut>;
+}
+export {};

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilteredOutSemverGroup = void 0;
+const effect_1 = require("effect");
+const get_filter_1 = require("../config/get-filter");
+const report_1 = require("../report");
+/**
+ * Instances which do not match a given `--filter` option are assigned to this
+ * group and nothing will be changed.
+ */
+class FilteredOutSemverGroup extends effect_1.Data.TaggedClass('FilteredOut') {
+    groupType = 'semverGroup';
+    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;
+    }
+    getFixed(specifier) {
+        return effect_1.Effect.succeed(specifier);
+    }
+    inspectAll() {
+        return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
+    }
+    inspect(instance) {
+        return effect_1.Effect.succeed(new report_1.Report.FilteredOut({
+            instance,
+        }));
+    }
+}
+exports.FilteredOutSemverGroup = FilteredOutSemverGroup;

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

@@ -0,0 +1,22 @@
+import { Data, Effect } from 'effect';
+import type { SemverGroupConfig } from '../config/types';
+import type { Instance } from '../get-instances/instance';
+import { Report } from '../report';
+import type { Specifier } from '../specifier';
+import type { NonSemverError } from '../specifier/lib/non-semver-error';
+declare const IgnoredSemverGroup_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";
+}>;
+/** Every instance in this group is ignored and nothing will be changed */
+export declare class IgnoredSemverGroup extends IgnoredSemverGroup_base<{
+    config: SemverGroupConfig.Ignored;
+    instances: Instance[];
+}> {
+    groupType: string;
+    constructor(config: SemverGroupConfig.Ignored);
+    canAdd(_: Instance): boolean;
+    getFixed(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, Specifier.Any>;
+    inspectAll(): Effect.Effect<never, never, Report.Ignored[]>;
+    inspect(instance: Instance): Effect.Effect<never, never, Report.Ignored>;
+}
+export {};

package/dist/semver-group/ignored.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IgnoredSemverGroup = void 0;
+const effect_1 = require("effect");
+const report_1 = require("../report");
+/** Every instance in this group is ignored and nothing will be changed */
+class IgnoredSemverGroup extends effect_1.Data.TaggedClass('Ignored') {
+    groupType = 'semverGroup';
+    constructor(config) {
+        super({
+            config,
+            instances: [],
+        });
+    }
+    canAdd(_) {
+        return true;
+    }
+    getFixed(specifier) {
+        return effect_1.Effect.succeed(specifier);
+    }
+    inspectAll() {
+        return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
+    }
+    inspect(instance) {
+        return effect_1.Effect.succeed(new report_1.Report.Ignored({
+            instance,
+        }));
+    }
+}
+exports.IgnoredSemverGroup = IgnoredSemverGroup;

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

@@ -0,0 +1,22 @@
+import { Data } from 'effect';
+import type { Union } from 'ts-toolbelt';
+import type { DisabledSemverGroup } from './disabled';
+import type { FilteredOutSemverGroup } from './filtered-out';
+import type { IgnoredSemverGroup } from './ignored';
+import type { WithRangeSemverGroup } from './with-range';
+export declare namespace SemverGroup {
+    export type Disabled = DisabledSemverGroup;
+    export type FilteredOut = FilteredOutSemverGroup;
+    export type Ignored = IgnoredSemverGroup;
+    export type WithRange = WithRangeSemverGroup;
+    export type Any = Union.Strict<Disabled | FilteredOut | Ignored | WithRange>;
+    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: "SemverGroupConfigError";
+    }>;
+    export class ConfigError extends ConfigError_base<{
+        readonly config: unknown;
+        readonly error: string;
+    }> {
+    }
+    export {};
+}

package/dist/semver-group/index.js

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

package/dist/semver-group/with-range.d.ts

@@ -0,0 +1,22 @@
+import { Data, Effect } from 'effect';
+import type { SemverGroupConfig } from '../config/types';
+import type { Instance } from '../get-instances/instance';
+import { Report } from '../report';
+import { Specifier } from '../specifier';
+import type { NonSemverError } from '../specifier/lib/non-semver-error';
+declare const WithRangeSemverGroup_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: "WithRange";
+}>;
+export declare class WithRangeSemverGroup extends WithRangeSemverGroup_base<{
+    config: SemverGroupConfig.WithRange;
+    instances: Instance[];
+    isCatchAll: boolean;
+}> {
+    groupType: string;
+    constructor(isCatchAll: boolean, config: SemverGroupConfig.WithRange);
+    canAdd(_: Instance): boolean;
+    getFixed(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, Specifier.Any>;
+    inspectAll(): Effect.Effect<never, never, (Report.UnsupportedMismatch | Report.SemverRangeMismatch | Report.Valid)[]>;
+    inspect(instance: Instance): Effect.Effect<never, never, Report.UnsupportedMismatch | Report.SemverRangeMismatch | Report.Valid>;
+}
+export {};

package/dist/semver-group/with-range.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithRangeSemverGroup = void 0;
+const effect_1 = require("effect");
+const set_semver_range_1 = require("../lib/set-semver-range");
+const report_1 = require("../report");
+const specifier_1 = require("../specifier");
+class WithRangeSemverGroup extends effect_1.Data.TaggedClass('WithRange') {
+    groupType = 'semverGroup';
+    constructor(isCatchAll, config) {
+        super({
+            config,
+            instances: [],
+            isCatchAll,
+        });
+        this.getFixed = this.getFixed.bind(this);
+    }
+    canAdd(_) {
+        return true;
+    }
+    getFixed(specifier) {
+        return (0, effect_1.pipe)(specifier.getSemver(), effect_1.Effect.map((semver) => (0, set_semver_range_1.setSemverRange)(this.config.range, semver)), effect_1.Effect.flatMap((nextSemver) => specifier.setSemver(nextSemver)));
+    }
+    inspectAll() {
+        return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
+    }
+    inspect(instance) {
+        const current = specifier_1.Specifier.create(instance, instance.rawSpecifier);
+        return (0, effect_1.pipe)(this.getFixed(current), effect_1.Effect.match({
+            // if range is fixable
+            onSuccess: (valid) => 
+            // if it is pinned and matches its pin
+            instance.versionGroup._tag === 'Pinned' &&
+                instance.rawSpecifier === instance.versionGroup.config.pinVersion
+                ? // the pinned version takes precendence and is a match
+                    new report_1.Report.Valid({
+                        specifier: current,
+                    })
+                : // if it is already like this on disk
+                    instance.rawSpecifier === valid.raw
+                        ? // it is a match
+                            new report_1.Report.Valid({
+                                specifier: current,
+                            })
+                        : // it is a mismatch and should be this one
+                            new report_1.Report.SemverRangeMismatch({
+                                fixable: valid,
+                            }),
+            // if range is NOT fixable, it is a mismatch we can't auto-fix
+            // as it seems to not be semver
+            onFailure: () => new report_1.Report.UnsupportedMismatch({
+                unfixable: instance,
+            }),
+        }));
+    }
+}
+exports.WithRangeSemverGroup = WithRangeSemverGroup;

package/dist/specifier/alias.d.ts

@@ -0,0 +1,15 @@
+import { Effect } from 'effect';
+import type { AliasResult } from 'npm-package-arg';
+import { Specifier } from '.';
+import { BaseSpecifier } from './base';
+import { NonSemverError } from './lib/non-semver-error';
+type T = AliasResult;
+/** @example "npm:imageoptim-cli@3.1.7" */
+export declare class AliasSpecifier extends BaseSpecifier<T> {
+    _tag: string;
+    /** Return the version portion if it is valid semver */
+    getSemver(): Effect.Effect<never, NonSemverError, string>;
+    /** Get a new `Specifier` from the given semver version applied to this one */
+    setSemver(version: string): Effect.Effect<never, NonSemverError, Specifier.Any>;
+}
+export {};