syncpack 10.9.3 → 12.0.0-alpha.0

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

@@ -0,0 +1,108 @@
+"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') {
+    constructor(ctx, config) {
+        super({
+            ctx,
+            config,
+            instances: [],
+        });
+        this.groupType = 'versionGroup';
+    }
+    canAdd(_) {
+        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)), effect_1.Effect.flatMap((specifier) => (0, effect_1.pipe)(specifier.getSemver(), effect_1.Effect.matchEffect({
+            onFailure: () => effect_1.Effect.fail(
+            // ✘ expected version is not semver
+            // ✘ is a mismatch we can't auto-fix
+            new report_1.Report.UnsupportedMismatch({ unfixable: specifier.instance })),
+            onSuccess: () => (0, effect_1.pipe)(specifier.instance.semverGroup.getFixed(specifier), effect_1.Effect.matchEffect({
+                onFailure: () => effect_1.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({
+                    unfixable: specifier.instance,
+                })),
+                onSuccess: (valid) => specifier.instance.rawSpecifier === valid.raw
+                    ? effect_1.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(
+                    // ✓ 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({ fixable: valid })),
+            })),
+        }))))), effect_1.Effect.map(([allMismatches, allMatches]) => allMismatches.length === 0
+            ? allMatches.map((thisMatch) => {
+                if (thisMatch.specifier.instance.strategy.name === 'local') {
+                    // ✓ every instance is valid on its own
+                    // ✓ expected version is semver
+                    // ! is the original local package
+                    // ✓ others must match this, not the other way around
+                    return thisMatch;
+                }
+                const mismatches = getRangeMismatches(this.ctx, thisMatch, allMatches);
+                if (mismatches.length === 0) {
+                    // ✓ every instance is valid on its own
+                    // ✓ expected version is semver
+                    // ✓ expected version matches its semver group
+                    // ✓ current version matches expected
+                    // ! is not the original local package
+                    // ✓ current specifier matches every other specifier
+                    return thisMatch;
+                }
+                // ✓ every instance is valid on its own
+                // ✓ expected version is semver
+                // ✓ expected version matches its semver group
+                // ✓ current version matches expected
+                // ! is not the original local package
+                // ✘ current specifier does not match every other specifier
+                return new report_1.Report.SameRangeMismatch({
+                    unfixable: thisMatch.specifier.instance,
+                    mismatches: (0, uniq_1.uniq)(mismatches.map((report) => report.specifier.instance.rawSpecifier)),
+                });
+            })
+            : // ✘ 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 })))));
+    }
+}
+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));
+}
+/** 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);
+}
+/** Get the semver version synchronously from a specifier known to contain semver */
+function unwrapSemver(ctx, specifier) {
+    if (specifier._tag === 'RangeSpecifier' || specifier._tag === 'VersionSpecifier') {
+        return specifier.raw;
+    }
+    if (specifier._tag === 'WorkspaceProtocolSpecifier') {
+        return effect_1.Effect.runSync(specifier.getSemverEquivalent(ctx));
+    }
+    return effect_1.Effect.runSync(specifier.getSemver());
+}

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

@@ -0,0 +1,17 @@
+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/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "SnappedTo";
+}>;
+export declare class SnappedToVersionGroup extends SnappedToVersionGroup_base<{
+    config: VersionGroupConfig.SnappedTo;
+    instances: Instance[];
+}> {
+    groupType: string;
+    constructor(config: VersionGroupConfig.SnappedTo);
+    canAdd(_: Instance): boolean;
+    inspectAll(): Effect.Effect<never, never, Report.Version.Group[]>;
+}
+export {};

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

@@ -0,0 +1,83 @@
+"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') {
+    constructor(config) {
+        super({
+            config,
+            instances: [],
+        });
+        this.groupType = 'versionGroup';
+    }
+    canAdd(_) {
+        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) => 
+            // ✘ none of the snapTo packages contain this dependency
+            // ✘ is a user configuration error we can't auto-fix
+            new report_1.Report.MissingSnappedToMismatch({ unfixable: 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))), effect_1.Effect.bind('expected', () => effect_1.Effect.succeed(specifier_1.Specifier.create(instance, expected.rawSpecifier))), 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({
+                    onFailure: () => 
+                    // ✘ expected version is not semver
+                    // ✘ semver group expects semver
+                    // ✘ is a mismatch we can't auto-fix
+                    new report_1.Report.UnsupportedMismatch({
+                        unfixable: specifier.instance,
+                    }),
+                    onSuccess: (valid) => specifier.instance.rawSpecifier === valid.raw
+                        ? // ! expected version is not semver
+                            // ✓ semver group is disabled/ignored
+                            // ✓ current version matches expected
+                            new report_1.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({
+                                fixable: valid,
+                                localInstance: expected.instance,
+                            }),
+                })),
+                onSuccess: () => (0, effect_1.pipe)(specifier.replaceWith(expected), specifier.instance.semverGroup.getFixed, effect_1.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({
+                        unfixable: specifier.instance,
+                    }),
+                    onSuccess: (valid) => specifier.instance.rawSpecifier === valid.raw
+                        ? // ✓ expected version is semver
+                            // ✓ expected version matches its semver group
+                            // ✓ current version matches expected
+                            new report_1.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({
+                                fixable: valid,
+                                localInstance: expected.instance,
+                            }),
+                })),
+            })))))),
+        }), effect_1.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) {
+            return (0, effect_1.pipe)(effect_1.Effect.succeed(instance), effect_1.Effect.tap(() => effect_1.Effect.logDebug(`found snapped to version ${instance.rawSpecifier} 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)}`)));
+}

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

