syncpack 9.0.2 → 9.3.2

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

@@ -1,57 +1,34 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 exports.__esModule = true;
 exports.fixMismatches = void 0;
 var expect_more_1 = require("expect-more");
 function fixMismatches(ctx) {
-    ctx.versionGroups.reverse().forEach(function (versionGroup) {
+    ctx.versionGroups.forEach(function (versionGroup) {
         var invalidGroups = versionGroup.getInvalidInstanceGroups();
         // Nothing to do if there are no mismatches
         if (invalidGroups.length === 0)
             return;
         // Set the correct version on each instance.
         invalidGroups.forEach(function (instanceGroup) {
-            var nextVersion = instanceGroup.getExpectedVersion();
-            if (nextVersion === '')
-                console.trace(instanceGroup);
-            instanceGroup.instances.forEach(function (instance) {
-                return instance.setVersion(nextVersion);
-            });
+            if (!instanceGroup.hasUnsupportedVersion()) {
+                var nextVersion_1 = instanceGroup.getExpectedVersion();
+                instanceGroup.instances.forEach(function (instance) {
+                    return instance.setVersion(nextVersion_1);
+                });
+            }
         });
     });
-    ctx.packageJsonFiles.forEach(function (file) {
-        removeEmptyObjects(file.contents);
+    /** Remove eg `{"dependencies": {}, "devDependencies": {}}` */
+    ctx.packageJsonFiles.forEach(function (packageJsonFile) {
+        var contents = packageJsonFile.contents;
+        Object.keys(contents).forEach(function (key) {
+            var value = contents[key];
+            if ((0, expect_more_1.isObject)(value) &&
+                Object.values(value).every(expect_more_1.isUndefined)) {
+                delete contents[key];
+            }
+        });
     });
     return ctx;
-    /** Remove eg { "dependencies": {}, "devDependencies": {} }` */
-    function removeEmptyObjects(parent) {
-        if ((0, expect_more_1.isObject)(parent)) {
-            Object.entries(parent).forEach(function (_a) {
-                var _b = __read(_a, 2), key = _b[0], child = _b[1];
-                if ((0, expect_more_1.isObject)(child) &&
-                    ((0, expect_more_1.isEmptyObject)(child) || Object.values(child).every(expect_more_1.isUndefined))) {
-                    delete parent[key];
-                }
-                else {
-                    removeEmptyObjects(child);
-                }
-            });
-        }
-    }
 }
 exports.fixMismatches = fixMismatches;

package/dist/bin-lint-semver-ranges/lint-semver-ranges.js

@@ -50,28 +50,25 @@ exports.lintSemverRanges = void 0;
 var chalk_1 = __importDefault(require("chalk"));
 var constants_1 = require("../constants");
 var log = __importStar(require("../lib/log"));
-var set_semver_range_1 = require("../lib/set-semver-range");
 function lintSemverRanges(ctx) {
-    ctx.semverGroups.reverse().forEach(function (semverGroup, i) {
+    var hasUserGroups = ctx.semverGroups.length > 1;
+    ctx.semverGroups.forEach(function (semverGroup, i) {
         // Nothing to do if there are no mismatches
         if (!semverGroup.hasMismatches())
             return;
         // Record that this project has mismatches, so that eg. the CLI can exit
         // with the correct status code.
         ctx.isInvalid = true;
+        // Annotate each group
+        hasUserGroups && log.semverGroupHeader(semverGroup, i);
         // Log each group which has mismatches
         semverGroup.getMismatches().forEach(function (_a) {
             var _b = __read(_a, 2), name = _b[0], mismatches = _b[1];
-            // Annotate user-defined version groups
-            if (!semverGroup.isDefault)
-                log.semverGroupHeader(i);
             // Log the dependency name
             log.invalid(name);
             // Log each of the dependencies mismatches
             mismatches.forEach(function (instance) {
-                if (!instance.hasRange(semverGroup.range)) {
-                    logSemverRangeMismatch(instance, semverGroup);
-                }
+                logSemverRangeMismatch(instance, semverGroup);
             });
         });
     });
@@ -82,7 +79,7 @@ function logSemverRangeMismatch(instance, semverGroup) {
     var path = instance.pathDef.path;
     var shortPath = instance.packageJsonFile.shortPath;
     var actual = instance.version;
-    var expected = (0, set_semver_range_1.setSemverRange)(semverGroup.range, actual);
+    var expected = semverGroup.getExpectedVersion(instance);
     console.log((0, chalk_1["default"])(templateObject_1 || (templateObject_1 = __makeTemplateObject(["  {red ", "} ", " {green ", "} {dim in ", " of ", "}"], ["  {red ", "} ", " {green ", "} {dim in ", " of ", "}"])), actual, constants_1.ICON.rightArrow, expected, path, shortPath));
 }
 var templateObject_1;

package/dist/bin-list/list.js

@@ -35,34 +35,44 @@ var chalk_1 = __importDefault(require("chalk"));
 var constants_1 = require("../constants");
 var log = __importStar(require("../lib/log"));
 function list(ctx) {
-    ctx.versionGroups.reverse().forEach(function (versionGroup, i) {
-        // Annotate user-defined version groups
-        if (!versionGroup.isDefault)
-            log.versionGroupHeader(i);
-        versionGroup.instanceGroups.forEach(function (instanceGroup) {
-            var expected = instanceGroup.getExpectedVersion();
-            var uniques = instanceGroup.uniques;
+    var hasUserGroups = ctx.versionGroups.length > 1;
+    ctx.versionGroups.forEach(function (versionGroup, i) {
+        var instanceGroups = versionGroup.getAllInstanceGroups();
+        // Nothing to do if empty
+        if (instanceGroups.length === 0)
+            return;
+        // Annotate each group
+        hasUserGroups && log.versionGroupHeader(versionGroup, i);
+        instanceGroups.forEach(function (instanceGroup) {
             // Record that this project has mismatches, so that eg. the CLI can exit
             // with the correct status code.
-            if (instanceGroup.isInvalid)
+            if (instanceGroup.isInvalid())
                 ctx.isInvalid = true;
-            versionGroup.isBanned
-                ? logBanned(instanceGroup)
-                : versionGroup.isIgnored
-                    ? logIgnored(instanceGroup)
-                    : instanceGroup.hasMismatches
-                        ? logVersionMismatch(instanceGroup, uniques, expected)
-                        : logVersionMatch(instanceGroup, uniques);
+            if (versionGroup.isBanned())
+                return logBanned(instanceGroup);
+            if (versionGroup.isIgnored())
+                return logIgnored(instanceGroup);
+            if (versionGroup.isUnpinned())
+                return logUnpinned(instanceGroup);
+            if (instanceGroup.hasMismatchingVersions()) {
+                return instanceGroup.hasUnsupportedVersion()
+                    ? logUnsupportedMismatches(instanceGroup)
+                    : logVersionMismatch(instanceGroup);
+            }
+            logVersionMatch(instanceGroup);
         });
     });
     return ctx;
-    function logVersionMatch(instanceGroup, uniques) {
-        console.log((0, chalk_1["default"])(templateObject_1 || (templateObject_1 = __makeTemplateObject(["{dim -} {white ", "} {dim ", "}"], ["{dim -} {white ", "} {dim ", "}"])), instanceGroup.name, uniques));
+    function logVersionMatch(instanceGroup) {
+        console.log((0, chalk_1["default"])(templateObject_1 || (templateObject_1 = __makeTemplateObject(["{dim -} {white ", "} {dim ", "}"], ["{dim -} {white ", "} {dim ", "}"])), instanceGroup.name, instanceGroup.getUniqueVersions()));
     }
-    function logVersionMismatch(instanceGroup, uniques, expected) {
-        console.log((0, chalk_1["default"])(templateObject_2 || (templateObject_2 = __makeTemplateObject(["{red ", " ", "} ", ""], ["{red ", " ", "} ", ""])), constants_1.ICON.cross, instanceGroup.name, uniques
+    function logVersionMismatch(instanceGroup) {
+        console.log((0, chalk_1["default"])(templateObject_2 || (templateObject_2 = __makeTemplateObject(["{red ", " ", "} ", ""], ["{red ", " ", "} ", ""])), constants_1.ICON.cross, instanceGroup.name, instanceGroup
+            .getUniqueVersions()
             .map(function (version) {
-            return version === expected ? chalk_1["default"].green(version) : chalk_1["default"].red(version);
+            return version === instanceGroup.getExpectedVersion()
+                ? chalk_1["default"].green(version)
+                : chalk_1["default"].red(version);
         })
             .join(chalk_1["default"].dim(', '))));
     }
@@ -72,6 +82,16 @@ function list(ctx) {
     function logBanned(instanceGroup) {
         console.log((0, chalk_1["default"])(templateObject_4 || (templateObject_4 = __makeTemplateObject(["{red ", " ", "} {dim.red is banned in this version group}"], ["{red ", " ", "} {dim.red is banned in this version group}"])), constants_1.ICON.cross, instanceGroup.name));
     }
+    function logUnpinned(instanceGroup) {
+        var pinVersion = instanceGroup.versionGroup.getPinnedVersion();
+        console.log((0, chalk_1["default"])(templateObject_5 || (templateObject_5 = __makeTemplateObject(["{red ", " ", "} {dim.red is pinned to ", " in this version group}"], ["{red ", " ", "} {dim.red is pinned to ", " in this version group}"])), constants_1.ICON.cross, instanceGroup.name, pinVersion));
+    }
+    function logUnsupportedMismatches(instanceGroup) {
+        console.log((0, chalk_1["default"])(templateObject_6 || (templateObject_6 = __makeTemplateObject(["{red ", " ", "} {dim.red has mismatched versions which syncpack cannot fix: ", "}"], ["{red ", " ", "} {dim.red has mismatched versions which syncpack cannot fix: ", "}"])), constants_1.ICON.cross, instanceGroup.name, instanceGroup
+            .getUniqueVersions()
+            .map(function (version) { return chalk_1["default"].yellow(version); })
+            .join(chalk_1["default"].dim(', '))));
+    }
 }
 exports.list = list;
-var templateObject_1, templateObject_2, templateObject_3, templateObject_4;
+var templateObject_1, templateObject_2, templateObject_3, templateObject_4, templateObject_5, templateObject_6;

package/dist/bin-list-mismatches/list-mismatches.js

@@ -34,7 +34,8 @@ exports.listMismatches = void 0;
 var chalk_1 = __importDefault(require("chalk"));
 var log = __importStar(require("../lib/log"));
 function listMismatches(ctx) {
-    ctx.versionGroups.reverse().forEach(function (versionGroup, i) {
+    var hasUserGroups = ctx.versionGroups.length > 1;
+    ctx.versionGroups.forEach(function (versionGroup, i) {
         var invalidGroups = versionGroup.getInvalidInstanceGroups();
         // Nothing to do if there are no mismatches
         if (invalidGroups.length === 0)
@@ -42,51 +43,73 @@ function listMismatches(ctx) {
         // Record that this project has mismatches, so that eg. the CLI can exit
         // with the correct status code.
         ctx.isInvalid = true;
-        // Annotate user-defined version groups
-        if (!versionGroup.isDefault)
-            log.versionGroupHeader(i);
+        // Annotate each group
+        hasUserGroups && log.versionGroupHeader(versionGroup, i);
         // Log the mismatches
         invalidGroups.forEach(function (instanceGroup) {
-            var name = instanceGroup.name;
-            var workspaceInstance = instanceGroup.getWorkspaceInstance();
-            var expected = instanceGroup.getExpectedVersion() || '';
-            var isBanned = versionGroup.isBanned;
-            var isUnpinned = instanceGroup.isUnpinned;
-            // Log the dependency name
-            if (isBanned) {
-                logBanned(name);
+            if (versionGroup.isBanned())
+                return logBanned(instanceGroup);
+            if (versionGroup.isUnpinned())
+                return logUnpinned(instanceGroup);
+            if (instanceGroup.hasUnsupportedVersion())
+                return logUnsupportedMismatches(instanceGroup);
+            if (instanceGroup.hasWorkspaceInstance()) {
+                return logWorkspaceMismatch(instanceGroup);
             }
-            else if (isUnpinned) {
-                logPinVersionMismatch(name, versionGroup);
-            }
-            else if (workspaceInstance) {
-                logWorkspaceMismatch(workspaceInstance, expected, name);
-            }
-            else {
-                logHighestVersionMismatch(expected, name);
-            }
-            // Log each of the dependencies mismatches
-            instanceGroup.instances.forEach(function (instance) {
-                if (instance.version !== expected) {
-                    logVersionMismatch(instance);
-                }
-            });
+            logHighestVersionMismatch(instanceGroup);
         });
     });
     return ctx;
-    function logBanned(name) {
+    function logBanned(instanceGroup) {
+        var name = instanceGroup.name;
         log.invalid(name, 'is banned in this version group');
+        // Log each of the dependencies mismatches
+        instanceGroup.instances.forEach(function (instance) {
+            logVersionMismatch(instance);
+        });
     }
-    function logPinVersionMismatch(name, versionGroup) {
-        var pinVersion = versionGroup.pinVersion;
+    function logUnsupportedMismatches(instanceGroup) {
+        var name = instanceGroup.name;
+        log.invalid(name, 'has mismatched versions which syncpack cannot fix');
+        // Log each of the dependencies mismatches
+        instanceGroup.instances.forEach(function (instance) {
+            logUnsupportedVersionMismatch(instance);
+        });
+    }
+    function logUnpinned(instanceGroup) {
+        var name = instanceGroup.name;
+        var pinVersion = instanceGroup.versionGroup.getPinnedVersion();
         log.invalid(name, (0, chalk_1["default"])(templateObject_1 || (templateObject_1 = __makeTemplateObject(["is pinned in this version group at {reset.green ", "}"], ["is pinned in this version group at {reset.green ", "}"])), pinVersion));
+        // Log each of the dependencies mismatches
+        instanceGroup.instances.forEach(function (instance) {
+            if (instance.version !== pinVersion) {
+                logVersionMismatch(instance);
+            }
+        });
     }
-    function logWorkspaceMismatch(workspaceInstance, expected, name) {
-        var shortPath = workspaceInstance.packageJsonFile.shortPath;
+    function logWorkspaceMismatch(instanceGroup) {
+        var name = instanceGroup.name;
+        var workspaceInstance = instanceGroup.getWorkspaceInstance();
+        var shortPath = workspaceInstance === null || workspaceInstance === void 0 ? void 0 : workspaceInstance.packageJsonFile.shortPath;
+        var expected = instanceGroup.getExpectedVersion();
         log.invalid(name, (0, chalk_1["default"])(templateObject_2 || (templateObject_2 = __makeTemplateObject(["{reset.green ", "} {dim is developed in this repo at ", "}"], ["{reset.green ", "} {dim is developed in this repo at ", "}"])), expected, shortPath));
+        // Log each of the dependencies mismatches
+        instanceGroup.instances.forEach(function (instance) {
+            if (instance.version !== expected) {
+                logVersionMismatch(instance);
+            }
+        });
     }
-    function logHighestVersionMismatch(expected, name) {
+    function logHighestVersionMismatch(instanceGroup) {
+        var name = instanceGroup.name;
+        var expected = instanceGroup.getExpectedVersion();
         log.invalid(name, (0, chalk_1["default"])(templateObject_3 || (templateObject_3 = __makeTemplateObject(["{reset.green ", "} {dim is the highest valid semver version in use}"], ["{reset.green ", "} {dim is the highest valid semver version in use}"])), expected));
+        // Log each of the dependencies mismatches
+        instanceGroup.instances.forEach(function (instance) {
+            if (instance.version !== expected) {
+                logVersionMismatch(instance);
+            }
+        });
     }
     function logVersionMismatch(instance) {
         var type = instance.pathDef.path;
@@ -94,6 +117,12 @@ function listMismatches(ctx) {
         var actual = instance.version;
         console.log((0, chalk_1["default"])(templateObject_4 || (templateObject_4 = __makeTemplateObject(["  {red ", "} {dim in ", " of ", "}"], ["  {red ", "} {dim in ", " of ", "}"])), actual, type, shortPath));
     }
+    function logUnsupportedVersionMismatch(instance) {
+        var type = instance.pathDef.path;
+        var shortPath = instance.packageJsonFile.shortPath;
+        var actual = instance.version;
+        console.log((0, chalk_1["default"])(templateObject_5 || (templateObject_5 = __makeTemplateObject(["  {yellow ", "} {dim in ", " of ", "}"], ["  {yellow ", "} {dim in ", " of ", "}"])), actual, type, shortPath));
+    }
 }
 exports.listMismatches = listMismatches;
-var templateObject_1, templateObject_2, templateObject_3, templateObject_4;
+var templateObject_1, templateObject_2, templateObject_3, templateObject_4, templateObject_5;

package/dist/bin-set-semver-ranges/set-semver-ranges.js

@@ -2,9 +2,9 @@
 exports.__esModule = true;
 exports.setSemverRanges = void 0;
 var setSemverRanges = function (ctx) {
-    ctx.semverGroups.reverse().forEach(function (semverGroup) {
+    ctx.semverGroups.forEach(function (semverGroup) {
         semverGroup.instances.forEach(function (instance) {
-            instance.setRange(semverGroup.range);
+            instance.setVersion(semverGroup.getExpectedVersion(instance));
         });
     });
     return ctx;

package/dist/get-context/get-config/schema/base-group.d.ts

@@ -2,5 +2,6 @@ import { z } from 'zod';
 export declare const baseGroupFields: {
     dependencies: z.ZodArray<z.ZodString, "many">;
     dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    label: z.ZodDefault<z.ZodString>;
     packages: z.ZodArray<z.ZodString, "many">;
 };

package/dist/get-context/get-config/schema/base-group.js

@@ -5,5 +5,6 @@ var zod_1 = require("zod");
 exports.baseGroupFields = {
     dependencies: zod_1.z.array(zod_1.z.string()).min(1),
     dependencyTypes: zod_1.z.array(zod_1.z.string())["default"]([]),
+    label: zod_1.z.string()["default"](''),
     packages: zod_1.z.array(zod_1.z.string()).min(1)
 };