syncpack 12.3.0 → 12.3.2

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

@@ -1,11 +1,11 @@
-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> & {
+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';
+declare const FilteredOutVersionGroup_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";
-}>;
+};
 export declare class FilteredOutVersionGroup extends FilteredOutVersionGroup_base<{
     config: GroupConfig;
     filter: string;
@@ -14,6 +14,6 @@ export declare class FilteredOutVersionGroup extends FilteredOutVersionGroup_bas
     groupType: string;
     constructor(ctx: Ctx);
     canAdd(instance: Instance): boolean;
-    inspectAll(): Effect.Effect<never, never, Report.Version.Group[]>;
+    inspectAll(): Effect.Effect<Report.Version.Group[]>;
 }
 export {};

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

@@ -1,11 +1,8 @@
-"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') {
+import { Data, Effect } from 'effect';
+import { getFilter } from '../config/get-filter.js';
+import { Report } from '../report.js';
+import { groupBy } from './lib/group-by.js';
+export class FilteredOutVersionGroup extends Data.TaggedClass('FilteredOut') {
     groupType = 'versionGroup';
     constructor(ctx) {
         super({
@@ -15,7 +12,7 @@ class FilteredOutVersionGroup extends effect_1.Data.TaggedClass('FilteredOut') {
                 label: 'Filtered out',
                 packages: ['**'],
             },
-            filter: (0, get_filter_1.getFilter)(ctx.config),
+            filter: getFilter(ctx.config),
             instances: [],
         });
     }
@@ -23,12 +20,11 @@ class FilteredOutVersionGroup extends effect_1.Data.TaggedClass('FilteredOut') {
         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]) => ({
+        return Effect.succeed(Object.entries(groupBy('name', this.instances)).map(([name, instances]) => ({
             name,
             reports: instances.map((instance) => 
             // ✓ is ignored and dismissed as valid
-            new report_1.Report.FilteredOut(instance)),
+            new Report.FilteredOut(instance)),
         })));
     }
 }
-exports.FilteredOutVersionGroup = FilteredOutVersionGroup;

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

