syncpack 12.3.0 → 12.3.1

package/dist/option.js

@@ -1,18 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.option = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const constants_1 = require("./constants");
-exports.option = {
+import chalk from 'chalk-template';
+import { DEFAULT_CONFIG } from './constants.js';
+export const option = {
     config: ['-c, --config <path>', 'path to a syncpack config file'],
     filter: [
         '-f, --filter [pattern]',
-        (0, chalk_1.default) `only include dependencies whose {yellow name} matches this regex`,
+        chalk `only include dependencies whose {yellow name} matches this regex`,
     ],
-    indent: ['-i, --indent [value]', `override indentation. defaults to "${constants_1.DEFAULT_CONFIG.indent}"`],
+    indent: ['-i, --indent [value]', `override indentation. defaults to "${DEFAULT_CONFIG.indent}"`],
     source: [
         '-s, --source [pattern]',
         'glob pattern for package.json files to read from',
@@ -20,12 +14,12 @@ exports.option = {
         [],
     ],
     specs: [
-        '-s, --specs <names>',
-        (0, chalk_1.default) `only include dependencies whose version specifier match these types (eg. {yellow specs=latest,range,workspace-protocol})`,
+        '-S, --specs <names>',
+        chalk `only include dependencies whose version specifier match these types (eg. {yellow specs=latest,range,workspace-protocol})`,
     ],
     types: [
         '-t, --types <names>',
-        (0, chalk_1.default) `only include dependencies matching these types (eg. {yellow types=dev,prod,myCustomType})`,
+        chalk `only include dependencies matching these types (eg. {yellow types=dev,prod,myCustomType})`,
     ],
 };
 function collect(value, previous) {

package/dist/report.d.ts

@@ -1,5 +1,5 @@
-import type { Instance } from './get-instances/instance';
-import type { Specifier } from './specifier';
+import type { Instance } from './get-instances/instance.js';
+import type { Specifier } from './specifier/index.js';
 export declare namespace Report {
     export type Any = Semver.Any | Version.Any;
     export namespace Semver {

package/dist/report.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Report = void 0;
-var Report;
+export var Report;
 (function (Report) {
     class Excluded {
         _tagGroup = 'Excluded';
@@ -129,4 +126,4 @@ var Report;
         _tag = 'UnsupportedMismatch';
     }
     Report.UnsupportedMismatch = UnsupportedMismatch;
-})(Report || (exports.Report = Report = {}));
+})(Report || (Report = {}));

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

@@ -1,4 +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[]>;
+import type { Ctx } from '../get-context/index.js';
+import { SemverGroup } from './index.js';
+export declare function createSemverGroups(ctx: Ctx): Effect.Effect<SemverGroup.Any[], SemverGroup.ConfigError>;

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

@@ -1,22 +1,19 @@
-"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) {
+import { Effect } from 'effect';
+import { isArrayOfStrings } from 'tightrope/guard/is-array-of-strings.js';
+import { isNonEmptyArray } from 'tightrope/guard/is-non-empty-array.js';
+import { isNonEmptyString } from 'tightrope/guard/is-non-empty-string.js';
+import { isObject } from 'tightrope/guard/is-object.js';
+import { isValidSemverRange } from '../guards/is-valid-semver-range.js';
+import { DisabledSemverGroup } from './disabled.js';
+import { FilteredOutSemverGroup } from './filtered-out.js';
+import { IgnoredSemverGroup } from './ignored.js';
+import { SemverGroup } from './index.js';
+import { WithRangeSemverGroup } from './with-range.js';
+export 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, {
+        Effect.succeed(new FilteredOutSemverGroup(ctx)),
+        Effect.succeed(new WithRangeSemverGroup(false, {
             dependencies: ['**'],
             dependencyTypes: ['local'],
             label: 'the version property of package.json files must always be exact',
@@ -24,32 +21,32 @@ function createSemverGroups(ctx) {
             range: '',
         })),
     ];
-    if ((0, is_non_empty_array_1.isNonEmptyArray)(rcFile.semverGroups)) {
+    if (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({
+            if (!isObject(config)) {
+                return semverGroups.push(Effect.fail(new 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({
+                return semverGroups.push(Effect.fail(new 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)
+            const label = isNonEmptyString(config.label) ? config.label : '';
+            const dependencyTypes = 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 : ['**'];
-            const specifierTypes = (0, is_array_of_strings_1.isArrayOfStrings)(config.specifierTypes)
+            const dependencies = isArrayOfStrings(config.dependencies) ? config.dependencies : ['**'];
+            const packages = isArrayOfStrings(config.packages) ? config.packages : ['**'];
+            const specifierTypes = isArrayOfStrings(config.specifierTypes)
                 ? config.specifierTypes
                 : ['**'];
             if (config.isIgnored === true) {
-                semverGroups.push(effect_1.Effect.succeed(new ignored_1.IgnoredSemverGroup({
+                semverGroups.push(Effect.succeed(new IgnoredSemverGroup({
                     dependencies,
                     dependencyTypes,
                     specifierTypes,
@@ -58,8 +55,8 @@ function createSemverGroups(ctx) {
                     packages,
                 })));
             }
-            else if ((0, is_valid_semver_range_1.isValidSemverRange)(config.range)) {
-                semverGroups.push(effect_1.Effect.succeed(new with_range_1.WithRangeSemverGroup(false, {
+            else if (isValidSemverRange(config.range)) {
+                semverGroups.push(Effect.succeed(new WithRangeSemverGroup(false, {
                     dependencies,
                     dependencyTypes,
                     specifierTypes,
@@ -70,7 +67,7 @@ function createSemverGroups(ctx) {
             }
         });
     }
-    semverGroups.push(effect_1.Effect.succeed(new disabled_1.DisabledSemverGroup(true, {
+    semverGroups.push(Effect.succeed(new DisabledSemverGroup(true, {
         dependencies: ['**'],
         dependencyTypes: ['**'],
         specifierTypes: ['**'],
@@ -78,6 +75,5 @@ function createSemverGroups(ctx) {
         packages: ['**'],
         isDisabled: true,
     })));
-    return effect_1.Effect.all(semverGroups);
+    return Effect.all(semverGroups);
 }
-exports.createSemverGroups = createSemverGroups;

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

@@ -1,12 +1,12 @@
-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> & {
+import { Effect } from 'effect';
+import type { SemverGroupConfig } from '../config/types.js';
+import type { Instance } from '../get-instances/instance.js';
+import { Report } from '../report.js';
+import type { Specifier } from '../specifier/index.js';
+import type { NonSemverError } from '../specifier/lib/non-semver-error.js';
+declare const DisabledSemverGroup_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => 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.
@@ -19,8 +19,8 @@ export declare class DisabledSemverGroup extends DisabledSemverGroup_base<{
     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>;
+    getFixed(specifier: Specifier.Any): Effect.Effect<Specifier.Any, NonSemverError>;
+    inspectAll(): Effect.Effect<Report.Disabled[], never, never>;
+    inspect(instance: Instance): Effect.Effect<Report.Disabled>;
 }
 export {};

package/dist/semver-group/disabled.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DisabledSemverGroup = void 0;
-const effect_1 = require("effect");
-const report_1 = require("../report");
+import { Data, Effect } from 'effect';
+import { Report } from '../report.js';
 /**
  * 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') {
+export class DisabledSemverGroup extends Data.TaggedClass('Disabled') {
     groupType = 'semverGroup';
     constructor(isCatchAll, config) {
         super({
@@ -20,13 +17,12 @@ class DisabledSemverGroup extends effect_1.Data.TaggedClass('Disabled') {
         return true;
     }
     getFixed(specifier) {
-        return effect_1.Effect.succeed(specifier);
+        return Effect.succeed(specifier);
     }
     inspectAll() {
-        return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
+        return Effect.all(this.instances.map((instance) => this.inspect(instance)));
     }
     inspect(instance) {
-        return effect_1.Effect.succeed(new report_1.Report.Disabled(instance));
+        return Effect.succeed(new Report.Disabled(instance));
     }
 }
-exports.DisabledSemverGroup = DisabledSemverGroup;

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

@@ -1,13 +1,13 @@
-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> & {
+import { Effect } from 'effect';
+import type { GroupConfig } from '../config/types.js';
+import type { Ctx } from '../get-context/index.js';
+import type { Instance } from '../get-instances/instance.js';
+import { Report } from '../report.js';
+import type { Specifier } from '../specifier/index.js';
+import type { NonSemverError } from '../specifier/lib/non-semver-error.js';
+declare const FilteredOutSemverGroup_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
     readonly _tag: "FilteredOut";
-}>;
+};
 /**
  * Instances which do not match a given `--filter` option are assigned to this
  * group and nothing will be changed.
@@ -20,8 +20,8 @@ export declare class FilteredOutSemverGroup extends FilteredOutSemverGroup_base<
     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>;
+    getFixed(specifier: Specifier.Any): Effect.Effect<Specifier.Any, NonSemverError>;
+    inspectAll(): Effect.Effect<Report.FilteredOut[], never, never>;
+    inspect(instance: Instance): Effect.Effect<Report.FilteredOut>;
 }
 export {};

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

@@ -1,14 +1,11 @@
-"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");
+import { Data, Effect } from 'effect';
+import { getFilter } from '../config/get-filter.js';
+import { Report } from '../report.js';
 /**
  * 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') {
+export class FilteredOutSemverGroup extends Data.TaggedClass('FilteredOut') {
     groupType = 'semverGroup';
     constructor(ctx) {
         super({
@@ -18,7 +15,7 @@ class FilteredOutSemverGroup extends effect_1.Data.TaggedClass('FilteredOut') {
                 label: 'Filtered out',
                 packages: ['**'],
             },
-            filter: (0, get_filter_1.getFilter)(ctx.config),
+            filter: getFilter(ctx.config),
             instances: [],
         });
     }
@@ -26,13 +23,12 @@ class FilteredOutSemverGroup extends effect_1.Data.TaggedClass('FilteredOut') {
         return instance.name.search(new RegExp(this.filter)) === -1;
     }
     getFixed(specifier) {
-        return effect_1.Effect.succeed(specifier);
+        return Effect.succeed(specifier);
     }
     inspectAll() {
-        return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
+        return Effect.all(this.instances.map((instance) => this.inspect(instance)));
     }
     inspect(instance) {
-        return effect_1.Effect.succeed(new report_1.Report.FilteredOut(instance));
+        return Effect.succeed(new Report.FilteredOut(instance));
     }
 }
-exports.FilteredOutSemverGroup = FilteredOutSemverGroup;

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

@@ -1,12 +1,12 @@
-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> & {
+import { Effect } from 'effect';
+import type { SemverGroupConfig } from '../config/types.js';
+import type { Instance } from '../get-instances/instance.js';
+import { Report } from '../report.js';
+import type { Specifier } from '../specifier/index.js';
+import type { NonSemverError } from '../specifier/lib/non-semver-error.js';
+declare const IgnoredSemverGroup_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => 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;
@@ -15,8 +15,8 @@ export declare class IgnoredSemverGroup extends IgnoredSemverGroup_base<{
     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>;
+    getFixed(specifier: Specifier.Any): Effect.Effect<Specifier.Any, NonSemverError>;
+    inspectAll(): Effect.Effect<Report.Ignored[], never, never>;
+    inspect(instance: Instance): Effect.Effect<Report.Ignored>;
 }
 export {};

package/dist/semver-group/ignored.js

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

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

@@ -1,17 +1,16 @@
-import { Data } from 'effect';
-import type { DisabledSemverGroup } from './disabled';
-import type { FilteredOutSemverGroup } from './filtered-out';
-import type { IgnoredSemverGroup } from './ignored';
-import type { WithRangeSemverGroup } from './with-range';
+import type { DisabledSemverGroup } from './disabled.js';
+import type { FilteredOutSemverGroup } from './filtered-out.js';
+import type { IgnoredSemverGroup } from './ignored.js';
+import type { WithRangeSemverGroup } from './with-range.js';
 export declare namespace SemverGroup {
     export type Disabled = DisabledSemverGroup;
     export type FilteredOut = FilteredOutSemverGroup;
     export type Ignored = IgnoredSemverGroup;
     export type WithRange = WithRangeSemverGroup;
     export type Any = 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> & {
+    const ConfigError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
         readonly _tag: "SemverGroupConfigError";
-    }>;
+    };
     export class ConfigError extends ConfigError_base<{
         readonly config: unknown;
         readonly error: string;

package/dist/semver-group/index.js

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

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

@@ -1,12 +1,12 @@
-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> & {
+import { Effect } from 'effect';
+import type { SemverGroupConfig } from '../config/types.js';
+import type { Instance } from '../get-instances/instance.js';
+import { Report } from '../report.js';
+import { Specifier } from '../specifier/index.js';
+import type { NonSemverError } from '../specifier/lib/non-semver-error.js';
+declare const WithRangeSemverGroup_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
     readonly _tag: "WithRange";
-}>;
+};
 export declare class WithRangeSemverGroup extends WithRangeSemverGroup_base<{
     config: SemverGroupConfig.WithRange;
     instances: Instance[];
@@ -15,8 +15,8 @@ export declare class WithRangeSemverGroup extends WithRangeSemverGroup_base<{
     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.SemverRangeMismatch | Report.UnsupportedMismatch | Report.Valid)[]>;
-    inspect(instance: Instance): Effect.Effect<never, never, Report.UnsupportedMismatch | Report.SemverRangeMismatch | Report.Valid>;
+    getFixed(specifier: Specifier.Any): Effect.Effect<Specifier.Any, NonSemverError>;
+    inspectAll(): Effect.Effect<(Report.SemverRangeMismatch | Report.UnsupportedMismatch | Report.Valid)[], never, never>;
+    inspect(instance: Instance): Effect.Effect<Report.UnsupportedMismatch | Report.SemverRangeMismatch | Report.Valid>;
 }
 export {};

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

@@ -1,11 +1,8 @@
-"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') {
+import { Data, Effect, pipe } from 'effect';
+import { setSemverRange } from '../lib/set-semver-range.js';
+import { Report } from '../report.js';
+import { Specifier } from '../specifier/index.js';
+export class WithRangeSemverGroup extends Data.TaggedClass('WithRange') {
     groupType = 'semverGroup';
     constructor(isCatchAll, config) {
         super({
@@ -19,31 +16,30 @@ class WithRangeSemverGroup extends effect_1.Data.TaggedClass('WithRange') {
         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)));
+        return pipe(specifier.getSemver(), Effect.map((semver) => setSemverRange(this.config.range, semver)), Effect.flatMap((nextSemver) => specifier.setSemver(nextSemver)));
     }
     inspectAll() {
-        return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
+        return Effect.all(this.instances.map((instance) => this.inspect(instance)));
     }
     inspect(instance) {
-        const current = specifier_1.Specifier.create(instance, instance.rawSpecifier.raw);
-        return (0, effect_1.pipe)(this.getFixed(current), effect_1.Effect.match({
+        const current = Specifier.create(instance, instance.rawSpecifier.raw);
+        return pipe(this.getFixed(current), Effect.match({
             // if range is fixable
             onSuccess: (valid) => 
             // if it is pinned and matches its pin
             instance.versionGroup._tag === 'Pinned' &&
                 instance.rawSpecifier.raw === instance.versionGroup.config.pinVersion
                 ? // the pinned version takes precendence and is a match
-                    new report_1.Report.Valid(current)
+                    new Report.Valid(current)
                 : // if it is already like this on disk
                     instance.rawSpecifier.raw === valid.raw
                         ? // it is a match
-                            new report_1.Report.Valid(current)
+                            new Report.Valid(current)
                         : // it is a mismatch and should be this one
-                            new report_1.Report.SemverRangeMismatch(valid),
+                            new Report.SemverRangeMismatch(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(instance),
+            onFailure: () => new Report.UnsupportedMismatch(instance),
         }));
     }
 }
-exports.WithRangeSemverGroup = WithRangeSemverGroup;

package/dist/specifier/alias.d.ts

@@ -1,8 +1,8 @@
 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';
+import { BaseSpecifier } from './base.js';
+import { Specifier } from './index.js';
+import { NonSemverError } from './lib/non-semver-error.js';
 type T = AliasResult;
 /** @example "npm:imageoptim-cli@3.1.7" */
 export declare class AliasSpecifier extends BaseSpecifier<T> {
@@ -10,8 +10,8 @@ export declare class AliasSpecifier extends BaseSpecifier<T> {
     /** The public name referenced in config */
     name: "alias";
     /** Return the version portion if it is valid semver */
-    getSemver(): Effect.Effect<never, NonSemverError, string>;
+    getSemver(): Effect.Effect<string, NonSemverError>;
     /** Get a new `Specifier` from the given semver version applied to this one */
-    setSemver(version: string): Effect.Effect<never, NonSemverError, Specifier.Any>;
+    setSemver(version: string): Effect.Effect<Specifier.Any, NonSemverError>;
 }
 export {};

package/dist/specifier/alias.js

@@ -1,24 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AliasSpecifier = void 0;
-const effect_1 = require("effect");
-const _1 = require(".");
-const base_1 = require("./base");
-const non_semver_error_1 = require("./lib/non-semver-error");
+import { Effect, pipe } from 'effect';
+import { BaseSpecifier } from './base.js';
+import { Specifier } from './index.js';
+import { NonSemverError } from './lib/non-semver-error.js';
 /** @example "npm:imageoptim-cli@3.1.7" */
-class AliasSpecifier extends base_1.BaseSpecifier {
+export class AliasSpecifier extends BaseSpecifier {
     _tag = 'Alias';
     /** The public name referenced in config */
     name = 'alias';
     /** Return the version portion if it is valid semver */
     getSemver() {
-        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => parsed.subSpec), effect_1.Effect.flatMap((subSpec) => ['range', 'version'].includes(subSpec.type) && subSpec.fetchSpec !== null
-            ? effect_1.Effect.succeed(subSpec.fetchSpec)
-            : non_semver_error_1.NonSemverError.asEffect(this)));
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => parsed.subSpec), Effect.flatMap((subSpec) => ['range', 'version'].includes(subSpec.type) && subSpec.fetchSpec !== null
+            ? Effect.succeed(subSpec.fetchSpec)
+            : NonSemverError.asEffect(this)));
     }
     /** Get a new `Specifier` from the given semver version applied to this one */
     setSemver(version) {
-        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => parsed.subSpec), effect_1.Effect.map((subSpec) => subSpec.name || ''), effect_1.Effect.map((name) => `npm:${name}@${version}`), effect_1.Effect.map((raw) => _1.Specifier.create(this.instance, raw)));
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => parsed.subSpec), Effect.map((subSpec) => subSpec.name || ''), Effect.map((name) => `npm:${name}@${version}`), Effect.map((raw) => Specifier.create(this.instance, raw)));
     }
 }
-exports.AliasSpecifier = AliasSpecifier;

package/dist/specifier/base.d.ts

@@ -1,8 +1,8 @@
 import { Effect } from 'effect';
-import { Specifier } from '.';
-import type { Instance } from '../get-instances/instance';
-import { NonSemverError } from './lib/non-semver-error';
-import type { NpmPackageArgResult } from './lib/parse-specifier';
+import type { Instance } from '../get-instances/instance.js';
+import { Specifier } from './index.js';
+import { NonSemverError } from './lib/non-semver-error.js';
+import type { NpmPackageArgResult } from './lib/parse-specifier.js';
 export declare class BaseSpecifier<T extends NpmPackageArgResult | unknown> {
     /** should be overridden by sub classes */
     _tag: string;
@@ -31,11 +31,11 @@ export declare class BaseSpecifier<T extends NpmPackageArgResult | unknown> {
      * Parse the raw version specifier using
      * https://github.com/npm/npm-package-arg
      */
-    protected parse(): Effect.Effect<never, unknown, T>;
+    protected parse(): Effect.Effect<T, unknown>;
     /** Return the version portion if it is valid semver */
-    getSemver(this: Specifier.Any): Effect.Effect<never, NonSemverError, string>;
+    getSemver(this: Specifier.Any): Effect.Effect<string, NonSemverError>;
     /** Get a new `Specifier` from the given semver version applied to this one */
-    setSemver(this: Specifier.Any, _version: string): Effect.Effect<never, NonSemverError, Specifier.Any>;
+    setSemver(this: Specifier.Any, _version: string): Effect.Effect<Specifier.Any, NonSemverError>;
     /** Apply the given specifier to a new one with this instance bound to it */
     replaceWith<T extends Specifier.Any>(specifier: T): T;
 }