syncpack 12.4.0 → 13.0.0

package/dist/version-group/pinned.js

@@ -14,13 +14,13 @@ export class PinnedVersionGroup extends Data.TaggedClass('Pinned') {
         return true;
     }
     inspectAll() {
-        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
+        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.Valid(expected)
             : // ✓ pinned takes precedence over any semver group
                 // ✘ current version mismatches expected
                 // ✓ is a mismatch we can auto-fix
-                new Report.PinnedMismatch(expected)))), Effect.map((reports) => ({ name, reports })))));
+                new Report.PinnedMismatch(expected)))), Effect.map(reports => ({ name, reports })))));
     }
 }

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

@@ -17,7 +17,7 @@ export class SameRangeVersionGroup extends Data.TaggedClass('SameRange') {
         return true;
     }
     inspectAll() {
-        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({
+        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
@@ -28,7 +28,7 @@ export class SameRangeVersionGroup extends Data.TaggedClass('SameRange') {
                 // ✘ expected version is not fixable by its semver group
                 // ✘ is a mismatch we can't auto-fix
                 new Report.UnsupportedMismatch(specifier.instance)),
-                onSuccess: (valid) => specifier.instance.rawSpecifier.raw === valid.raw
+                onSuccess: valid => specifier.instance.rawSpecifier.raw === valid.raw
                     ? Effect.succeed(
                     // ✓ expected version is semver
                     // ✓ expected version matches its semver group
@@ -42,7 +42,7 @@ export class SameRangeVersionGroup extends Data.TaggedClass('SameRange') {
                     new Report.SemverRangeMismatch(valid)),
             })),
         }))))), Effect.map(([allMismatches, allMatches]) => allMismatches.length === 0
-            ? allMatches.map((thisMatch) => {
+            ? allMatches.map(thisMatch => {
                 if (thisMatch.specifier.instance.strategy.name === 'local') {
                     // ✓ every instance is valid on its own
                     // ✓ expected version is semver
@@ -66,18 +66,18 @@ export class SameRangeVersionGroup extends Data.TaggedClass('SameRange') {
                 // ✓ current version matches expected
                 // ! is not the original local package
                 // ✘ current specifier does not match every other specifier
-                return new Report.SameRangeMismatch(thisMatch.specifier.instance, 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.map((reports) => ({ name, reports })))));
+                [...allMatches, ...allMismatches]), Effect.map(reports => ({ name, reports })))));
     }
 }
 /** Find all ranges/versions which this semver version does not cover */
 function getRangeMismatches(ctx, report, others) {
-    return others.filter((other) => !matchesRange(ctx, report, other));
+    return others.filter(other => !matchesRange(ctx, report, other));
 }
 /** Does semver version `a` match semver version `b`? */
 function matchesRange(ctx, a, b) {

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

@@ -15,18 +15,19 @@ export class SnappedToVersionGroup extends Data.TaggedClass('SnappedTo') {
     }
     inspectAll() {
         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) => 
+            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.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({
+            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.UnsupportedMismatch(specifier.instance),
-                    onSuccess: (valid) => specifier.instance.rawSpecifier.raw === valid.raw
+                    onSuccess: valid => specifier.instance.rawSpecifier.raw ===
+                        valid.raw
                         ? // ! expected version is not semver
                             // ✓ semver group is disabled/ignored
                             // ✓ current version matches expected
@@ -44,7 +45,8 @@ export class SnappedToVersionGroup extends Data.TaggedClass('SnappedTo') {
                     // ✘ is a mismatch we can't auto-fix
                     // ✘ this should be impossible - we already proved the local version is exact semver
                     new Report.UnsupportedMismatch(specifier.instance),
-                    onSuccess: (valid) => specifier.instance.rawSpecifier.raw === valid.raw
+                    onSuccess: valid => specifier.instance.rawSpecifier.raw ===
+                        valid.raw
                         ? // ✓ expected version is semver
                             // ✓ expected version matches its semver group
                             // ✓ current version matches expected
@@ -56,7 +58,7 @@ export class SnappedToVersionGroup extends Data.TaggedClass('SnappedTo') {
                             new Report.SnappedToMismatch(valid, expected.instance),
                 })),
             })))))),