@@ -1,10 +1,10 @@
-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> & {
+import { Effect } from 'effect';
+import type { VersionGroupConfig } from '../config/types.js';
+import type { Instance } from '../get-instances/instance.js';
+import { Report } from '../report.js';
+declare const IgnoredVersionGroup_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";
-}>;
+};
 export declare class IgnoredVersionGroup extends IgnoredVersionGroup_base<{
     config: VersionGroupConfig.Ignored;
     instances: Instance[];
@@ -12,6 +12,6 @@ export declare class IgnoredVersionGroup extends IgnoredVersionGroup_base<{
     groupType: string;
     constructor(config: VersionGroupConfig.Ignored);
     canAdd(_: Instance): boolean;
-    inspectAll(): Effect.Effect<never, never, Report.Version.Group[]>;
+    inspectAll(): Effect.Effect<Report.Version.Group[]>;
 }
 export {};

package/dist/version-group/ignored.js

@@ -1,10 +1,7 @@
-"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') {
+import { Data, Effect } from 'effect';
+import { Report } from '../report.js';
+import { groupBy } from './lib/group-by.js';
+export class IgnoredVersionGroup extends Data.TaggedClass('Ignored') {
     groupType = 'versionGroup';
     constructor(config) {
         super({
@@ -16,12 +13,11 @@ class IgnoredVersionGroup extends effect_1.Data.TaggedClass('Ignored') {
         return true;
     }
     inspectAll() {
-        return effect_1.Effect.succeed(Object.entries((0, group_by_1.groupBy)('name', this.instances)).map(([name, instances]) => ({
+        return Effect.succeed(Object.entries(groupBy('name', this.instances)).map(([name, instances]) => ({
             name,
             reports: instances.map((instance) => 
             // ✓ is ignored and dismissed as valid
-            new report_1.Report.Ignored(instance)),
+            new Report.Ignored(instance)),
         })));
     }
 }
-exports.IgnoredVersionGroup = IgnoredVersionGroup;

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

@@ -1,11 +1,10 @@
-import { Data } from 'effect';
-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';
+import type { BannedVersionGroup } from './banned.js';
+import type { FilteredOutVersionGroup } from './filtered-out.js';
+import type { IgnoredVersionGroup } from './ignored.js';
+import type { PinnedVersionGroup } from './pinned.js';
+import type { SameRangeVersionGroup } from './same-range.js';
+import type { SnappedToVersionGroup } from './snapped-to.js';
+import type { StandardVersionGroup } from './standard.js';
 export declare namespace VersionGroup {
     export type Banned = BannedVersionGroup;
     export type FilteredOut = FilteredOutVersionGroup;
@@ -15,9 +14,9 @@ export declare namespace VersionGroup {
     export type SnappedTo = SnappedToVersionGroup;
     export type Standard = StandardVersionGroup;
     export type Any = 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> & {
+    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: "VersionGroupConfigError";
-    }>;
+    };
     export class ConfigError extends ConfigError_base<{
         readonly config: unknown;
         readonly error: string;

package/dist/version-group/index.js

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

package/dist/version-group/lib/clean.js

@@ -1,13 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clean = void 0;
-const coerce_1 = __importDefault(require("semver/functions/coerce"));
-const valid_1 = __importDefault(require("semver/functions/valid"));
+import coerce from 'semver/functions/coerce.js';
+import valid from 'semver/functions/valid.js';
 /** Convert eg "1" to "1.0.0" which the semver lib does not understand */
-function clean(v) {
-    return (0, valid_1.default)((0, coerce_1.default)(v)) || '';
+export function clean(v) {
+    return valid(coerce(v)) || '';
 }
-exports.clean = clean;

package/dist/version-group/lib/delete.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DELETE = void 0;
-exports.DELETE = Symbol('DELETE');
+export const DELETE = Symbol('DELETE');

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

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

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

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

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

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

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

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

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

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

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

@@ -1,26 +1,19 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPreferredVersion = void 0;
-const effect_1 = require("effect");
-const gt_1 = __importDefault(require("semver/functions/gt"));
-const lt_1 = __importDefault(require("semver/functions/lt"));
-const clean_1 = require("./clean");
-const get_range_score_1 = require("./get-range-score");
-function getPreferredVersion(preferVersion, specifiers) {
-    return (0, effect_1.pipe)(
+import { Effect, pipe } from 'effect';
+import gt from 'semver/functions/gt.js';
+import lt from 'semver/functions/lt.js';
+import { clean } from './clean.js';
+import { getRangeScore } from './get-range-score.js';
+export function getPreferredVersion(preferVersion, specifiers) {
+    return pipe(
     // every instance must have a semver version
-    effect_1.Effect.all(specifiers.map((specifier) => (0, effect_1.pipe)(specifier.getSemver(), effect_1.Effect.map((semver) => ({ semver, specifier }))))), 
+    Effect.all(specifiers.map((specifier) => pipe(specifier.getSemver(), Effect.map((semver) => ({ semver, specifier }))))), 
     // comparing semver can error on some loose ranges, all must succeed
-    effect_1.Effect.map((semvers) => semvers.sort((a, b) => compareSemver(a.semver, b.semver))), 
+    Effect.map((semvers) => semvers.sort((a, b) => compareSemver(a.semver, b.semver))), 
     // get the preferred value from the list
-    effect_1.Effect.map((sorted) => sorted[preferVersion === 'lowestSemver' ? 0 : sorted.length - 1]), 
+    Effect.map((sorted) => sorted[preferVersion === 'lowestSemver' ? 0 : sorted.length - 1]), 
     // return just the specifier
-    effect_1.Effect.map((preferred) => preferred?.specifier));
+    Effect.map((preferred) => preferred?.specifier));
 }
-exports.getPreferredVersion = getPreferredVersion;
 const EQ = 0;
 const LT = -1;
 const GT = 1;
@@ -35,14 +28,14 @@ function compareSemver(a, b) {
         return GT;
     if (b === '*')
         return LT;
-    const cleanA = (0, clean_1.clean)(a);
-    const cleanB = (0, clean_1.clean)(b);
-    if ((0, gt_1.default)(cleanA, cleanB))
+    const cleanA = clean(a);
+    const cleanB = clean(b);
+    if (gt(cleanA, cleanB))
         return GT;
-    if ((0, lt_1.default)(cleanA, cleanB))
+    if (lt(cleanA, cleanB))
         return LT;
-    const scoreA = (0, get_range_score_1.getRangeScore)(a);
-    const scoreB = (0, get_range_score_1.getRangeScore)(b);
+    const scoreA = getRangeScore(a);
+    const scoreB = getRangeScore(b);
     if (scoreA < scoreB)
         return LT;
     if (scoreA > scoreB)

package/dist/version-group/lib/get-range-score.js

@@ -1,22 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRangeScore = void 0;
-const constants_1 = require("../../constants");
+import { RANGE } from '../../constants.js';
 const scoresByRange = {
-    [constants_1.RANGE.ANY]: 9,
-    [constants_1.RANGE.WORKSPACE]: 8,
-    [constants_1.RANGE.GT]: 7,
-    [constants_1.RANGE.GTE]: 6,
-    [constants_1.RANGE.MINOR]: 5,
-    [constants_1.RANGE.LOOSE]: 4,
-    [constants_1.RANGE.PATCH]: 3,
-    [constants_1.RANGE.EXACT]: 2,
-    [constants_1.RANGE.LTE]: 1,
-    [constants_1.RANGE.LT]: 0,
+    [RANGE.ANY]: 9,
+    [RANGE.WORKSPACE]: 8,
+    [RANGE.GT]: 7,
+    [RANGE.GTE]: 6,
+    [RANGE.MINOR]: 5,
+    [RANGE.LOOSE]: 4,
+    [RANGE.PATCH]: 3,
+    [RANGE.EXACT]: 2,
+    [RANGE.LTE]: 1,
+    [RANGE.LT]: 0,
 };
 /** Rank a Semver Range according to its greediness */
-function getRangeScore(version) {
-    const range = version.indexOf('.x') !== -1 ? constants_1.RANGE.LOOSE : version.slice(0, version.search(/[0-9]/));
+export function getRangeScore(version) {
+    const range = version.indexOf('.x') !== -1 ? RANGE.LOOSE : version.slice(0, version.search(/[0-9]/));
     return scoresByRange[range] || 0;
 }
-exports.getRangeScore = getRangeScore;

package/dist/version-group/lib/group-by.js

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

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

@@ -1,10 +1,10 @@
-import { Data, Effect } from 'effect';
-import type { VersionGroupConfig } from '../config/types';
-import type { Instance } from '../get-instances/instance';
-import { Report } from '../report';
-declare const PinnedVersionGroup_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/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 { VersionGroupConfig } from '../config/types.js';
+import type { Instance } from '../get-instances/instance.js';
+import { Report } from '../report.js';
+declare const PinnedVersionGroup_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: "Pinned";
-}>;
+};
 export declare class PinnedVersionGroup extends PinnedVersionGroup_base<{
     config: VersionGroupConfig.Pinned;
     instances: Instance[];
@@ -12,6 +12,6 @@ export declare class PinnedVersionGroup extends PinnedVersionGroup_base<{
     groupType: string;
     constructor(config: VersionGroupConfig.Pinned);
     canAdd(_: Instance): boolean;
-    inspectAll(): Effect.Effect<never, never, Report.Version.Group[]>;
+    inspectAll(): Effect.Effect<Report.Version.Group[]>;
 }
 export {};

package/dist/version-group/pinned.js

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

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

@@ -1,11 +1,11 @@
-import { Data, Effect } from 'effect';
-import type { VersionGroupConfig } from '../config/types';
-import type { Ctx } from '../get-context';
-import type { Instance } from '../get-instances/instance';
-import { Report } from '../report';
-declare const SameRangeVersionGroup_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/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 { VersionGroupConfig } 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';
+declare const SameRangeVersionGroup_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: "SameRange";
-}>;
+};
 export declare class SameRangeVersionGroup extends SameRangeVersionGroup_base<{
     ctx: Ctx;
     config: VersionGroupConfig.SameRange;
@@ -14,6 +14,6 @@ export declare class SameRangeVersionGroup extends SameRangeVersionGroup_base<{
     groupType: string;
     constructor(ctx: Ctx, config: VersionGroupConfig.SameRange);
     canAdd(_: Instance): boolean;
-    inspectAll(): Effect.Effect<never, never, Report.Version.Group[]>;
+    inspectAll(): Effect.Effect<Report.Version.Group[]>;
 }
 export {};

package/dist/version-group/same-range.js

@@ -1,16 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SameRangeVersionGroup = void 0;
-const effect_1 = require("effect");
-const intersects_1 = __importDefault(require("semver/ranges/intersects"));
-const uniq_1 = require("tightrope/array/uniq");
-const report_1 = require("../report");
-const specifier_1 = require("../specifier");
-const group_by_1 = require("./lib/group-by");
-class SameRangeVersionGroup extends effect_1.Data.TaggedClass('SameRange') {
+import { Data, Effect, pipe } from 'effect';
+import intersects from 'semver/ranges/intersects.js';
+import { uniq } from 'tightrope/array/uniq.js';
+import { Report } from '../report.js';
+import { Specifier } from '../specifier/index.js';
+import { groupBy } from './lib/group-by.js';
+export class SameRangeVersionGroup extends Data.TaggedClass('SameRange') {
     groupType = 'versionGroup';
     constructor(ctx, config) {
         super({
@@ -23,31 +17,31 @@ class SameRangeVersionGroup extends effect_1.Data.TaggedClass('SameRange') {
         return true;
     }
     inspectAll() {
-        return effect_1.Effect.all(Object.entries((0, group_by_1.groupBy)('name', this.instances)).flatMap(([name, instances]) => (0, effect_1.pipe)(instances, effect_1.Effect.partition((instance) => (0, effect_1.pipe)(effect_1.Effect.succeed(specifier_1.Specifier.create(instance, instance.rawSpecifier.raw)), effect_1.Effect.flatMap((specifier) => (0, effect_1.pipe)(specifier.getSemver(), effect_1.Effect.matchEffect({
-            onFailure: () => effect_1.Effect.fail(
+        return Effect.all(Object.entries(groupBy('name', this.instances)).flatMap(([name, instances]) => pipe(instances, Effect.partition((instance) => pipe(Effect.succeed(Specifier.create(instance, instance.rawSpecifier.raw)), Effect.flatMap((specifier) => pipe(specifier.getSemver(), Effect.matchEffect({
+            onFailure: () => Effect.fail(
             // ✘ expected version is not semver
             // ✘ is a mismatch we can't auto-fix
-            new report_1.Report.UnsupportedMismatch(specifier.instance)),
-            onSuccess: () => (0, effect_1.pipe)(specifier.instance.semverGroup.getFixed(specifier), effect_1.Effect.matchEffect({
-                onFailure: () => effect_1.Effect.fail(
+            new Report.UnsupportedMismatch(specifier.instance)),
+            onSuccess: () => pipe(specifier.instance.semverGroup.getFixed(specifier), Effect.matchEffect({
+                onFailure: () => Effect.fail(
                 // ✓ expected version is semver
                 // ✘ expected version is not fixable by its semver group
                 // ✘ is a mismatch we can't auto-fix
-                new report_1.Report.UnsupportedMismatch(specifier.instance)),
+                new Report.UnsupportedMismatch(specifier.instance)),
                 onSuccess: (valid) => specifier.instance.rawSpecifier.raw === valid.raw
-                    ? effect_1.Effect.succeed(
+                    ? Effect.succeed(
                     // ✓ expected version is semver
                     // ✓ expected version matches its semver group
                     // ✓ current version matches expected
-                    new report_1.Report.Valid(specifier))
-                    : effect_1.Effect.fail(
+                    new Report.Valid(specifier))
+                    : Effect.fail(
                     // ✓ expected version is semver
                     // ✓ expected version matches its semver group
                     // ✘ current version mismatches expected
                     // ✓ is a mismatch we can auto-fix
-                    new report_1.Report.SemverRangeMismatch(valid)),
+                    new Report.SemverRangeMismatch(valid)),
             })),
-        }))))), effect_1.Effect.map(([allMismatches, allMatches]) => allMismatches.length === 0
+        }))))), Effect.map(([allMismatches, allMatches]) => allMismatches.length === 0
             ? allMatches.map((thisMatch) => {
                 if (thisMatch.specifier.instance.strategy.name === 'local') {
                     // ✓ every instance is valid on its own
@@ -72,16 +66,15 @@ class SameRangeVersionGroup extends effect_1.Data.TaggedClass('SameRange') {
                 // ✓ current version matches expected
                 // ! is not the original local package
                 // ✘ current specifier does not match every other specifier
-                return new report_1.Report.SameRangeMismatch(thisMatch.specifier.instance, (0, uniq_1.uniq)(mismatches.map((report) => String(report.specifier.instance.rawSpecifier.raw))));
+                return new Report.SameRangeMismatch(thisMatch.specifier.instance, uniq(mismatches.map((report) => String(report.specifier.instance.rawSpecifier.raw))));
             })
             : // ✘ not every instance is valid on its own
                 // ! report on their validity individually ! when all are valid
                 //   they can progress to being checked for having compatible
                 //   ranges
-                [...allMatches, ...allMismatches]), effect_1.Effect.map((reports) => ({ name, reports })))));
+                [...allMatches, ...allMismatches]), Effect.map((reports) => ({ name, reports })))));
     }
 }
-exports.SameRangeVersionGroup = SameRangeVersionGroup;
 /** Find all ranges/versions which this semver version does not cover */
 function getRangeMismatches(ctx, report, others) {
     return others.filter((other) => !matchesRange(ctx, report, other));
@@ -89,7 +82,7 @@ function getRangeMismatches(ctx, report, others) {
 /** Does semver version `a` match semver version `b`? */
 function matchesRange(ctx, a, b) {
     const loose = true;
-    return (0, intersects_1.default)(unwrapSemver(ctx, a.specifier), unwrapSemver(ctx, b.specifier), loose);
+    return intersects(unwrapSemver(ctx, a.specifier), unwrapSemver(ctx, b.specifier), loose);
 }
 /** Get the semver version synchronously from a specifier known to contain semver */
 function unwrapSemver(ctx, specifier) {
@@ -97,7 +90,7 @@ function unwrapSemver(ctx, specifier) {
         return specifier.raw;
     }
     if (specifier._tag === 'WorkspaceProtocol') {
-        return effect_1.Effect.runSync(specifier.getSemverEquivalent(ctx));
+        return Effect.runSync(specifier.getSemverEquivalent(ctx));
     }
-    return effect_1.Effect.runSync(specifier.getSemver());
+    return Effect.runSync(specifier.getSemver());
 }

package/dist/version-group/snapped-to.d.ts

@@ -1,10 +1,10 @@
-import { Data, Effect } from 'effect';
-import type { VersionGroupConfig } from '../config/types';
-import type { Instance } from '../get-instances/instance';
-import { Report } from '../report';
-declare const SnappedToVersionGroup_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 { VersionGroupConfig } from '../config/types.js';
+import type { Instance } from '../get-instances/instance.js';
+import { Report } from '../report.js';
+declare const SnappedToVersionGroup_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: "SnappedTo";
-}>;
+};
 export declare class SnappedToVersionGroup extends SnappedToVersionGroup_base<{
     config: VersionGroupConfig.SnappedTo;
     instances: Instance[];
@@ -12,6 +12,6 @@ export declare class SnappedToVersionGroup extends SnappedToVersionGroup_base<{
     groupType: string;
     constructor(config: VersionGroupConfig.SnappedTo);
     canAdd(_: Instance): boolean;
-    inspectAll(): Effect.Effect<never, never, Report.Version.Group[]>;
+    inspectAll(): Effect.Effect<Report.Version.Group[]>;
 }
 export {};