syncpack 12.0.1 → 12.1.0

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

@@ -7,7 +7,7 @@ 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.cosmiconfigSync('syncpack')), effect_1.Effect.flatMap((client) => effect_1.Effect.try(() => (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({})));
+    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;
 /**

package/dist/option.d.ts

@@ -1,7 +1,7 @@
 export declare const option: {
     readonly config: readonly ["-c, --config <path>", "path to a syncpack config file"];
     readonly filter: readonly ["-f, --filter [pattern]", string];
-    readonly indent: readonly ["-i, --indent [value]", "override indentation. defaults to \"  \""];
+    readonly indent: readonly ["-i, --indent [value]", `override indentation. defaults to "${string}"`];
     readonly source: readonly ["-s, --source [pattern]", "glob pattern for package.json files to read from", typeof collect, string[]];
     readonly types: readonly ["-t, --types <names>", string];
 };

package/dist/report.d.ts

@@ -1,15 +1,14 @@
-import { Data } from 'effect';
-import type { Union } from 'ts-toolbelt';
 import type { Instance } from './get-instances/instance';
 import type { Specifier } from './specifier';
 export declare namespace Report {
+    export type Any = Semver.Any | Version.Any;
     export namespace Semver {
-        type Any = Union.Strict<Report.Semver.Invalid.Any | Report.Semver.Valid.Any>;
+        type Any = Report.Semver.Invalid.Any | Report.Semver.Valid.Any;
         namespace Valid {
-            type Any = Union.Strict<Report.Disabled | Report.FilteredOut | Report.Ignored | Report.Valid>;
+            type Any = Report.Disabled | Report.FilteredOut | Report.Ignored | Report.Valid;
         }
         namespace Invalid {
-            type Any = Union.Strict<Report.Semver.Fixable.Any | Report.Semver.Unfixable.Any>;
+            type Any = Report.Semver.Fixable.Any | Report.Semver.Unfixable.Any;
         }
         namespace Fixable {
             type Any = Report.SemverRangeMismatch;
@@ -23,144 +22,110 @@ export declare namespace Report {
             name: string;
             reports: Report.Version.Any[];
         }
-        type Any = Union.Strict<Report.Version.Invalid.Any | Report.Version.Valid.Any>;
+        type Any = Report.Version.Invalid.Any | Report.Version.Valid.Any;
         namespace Valid {
-            type Any = Union.Strict<Report.Disabled | Report.FilteredOut | Report.Ignored | Report.Valid>;
+            type Any = Report.Disabled | Report.FilteredOut | Report.Ignored | Report.Valid;
         }
         namespace Invalid {
-            type Any = Union.Strict<Report.Version.Fixable.Any | Report.Version.Unfixable.Any>;
+            type Any = Report.Version.Fixable.Any | Report.Version.Unfixable.Any;
         }
         namespace Fixable {
-            type Any = Union.Strict<Report.Banned | Report.HighestSemverMismatch | Report.LocalPackageMismatch | Report.LowestSemverMismatch | Report.PinnedMismatch | Report.SemverRangeMismatch | Report.SnappedToMismatch>;
+            type Any = Report.Banned | Report.HighestSemverMismatch | Report.LocalPackageMismatch | Report.LowestSemverMismatch | Report.PinnedMismatch | Report.SemverRangeMismatch | Report.SnappedToMismatch;
         }
         namespace Unfixable {
-            type Any = Union.Strict<Report.MissingLocalVersion | Report.MissingSnappedToMismatch | Report.UnsupportedMismatch | Report.SameRangeMismatch>;
+            type Any = Report.MissingLocalVersion | Report.MissingSnappedToMismatch | Report.UnsupportedMismatch | Report.SameRangeMismatch;
         }
     }
-    const Disabled_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> & {
-        readonly _tag: "Disabled";
-    }>;
-    /** Semver Groups are disabled by default */
-    export class Disabled extends Disabled_base<{
+    class Excluded {
+        readonly _tagGroup = "Excluded";
+        readonly isInvalid = false;
         readonly instance: Instance;
-    }> {
+        constructor(instance: Instance);
+    }
+    class Unfixable {
+        readonly _tagGroup = "Unfixable";
+        readonly isInvalid = true;
+        readonly unfixable: Instance;
+        constructor(unfixable: Instance);
+    }
+    class Fixable {
+        readonly _tagGroup = "Fixable";
+        readonly isInvalid = true;
+        readonly fixable: Specifier.Any;
+        constructor(fixable: Specifier.Any);
+    }
+    /** Semver Groups are disabled by default */
+    export class Disabled extends Excluded {
+        readonly _tag = "Disabled";
     }
-    const FilteredOut_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> & {
-        readonly _tag: "FilteredOut";
-    }>;
     /** Has a name which does not match the `--filter` RegExp */
-    export class FilteredOut extends FilteredOut_base<{
-        readonly instance: Instance;
-    }> {
+    export class FilteredOut extends Excluded {
+        readonly _tag = "FilteredOut";
     }
-    const Ignored_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> & {
-        readonly _tag: "Ignored";
-    }>;
     /** Is in an ignored version group */
-    export class Ignored extends Ignored_base<{
-        readonly instance: Instance;
-    }> {
+    export class Ignored extends Excluded {
+        readonly _tag = "Ignored";
     }
-    const Valid_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> & {
-        readonly _tag: "Valid";
-    }>;
     /** Version satisfies the rules of its version group */
-    export class Valid extends Valid_base<{
+    export class Valid {
+        readonly _tag = "Valid";
+        readonly _tagGroup = "Valid";
+        readonly isInvalid = false;
         readonly specifier: Specifier.Any;
-    }> {
+        constructor(specifier: Specifier.Any);
     }
-    const Banned_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> & {
-        readonly _tag: "Banned";
-    }>;
     /** Must be removed */
-    export class Banned extends Banned_base<{
-        readonly fixable: Specifier.Any;
-    }> {
+    export class Banned extends Fixable {
+        readonly _tag = "Banned";
     }
-    const HighestSemverMismatch_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> & {
-        readonly _tag: "HighestSemverMismatch";
-    }>;
     /** Version mismatches and should use a higher version found on another */
-    export class HighestSemverMismatch extends HighestSemverMismatch_base<{
-        readonly fixable: Specifier.Any;
-    }> {
+    export class HighestSemverMismatch extends Fixable {
+        readonly _tag = "HighestSemverMismatch";
     }
-    const LocalPackageMismatch_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> & {
-        readonly _tag: "LocalPackageMismatch";
-    }>;
     /** Version mismatches the `.version` of the package developed in this repo */
-    export class LocalPackageMismatch extends LocalPackageMismatch_base<{
-        readonly fixable: Specifier.Any;
+    export class LocalPackageMismatch extends Fixable {
+        readonly _tag = "LocalPackageMismatch";
         readonly localInstance: Instance;
-    }> {
+        constructor(fixable: Specifier.Any, localInstance: Instance);
     }
-    const LowestSemverMismatch_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> & {
-        readonly _tag: "LowestSemverMismatch";
-    }>;
     /** Version mismatches and should use a lower version found on another */
-    export class LowestSemverMismatch extends LowestSemverMismatch_base<{
-        readonly fixable: Specifier.Any;
-    }> {
+    export class LowestSemverMismatch extends Fixable {
+        readonly _tag = "LowestSemverMismatch";
     }
-    const PinnedMismatch_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> & {
-        readonly _tag: "PinnedMismatch";
-    }>;
     /** Version is not identical to the `pinVersion` of its Pinned version group */
-    export class PinnedMismatch extends PinnedMismatch_base<{
-        readonly fixable: Specifier.Any;
-    }> {
+    export class PinnedMismatch extends Fixable {
+        readonly _tag = "PinnedMismatch";
     }
-    const SemverRangeMismatch_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> & {
-        readonly _tag: "SemverRangeMismatch";
-    }>;
     /** Version is identical but the semver range does not match its semver group */
-    export class SemverRangeMismatch extends SemverRangeMismatch_base<{
-        readonly fixable: Specifier.Any;
-    }> {
+    export class SemverRangeMismatch extends Fixable {
+        readonly _tag = "SemverRangeMismatch";
     }
-    const SnappedToMismatch_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> & {
-        readonly _tag: "SnappedToMismatch";
-    }>;
     /** Version mismatches the version used by the packages in the `snapTo` array */
-    export class SnappedToMismatch extends SnappedToMismatch_base<{
-        readonly fixable: Specifier.Any;
+    export class SnappedToMismatch extends Fixable {
+        readonly _tag = "SnappedToMismatch";
         readonly localInstance: Instance;
-    }> {
+        constructor(fixable: Specifier.Any, localInstance: Instance);
     }
-    const MissingLocalVersion_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> & {
-        readonly _tag: "MissingLocalVersion";
-    }>;
     /** Dependency should match a local package.json which is missing a .version */
-    export class MissingLocalVersion extends MissingLocalVersion_base<{
+    export class MissingLocalVersion extends Unfixable {
+        readonly _tag = "MissingLocalVersion";
         readonly localInstance: Instance;
-        readonly unfixable: Instance;
-    }> {
+        constructor(unfixable: Instance, localInstance: Instance);
     }
-    const MissingSnappedToMismatch_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> & {
-        readonly _tag: "MissingSnappedToMismatch";
-    }>;
     /** Dependency is not present in any of the packages in the `snapTo` array */
-    export class MissingSnappedToMismatch extends MissingSnappedToMismatch_base<{
-        readonly unfixable: Instance;
-    }> {
+    export class MissingSnappedToMismatch extends Unfixable {
+        readonly _tag = "MissingSnappedToMismatch";
     }
-    const SameRangeMismatch_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> & {
-        readonly _tag: "SameRangeMismatch";
-    }>;
     /** Specifier does not cover the specifiers of every other instance in this group */
-    export class SameRangeMismatch extends SameRangeMismatch_base<{
-        readonly unfixable: Instance;
+    export class SameRangeMismatch extends Unfixable {
+        readonly _tag = "SameRangeMismatch";
         /** the raw specifiers which this instance's specifier did not cover */
         readonly mismatches: string[];
-    }> {
+        constructor(unfixable: Instance, mismatches: string[]);
     }
-    const UnsupportedMismatch_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> & {
-        readonly _tag: "UnsupportedMismatch";
-    }>;
     /** Version mismatches and is not semver, syncpack cannot guess what to do */
-    export class UnsupportedMismatch extends UnsupportedMismatch_base<{
-        readonly unfixable: Instance;
-    }> {
+    export class UnsupportedMismatch extends Unfixable {
+        readonly _tag = "UnsupportedMismatch";
     }
     export {};
 }

package/dist/report.js

@@ -1,67 +1,132 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Report = void 0;
-const effect_1 = require("effect");
 var Report;
 (function (Report) {
+    class Excluded {
+        _tagGroup = 'Excluded';
+        isInvalid = false;
+        instance;
+        constructor(instance) {
+            this.instance = instance;
+        }
+    }
+    class Unfixable {
+        _tagGroup = 'Unfixable';
+        isInvalid = true;
+        unfixable;
+        constructor(unfixable) {
+            this.unfixable = unfixable;
+        }
+    }
+    class Fixable {
+        _tagGroup = 'Fixable';
+        isInvalid = true;
+        fixable;
+        constructor(fixable) {
+            this.fixable = fixable;
+        }
+    }
     /** Semver Groups are disabled by default */
-    class Disabled extends effect_1.Data.TaggedClass('Disabled') {
+    class Disabled extends Excluded {
+        _tag = 'Disabled';
     }
     Report.Disabled = Disabled;
     /** Has a name which does not match the `--filter` RegExp */
-    class FilteredOut extends effect_1.Data.TaggedClass('FilteredOut') {
+    class FilteredOut extends Excluded {
+        _tag = 'FilteredOut';
     }
     Report.FilteredOut = FilteredOut;
     /** Is in an ignored version group */
-    class Ignored extends effect_1.Data.TaggedClass('Ignored') {
+    class Ignored extends Excluded {
+        _tag = 'Ignored';
     }
     Report.Ignored = Ignored;
     /** Version satisfies the rules of its version group */
-    class Valid extends effect_1.Data.TaggedClass('Valid') {
+    class Valid {
+        _tag = 'Valid';
+        _tagGroup = 'Valid';
+        isInvalid = false;
+        specifier;
+        constructor(specifier) {
+            this.specifier = specifier;
+        }
     }
     Report.Valid = Valid;
     /** Must be removed */
-    class Banned extends effect_1.Data.TaggedClass('Banned') {
+    class Banned extends Fixable {
+        _tag = 'Banned';
     }
     Report.Banned = Banned;
     /** Version mismatches and should use a higher version found on another */
-    class HighestSemverMismatch extends effect_1.Data.TaggedClass('HighestSemverMismatch') {
+    class HighestSemverMismatch extends Fixable {
+        _tag = 'HighestSemverMismatch';
     }
     Report.HighestSemverMismatch = HighestSemverMismatch;
     /** Version mismatches the `.version` of the package developed in this repo */
-    class LocalPackageMismatch extends effect_1.Data.TaggedClass('LocalPackageMismatch') {
+    class LocalPackageMismatch extends Fixable {
+        _tag = 'LocalPackageMismatch';
+        localInstance;
+        constructor(fixable, localInstance) {
+            super(fixable);
+            this.localInstance = localInstance;
+        }
     }
     Report.LocalPackageMismatch = LocalPackageMismatch;
     /** Version mismatches and should use a lower version found on another */
-    class LowestSemverMismatch extends effect_1.Data.TaggedClass('LowestSemverMismatch') {
+    class LowestSemverMismatch extends Fixable {
+        _tag = 'LowestSemverMismatch';
     }
     Report.LowestSemverMismatch = LowestSemverMismatch;
     /** Version is not identical to the `pinVersion` of its Pinned version group */
-    class PinnedMismatch extends effect_1.Data.TaggedClass('PinnedMismatch') {
+    class PinnedMismatch extends Fixable {
+        _tag = 'PinnedMismatch';
     }
     Report.PinnedMismatch = PinnedMismatch;
     /** Version is identical but the semver range does not match its semver group */
-    class SemverRangeMismatch extends effect_1.Data.TaggedClass('SemverRangeMismatch') {
+    class SemverRangeMismatch extends Fixable {
+        _tag = 'SemverRangeMismatch';
     }
     Report.SemverRangeMismatch = SemverRangeMismatch;
     /** Version mismatches the version used by the packages in the `snapTo` array */
-    class SnappedToMismatch extends effect_1.Data.TaggedClass('SnappedToMismatch') {
+    class SnappedToMismatch extends Fixable {
+        _tag = 'SnappedToMismatch';
+        localInstance;
+        constructor(fixable, localInstance) {
+            super(fixable);
+            this.localInstance = localInstance;
+        }
     }
     Report.SnappedToMismatch = SnappedToMismatch;
     /** Dependency should match a local package.json which is missing a .version */
-    class MissingLocalVersion extends effect_1.Data.TaggedClass('MissingLocalVersion') {
+    class MissingLocalVersion extends Unfixable {
+        _tag = 'MissingLocalVersion';
+        localInstance;
+        constructor(unfixable, localInstance) {
+            super(unfixable);
+            this.localInstance = localInstance;
+        }
     }
     Report.MissingLocalVersion = MissingLocalVersion;
     /** Dependency is not present in any of the packages in the `snapTo` array */
-    class MissingSnappedToMismatch extends effect_1.Data.TaggedClass('MissingSnappedToMismatch') {
+    class MissingSnappedToMismatch extends Unfixable {
+        _tag = 'MissingSnappedToMismatch';
     }
     Report.MissingSnappedToMismatch = MissingSnappedToMismatch;
     /** Specifier does not cover the specifiers of every other instance in this group */
-    class SameRangeMismatch extends effect_1.Data.TaggedClass('SameRangeMismatch') {
+    class SameRangeMismatch extends Unfixable {
+        _tag = 'SameRangeMismatch';
+        /** the raw specifiers which this instance's specifier did not cover */
+        mismatches;
+        constructor(unfixable, mismatches) {
+            super(unfixable);
+            this.mismatches = mismatches;
+        }
     }
     Report.SameRangeMismatch = SameRangeMismatch;
     /** Version mismatches and is not semver, syncpack cannot guess what to do */
-    class UnsupportedMismatch extends effect_1.Data.TaggedClass('UnsupportedMismatch') {
+    class UnsupportedMismatch extends Unfixable {
+        _tag = 'UnsupportedMismatch';
     }
     Report.UnsupportedMismatch = UnsupportedMismatch;
 })(Report || (exports.Report = Report = {}));