-        }), Effect.map((reports) => ({ name, reports })))));
+        }), Effect.map(reports => ({ name, reports })))));
     }
 }
 function findSnappedToInstance(name, snapTo, instances) {

package/dist/version-group/standard.js

@@ -21,15 +21,15 @@ export class StandardVersionGroup extends Data.TaggedClass('Standard') {
             const localInstance = getLocalInstance(instances);
             if (localInstance) {
                 const localVersion = localInstance?.rawSpecifier.raw;
-                return pipe(Effect.succeed(Specifier.create(localInstance, localVersion)), Effect.flatMap((local) => Effect.all(local._tag !== 'Exact' && instances.length > 1
-                    ? instances.map((instance) => 
+                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.succeed(new Report.MissingLocalVersion(instance, localInstance)))
-                    : instances.flatMap((instance) => 
+                    : instances.flatMap(instance => 
                     // instances.flatMap((instance) =>
-                    pipe(Effect.succeed(Specifier.create(instance, instance.rawSpecifier.raw)), 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
@@ -41,12 +41,14 @@ export class StandardVersionGroup extends Data.TaggedClass('Standard') {
                             // ✘ is a mismatch we can't auto-fix
                             // ✘ this should be impossible - we already proved the local version is exact semver
                             new Report.UnsupportedMismatch(specifier.instance),
-                            onSuccess: (valid) => specifier.instance.rawSpecifier.raw === valid.raw
+                            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.Valid(specifier)
-                                : localVersion === 'PACKAGE_JSON_HAS_NO_VERSION'
+                                : localVersion ===
+                                    'PACKAGE_JSON_HAS_NO_VERSION'
                                     ? // ! is not the local package instance
                                         // ✘ local package has a version defined
                                         // ✓ local version matches this semver group
@@ -57,37 +59,38 @@ export class StandardVersionGroup extends Data.TaggedClass('Standard') {
                                         // ✓ local version matches this semver group
                                         // ✘ current version mismatches local
                                         new Report.LocalPackageMismatch(valid, localInstance),
-                        }))))))), Effect.map((reports) => ({ name, reports })));
+                        }))))))), Effect.map(reports => ({ name, reports })));
             }
             const PreferredMismatch = this.config.preferVersion === 'lowestSemver'
                 ? 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) => 
+            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.Valid(specifier))
-                    : instances.map((instance) => 
+                    : instances.map(instance => 
                     // ✘ not every version is semver
                     // ✘ some versions are not identical
                     // ✘ is a mismatch we can't auto-fix
                     new Report.UnsupportedMismatch(instance))),
-                onSuccess: (expectedVersion) => pipe(specifiers, Effect.forEach((current) => pipe(current.replaceWith(expectedVersion), current.instance.semverGroup.getFixed, Effect.match({
+                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.UnsupportedMismatch(current.instance),
-                    onSuccess: (expectedRange) => current.instance.rawSpecifier.raw === expectedRange.raw
+                    onSuccess: expectedRange => current.instance.rawSpecifier.raw ===
+                        expectedRange.raw
                         ? // ✓ every version is semver
                             // ✓ current version matches expected semver
                             // ✓ current version matches expected version
                             new Report.Valid(current)
-                        : current.instance.rawSpecifier.raw === expectedVersion.raw
+                        : current.instance.rawSpecifier.raw ===
+                            expectedVersion.raw
                             ? // ✓ every version is semver
                                 // ✓ current version matches expected version
                                 // ✘ current version does not match expected semver
@@ -99,7 +102,7 @@ export class StandardVersionGroup extends Data.TaggedClass('Standard') {
                                 // ✓ is a mismatch we can auto-fix
                                 new PreferredMismatch(expectedRange),
                 })))),
-            }))), Effect.map((reports) => ({ name, reports })));
+            }))), Effect.map(reports => ({ name, reports })));
         }));
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "syncpack",
   "description": "Consistent dependency versions in large JavaScript Monorepos",
