syncpack 12.2.0 → 12.3.1

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 {};

package/dist/version-group/snapped-to.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SnappedToVersionGroup = 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 SnappedToVersionGroup extends effect_1.Data.TaggedClass('SnappedTo') {
+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 SnappedToVersionGroup extends Data.TaggedClass('SnappedTo') {
     groupType = 'versionGroup';
     constructor(config) {
         super({
@@ -17,57 +14,56 @@ class SnappedToVersionGroup extends effect_1.Data.TaggedClass('SnappedTo') {
         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)(findSnappedToInstance(name, this.config.snapTo, instances), effect_1.Effect.matchEffect({
-            onFailure: () => effect_1.Effect.succeed(instances.map((instance) => 
+        return Effect.all(Object.entries(groupBy('name', this.instances)).flatMap(([name, instances]) => pipe(findSnappedToInstance(name, this.config.snapTo, instances), Effect.matchEffect({
+            onFailure: () => Effect.succeed(instances.map((instance) => 
             // ✘ none of the snapTo packages contain this dependency
             // ✘ is a user configuration error we can't auto-fix
-            new report_1.Report.MissingSnappedToMismatch(instance))),
-            onSuccess: (expected) => (0, effect_1.pipe)(instances, effect_1.Effect.forEach((instance) => (0, effect_1.pipe)(effect_1.Effect.Do, effect_1.Effect.bind('specifier', () => effect_1.Effect.succeed(specifier_1.Specifier.create(instance, instance.rawSpecifier.raw))), effect_1.Effect.bind('expected', () => effect_1.Effect.succeed(specifier_1.Specifier.create(instance, expected.rawSpecifier.raw))), effect_1.Effect.flatMap(({ expected, specifier }) => (0, effect_1.pipe)(expected.getSemver(), effect_1.Effect.matchEffect({
-                onFailure: () => (0, effect_1.pipe)(specifier.replaceWith(expected), specifier.instance.semverGroup.getFixed, effect_1.Effect.match({
+            new Report.MissingSnappedToMismatch(instance))),
+            onSuccess: (expected) => pipe(instances, Effect.forEach((instance) => pipe(Effect.Do, Effect.bind('specifier', () => Effect.succeed(Specifier.create(instance, instance.rawSpecifier.raw))), Effect.bind('expected', () => Effect.succeed(Specifier.create(instance, expected.rawSpecifier.raw))), Effect.flatMap(({ expected, specifier }) => pipe(expected.getSemver(), Effect.matchEffect({
+                onFailure: () => pipe(specifier.replaceWith(expected), specifier.instance.semverGroup.getFixed, Effect.match({
                     onFailure: () => 
                     // ✘ expected version is not semver
                     // ✘ semver group expects semver
                     // ✘ 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
                         ? // ! expected version is not semver
                             // ✓ semver group is disabled/ignored
                             // ✓ current version matches expected
-                            new report_1.Report.Valid(specifier)
+                            new Report.Valid(specifier)
                         : // ! expected version is not semver
                             // ✓ semver group is disabled/ignored
                             // ✘ current version mismatches expected
                             // ✓ is a mismatch we can auto-fix by replacing with the non-semver version
-                            new report_1.Report.SnappedToMismatch(valid, expected.instance),
+                            new Report.SnappedToMismatch(valid, expected.instance),
                 })),
-                onSuccess: () => (0, effect_1.pipe)(specifier.replaceWith(expected), specifier.instance.semverGroup.getFixed, effect_1.Effect.match({
+                onSuccess: () => pipe(specifier.replaceWith(expected), specifier.instance.semverGroup.getFixed, Effect.match({
                     onFailure: /* istanbul ignore next */ () => 
                     // ✓ expected version is semver
                     // ✘ expected version is not fixable by its semver group
                     // ✘ is a mismatch we can't auto-fix
                     // ✘ this should be impossible - we already proved the local version is exact semver
-                    new report_1.Report.UnsupportedMismatch(specifier.instance),
+                    new Report.UnsupportedMismatch(specifier.instance),
                     onSuccess: (valid) => specifier.instance.rawSpecifier.raw === valid.raw
                         ? // ✓ expected version is semver
                             // ✓ expected version matches its semver group
                             // ✓ current version matches expected
-                            new report_1.Report.Valid(specifier)
+                            new Report.Valid(specifier)
                         : // ✓ 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.SnappedToMismatch(valid, expected.instance),
+                            new Report.SnappedToMismatch(valid, expected.instance),
                 })),
             })))))),
-        }), effect_1.Effect.map((reports) => ({ name, reports })))));
+        }), Effect.map((reports) => ({ name, reports })))));
     }
 }
-exports.SnappedToVersionGroup = SnappedToVersionGroup;
 function findSnappedToInstance(name, snapTo, instances) {
     for (const instance of instances) {
         if (snapTo.includes(instance.pkgName) && instance.rawSpecifier.raw) {
-            return (0, effect_1.pipe)(effect_1.Effect.succeed(instance), effect_1.Effect.tap(() => effect_1.Effect.logDebug(`found snapped to version ${String(instance.rawSpecifier.raw)} for ${name} in <${instance.packageJsonFile.jsonFile.shortPath}>`)));
+            return pipe(Effect.succeed(instance), Effect.tap(() => Effect.logDebug(`found snapped to version ${String(instance.rawSpecifier.raw)} for ${name} in <${instance.packageJsonFile.jsonFile.shortPath}>`)));
         }
     }
-    return (0, effect_1.pipe)(effect_1.Effect.fail('getSnappedTo found nothing'), effect_1.Effect.tapError(() => effect_1.Effect.logError(`failed to get snapped to version for ${name} using ${JSON.stringify(snapTo)}`)));
+    return pipe(Effect.fail('getSnappedTo found nothing'), Effect.tapError(() => Effect.logError(`failed to get snapped to version for ${name} using ${JSON.stringify(snapTo)}`)));
 }

package/dist/version-group/standard.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 StandardVersionGroup_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 StandardVersionGroup_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: "Standard";
-}>;
+};
 export declare class StandardVersionGroup extends StandardVersionGroup_base<{
     config: VersionGroupConfig.Standard;
     instances: Instance[];
@@ -13,6 +13,6 @@ export declare class StandardVersionGroup extends StandardVersionGroup_base<{
     groupType: string;
     constructor(isCatchAll: boolean, config: VersionGroupConfig.Standard);
     canAdd(_: Instance): boolean;
-    inspectAll(): Effect.Effect<never, never, Report.Version.Group[]>;
+    inspectAll(): Effect.Effect<Report.Version.Group[]>;
 }
 export {};

package/dist/version-group/standard.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StandardVersionGroup = void 0;
-const effect_1 = require("effect");
-const uniq_1 = require("tightrope/array/uniq");
-const report_1 = require("../report");
-const specifier_1 = require("../specifier");
-const get_preferred_version_1 = require("./lib/get-preferred-version");
-const group_by_1 = require("./lib/group-by");
-class StandardVersionGroup extends effect_1.Data.TaggedClass('Standard') {
+import { Data, Effect, pipe } from 'effect';
+import { uniq } from 'tightrope/array/uniq.js';
+import { Report } from '../report.js';
+import { Specifier } from '../specifier/index.js';
+import { getPreferredVersion } from './lib/get-preferred-version.js';
+import { groupBy } from './lib/group-by.js';
+export class StandardVersionGroup extends Data.TaggedClass('Standard') {
     groupType = 'versionGroup';
     constructor(isCatchAll, config) {
         super({
@@ -20,93 +17,92 @@ class StandardVersionGroup extends effect_1.Data.TaggedClass('Standard') {
         return true;
     }
     inspectAll() {
-        return effect_1.Effect.all(Object.entries((0, group_by_1.groupBy)('name', this.instances)).flatMap(([name, instances]) => {
+        return Effect.all(Object.entries(groupBy('name', this.instances)).flatMap(([name, instances]) => {
             const localInstance = getLocalInstance(instances);
             if (localInstance) {
                 const localVersion = localInstance?.rawSpecifier.raw;
-                return (0, effect_1.pipe)(effect_1.Effect.succeed(specifier_1.Specifier.create(localInstance, localVersion)), effect_1.Effect.flatMap((local) => effect_1.Effect.all(local._tag !== 'Exact' && instances.length > 1
+                return pipe(Effect.succeed(Specifier.create(localInstance, localVersion)), Effect.flatMap((local) => Effect.all(local._tag !== 'Exact' && instances.length > 1
                     ? instances.map((instance) => 
                     // ! dependency is a package developed in this repo
                     // ✘ local package has an invalid .version property
                     // ✘ is a mismatch we can't auto-fix
-                    effect_1.Effect.succeed(new report_1.Report.MissingLocalVersion(instance, localInstance)))
+                    Effect.succeed(new Report.MissingLocalVersion(instance, localInstance)))
                     : instances.flatMap((instance) => 
                     // instances.flatMap((instance) =>
-                    (0, effect_1.pipe)(effect_1.Effect.succeed(specifier_1.Specifier.create(instance, instance.rawSpecifier.raw)), effect_1.Effect.flatMap((specifier) => specifier.instance === localInstance
+                    pipe(Effect.succeed(Specifier.create(instance, instance.rawSpecifier.raw)), Effect.flatMap((specifier) => specifier.instance === localInstance
                         ? // ✓ this is the local package which the others should match
                             // ! its version must always remain as exact semver
                             // ! other instances need to be adjusted for their semver groups
-                            effect_1.Effect.succeed(new report_1.Report.Valid(specifier))
-                        : (0, effect_1.pipe)(specifier.replaceWith(local), specifier.instance.semverGroup.getFixed, effect_1.Effect.match({
+                            Effect.succeed(new Report.Valid(specifier))
+                        : pipe(specifier.replaceWith(local), specifier.instance.semverGroup.getFixed, Effect.match({
                             onFailure: /* istanbul ignore next */ () => 
                             // ! is not the local package instance
                             // ✘ local version is not fixable by this semver group
                             // ✘ is a mismatch we can't auto-fix
                             // ✘ this should be impossible - we already proved the local version is exact semver
-                            new report_1.Report.UnsupportedMismatch(specifier.instance),
+                            new Report.UnsupportedMismatch(specifier.instance),
                             onSuccess: (valid) => specifier.instance.rawSpecifier.raw === valid.raw
                                 ? // ! is not the local package instance
                                     // ✓ local version matches this semver group
                                     // ✓ current version matches local
-                                    new report_1.Report.Valid(specifier)
+                                    new Report.Valid(specifier)
                                 : localVersion === 'PACKAGE_JSON_HAS_NO_VERSION'
                                     ? // ! is not the local package instance
                                         // ✘ local package has a version defined
                                         // ✓ local version matches this semver group
                                         // ✘ current version mismatches local
-                                        new report_1.Report.MissingLocalVersion(specifier.instance, localInstance)
+                                        new Report.MissingLocalVersion(specifier.instance, localInstance)
                                     : // ! is not the local package instance
                                         // ✓ local package has a version defined
                                         // ✓ local version matches this semver group
                                         // ✘ current version mismatches local
-                                        new report_1.Report.LocalPackageMismatch(valid, localInstance),
-                        }))))))), effect_1.Effect.map((reports) => ({ name, reports })));
+                                        new Report.LocalPackageMismatch(valid, localInstance),
+                        }))))))), Effect.map((reports) => ({ name, reports })));
             }
             const PreferredMismatch = this.config.preferVersion === 'lowestSemver'
-                ? report_1.Report.LowestSemverMismatch
-                : report_1.Report.HighestSemverMismatch;
-            return (0, effect_1.pipe)(effect_1.Effect.succeed(instances.map((instance) => specifier_1.Specifier.create(instance, instance.rawSpecifier.raw))), effect_1.Effect.flatMap((specifiers) => (0, effect_1.pipe)((0, get_preferred_version_1.getPreferredVersion)(this.config.preferVersion, specifiers), effect_1.Effect.matchEffect({
-                onFailure: () => effect_1.Effect.succeed((0, uniq_1.uniq)(specifiers.map((specifier) => specifier.instance.rawSpecifier.raw))
+                ? Report.LowestSemverMismatch
+                : Report.HighestSemverMismatch;
+            return pipe(Effect.succeed(instances.map((instance) => Specifier.create(instance, instance.rawSpecifier.raw))), Effect.flatMap((specifiers) => pipe(getPreferredVersion(this.config.preferVersion, specifiers), Effect.matchEffect({
+                onFailure: () => Effect.succeed(uniq(specifiers.map((specifier) => specifier.instance.rawSpecifier.raw))
                     .length === 1
                     ? specifiers.map((specifier) => 
                     // ✘ not every version is semver
                     // ✓ every version is identical
                     // ✓ is a match
-                    new report_1.Report.Valid(specifier))
+                    new Report.Valid(specifier))
                     : instances.map((instance) => 
                     // ✘ not every version is semver
                     // ✘ some versions are not identical
                     // ✘ is a mismatch we can't auto-fix
-                    new report_1.Report.UnsupportedMismatch(instance))),
-                onSuccess: (expectedVersion) => (0, effect_1.pipe)(specifiers, effect_1.Effect.forEach((current) => (0, effect_1.pipe)(current.replaceWith(expectedVersion), current.instance.semverGroup.getFixed, effect_1.Effect.match({
+                    new Report.UnsupportedMismatch(instance))),
+                onSuccess: (expectedVersion) => pipe(specifiers, Effect.forEach((current) => pipe(current.replaceWith(expectedVersion), current.instance.semverGroup.getFixed, Effect.match({
                     onFailure: /* istanbul ignore next */ () => 
                     // ✓ every version is semver
                     // ✘ expected version is not fixable by its semver group
                     // ✘ is a mismatch we can't auto-fix
                     // ✘ this should be impossible - any valid semver is fixable by a semver group
-                    new report_1.Report.UnsupportedMismatch(current.instance),
+                    new Report.UnsupportedMismatch(current.instance),
                     onSuccess: (expectedRange) => current.instance.rawSpecifier.raw === expectedRange.raw
                         ? // ✓ every version is semver
                             // ✓ current version matches expected semver
                             // ✓ current version matches expected version
-                            new report_1.Report.Valid(current)
+                            new Report.Valid(current)
                         : current.instance.rawSpecifier.raw === expectedVersion.raw
                             ? // ✓ every version is semver
                                 // ✓ current version matches expected version
                                 // ✘ current version does not match expected semver
                                 // ✓ is a mismatch we can auto-fix
-                                new report_1.Report.SemverRangeMismatch(expectedRange)
+                                new Report.SemverRangeMismatch(expectedRange)
                             : // ✓ every version is semver
                                 // ✘ current version does not match expected version
                                 // ✘ expected version does not match expected semver
                                 // ✓ is a mismatch we can auto-fix
                                 new PreferredMismatch(expectedRange),
                 })))),
-            }))), effect_1.Effect.map((reports) => ({ name, reports })));
+            }))), Effect.map((reports) => ({ name, reports })));
         }));
     }
 }
-exports.StandardVersionGroup = StandardVersionGroup;
 /**
  * If this dependency is developed in this monorepo, get the instance which
  * represents the canonical .version property of its package.json file.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "syncpack",
   "description": "Consistent dependency versions in large JavaScript Monorepos",
-  "version": "12.2.0",
+  "version": "12.3.1",
   "author": "Jamie Mason <jamie@foldleft.io> (https://github.com/JamieMason)",
   "bin": {
     "syncpack": "dist/bin.js",
@@ -33,51 +33,53 @@
     "Tom Fletcher (https://github.com/tom-fletcher)"
   ],
   "dependencies": {
-    "@effect/schema": "0.56.1",
-    "chalk": "4.1.2",
-    "commander": "11.1.0",
+    "@effect/schema": "0.66.5",
+    "chalk": "5.3.0",
+    "chalk-template": "1.1.0",
+    "commander": "12.0.0",
     "cosmiconfig": "9.0.0",
-    "effect": "2.0.0-next.62",
+    "effect": "3.0.3",
     "enquirer": "2.4.1",
-    "fast-check": "3.15.0",
-    "globby": "11.1.0",
-    "minimatch": "9.0.3",
-    "npm-package-arg": "11.0.1",
-    "ora": "5.4.1",
+    "fast-check": "3.17.2",
+    "globby": "14.0.1",
+    "minimatch": "9.0.4",
+    "npm-package-arg": "11.0.2",
+    "ora": "8.0.1",
     "prompts": "2.4.2",
     "read-yaml-file": "2.1.0",
-    "semver": "7.5.4",
-    "tightrope": "0.1.0",
+    "semver": "7.6.0",
+    "tightrope": "0.2.0",
     "ts-toolbelt": "9.6.0"
   },
   "devDependencies": {
     "@release-it/conventional-changelog": "8.0.1",
-    "@tsconfig/node18": "18.2.2",
-    "@types/node": "20.10.6",
+    "@tsconfig/node18": "18.2.4",
+    "@types/node": "20.12.7",
     "@types/npm-package-arg": "6.1.4",
     "@types/prompts": "2.4.9",
-    "@types/semver": "7.5.6",
-    "@typescript-eslint/eslint-plugin": "6.16.0",
-    "@typescript-eslint/parser": "6.16.0",
-    "@vitest/coverage-v8": "1.1.0",
+    "@types/semver": "7.5.8",
+    "@typescript-eslint/eslint-plugin": "6.19.0",
+    "@typescript-eslint/parser": "6.19.0",
+    "@vitest/coverage-v8": "1.5.0",
     "auto-changelog": "2.4.0",
     "eslint": "8.56.0",
     "eslint-plugin-import": "2.29.1",
-    "memfs": "4.6.0",
-    "prettier": "3.1.1",
-    "prettier-plugin-astro": "0.12.3",
+    "memfs": "4.8.2",
+    "prettier": "3.2.5",
+    "prettier-plugin-astro": "0.13.0",
     "quill-delta": "5.1.0",
-    "release-it": "17.0.1",
+    "release-it": "17.2.0",
     "rxjs": "7.8.1",
     "ts-node": "10.9.2",
     "tslib": "2.6.2",
-    "typescript": "5.3.3",
-    "typescript-json-schema": "0.62.0",
-    "vitest": "1.1.0"
+    "typescript": "5.4.5",
+    "typescript-json-schema": "0.63.0",
+    "vitest": "1.5.0"
   },
   "engines": {
     "node": ">=16"
   },
+  "exports": "./dist/index.js",
   "files": [
     "dist"
   ],
@@ -103,20 +105,10 @@
     "yarn"
   ],
   "license": "MIT",
-  "main": "dist/index.js",
-  "pnpm": {
-    "overrides": {
-      "chalk": "4.1.2",
-      "effect": "2.0.0-next.62",
-      "string-width": "<5.0.0",
-      "strip-ansi": "<7.0.0",
-      "wrap-ansi": "<8.0.0"
-    }
-  },
   "repository": "JamieMason/syncpack",
   "scripts": {
     "build": "pnpm run clean && pnpm run build:source && pnpm run build:json-schema",
-    "build:json-schema": "typescript-json-schema --esModuleInterop --noExtraProps src/index.ts RcFile --out dist/schema.json",
+    "build:json-schema": "typescript-json-schema --esModuleInterop --noExtraProps --ignoreErrors src/index.ts RcFile --out dist/schema.json",
     "build:source": "tsc --project tsconfig.build.json",
     "clean": "rm -rf ./dist",
     "format": "pnpm run format:lint && pnpm run format:source",
@@ -128,5 +120,6 @@
     "prepack": "pnpm run build",
     "release": "release-it",
     "test": "vitest run --config vitest.config.ts"
-  }
+  },
+  "type": "module"
 }

package/dist/io/read-config-file-sync.d.ts

@@ -1,7 +0,0 @@
-import { Effect } from 'effect';
-import type { O } from 'ts-toolbelt';
-import type { Io } from '.';
-import type { RcConfig } from '../config/types';
-type UnverifiedRcConfig = O.Partial<RcConfig, 'deep'>;
-export declare function readConfigFileSync(io: Io, configPath?: string): Effect.Effect<never, never, UnverifiedRcConfig>;
-export {};

package/dist/io/read-config-file-sync.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readConfigFileSync = void 0;
-const effect_1 = require("effect");
-const path_1 = require("path");
-const is_non_empty_object_1 = require("tightrope/guard/is-non-empty-object");
-const read_json_file_sync_1 = require("./read-json-file-sync");
-const getOptionOfNonEmptyObject = effect_1.Option.liftPredicate((is_non_empty_object_1.isNonEmptyObject));
-function readConfigFileSync(io, configPath) {
-    return (0, effect_1.pipe)(effect_1.Effect.try(() => io.cosmiconfig.cosmiconfig('syncpack')), effect_1.Effect.flatMap((client) => effect_1.Effect.tryPromise(() => (configPath ? client.load(configPath) : client.search()))), effect_1.Effect.flatMap((result) => result !== null ? getValueFromCosmiconfig(result) : findConfigInPackageJson(io)), effect_1.Effect.tap((config) => effect_1.Effect.logDebug(`config file found: ${JSON.stringify(config)}`)), effect_1.Effect.tapError(() => effect_1.Effect.logDebug('no config file found, will use defaults')), effect_1.Effect.catchAll(() => effect_1.Effect.succeed({})));
-}
-exports.readConfigFileSync = readConfigFileSync;
-/**
- * Look for a .config.syncpack property in the root package.json.
- * @see https://github.com/JamieMason/syncpack/issues/86
- */
-function findConfigInPackageJson(io) {
-    return (0, effect_1.pipe)(effect_1.Effect.Do, effect_1.Effect.bind('rcPath', () => effect_1.Effect.succeed((0, path_1.join)(io.process.cwd(), 'package.json'))), effect_1.Effect.bind('packageJson', ({ rcPath }) => (0, read_json_file_sync_1.readJsonFileSync)(io, rcPath)), effect_1.Effect.bind('config', ({ packageJson }) => effect_1.Effect.try(() => packageJson.contents?.config?.syncpack)), effect_1.Effect.flatMap(({ config }) => getOptionOfNonEmptyObject(config)), effect_1.Effect.tapBoth({
-        onSuccess: () => effect_1.Effect.logDebug('config found in <package.json>.config.syncpack'),
-        onFailure: () => effect_1.Effect.logDebug('config not found in <package.json>.config.syncpack'),
-    }));
-}
-/** Extract the value from a successful search by cosmiconfig */
-function getValueFromCosmiconfig(result) {
-    return (0, effect_1.pipe)(effect_1.Effect.succeed(result), effect_1.Effect.tap((result) => effect_1.Effect.logDebug(`cosmiconfig found ${result.filepath}`)), effect_1.Effect.flatMap((result) => getOptionOfNonEmptyObject(result.config)));
-}