syncpack 13.0.1 → 14.0.0-alpha.2

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

@@ -1,71 +0,0 @@
-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({
-            config,
-            instances: [],
-        });
-    }
-    canAdd(_) {
-        return true;
-    }
-    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 => 
-            // ✘ 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({
-                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
-                        ? // ! expected version is not semver
-                            // ✓ semver group is disabled/ignored
-                            // ✓ current version matches expected
-                            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.SnappedToMismatch(valid, expected.instance),
-                })),
-                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.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.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.SnappedToMismatch(valid, expected.instance),
-                })),
-            })))))),
-        }), Effect.map(reports => ({ name, reports })))));
-    }
-}
-function findSnappedToInstance(name, snapTo, instances) {
-    for (const instance of instances) {
-        if (snapTo.includes(instance.pkgName) && instance.rawSpecifier.raw) {
-            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 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,18 +0,0 @@
-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[];
-    isCatchAll: boolean;
-}> {
-    groupType: string;
-    constructor(isCatchAll: boolean, config: VersionGroupConfig.Standard);
-    canAdd(_: Instance): boolean;
-    inspectAll(): Effect.Effect<Report.Version.Group[]>;
-}
-export {};

package/dist/version-group/standard.js

@@ -1,119 +0,0 @@
-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({
-            config,
-            instances: [],
-            isCatchAll,
-        });
-    }
-    canAdd(_) {
-        return true;
-    }
-    inspectAll() {
-        return Effect.all(Object.entries(groupBy('name', this.instances)).flatMap(([name, instances]) => {
-            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 => 
-                    // ! 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) =>
-                    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.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.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.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.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.LocalPackageMismatch(valid, localInstance),
-                        }))))))), 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 => 
-                    // ✘ not every version is semver
-                    // ✓ every version is identical
-                    // ✓ is a match
-                    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.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.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.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.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.map(reports => ({ name, reports })));
-        }));
-    }
-}
-/**
- * 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';
-}