-  "version": "12.4.0",
+  "version": "13.0.0",
   "author": "Jamie Mason <jamie@foldleft.io> (https://github.com/JamieMason)",
   "bin": {
     "syncpack": "dist/bin.js",
@@ -41,19 +41,21 @@
     "Michał Warać (https://github.com/auto200)",
     "Nick Saunders (https://github.com/nsaunders)",
     "Siraj (https://github.com/Syhner)",
+    "Stuart Knightley (https://github.com/Stuk)",
     "Tom Fletcher (https://github.com/tom-fletcher)"
   ],
   "dependencies": {
-    "@effect/schema": "0.69.0",
+    "@effect/schema": "0.71.1",
     "chalk": "5.3.0",
     "chalk-template": "1.1.0",
     "commander": "12.1.0",
     "cosmiconfig": "9.0.0",
-    "effect": "3.5.7",
+    "effect": "3.6.5",
     "enquirer": "2.4.1",
-    "fast-check": "3.20.0",
+    "fast-check": "3.21.0",
     "globby": "14.0.2",
-    "minimatch": "10.0.1",
+    "jsonc-parser": "3.3.1",
+    "minimatch": "9.0.5",
     "npm-package-arg": "11.0.3",
     "ora": "8.0.1",
     "prompts": "2.4.2",
@@ -63,32 +65,26 @@
     "ts-toolbelt": "9.6.0"
   },
   "devDependencies": {
+    "@biomejs/biome": "1.8.3",
     "@release-it/conventional-changelog": "8.0.1",
     "@tsconfig/node18": "18.2.4",
-    "@types/node": "20.14.12",
+    "@types/node": "22.5.0",
     "@types/npm-package-arg": "6.1.4",
     "@types/prompts": "2.4.9",
     "@types/semver": "7.5.8",
-    "@typescript-eslint/eslint-plugin": "7.17.0",
-    "@typescript-eslint/parser": "7.17.0",
-    "@vitest/coverage-v8": "2.0.4",
+    "@vitest/coverage-v8": "2.0.5",
     "auto-changelog": "2.4.0",
-    "eslint": "8.56.0",
-    "eslint-plugin-import": "2.29.1",
-    "memfs": "4.9.4",
+    "memfs": "4.11.1",
     "prettier": "3.3.3",
     "prettier-plugin-astro": "0.14.1",
-    "quill-delta": "5.1.0",
     "release-it": "17.6.0",
-    "rxjs": "7.8.1",
     "ts-node": "10.9.2",
-    "tslib": "2.6.3",
     "typescript": "5.5.4",
-    "typescript-json-schema": "0.64.0",
-    "vitest": "2.0.4"
+    "typescript-json-schema": "0.65.1",
+    "vitest": "2.0.5"
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=18.18.0"
   },
   "exports": "./dist/index.js",
   "files": [
@@ -122,15 +118,16 @@
     "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",
-    "format:lint": "eslint --ext .ts . --fix",
-    "format:source": "prettier --write .",
-    "lint": "pnpm run lint:ts && pnpm run lint:eslint",
-    "lint:eslint": "eslint --ext .ts .",
-    "lint:ts": "tsc --noEmit --project tsconfig.json",
+    "format": "pnpm run format:source && pnpm run format:astro",
+    "format:astro": "prettier --write site/src",
+    "format:source": "biome check --write --unsafe",
+    "lint": "npm run lint:source && npm run lint:engines",
+    "lint:engines": "node scripts/check-engines.mjs",
+    "lint:source": "biome check && tsc --noEmit",
     "prepack": "pnpm run build",
     "release": "release-it",
-    "test": "vitest run --config vitest.config.ts"
+    "test": "vitest run --coverage src",
+    "test:watch": "vitest run --no-coverage --watch"
   },
   "type": "module",
   "types": "./dist/index.d.ts"