syncpack 11.2.1 → 12.0.0-alpha.1

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFileSync = exports.ReadFileError = void 0;
+const effect_1 = require("effect");
+class ReadFileError extends effect_1.Data.TaggedClass('ReadFileError') {
+}
+exports.ReadFileError = ReadFileError;
+function readFileSync(io, filePath) {
+    return effect_1.Effect.try({
+        try: () => io.fs.readFileSync(filePath, { encoding: 'utf8' }),
+        catch: (err) => new ReadFileError({ filePath, error: String(err) }),
+    });
+}
+exports.readFileSync = readFileSync;

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

@@ -0,0 +1,30 @@
+import { Data, Effect } from 'effect';
+import type { Io } from '.';
+import type { ReadFileError } from './read-file-sync';
+declare const JsonParseError_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: "JsonParseError";
+}>;
+export declare class JsonParseError extends JsonParseError_base<{
+    readonly error: unknown;
+    readonly filePath: string;
+    readonly json: string;
+}> {
+}
+declare const JsonFile_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: "JsonFile";
+}>;
+export declare class JsonFile<T> extends JsonFile_base<{
+    /** absolute path on disk to the directory of this file */
+    readonly dirPath: string;
+    /** absolute path on disk to this file */
+    readonly filePath: string;
+    /** relative path on disk to this file */
+    readonly shortPath: string;
+    /** parsed JSON contents of the file */
+    contents: T;
+    /** raw file contents of the file */
+    readonly json: string;
+}> {
+}
+export declare function readJsonFileSync<T>(io: Io, filePath: string): Effect.Effect<never, ReadFileError | JsonParseError, JsonFile<T>>;
+export {};

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJsonFileSync = exports.JsonFile = exports.JsonParseError = void 0;
+const effect_1 = require("effect");
+const path_1 = require("path");
+const read_file_sync_1 = require("./read-file-sync");
+class JsonParseError extends effect_1.Data.TaggedClass('JsonParseError') {
+}
+exports.JsonParseError = JsonParseError;
+class JsonFile extends effect_1.Data.TaggedClass('JsonFile') {
+}
+exports.JsonFile = JsonFile;
+function readJsonFileSync(io, filePath) {
+    return (0, effect_1.pipe)(effect_1.Effect.Do, effect_1.Effect.bind('json', () => (0, read_file_sync_1.readFileSync)(io, filePath)), effect_1.Effect.bind('contents', ({ json }) => effect_1.Effect.try({
+        try: () => JSON.parse(json),
+        catch: (error) => new JsonParseError({ error, filePath, json }),
+    })), effect_1.Effect.map(({ contents, json }) => new JsonFile({
+        contents,
+        dirPath: (0, path_1.dirname)(filePath),
+        filePath,
+        json,
+        shortPath: (0, path_1.relative)(io.process.cwd(), filePath),
+    })));
+}
+exports.readJsonFileSync = readJsonFileSync;

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

@@ -0,0 +1,12 @@
+import { Data, Effect } from 'effect';
+import type { Io } from '.';
+declare const ReadYamlFileError_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: "ReadYamlFileError";
+}>;
+declare class ReadYamlFileError extends ReadYamlFileError_base<{
+    readonly filePath: string;
+    readonly error: string;
+}> {
+}
+export declare function readYamlFileSync<T = unknown>(io: Io, filePath: string): Effect.Effect<never, ReadYamlFileError, T>;
+export {};

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readYamlFileSync = void 0;
+const effect_1 = require("effect");
+class ReadYamlFileError extends effect_1.Data.TaggedClass('ReadYamlFileError') {
+}
+function readYamlFileSync(io, filePath) {
+    return effect_1.Effect.try({
+        try: () => io.readYamlFile.sync(filePath),
+        catch: (err) => new ReadYamlFileError({ filePath, error: String(err) }),
+    });
+}
+exports.readYamlFileSync = readYamlFileSync;

package/dist/io/write-file-sync.d.ts

@@ -0,0 +1,12 @@
+import { Data, Effect } from 'effect';
+import type { Io } from '.';
+declare const WriteFileError_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: "WriteFileError";
+}>;
+export declare class WriteFileError extends WriteFileError_base<{
+    readonly filePath: string;
+    readonly error: string;
+}> {
+}
+export declare function writeFileSync(filePath: string, contents: string): Effect.Effect<Io, WriteFileError, void>;
+export {};