@@ -0,0 +1,18 @@
+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/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "Standard";
+}>;
+export declare class StandardVersionGroup extends StandardVersionGroup_base<{
+    config: VersionGroupConfig.Standard;
+    instances: Instance[];
+    isCatchAll: boolean;
+}> {
+    groupType: string;
+    constructor(isCatchAll: boolean, config: VersionGroupConfig.Standard);
+    canAdd(_: Instance): boolean;
+    inspectAll(): Effect.Effect<never, never, Report.Version.Group[]>;
+}
+export {};

package/dist/version-group/standard.js

@@ -0,0 +1,131 @@
+"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') {
+    constructor(isCatchAll, config) {
+        super({
+            config,
+            instances: [],
+            isCatchAll,
+        });
+        this.groupType = 'versionGroup';
+    }
+    canAdd(_) {
+        return true;
+    }
+    inspectAll() {
+        return effect_1.Effect.all(Object.entries((0, group_by_1.groupBy)('name', this.instances)).flatMap(([name, instances]) => {
+            const localInstance = getLocalInstance(instances);
+            if (localInstance) {
+                const localVersion = localInstance?.rawSpecifier;
+                return localVersion === 'PACKAGE_JSON_HAS_NO_VERSION'
+                    ? effect_1.Effect.succeed({
+                        name,
+                        reports: instances.map((instance) => 
+                        // ! dependency is a package developed in this repo
+                        // ✘ local package is missing a .version property
+                        // ✘ is a mismatch we can't auto-fix
+                        new report_1.Report.MissingLocalVersion({
+                            localInstance,
+                            unfixable: instance,
+                        })),
+                    })
+                    : (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 !== 'VersionSpecifier'
+                        ? 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({
+                            localInstance,
+                            unfixable: instance,
+                        })))
+                        : instances.flatMap((instance) => (0, effect_1.pipe)(effect_1.Effect.succeed(specifier_1.Specifier.create(instance, instance.rawSpecifier)), effect_1.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({
+                                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({
+                                    unfixable: specifier.instance,
+                                }),
+                                onSuccess: (valid) => specifier.instance.rawSpecifier === valid.raw
+                                    ? // ! is not the local package instance
+                                        // ✓ local version matches this semver group
+                                        // ✓ current version matches local
+                                        new report_1.Report.Valid({ specifier })
+                                    : // ! is not the local package instance
+                                        // ✓ local version matches this semver group
+                                        // ✘ current version mismatches local
+                                        new report_1.Report.LocalPackageMismatch({
+                                            fixable: valid,
+                                            localInstance,
+                                        }),
+                            }))))))), effect_1.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))), 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)).length ===
+                    1
+                    ? specifiers.map((specifier) => 
+                    // ✘ not every version is semver
+                    // ✓ every version is identical
+                    // ✓ is a match
+                    new report_1.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({ unfixable: 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({
+                    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({ unfixable: current.instance }),
+                    onSuccess: (expectedRange) => current.instance.rawSpecifier === expectedRange.raw
+                        ? // ✓ every version is semver
+                            // ✓ current version matches expected semver
+                            // ✓ current version matches expected version
+                            new report_1.Report.Valid({ specifier: current })
+                        : current.instance.rawSpecifier === 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({ fixable: 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({ fixable: expectedRange }),
+                })))),
+            }))), effect_1.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.
+ */
+function getLocalInstance(instances) {
+    return instances.find(isLocalInstance);
+}
+/** Is this dependency developed in this monorepo */
+function isLocalInstance(instance) {
+    return instance.strategy.name === 'local';
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "syncpack",
   "description": "Consistent dependency versions in large JavaScript Monorepos",
-  "version": "10.9.3",
+  "version": "12.0.0-alpha.0",
   "author": "Jamie Mason <jamie@foldleft.io> (https://github.com/JamieMason)",
   "bin": {
     "syncpack": "dist/bin.js",
@@ -31,18 +31,16 @@
     "Tom Fletcher (https://github.com/tom-fletcher)"
   ],
   "dependencies": {
-    "@effect/data": "0.17.1",
-    "@effect/io": "0.37.1",
-    "@effect/match": "0.31.0",
-    "@effect/schema": "0.32.0",
+    "@effect/match": "0.40.0",
+    "@effect/schema": "0.43.0",
     "chalk": "4.1.2",
     "commander": "11.0.0",
-    "cosmiconfig": "8.2.0",
+    "cosmiconfig": "8.3.6",
+    "effect": "2.0.0-next.48",
     "enquirer": "2.4.1",
-    "fs-extra": "11.1.1",
     "globby": "11.1.0",
     "minimatch": "9.0.3",
-    "npm-package-arg": "10.1.0",
+    "npm-package-arg": "11.0.1",
     "ora": "5.4.1",
     "prompts": "2.4.2",
     "read-yaml-file": "2.1.0",
@@ -51,25 +49,27 @@
     "ts-toolbelt": "9.6.0"
   },
   "devDependencies": {
-    "@tsconfig/node18": "18.2.0",
-    "@types/fs-extra": "11.0.1",
-    "@types/jest": "29.5.3",
+    "@tsconfig/node18": "18.2.2",
+    "@types/jest": "29.5.5",
     "@types/node": "14.18.36",
-    "@types/npm-package-arg": "6.1.1",
-    "@types/prompts": "2.4.4",
-    "@types/semver": "7.5.0",
-    "@typescript-eslint/eslint-plugin": "6.2.1",
-    "@typescript-eslint/parser": "6.2.1",
-    "eslint": "8.46.0",
-    "eslint-plugin-import": "2.28.0",
-    "eslint-plugin-jest": "27.2.3",
+    "@types/npm-package-arg": "6.1.2",
+    "@types/prompts": "2.4.5",
+    "@types/semver": "7.5.3",
+    "@typescript-eslint/eslint-plugin": "6.7.5",
+    "@typescript-eslint/parser": "6.7.5",
+    "eslint": "8.51.0",
+    "eslint-plugin-import": "2.28.1",
+    "eslint-plugin-jest": "27.4.2",
     "expect-more-jest": "5.5.0",
-    "jest": "29.6.2",
-    "prettier": "2.8.8",
-    "rimraf": "5.0.1",
+    "immer": "10.0.3",
+    "jest": "29.7.0",
+    "memfs": "4.6.0",
+    "prettier": "3.0.3",
+    "rimraf": "5.0.5",
     "ts-jest": "29.1.1",
     "ts-node": "10.9.1",
-    "typescript": "5.1.6"
+    "typescript": "5.2.2",
+    "typescript-json-schema": "0.61.0"
   },
   "engines": {
     "node": ">=16"
@@ -109,7 +109,10 @@
     "wrap-ansi": "<8.0.0"
   },
   "scripts": {
-    "build": "rm -rf ./dist && tsc --project tsconfig.build.json",
+    "build": "yarn clean && yarn build:source && yarn build:json-schema",
+    "build:json-schema": "typescript-json-schema --noExtraProps src/index.ts RcFile --out dist/schema.json",
+    "build:source": "tsc --project tsconfig.build.json",
+    "clean": "rm -rf ./dist",
     "format": "yarn format:lint && yarn format:source",
     "format:lint": "yarn lint --fix",
     "format:source": "prettier --write .",
@@ -117,7 +120,7 @@
     "lint:eslint": "eslint --ext .ts .",
     "lint:ts": "tsc --noEmit --project tsconfig.json",
     "prepack": "yarn build",
-    "test": "jest src test"
+    "test": "jest"
   },
   "types": "dist/index.d.ts"
 }

