syncpack 10.2.0 → 10.6.1

package/dist/get-version-groups/pinned.js

@@ -1,40 +1,63 @@
 "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.PinnedVersionGroup = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Effect = __importStar(require("@effect/io/Effect"));
+const _1 = require(".");
 const group_by_1 = require("./lib/group-by");
-class PinnedVersionGroup {
+class PinnedVersionGroup extends Data.TaggedClass('Pinned') {
     constructor(config) {
-        this._tag = 'Pinned';
-        this.config = config;
-        this.instances = [];
+        super({
+            config,
+            instances: [],
+        });
     }
     canAdd(_) {
         return true;
     }
     inspect() {
-        const report = [];
         const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
         const expectedVersion = this.config.pinVersion;
-        Object.entries(instancesByName).forEach(([name, instances]) => {
+        return Object.entries(instancesByName).map(([name, instances]) => {
             if (hasMismatch(expectedVersion, instances)) {
-                report.push({
-                    expectedVersion,
+                return Effect.fail(new _1.VersionGroupReport.PinnedMismatch({
+                    name,
                     instances,
                     isValid: false,
-                    name,
-                    status: 'PINNED_MISMATCH',
-                });
+                    expectedVersion,
+                }));
             }
             else {
-                report.push({
+                return Effect.succeed(new _1.VersionGroupReport.Valid({
+                    name,
                     instances,
                     isValid: true,
-                    name,
-                    status: 'VALID',
-                });
+                }));
             }
         });
-        return report;
     }
 }
 exports.PinnedVersionGroup = PinnedVersionGroup;

package/dist/get-version-groups/same-range.d.ts

@@ -0,0 +1,17 @@
+import * as Data from '@effect/data/Data';
+import * as Effect from '@effect/io/Effect';
+import { VersionGroupReport } from '.';
+import type { VersionGroupConfig } from '../config/types';
+import type { Instance } from '../get-package-json-files/instance';
+declare const SameRangeVersionGroup_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "SameRange";
+}>;
+export declare class SameRangeVersionGroup extends SameRangeVersionGroup_base<{
+    config: VersionGroupConfig.SameRange;
+    instances: Instance[];
+}> {
+    constructor(config: VersionGroupConfig.SameRange);
+    canAdd(_: Instance): boolean;
+    inspect(): Effect.Effect<never, VersionGroupReport.SameRangeMismatch, VersionGroupReport.Valid>[];
+}
+export {};

package/dist/get-version-groups/same-range.js

@@ -0,0 +1,70 @@
+"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.SameRangeVersionGroup = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Effect = __importStar(require("@effect/io/Effect"));
+const intersects_1 = __importDefault(require("semver/ranges/intersects"));
+const _1 = require(".");
+const group_by_1 = require("./lib/group-by");
+class SameRangeVersionGroup extends Data.TaggedClass('SameRange') {
+    constructor(config) {
+        super({
+            config,
+            instances: [],
+        });
+    }
+    canAdd(_) {
+        return true;
+    }
+    inspect() {
+        const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
+        return Object.entries(instancesByName).map(([name, instances]) => {
+            if (hasMismatch(instances)) {
+                return Effect.fail(new _1.VersionGroupReport.SameRangeMismatch({
+                    name,
+                    instances,
+                    isValid: false,
+                }));
+            }
+            else {
+                return Effect.succeed(new _1.VersionGroupReport.Valid({
+                    name,
+                    instances,
+                    isValid: true,
+                }));
+            }
+        });
+    }
+}
+exports.SameRangeVersionGroup = SameRangeVersionGroup;
+/** Every range must fall within every other range */
+function hasMismatch(instances) {
+    const loose = true;
+    return instances.some((a) => instances.some((b) => !(0, intersects_1.default)(a.version, b.version, loose)));
+}

package/dist/get-version-groups/snapped-to.d.ts

@@ -1,11 +1,17 @@
-import type { VersionGroupReport } from '.';
+import * as Data from '@effect/data/Data';
+import * as Effect from '@effect/io/Effect';
+import { VersionGroupReport } from '.';
 import type { VersionGroupConfig } from '../config/types';
 import type { Instance } from '../get-package-json-files/instance';
-export declare class SnappedToVersionGroup {
-    _tag: string;
+declare const SnappedToVersionGroup_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "SnappedTo";
+}>;
+export declare class SnappedToVersionGroup extends SnappedToVersionGroup_base<{
     config: VersionGroupConfig.SnappedTo;
     instances: Instance[];
+}> {
     constructor(config: VersionGroupConfig.SnappedTo);
     canAdd(_: Instance): boolean;
-    inspect(): VersionGroupReport[];
+    inspect(): Effect.Effect<never, VersionGroupReport.SnappedToMismatch, VersionGroupReport.Valid>[];
 }
+export {};

package/dist/get-version-groups/snapped-to.js

@@ -1,41 +1,65 @@
 "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.SnappedToVersionGroup = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Effect = __importStar(require("@effect/io/Effect"));
+const _1 = require(".");
 const group_by_1 = require("./lib/group-by");
-class SnappedToVersionGroup {
+class SnappedToVersionGroup extends Data.TaggedClass('SnappedTo') {
     constructor(config) {
-        this._tag = 'SnappedTo';
-        this.config = config;
-        this.instances = [];
+        super({
+            config,
+            instances: [],
+        });
     }
     canAdd(_) {
         return true;
     }
     inspect() {
-        const report = [];
         const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
-        Object.entries(instancesByName).forEach(([name, instances]) => {
+        return Object.entries(instancesByName).map(([name, instances]) => {
             const snapTo = this.config.snapTo;
             const expectedVersion = getExpectedVersion(snapTo, instances);
             if (hasMismatch(expectedVersion, instances)) {
-                report.push({
-                    expectedVersion,
+                return Effect.fail(new _1.VersionGroupReport.SnappedToMismatch({
+                    name,
                     instances,
                     isValid: false,
-                    name,
-                    status: 'SNAPPED_TO_MISMATCH',
-                });
+                    expectedVersion,
+                    snapTo,
+                }));
             }
             else {
-                report.push({
+                return Effect.succeed(new _1.VersionGroupReport.Valid({
+                    name,
                     instances,
                     isValid: true,
-                    name,
-                    status: 'VALID',
-                });
+                }));
             }
         });
-        return report;
     }
 }
 exports.SnappedToVersionGroup = SnappedToVersionGroup;
@@ -45,6 +69,7 @@ function getExpectedVersion(snapTo, instances) {
         .find((i) => i.version)?.version;
     if (expectedVersion)
         return expectedVersion;
+    // @FIXME: create tagged error for this
     throw new Error('versionGroup.snapTo does not match any package versions');
 }
 function hasMismatch(expectedVersion, instances) {

package/dist/get-version-groups/standard.d.ts

@@ -1,11 +1,18 @@
-import type { VersionGroupReport } from '.';
+import * as Data from '@effect/data/Data';
+import * as Effect from '@effect/io/Effect';
+import { VersionGroupReport } from '.';
 import type { VersionGroupConfig } from '../config/types';
 import type { Instance } from '../get-package-json-files/instance';
-export declare class StandardVersionGroup {
-    _tag: string;
+declare const StandardVersionGroup_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "Standard";
+}>;
+export declare class StandardVersionGroup extends StandardVersionGroup_base<{
     config: VersionGroupConfig.Standard;
     instances: Instance[];
-    constructor(config: VersionGroupConfig.Standard);
+    isCatchAll: boolean;
+}> {
+    constructor(isCatchAll: boolean, config: VersionGroupConfig.Standard);
     canAdd(_: Instance): boolean;
-    inspect(): VersionGroupReport[];
+    inspect(): Effect.Effect<never, VersionGroupReport.WorkspaceMismatch | VersionGroupReport.UnsupportedMismatch | VersionGroupReport.HighestSemverMismatch | VersionGroupReport.LowestSemverMismatch, VersionGroupReport.Valid>[];
 }
+export {};

package/dist/get-version-groups/standard.js

@@ -1,32 +1,58 @@
 "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.StandardVersionGroup = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Effect = __importStar(require("@effect/io/Effect"));
 const unwrap_1 = require("tightrope/result/unwrap");
-const is_semver_1 = require("../lib/is-semver");
+const _1 = require(".");
+const is_supported_1 = require("../guards/is-supported");
 const get_highest_version_1 = require("./lib/get-highest-version");
 const get_lowest_version_1 = require("./lib/get-lowest-version");
 const get_unique_versions_1 = require("./lib/get-unique-versions");
 const group_by_1 = require("./lib/group-by");
-class StandardVersionGroup {
-    constructor(config) {
-        this._tag = 'Standard';
-        this.config = config;
-        this.instances = [];
+class StandardVersionGroup extends Data.TaggedClass('Standard') {
+    constructor(isCatchAll, config) {
+        super({
+            config,
+            instances: [],
+            isCatchAll,
+        });
     }
     canAdd(_) {
         return true;
     }
     inspect() {
-        const report = [];
         const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
-        Object.entries(instancesByName).forEach(([name, instances]) => {
+        return Object.entries(instancesByName).map(([name, instances]) => {
             if (!hasMismatch(instances)) {
-                return report.push({
-                    status: 'VALID',
+                return Effect.succeed(new _1.VersionGroupReport.Valid({
+                    name,
                     instances,
                     isValid: true,
-                    name,
-                });
+                }));
             }
             const wsInstance = getWorkspaceInstance(instances);
             const wsFile = wsInstance?.packageJsonFile;
@@ -35,57 +61,55 @@ class StandardVersionGroup {
             if (isWorkspacePackage) {
                 const nonWsInstances = getNonWorkspaceInstances(instances);
                 if (!hasMismatch(nonWsInstances)) {
-                    return report.push({
-                        status: 'VALID',
+                    return Effect.succeed(new _1.VersionGroupReport.Valid({
+                        name,
                         instances,
                         isValid: true,
-                        name,
-                    });
+                    }));
                 }
-                return report.push({
-                    status: 'WORKSPACE_MISMATCH',
-                    expectedVersion: wsVersion,
+                return Effect.fail(new _1.VersionGroupReport.WorkspaceMismatch({
+                    name,
                     instances,
                     isValid: false,
-                    name,
+                    expectedVersion: wsVersion,
                     workspaceInstance: wsInstance,
-                });
+                }));
             }
             if (hasUnsupported(instances)) {
-                return report.push({
-                    status: 'UNSUPPORTED_MISMATCH',
+                return Effect.fail(new _1.VersionGroupReport.UnsupportedMismatch({
+                    name,
                     instances,
                     isValid: false,
-                    name,
-                });
+                }));
             }
             const preferVersion = this.config.preferVersion;
             const expectedVersion = getExpectedVersion(preferVersion, instances);
-            return report.push({
-                status: preferVersion === 'highestSemver'
-                    ? 'HIGHEST_SEMVER_MISMATCH'
-                    : 'LOWEST_SEMVER_MISMATCH',
-                expectedVersion,
-                instances,
-                isValid: false,
-                name,
-            });
+            return Effect.fail(preferVersion === 'highestSemver'
+                ? new _1.VersionGroupReport.HighestSemverMismatch({
+                    name,
+                    instances,
+                    isValid: false,
+                    expectedVersion,
+                })
+                : new _1.VersionGroupReport.LowestSemverMismatch({
+                    name,
+                    instances,
+                    isValid: false,
+                    expectedVersion,
+                }));
         });
-        return report;
     }
 }
 exports.StandardVersionGroup = StandardVersionGroup;
 function getExpectedVersion(preferVersion, instances) {
     const versions = (0, get_unique_versions_1.getUniqueVersions)(instances);
-    return (0, unwrap_1.unwrap)(preferVersion === 'highestSemver'
-        ? (0, get_highest_version_1.getHighestVersion)(versions)
-        : (0, get_lowest_version_1.getLowestVersion)(versions));
+    return (0, unwrap_1.unwrap)(preferVersion === 'highestSemver' ? (0, get_highest_version_1.getHighestVersion)(versions) : (0, get_lowest_version_1.getLowestVersion)(versions));
 }
 function hasMismatch(instances) {
     return (0, get_unique_versions_1.getUniqueVersions)(instances).length > 1;
 }
 function hasUnsupported(instances) {
-    return instances.some((instance) => !(0, is_semver_1.isSupported)(instance.version));
+    return instances.some((instance) => !(0, is_supported_1.isSupported)(instance.version));
 }
 function getWorkspaceInstance(instances) {
     return instances.find((instance) => instance.strategy.name === 'workspace');

package/dist/guards/can-add-to-group.d.ts

@@ -0,0 +1,4 @@
+import type { Instance } from '../get-package-json-files/instance';
+import type { AnySemverGroup } from '../get-semver-groups';
+import type { AnyVersionGroup } from '../get-version-groups';
+export declare function canAddToGroup(group: AnySemverGroup | AnyVersionGroup, instance: Instance): boolean;

package/dist/guards/can-add-to-group.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canAddToGroup = void 0;
+const minimatch_1 = require("minimatch");
+const is_non_empty_array_1 = require("tightrope/guard/is-non-empty-array");
+function canAddToGroup(group, instance) {
+    const { dependencies, dependencyTypes, packages } = group.config;
+    return (group.canAdd(instance) &&
+        (!(0, is_non_empty_array_1.isNonEmptyArray)(dependencyTypes) || dependencyTypes.includes(instance.strategy.name)) &&
+        (!(0, is_non_empty_array_1.isNonEmptyArray)(packages) ||
+            packages.some((pattern) => (0, minimatch_1.minimatch)(instance.pkgName, pattern))) &&
+        (!(0, is_non_empty_array_1.isNonEmptyArray)(dependencies) ||
+            dependencies.some((pattern) => (0, minimatch_1.minimatch)(instance.name, pattern))));
+}
+exports.canAddToGroup = canAddToGroup;

package/dist/guards/is-loose-semver.d.ts

@@ -0,0 +1 @@
+export declare function isLooseSemver(version: unknown): boolean;

package/dist/guards/is-loose-semver.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLooseSemver = void 0;
+const is_string_1 = require("tightrope/guard/is-string");
+const is_semver_1 = require("./is-semver");
+function isLooseSemver(version) {
+    return (0, is_string_1.isString)(version) && (0, is_semver_1.isSemver)(version) && version.search(/\.x(\.|$)/) !== -1;
+}
+exports.isLooseSemver = isLooseSemver;

package/dist/guards/is-semver.d.ts

@@ -0,0 +1 @@
+export declare function isSemver(version: unknown): boolean;

package/dist/guards/is-semver.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSemver = void 0;
+const is_string_1 = require("tightrope/guard/is-string");
+function isSemver(version) {
+    const range = '(~|\\^|>=|>|<=|<)?';
+    const ints = '[0-9]+';
+    const intsOrX = '([0-9]+|x)';
+    const dot = '\\.';
+    const major = new RegExp(`^${range}${ints}$`);
+    const minor = new RegExp(`^${range}${ints}${dot}${intsOrX}$`);
+    const patch = new RegExp(`^${range}${ints}${dot}${intsOrX}${dot}${intsOrX}$`);
+    return ((0, is_string_1.isString)(version) &&
+        (version.search(major) !== -1 || version.search(minor) !== -1 || version.search(patch) !== -1));
+}
+exports.isSemver = isSemver;

package/dist/guards/is-supported.d.ts

@@ -0,0 +1 @@
+export declare function isSupported(version: unknown): version is string;

package/dist/guards/is-supported.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSupported = void 0;
+const is_string_1 = require("tightrope/guard/is-string");
+const is_semver_1 = require("./is-semver");
+function isSupported(version) {
+    return version === '*' || (0, is_semver_1.isSemver)(version) || isWorkspaceProtocol(version);
+}
+exports.isSupported = isSupported;
+function isWorkspaceProtocol(version) {
+    if (!(0, is_string_1.isString)(version))
+        return false;
+    if (!version.startsWith('workspace:'))
+        return false;
+    const value = version.replace(/^workspace:/, '');
+    return value === '*' || (0, is_semver_1.isSemver)(value);
+}

package/dist/guards/is-valid-semver-range.d.ts

@@ -0,0 +1,2 @@
+import type { SemverRange } from '../config/types';
+export declare function isValidSemverRange(value: unknown): value is SemverRange;

package/dist/guards/is-valid-semver-range.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidSemverRange = void 0;
+const constants_1 = require("../constants");
+function isValidSemverRange(value) {
+    return (value === constants_1.RANGE.ANY ||
+        value === constants_1.RANGE.EXACT ||
+        value === constants_1.RANGE.GT ||
+        value === constants_1.RANGE.GTE ||
+        value === constants_1.RANGE.LOOSE ||
+        value === constants_1.RANGE.LT ||
+        value === constants_1.RANGE.LTE ||
+        value === constants_1.RANGE.MINOR ||
+        value === constants_1.RANGE.PATCH ||
+        value === constants_1.RANGE.WORKSPACE);
+}
+exports.isValidSemverRange = isValidSemverRange;

package/dist/lib/$R.js

@@ -4,7 +4,7 @@ exports.$R = void 0;
 const result_1 = require("tightrope/result");
 const is_err_1 = require("tightrope/result/is-err");
 const unwrap_1 = require("tightrope/result/unwrap");
-const log_1 = require("./log");
+const log_verbose_1 = require("./log-verbose");
 exports.$R = {
     /**
      * Return a single `Ok<output[]>` containing an array of the output of every
@@ -28,7 +28,7 @@ exports.$R = {
     /** Log verbose only when Result is an Err */
     tapErrVerbose(result) {
         if ((0, is_err_1.isErr)(result))
-            (0, log_1.verbose)(result.value);
+            (0, log_verbose_1.logVerbose)(result.value);
         return result;
     },
 };

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

@@ -0,0 +1,6 @@
+import type { AnySemverGroup } from '../get-semver-groups';
+import type { AnyVersionGroup } from '../get-version-groups';
+export declare const logGroupHeader: {
+    semverGroup(group: AnySemverGroup, i: number): void;
+    versionGroup(group: AnyVersionGroup, i: number): void;
+};

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

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logGroupHeader = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+exports.logGroupHeader = {
+    semverGroup(group, i) {
+        log(group, 'Semver', i);
+    },
+    versionGroup(group, i) {
+        log(group, 'Version', i);
+    },
+};
+function log(group, type, i) {
+    const customLabel = group.config.label;
+    const labelWhenDefault = group.isCatchAll === true ? `Default ${type} Group` : '';
+    const anonymousLabel = `${type} Group ${i + 1}`;
+    const label = (customLabel || labelWhenDefault || anonymousLabel).trim();
+    const hasNewLines = label.search(/[\r\n]/) !== -1;
+    const header = hasNewLines ? formatMultiLine(label) : formatSingleLine(label);
+    console.log(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/log-verbose.d.ts

@@ -0,0 +1 @@
+export declare function logVerbose(...values: unknown[]): void;

package/dist/lib/log-verbose.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logVerbose = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const is_string_1 = require("tightrope/guard/is-string");
+const util_1 = require("util");
+const constants_1 = require("../constants");
+function logVerbose(...values) {
+    /* istanbul ignore if */
+    if (process.env.SYNCPACK_VERBOSE) {
+        console.info(chalk_1.default.yellow(constants_1.ICON.debug), ...values.map((value) => (0, is_string_1.isString)(value)
+            ? chalk_1.default.yellow(value)
+            : (0, util_1.inspect)(value, {
+                colors: true,
+                compact: true,
+                depth: 20,
+                showHidden: false,
+            })));
+    }
+}
+exports.logVerbose = logVerbose;