package/dist/io/write-file-sync.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileSync = exports.WriteFileError = void 0;
+const effect_1 = require("effect");
+const _1 = require(".");
+class WriteFileError extends effect_1.Data.TaggedClass('WriteFileError') {
+}
+exports.WriteFileError = WriteFileError;
+function writeFileSync(filePath, contents) {
+    return (0, effect_1.pipe)(_1.IoTag, effect_1.Effect.flatMap((io) => effect_1.Effect.try({
+        try: () => io.fs.writeFileSync(filePath, contents),
+        catch: (err) => new WriteFileError({ filePath, error: String(err) }),
+    })));
+}
+exports.writeFileSync = writeFileSync;

package/dist/{env → io}/write-if-changed.d.ts

@@ -1,8 +1,8 @@
-import * as Effect from '@effect/io/Effect';
+import { Effect } from 'effect';
+import type { Io } from '.';
 import type { Ctx } from '../get-context';
-import { type Env } from './create-env';
-import type { WriteFileError } from './tags';
-export declare function writeIfChanged(ctx: Ctx): Effect.Effect<Env, WriteFileError, Ctx>;
+import type { WriteFileError } from './write-file-sync';
+export declare function writeIfChanged(ctx: Ctx): Effect.Effect<Io, WriteFileError, Ctx>;
 type Ending = '\n' | '\r' | '\r\n' | string;
 export declare const newlines: {
     detect(source: string): Ending;

package/dist/io/write-if-changed.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newlines = exports.writeIfChanged = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const effect_1 = require("effect");
+const os_1 = require("os");
+const get_indent_1 = require("../config/get-indent");
+const constants_1 = require("../constants");
+const write_file_sync_1 = require("./write-file-sync");
+function writeIfChanged(ctx) {
+    return (0, effect_1.pipe)(effect_1.Effect.all(ctx.packageJsonFiles.map((file) => (0, effect_1.pipe)(effect_1.Effect.Do, effect_1.Effect.bind('nextJson', () => toJson(file)), effect_1.Effect.bind('hasChanged', ({ nextJson }) => effect_1.Effect.succeed(file.jsonFile.json !== nextJson)), effect_1.Effect.flatMap(({ hasChanged, nextJson }) => hasChanged
+        ? (0, effect_1.pipe)((0, write_file_sync_1.writeFileSync)(file.jsonFile.filePath, nextJson), effect_1.Effect.flatMap(() => effect_1.Effect.logInfo((0, chalk_1.default) `{green ${constants_1.ICON.tick}} ${file.jsonFile.shortPath}`)))
+        : effect_1.Effect.logInfo((0, chalk_1.default) `{dim ${constants_1.ICON.skip} ${file.jsonFile.shortPath}}`))))), effect_1.Effect.map(() => ctx));
+    function toJson(file) {
+        const contents = file.jsonFile.contents;
+        const indent = (0, get_indent_1.getIndent)(ctx.config);
+        const EOL = exports.newlines.detect(file.jsonFile.json);
+        const source = `${JSON.stringify(contents, null, indent)}${EOL}`;
+        return effect_1.Effect.succeed(exports.newlines.fix(source, EOL));
+    }
+}
+exports.writeIfChanged = writeIfChanged;
+const CR = '\r';
+const CRLF = '\r\n';
+const LF = '\n';
+exports.newlines = {
+    detect(source) {
+        const cr = source.split(CR).length;
+        const lf = source.split(LF).length;
+        const crlf = source.split(CRLF).length;
+        if (cr + lf === 0)
+            return os_1.EOL;
+        if (crlf === cr && crlf === lf)
+            return CRLF;
+        if (cr > lf)
+            return CR;
+        return LF;
+    },
+    fix(source, lineEnding) {
+        return source.replace(/\r\n|\n|\r/g, lineEnding);
+    },
+};

package/dist/lib/get-group-header.d.ts

@@ -0,0 +1,10 @@
+import type { SemverGroup } from '../semver-group';
+import type { VersionGroup } from '../version-group';
+export declare function getSemverGroupHeader(input: {
+    group: SemverGroup.Any;
+    index: number;
+}): string;
+export declare function getVersionGroupHeader(input: {
+    group: VersionGroup.Any;
+    index: number;
+}): string;

package/dist/lib/get-group-header.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVersionGroupHeader = exports.getSemverGroupHeader = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+function getSemverGroupHeader(input) {
+    return getGroupHeader(input.group.config.label || `Semver Group ${input.index + 1}`);
+}
+exports.getSemverGroupHeader = getSemverGroupHeader;
+function getVersionGroupHeader(input) {
+    return getGroupHeader(input.group.config.label || `Version Group ${input.index + 1}`);
+}
+exports.getVersionGroupHeader = getVersionGroupHeader;
+function getGroupHeader(label) {
+    const trimmed = label.trim();
+    const hasNewLines = trimmed.search(/[\r\n]/) !== -1;
+    const header = hasNewLines ? formatMultiLine(trimmed) : formatSingleLine(trimmed);
+    return chalk_1.default.blue(header);
+}
+function formatSingleLine(label) {
+    const leftSide = `= ${label} `;
+    const dividerWidth = 80 - leftSide.length;
+    const rightSide = dividerWidth > 0 ? '='.repeat(dividerWidth) : '';
+    return `${leftSide}${rightSide}`;
+}
+function formatMultiLine(label) {
+    const reindented = label.replace(/^\s+/gm, '  ');
+    return `= ${reindented}`;
+}

package/dist/lib/get.d.ts

@@ -0,0 +1,11 @@
+import { Either } from 'effect';
+export declare function get<T, P1 extends keyof NonNullable<T>>(obj: T, prop1: P1): Either.Either<Error, NonNullable<T>[P1]>;
+export declare function get<T, P1 extends keyof NonNullable<T>, P2 extends keyof NonNullable<NonNullable<T>[P1]>>(obj: T, prop1: P1, prop2: P2): Either.Either<Error, NonNullable<NonNullable<T>[P1]>[P2]>;
+export declare function get<T, P1 extends keyof NonNullable<T>, P2 extends keyof NonNullable<NonNullable<T>[P1]>, P3 extends keyof NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>>(obj: T, prop1: P1, prop2: P2, prop3: P3): Either.Either<Error, NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>;
+export declare function get<T, P1 extends keyof NonNullable<T>, P2 extends keyof NonNullable<NonNullable<T>[P1]>, P3 extends keyof NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>, P4 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>>(obj: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Either.Either<Error, NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>;
+export declare function get<T, P1 extends keyof NonNullable<T>, P2 extends keyof NonNullable<NonNullable<T>[P1]>, P3 extends keyof NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>, P4 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>, P5 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>>(obj: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Either.Either<Error, NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>;
+export declare function get<T, P1 extends keyof NonNullable<T>, P2 extends keyof NonNullable<NonNullable<T>[P1]>, P3 extends keyof NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>, P4 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>, P5 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>, P6 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>>(obj: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Either.Either<Error, NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>;
+export declare function get<T, P1 extends keyof NonNullable<T>, P2 extends keyof NonNullable<NonNullable<T>[P1]>, P3 extends keyof NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>, P4 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>, P5 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>, P6 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>, P7 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>>(obj: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7): Either.Either<Error, NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>[P7]>;
+export declare function get<T, P1 extends keyof NonNullable<T>, P2 extends keyof NonNullable<NonNullable<T>[P1]>, P3 extends keyof NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>, P4 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>, P5 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>, P6 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>, P7 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>, P8 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>[P7]>>(obj: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8): Either.Either<Error, NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>[P7]>[P8]>;
+export declare function get<T, P1 extends keyof NonNullable<T>, P2 extends keyof NonNullable<NonNullable<T>[P1]>, P3 extends keyof NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>, P4 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>, P5 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>, P6 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>, P7 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>, P8 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>[P7]>, P9 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>[P7]>[P8]>>(obj: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9): Either.Either<Error, NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>[P7]>[P8]>[P9]>;
+export declare function get<T>(obj: T, ...props: any[]): Either.Either<Error, unknown>;

package/dist/lib/get.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get = void 0;
+const effect_1 = require("effect");
+const is_function_1 = require("tightrope/guard/is-function");
+const is_primitive_1 = require("tightrope/guard/is-primitive");
+const is_readable_1 = require("tightrope/guard/is-readable");
+function get(origin, ...props) {
+    return (0, is_readable_1.isReadable)(origin) ? props.reduce(getChild, origin) : ERR_UNREADABLE_ORIGIN(props, origin);
+}
+exports.get = get;
+/** Used internally by get to retrieve a single child property from a parent object. */
+function getChild(parent, prop) {
+    // quit if any ancestor was already not found
+    if (effect_1.Either.isEither(parent) && effect_1.Either.isLeft(parent))
+        return parent;
+    // ensure we have a plain value and not an Ok
+    const value = effect_1.Either.isEither(parent) && effect_1.Either.isRight(parent) ? effect_1.Either.getOrThrow(parent) : parent;
+    // quit if we can't read properties of value (eg value.likeThis)
+    if (!(0, is_readable_1.isReadable)(value))
+        return ERR_UNREADABLE_CHILD(prop, value);
+    // quit if value is object/array/function etc but the child is not found
+    if (!(0, is_primitive_1.isPrimitive)(value) && prop in value === false)
+        return ERR_NOT_FOUND(prop, value);
+    // quit if eg true.toFixed, 12.toUpperCase
+    if ((0, is_primitive_1.isPrimitive)(value) && value[prop] === undefined)
+        return ERR_NOT_FOUND(prop, value);
+    // the value is present, return it
+    const child = value[prop];
+    return effect_1.Either.right((0, is_function_1.isFunction)(child) ? child.bind(value) : child);
+}
+function ERR_UNREADABLE_CHILD(child, value) {
+    return effect_1.Either.left(new Error(`Cannot read "${child}" from unreadable value: ${value}`));
+}
+function ERR_NOT_FOUND(child, value) {
+    return effect_1.Either.left(new Error(`Property "${child}" not found on value: ${value}`));
+}
+function ERR_UNREADABLE_ORIGIN(props, origin) {
+    return effect_1.Either.left(new Error(`Cannot read "${props.join('.')}" from unreadable value: ${origin}`));
+}

package/dist/lib/pad-start.d.ts

@@ -0,0 +1 @@
+export declare function padStart(value: number): string;

package/dist/lib/pad-start.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.padStart = void 0;
+function padStart(value) {
+    return String(value).padStart(6, ' ');
+}
+exports.padStart = padStart;

package/dist/lib/ring-buffer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * An Array with a maximum size which, once reached, will replace the oldest
+ * item when a new one is added.
+ */
+export declare class RingBuffer<T> extends Array {
+    cursor: number;
+    fixedLength: number;
+    constructor(fixedLength: number);
+    push(...values: T[]): number;
+}

package/dist/lib/ring-buffer.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RingBuffer = void 0;
+/**
+ * An Array with a maximum size which, once reached, will replace the oldest
+ * item when a new one is added.
+ */
+class RingBuffer extends Array {
+    cursor;
+    fixedLength;
+    constructor(fixedLength) {
+        super(fixedLength);
+        this.cursor = 0;
+        this.fixedLength = fixedLength;
+    }
+    push(...values) {
+        values.forEach((value) => {
+            this[this.cursor++] = value;
+            this.cursor %= this.length;
+        });
+        return this.length;
+    }
+}
+exports.RingBuffer = RingBuffer;

package/dist/lib/set-semver-range.d.ts

@@ -1,3 +1,3 @@
 import type { SemverRange } from '../config/types';
-export declare function getSemverRange(version: string): SemverRange;
+/** @deprecated migrate to make better use of npm-package-arg */
 export declare function setSemverRange(semverRange: SemverRange, version: string): string;

package/dist/lib/set-semver-range.js

@@ -1,24 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setSemverRange = exports.getSemverRange = void 0;
+exports.setSemverRange = void 0;
+const is_string_1 = require("tightrope/guard/is-string");
 const constants_1 = require("../constants");
-const is_loose_semver_1 = require("../guards/is-loose-semver");
 const is_semver_1 = require("../guards/is-semver");
 const is_valid_semver_range_1 = require("../guards/is-valid-semver-range");
-function getSemverRange(version) {
-    if (version === '*')
-        return version;
-    const from1stNumber = version.search(/[0-9]/);
-    const semverRange = version.slice(0, from1stNumber);
-    return (0, is_valid_semver_range_1.isValidSemverRange)(semverRange) ? semverRange : '';
-}
-exports.getSemverRange = getSemverRange;
+/** @deprecated migrate to make better use of npm-package-arg */
 function setSemverRange(semverRange, version) {
     if (!(0, is_semver_1.isSemver)(version) || !(0, is_valid_semver_range_1.isValidSemverRange)(semverRange))
         return version;
     if (semverRange === '*')
         return semverRange;
-    const nextVersion = (0, is_loose_semver_1.isLooseSemver)(version) ? version.replace(/\.x/g, '.0') : version;
+    const nextVersion = isLooseSemver(version) ? version.replace(/\.x/g, '.0') : version;
     const from1stNumber = nextVersion.search(/[0-9]/);
     const from1stDot = nextVersion.indexOf('.');
     return semverRange === constants_1.RANGE.LOOSE
@@ -26,3 +19,6 @@ function setSemverRange(semverRange, version) {
         : `${semverRange}${nextVersion.slice(from1stNumber)}`;
 }
 exports.setSemverRange = setSemverRange;
+function isLooseSemver(version) {
+    return (0, is_string_1.isString)(version) && (0, is_semver_1.isSemver)(version) && version.search(/\.x(\.|$)/) !== -1;
+}

package/dist/lib/with-logger.d.ts

@@ -0,0 +1,2 @@
+import { Effect } from 'effect';
+export declare function withLogger(program: Effect.Effect<never, never, unknown>): Effect.Effect<never, never, unknown>;

package/dist/lib/with-logger.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withLogger = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const effect_1 = require("effect");
+function withLogger(program) {
+    const logger = effect_1.Logger.make(({ logLevel, message }) => {
+        if (logLevel === effect_1.LogLevel.Info) {
+            globalThis.console.info(message);
+        }
+        else if (logLevel === effect_1.LogLevel.Debug) {
+            globalThis.console.info((0, chalk_1.default) `{magenta ? %s}`, message);
+        }
+        else if (logLevel === effect_1.LogLevel.Error) {
+            globalThis.console.error((0, chalk_1.default) `{red ! %s}`, message);
+        }
+        else if (logLevel === effect_1.LogLevel.Warning) {
+            globalThis.console.warn((0, chalk_1.default) `{yellow ! %s}`, message);
+        }
+        else {
+            globalThis.console.log((0, chalk_1.default) `{cyan [%s] %s}`, logLevel, message);
+        }
+    });
+    const layer = effect_1.Logger.replace(effect_1.Logger.defaultLogger, logger);
+    const logLevel = process.env.SYNCPACK_VERBOSE === 'true'
+        ? effect_1.LogLevel.Debug
+        : process.env.NODE_ENV === 'test'
+            ? effect_1.LogLevel.None
+            : effect_1.LogLevel.Info;
+    return effect_1.Effect.provide(effect_1.Logger.withMinimumLogLevel(program, logLevel), layer);
+}
+exports.withLogger = withLogger;

package/dist/option.d.ts

@@ -2,7 +2,6 @@ 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 semverRange: readonly ["-r, --semver-range <range>", "see supported ranges below. defaults to \"\""];
     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/option.js

@@ -13,10 +13,6 @@ exports.option = {
         (0, chalk_1.default) `only include dependencies whose {yellow name} matches this regex`,
     ],
     indent: ['-i, --indent [value]', `override indentation. defaults to "${constants_1.DEFAULT_CONFIG.indent}"`],
-    semverRange: [
-        '-r, --semver-range <range>',
-        `see supported ranges below. defaults to "${constants_1.DEFAULT_CONFIG.semverRange}"`,
-    ],
     source: [
         '-s, --source [pattern]',
         'glob pattern for package.json files to read from',

package/dist/report.d.ts

@@ -0,0 +1,166 @@
+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 namespace Semver {
+        type Any = Union.Strict<Report.Semver.Invalid.Any | Report.Semver.Valid.Any>;
+        namespace Valid {
+            type Any = Union.Strict<Report.Disabled | Report.FilteredOut | Report.Ignored | Report.Valid>;
+        }
+        namespace Invalid {
+            type Any = Union.Strict<Report.Semver.Fixable.Any | Report.Semver.Unfixable.Any>;
+        }
+        namespace Fixable {
+            type Any = Report.SemverRangeMismatch;
+        }
+        namespace Unfixable {
+            type Any = Report.UnsupportedMismatch;
+        }
+    }
+    export namespace Version {
+        interface Group {
+            name: string;
+            reports: Report.Version.Any[];
+        }
+        type Any = Union.Strict<Report.Version.Invalid.Any | Report.Version.Valid.Any>;
+        namespace Valid {
+            type Any = Union.Strict<Report.Disabled | Report.FilteredOut | Report.Ignored | Report.Valid>;
+        }
+        namespace Invalid {
+            type Any = Union.Strict<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>;
+        }
+        namespace Unfixable {
+            type Any = Union.Strict<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<{
+        readonly instance: Instance;
+    }> {
+    }
+    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;
+    }> {
+    }
+    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;
+    }> {
+    }
+    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<{
+        readonly 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;
+    }> {
+    }
+    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;
+    }> {
+    }
+    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;
+        readonly 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;
+    }> {
+    }
+    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;
+    }> {
+    }
+    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;
+    }> {
+    }
+    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;
+        readonly 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<{
+        readonly localInstance: Instance;
+        readonly unfixable: 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;
+    }> {
+    }
+    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;
+        /** the raw specifiers which this instance's specifier did not cover */
+        readonly 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 {};
+}