package/dist/bin-fix-mismatches/effects.d.ts

@@ -1,2 +0,0 @@
-import type { VersionEffects } from '../create-program/effects';
-export declare const fixMismatchesEffects: VersionEffects<void>;

package/dist/bin-fix-mismatches/effects.js

@@ -1,112 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fixMismatchesEffects = void 0;
-const Function_1 = require("@effect/data/Function");
-const Effect = __importStar(require("@effect/io/Effect"));
-const chalk_1 = __importDefault(require("chalk"));
-const os_1 = require("os");
-const is_object_1 = require("tightrope/guard/is-object");
-const is_undefined_1 = require("tightrope/guard/is-undefined");
-const constants_1 = require("../constants");
-const delete_1 = require("../get-version-groups/lib/delete");
-const log_group_header_1 = require("../lib/log-group-header");
-exports.fixMismatchesEffects = {
-    onFilteredOut() {
-        return Effect.unit;
-    },
-    onIgnored() {
-        return Effect.unit;
-    },
-    onValid() {
-        return Effect.unit;
-    },
-    onBanned(input) {
-        return Effect.sync(() => removeVersions(input));
-    },
-    onHighestSemverMismatch(input) {
-        return Effect.sync(() => setVersions(input));
-    },
-    onLowestSemverMismatch(input) {
-        return Effect.sync(() => setVersions(input));
-    },
-    onPinnedMismatch(input) {
-        return Effect.sync(() => setVersions(input));
-    },
-    onSameRangeMismatch(input) {
-        return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logSameRangeMismatch));
-    },
-    onSnappedToMismatch(input) {
-        return Effect.sync(() => setVersions(input));
-    },
-    onNonSemverMismatch(input) {
-        return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logNonSemverMismatch));
-    },
-    onLocalPackageMismatch(input) {
-        return Effect.sync(() => setVersions(input));
-    },
-    onComplete(ctx) {
-        return Effect.sync(() => deleteEmptyObjects(ctx));
-    },
-};
-function logHeader(input) {
-    if (input.index === 0) {
-        log_group_header_1.logGroupHeader.versionGroup(input.group, input.index);
-    }
-    return input;
-}
-function setVersions({ report }) {
-    report.instances.forEach((instance) => {
-        instance.setSpecifier(report.expectedVersion);
-    });
-}
-function removeVersions({ report }) {
-    report.instances.forEach((instance) => {
-        instance.setSpecifier(delete_1.DELETE);
-    });
-}
-function logSameRangeMismatch({ ctx, report }) {
-    ctx.isInvalid = true;
-    console.log((0, chalk_1.default) `{yellow %s %s} {dim has mismatched versions under the "sameRange" policy which syncpack cannot auto fix}%s`, constants_1.ICON.panic, report.name, (0, chalk_1.default) `${os_1.EOL}  use {blue syncpack prompt} to fix manually`);
-}
-function logNonSemverMismatch({ ctx, report }) {
-    ctx.isInvalid = true;
-    console.log((0, chalk_1.default) `{yellow %s %s} {dim has mismatched unsupported versions which syncpack cannot auto fix}%s`, constants_1.ICON.panic, report.name, (0, chalk_1.default) `${os_1.EOL}  use {blue syncpack prompt} to fix manually`);
-}
-/** Remove empty objects such as `{"dependencies": {}}` left after deleting */
-function deleteEmptyObjects(ctx) {
-    ctx.packageJsonFiles.forEach((packageJsonFile) => {
-        const contents = packageJsonFile.contents;
-        Object.keys(contents).forEach((key) => {
-            const value = contents[key];
-            if ((0, is_object_1.isObject)(value) && Object.values(value).every(is_undefined_1.isUndefined)) {
-                delete contents[key];
-            }
-        });
-    });
-}

package/dist/bin-format/format-cli.d.ts

@@ -1,4 +0,0 @@
-import * as Effect from '@effect/io/Effect';
-import { type CliConfig } from '../config/types';
-import type { DefaultEnv } from '../env/default-env';
-export declare function formatCli(cli: Partial<CliConfig>, env: DefaultEnv): Effect.Effect<never, never, void | import("../get-context").Ctx>;

package/dist/bin-format/format-cli.js

@@ -1,42 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatCli = void 0;
-const Context = __importStar(require("@effect/data/Context"));
-const Function_1 = require("@effect/data/Function");
-const Effect = __importStar(require("@effect/io/Effect"));
-const types_1 = require("../config/types");
-const create_env_1 = require("../env/create-env");
-const exit_if_invalid_1 = require("../env/exit-if-invalid");
-const tags_1 = require("../env/tags");
-const write_if_changed_1 = require("../env/write-if-changed");
-const create_error_handlers_1 = require("../error-handlers/create-error-handlers");
-const default_error_handlers_1 = require("../error-handlers/default-error-handlers");
-const get_context_1 = require("../get-context");
-const format_1 = require("./format");
-function formatCli(cli, env) {
-    return (0, Function_1.pipe)((0, get_context_1.getContext)(), Effect.flatMap(format_1.format), Effect.flatMap(write_if_changed_1.writeIfChanged), Effect.flatMap(exit_if_invalid_1.exitIfInvalid), Effect.catchTags((0, create_error_handlers_1.createErrorHandlers)(default_error_handlers_1.defaultErrorHandlers)), Effect.provideContext((0, Function_1.pipe)(Context.empty(), Context.add(types_1.CliConfigTag, cli), Context.add(tags_1.EnvTag, (0, create_env_1.createEnv)(env)))));
-}
-exports.formatCli = formatCli;

package/dist/bin-lint-semver-ranges/effects.d.ts

@@ -1,2 +0,0 @@
-import type { SemverRangeEffects } from '../create-program/effects';
-export declare const lintSemverRangesEffects: SemverRangeEffects<void>;