syncpack 9.8.4 → 10.0.0

package/dist/get-semver-groups/index.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSemverGroups = void 0;
+const minimatch_1 = __importDefault(require("minimatch"));
+const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
+const is_non_empty_array_1 = require("tightrope/guard/is-non-empty-array");
+const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
+const is_object_1 = require("tightrope/guard/is-object");
+const get_enabled_types_1 = require("../config/get-enabled-types");
+const get_semver_range_1 = require("../config/get-semver-range");
+const is_semver_1 = require("../lib/is-semver");
+const catch_all_1 = require("./catch-all");
+const filtered_out_1 = require("./filtered-out");
+const ignored_1 = require("./ignored");
+const with_range_1 = require("./with-range");
+function getSemverGroups(ctx) {
+    const enabledTypes = (0, get_enabled_types_1.getEnabledTypes)(ctx.config);
+    const semverGroups = createSemverGroups(ctx);
+    ctx.packageJsonFiles.forEach((file) => {
+        file.getInstances(enabledTypes).forEach((instance) => {
+            const { name, pkgName } = instance;
+            for (const group of semverGroups) {
+                const { dependencies, dependencyTypes, packages } = group.config;
+                if (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.default)(instance.pkgName, pattern))) &&
+                    (!(0, is_non_empty_array_1.isNonEmptyArray)(dependencies) ||
+                        dependencies.some((pattern) => (0, minimatch_1.default)(instance.name, pattern)))) {
+                    group.instances.push(instance);
+                    return;
+                }
+            }
+            throw new Error(`${name} in ${pkgName} did not match any semver groups`);
+        });
+    });
+    return semverGroups.filter((group) => (0, is_non_empty_array_1.isNonEmptyArray)(group.instances));
+}
+exports.getSemverGroups = getSemverGroups;
+function createSemverGroups(ctx) {
+    const { cli, rcFile } = ctx.config;
+    const semverGroups = [new filtered_out_1.FilteredOutSemverGroup(ctx)];
+    if ((0, is_non_empty_array_1.isNonEmptyArray)(rcFile.semverGroups)) {
+        const ERR_OBJ = new Error('Invalid semverGroup');
+        const ERR_DEPS = new Error('Invalid semverGroup dependencies');
+        const ERR_PKGS = new Error('Invalid semverGroup packages');
+        rcFile.semverGroups.forEach((config) => {
+            if (!(0, is_object_1.isObject)(config))
+                throw ERR_OBJ;
+            if (!(0, is_array_of_strings_1.isArrayOfStrings)(config.dependencies))
+                throw ERR_DEPS;
+            if (!(0, is_array_of_strings_1.isArrayOfStrings)(config.packages))
+                throw ERR_PKGS;
+            const { dependencies, packages } = config;
+            const label = (0, is_non_empty_string_1.isNonEmptyString)(config.label) ? config.label : '';
+            const dependencyTypes = (0, is_array_of_strings_1.isArrayOfStrings)(config.dependencyTypes)
+                ? config.dependencyTypes
+                : [];
+            if (config.isIgnored === true) {
+                semverGroups.push(new ignored_1.IgnoredSemverGroup({
+                    dependencies,
+                    dependencyTypes,
+                    isIgnored: true,
+                    label,
+                    packages,
+                }));
+            }
+            else if ((0, is_semver_1.isValidSemverRange)(config.range)) {
+                semverGroups.push(new with_range_1.WithRangeSemverGroup({
+                    dependencies,
+                    dependencyTypes,
+                    label,
+                    packages,
+                    range: config.range,
+                }));
+            }
+        });
+    }
+    semverGroups.push(new catch_all_1.CatchAllSemverGroup({
+        dependencies: ['**'],
+        label: '',
+        packages: ['**'],
+        range: (0, get_semver_range_1.getSemverRange)({ cli, rcFile }),
+    }));
+    return semverGroups;
+}

package/dist/get-semver-groups/with-range.d.ts

@@ -0,0 +1,11 @@
+import type { SemverGroupReport } from '.';
+import type { SemverGroupConfig } from '../config/types';
+import type { Instance } from '../get-package-json-files/instance';
+export declare class WithRangeSemverGroup {
+    _tag: string;
+    config: SemverGroupConfig.WithRange;
+    instances: Instance[];
+    constructor(config: SemverGroupConfig.WithRange);
+    canAdd(_: Instance): boolean;
+    inspect(): SemverGroupReport[];
+}

package/dist/get-semver-groups/with-range.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithRangeSemverGroup = void 0;
+const is_semver_1 = require("../lib/is-semver");
+const set_semver_range_1 = require("../lib/set-semver-range");
+class WithRangeSemverGroup {
+    constructor(config) {
+        this._tag = 'WithRange';
+        this.config = config;
+        this.instances = [];
+    }
+    canAdd(_) {
+        return true;
+    }
+    inspect() {
+        return this.instances.map((instance) => {
+            if (!(0, is_semver_1.isSupported)(instance.version)) {
+                return {
+                    status: 'UNSUPPORTED_VERSION',
+                    instance,
+                    isValid: false,
+                    name: instance.name,
+                };
+            }
+            const isWsInstance = instance.strategy.name === 'workspace';
+            const exactVersion = (0, set_semver_range_1.setSemverRange)('', instance.version);
+            const expectedVersion = (0, set_semver_range_1.setSemverRange)(this.config.range, instance.version);
+            if (isWsInstance && instance.version !== exactVersion) {
+                return {
+                    status: 'WORKSPACE_SEMVER_RANGE_MISMATCH',
+                    expectedVersion: exactVersion,
+                    instance,
+                    isValid: false,
+                    name: instance.name,
+                };
+            }
+            if (instance.version === expectedVersion) {
+                return {
+                    status: 'VALID',
+                    instance,
+                    isValid: true,
+                    name: instance.name,
+                };
+            }
+            return {
+                status: 'SEMVER_RANGE_MISMATCH',
+                expectedVersion,
+                instance,
+                isValid: false,
+                name: instance.name,
+            };
+        });
+    }
+}
+exports.WithRangeSemverGroup = WithRangeSemverGroup;

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

@@ -0,0 +1,11 @@
+import type { VersionGroupReport } from '.';
+import type { VersionGroupConfig } from '../config/types';
+import type { Instance } from '../get-package-json-files/instance';
+export declare class BannedVersionGroup {
+    _tag: string;
+    config: VersionGroupConfig.Banned;
+    instances: Instance[];
+    constructor(config: VersionGroupConfig.Banned);
+    canAdd(_: Instance): boolean;
+    inspect(): VersionGroupReport[];
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BannedVersionGroup = void 0;
+const group_by_1 = require("./lib/group-by");
+class BannedVersionGroup {
+    constructor(config) {
+        this._tag = 'Banned';
+        this.config = config;
+        this.instances = [];
+    }
+    canAdd(_) {
+        return true;
+    }
+    inspect() {
+        const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
+        return Object.entries(instancesByName).map(([name, instances]) => ({
+            instances,
+            isValid: false,
+            name,
+            status: 'BANNED',
+        }));
+    }
+}
+exports.BannedVersionGroup = BannedVersionGroup;

package/dist/get-version-groups/catch-all.d.ts

@@ -0,0 +1,4 @@
+import { StandardVersionGroup } from './standard';
+export declare class CatchAllVersionGroup extends StandardVersionGroup {
+    _tag: string;
+}

package/dist/get-version-groups/catch-all.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatchAllVersionGroup = void 0;
+const standard_1 = require("./standard");
+class CatchAllVersionGroup extends standard_1.StandardVersionGroup {
+    constructor() {
+        super(...arguments);
+        this._tag = 'CatchAll';
+    }
+}
+exports.CatchAllVersionGroup = CatchAllVersionGroup;

package/dist/get-version-groups/filtered-out.d.ts

@@ -0,0 +1,13 @@
+import type { VersionGroupReport } from '.';
+import type { GroupConfig } from '../config/types';
+import type { Context } from '../get-context';
+import type { Instance } from '../get-package-json-files/instance';
+export declare class FilteredOutVersionGroup {
+    _tag: string;
+    config: GroupConfig;
+    filter: string;
+    instances: Instance[];
+    constructor(ctx: Context);
+    canAdd(instance: Instance): boolean;
+    inspect(): VersionGroupReport[];
+}

package/dist/get-version-groups/filtered-out.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilteredOutVersionGroup = void 0;
+const get_filter_1 = require("../config/get-filter");
+const group_by_1 = require("./lib/group-by");
+class FilteredOutVersionGroup {
+    constructor(ctx) {
+        this._tag = 'FilteredOut';
+        this.config = {
+            dependencies: ['**'],
+            dependencyTypes: [],
+            label: 'Filtered out',
+            packages: ['**'],
+        };
+        this.filter = (0, get_filter_1.getFilter)(ctx.config);
+        this.instances = [];
+    }
+    canAdd(instance) {
+        return instance.name.search(new RegExp(this.filter)) === -1;
+    }
+    inspect() {
+        const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
+        return Object.entries(instancesByName).map(([name, instances]) => ({
+            instances,
+            isValid: true,
+            name,
+            status: 'FILTERED_OUT',
+        }));
+    }
+}
+exports.FilteredOutVersionGroup = FilteredOutVersionGroup;

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

@@ -0,0 +1,11 @@
+import type { VersionGroupReport } from '.';
+import type { VersionGroupConfig } from '../config/types';
+import type { Instance } from '../get-package-json-files/instance';
+export declare class IgnoredVersionGroup {
+    _tag: string;
+    config: VersionGroupConfig.Ignored;
+    instances: Instance[];
+    constructor(config: VersionGroupConfig.Ignored);
+    canAdd(_: Instance): boolean;
+    inspect(): VersionGroupReport[];
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IgnoredVersionGroup = void 0;
+const group_by_1 = require("./lib/group-by");
+class IgnoredVersionGroup {
+    constructor(config) {
+        this._tag = 'Ignored';
+        this.config = config;
+        this.instances = [];
+    }
+    canAdd(_) {
+        return true;
+    }
+    inspect() {
+        const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
+        return Object.entries(instancesByName).map(([name, instances]) => ({
+            instances,
+            isValid: true,
+            name,
+            status: 'IGNORED',
+        }));
+    }
+}
+exports.IgnoredVersionGroup = IgnoredVersionGroup;

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

@@ -0,0 +1,57 @@
+import type { Context } from '../get-context';
+import type { Instance } from '../get-package-json-files/instance';
+import { BannedVersionGroup } from './banned';
+import { CatchAllVersionGroup } from './catch-all';
+import { FilteredOutVersionGroup } from './filtered-out';
+import { IgnoredVersionGroup } from './ignored';
+import { PinnedVersionGroup } from './pinned';
+import { SnappedToVersionGroup } from './snapped-to';
+import { StandardVersionGroup } from './standard';
+export type AnyVersionGroup = BannedVersionGroup | CatchAllVersionGroup | FilteredOutVersionGroup | IgnoredVersionGroup | PinnedVersionGroup | SnappedToVersionGroup | StandardVersionGroup;
+export type VersionGroupReport = {
+    name: string;
+    instances: Instance[];
+} & ({
+    status: 'BANNED';
+    isValid: false;
+} | {
+    status: 'FILTERED_OUT';
+    isValid: true;
+} | {
+    status: 'HIGHEST_SEMVER_MISMATCH';
+    isValid: false;
+    expectedVersion: string;
+} | {
+    status: 'IGNORED';
+    isValid: true;
+} | {
+    status: 'LOWEST_SEMVER_MISMATCH';
+    isValid: false;
+    expectedVersion: string;
+} | {
+    status: 'PINNED_MISMATCH';
+    isValid: false;
+    expectedVersion: string;
+} | {
+    status: 'SEMVER_UNSATISFIED';
+    isValid: false;
+} | {
+    status: 'SNAPPED_TO_MISMATCH';
+    isValid: false;
+    expectedVersion: string;
+} | {
+    status: 'UNSUPPORTED_MISMATCH';
+    isValid: false;
+} | {
+    status: 'VALID';
+    isValid: true;
+} | {
+    status: 'WORKSPACE_MISMATCH';
+    isValid: false;
+    expectedVersion: string;
+    workspaceInstance: Instance;
+} | {
+    status: 'WORKSPACE_UNSATISFIED';
+    isValid: false;
+});
+export declare function getVersionGroups(ctx: Context): AnyVersionGroup[];

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

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVersionGroups = void 0;
+const minimatch_1 = __importDefault(require("minimatch"));
+const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
+const is_non_empty_array_1 = require("tightrope/guard/is-non-empty-array");
+const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
+const is_object_1 = require("tightrope/guard/is-object");
+const get_enabled_types_1 = require("../config/get-enabled-types");
+const banned_1 = require("./banned");
+const catch_all_1 = require("./catch-all");
+const filtered_out_1 = require("./filtered-out");
+const ignored_1 = require("./ignored");
+const pinned_1 = require("./pinned");
+const snapped_to_1 = require("./snapped-to");
+const standard_1 = require("./standard");
+function getVersionGroups(ctx) {
+    const enabledTypes = (0, get_enabled_types_1.getEnabledTypes)(ctx.config);
+    const versionGroups = createVersionGroups(ctx);
+    ctx.packageJsonFiles.forEach((file) => {
+        file.getInstances(enabledTypes).forEach((instance) => {
+            const { name, pkgName } = instance;
+            for (const group of versionGroups) {
+                const { dependencies, dependencyTypes, packages } = group.config;
+                if (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.default)(instance.pkgName, pattern))) &&
+                    (!(0, is_non_empty_array_1.isNonEmptyArray)(dependencies) ||
+                        dependencies.some((pattern) => (0, minimatch_1.default)(instance.name, pattern)))) {
+                    group.instances.push(instance);
+                    return;
+                }
+            }
+            throw new Error(`${name} in ${pkgName} did not match any version groups`);
+        });
+    });
+    return versionGroups.filter((group) => (0, is_non_empty_array_1.isNonEmptyArray)(group.instances));
+}
+exports.getVersionGroups = getVersionGroups;
+function createVersionGroups(ctx) {
+    const { rcFile } = ctx.config;
+    const versionGroups = [new filtered_out_1.FilteredOutVersionGroup(ctx)];
+    if ((0, is_non_empty_array_1.isNonEmptyArray)(rcFile.versionGroups)) {
+        const ERR_OBJ = new Error('Invalid versionGroup');
+        const ERR_DEPS = new Error('Invalid versionGroup dependencies');
+        const ERR_PKGS = new Error('Invalid versionGroup packages');
+        rcFile.versionGroups.forEach((config) => {
+            if (!(0, is_object_1.isObject)(config))
+                throw ERR_OBJ;
+            if (!(0, is_array_of_strings_1.isArrayOfStrings)(config.dependencies))
+                throw ERR_DEPS;
+            if (!(0, is_array_of_strings_1.isArrayOfStrings)(config.packages))
+                throw ERR_PKGS;
+            const { dependencies, packages } = config;
+            const label = (0, is_non_empty_string_1.isNonEmptyString)(config.label) ? config.label : '';
+            const dependencyTypes = (0, is_array_of_strings_1.isArrayOfStrings)(config.dependencyTypes)
+                ? config.dependencyTypes
+                : [];
+            if (config.isBanned === true) {
+                versionGroups.push(new banned_1.BannedVersionGroup({
+                    dependencies,
+                    dependencyTypes,
+                    isBanned: true,
+                    label,
+                    packages,
+                }));
+            }
+            else if (config.isIgnored === true) {
+                versionGroups.push(new ignored_1.IgnoredVersionGroup({
+                    dependencies,
+                    dependencyTypes,
+                    isIgnored: true,
+                    label,
+                    packages,
+                }));
+            }
+            else if ((0, is_non_empty_string_1.isNonEmptyString)(config.pinVersion)) {
+                versionGroups.push(new pinned_1.PinnedVersionGroup({
+                    dependencies,
+                    dependencyTypes,
+                    label,
+                    packages,
+                    pinVersion: config.pinVersion,
+                }));
+            }
+            else if ((0, is_array_of_strings_1.isArrayOfStrings)(config.snapTo)) {
+                versionGroups.push(new snapped_to_1.SnappedToVersionGroup({
+                    dependencies,
+                    dependencyTypes,
+                    label,
+                    packages,
+                    snapTo: config.snapTo,
+                }));
+            }
+            else {
+                versionGroups.push(new standard_1.StandardVersionGroup({
+                    dependencies,
+                    dependencyTypes,
+                    label,
+                    packages,
+                    preferVersion: config.preferVersion === 'lowestSemver'
+                        ? 'lowestSemver'
+                        : 'highestSemver',
+                }));
+            }
+        });
+    }
+    versionGroups.push(new catch_all_1.CatchAllVersionGroup({
+        dependencies: ['**'],
+        packages: ['**'],
+        preferVersion: 'highestSemver',
+    }));
+    return versionGroups;
+}

package/dist/get-version-groups/lib/delete.d.ts

@@ -0,0 +1,2 @@
+export declare const DELETE: unique symbol;
+export type Delete = typeof DELETE;

package/dist/get-version-groups/lib/delete.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELETE = void 0;
+exports.DELETE = Symbol('DELETE');

package/dist/get-version-groups/lib/get-highest-version.d.ts

@@ -0,0 +1,2 @@
+import type { Result } from 'tightrope/result';
+export declare function getHighestVersion(versions: string[]): Result<string>;

package/dist/get-version-groups/lib/get-highest-version.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHighestVersion = void 0;
+const pipe_1 = require("tightrope/fn/pipe");
+const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
+const filter_1 = require("tightrope/result/filter");
+const from_try_1 = require("tightrope/result/from-try");
+const map_1 = require("tightrope/result/map");
+const sort_1 = require("./sort");
+function getHighestVersion(versions) {
+    return (0, pipe_1.pipe)((0, from_try_1.fromTry)(() => [...versions].sort(sort_1.compareSemver)), (0, map_1.map)((sorted) => sorted[sorted.length - 1]), (0, filter_1.filter)(is_non_empty_string_1.isNonEmptyString, 'getHighestVersion(): did not return a version'));
+}
+exports.getHighestVersion = getHighestVersion;

package/dist/get-version-groups/lib/get-lowest-version.d.ts

@@ -0,0 +1,2 @@
+import type { Result } from 'tightrope/result';
+export declare function getLowestVersion(versions: string[]): Result<string>;

package/dist/get-version-groups/lib/get-lowest-version.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLowestVersion = void 0;
+const pipe_1 = require("tightrope/fn/pipe");
+const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
+const filter_1 = require("tightrope/result/filter");
+const from_try_1 = require("tightrope/result/from-try");
+const map_1 = require("tightrope/result/map");
+const sort_1 = require("./sort");
+function getLowestVersion(versions) {
+    return (0, pipe_1.pipe)((0, from_try_1.fromTry)(() => [...versions].sort(sort_1.compareSemver)), (0, map_1.map)(([lowest]) => lowest), (0, filter_1.filter)(is_non_empty_string_1.isNonEmptyString, 'getLowestVersion(): did not return a version'));
+}
+exports.getLowestVersion = getLowestVersion;

package/dist/{get-context/get-groups/version-group/instance-group → get-version-groups}/lib/get-range-score.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRangeScore = void 0;
-const constants_1 = require("../../../../../constants");
+const constants_1 = require("../../constants");
 const scoresByRange = {
-    [constants_1.RANGE.ANY]: 8,
+    [constants_1.RANGE.ANY]: 9,
+    [constants_1.RANGE.WORKSPACE]: 8,
     [constants_1.RANGE.GT]: 7,
     [constants_1.RANGE.GTE]: 6,
     [constants_1.RANGE.MINOR]: 5,

package/dist/get-version-groups/lib/get-unique-versions.d.ts

@@ -0,0 +1,2 @@
+import type { Instance } from '../../get-package-json-files/instance';
+export declare function getUniqueVersions(instances: Instance[]): string[];

package/dist/get-version-groups/lib/get-unique-versions.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUniqueVersions = void 0;
+const uniq_1 = require("tightrope/array/uniq");
+function getUniqueVersions(instances) {
+    return (0, uniq_1.uniq)(instances.map((i) => i.version));
+}
+exports.getUniqueVersions = getUniqueVersions;

package/dist/get-version-groups/lib/group-by.d.ts

@@ -0,0 +1 @@
+export declare function groupBy<A extends any[]>(key: string, array: A): Record<string, A>;

package/dist/get-version-groups/lib/group-by.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupBy = void 0;
+function groupBy(key, array) {
+    return array.reduce((objectsByKeyValue, obj) => {
+        const value = obj[key];
+        objectsByKeyValue[value] = (objectsByKeyValue[value] || []).concat(obj);
+        return objectsByKeyValue;
+    }, {});
+}
+exports.groupBy = groupBy;

package/dist/get-version-groups/lib/sort.d.ts

@@ -0,0 +1 @@
+export declare function compareSemver(a: string, b: string): -1 | 0 | 1;

package/dist/get-version-groups/lib/sort.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareSemver = void 0;
+const gt_1 = __importDefault(require("semver/functions/gt"));
+const lt_1 = __importDefault(require("semver/functions/lt"));
+const is_semver_1 = require("../../lib/is-semver");
+const clean_1 = require("./clean");
+const get_range_score_1 = require("./get-range-score");
+const EQ = 0;
+const LT = -1;
+const GT = 1;
+function compareSemver(a, b) {
+    if (!(0, is_semver_1.isSupported)(a))
+        throw new Error(`"${a}" is not supported`);
+    if (!(0, is_semver_1.isSupported)(b))
+        throw new Error(`"${b}" is not supported`);
+    if (a.startsWith('workspace:'))
+        return LT;
+    if (b.startsWith('workspace:'))
+        return GT;
+    if (a === b)
+        return EQ;
+    if (a === '*')
+        return GT;
+    if (b === '*')
+        return LT;
+    const cleanA = (0, clean_1.clean)(a);
+    const cleanB = (0, clean_1.clean)(b);
+    if ((0, gt_1.default)(cleanA, cleanB))
+        return GT;
+    if ((0, lt_1.default)(cleanA, cleanB))
+        return LT;
+    const scoreA = (0, get_range_score_1.getRangeScore)(a);
+    const scoreB = (0, get_range_score_1.getRangeScore)(b);
+    if (scoreA < scoreB)
+        return LT;
+    if (scoreA > scoreB)
+        return GT;
+    return EQ;
+}
+exports.compareSemver = compareSemver;

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

@@ -0,0 +1,11 @@
+import type { VersionGroupReport } from '.';
+import type { VersionGroupConfig } from '../config/types';
+import type { Instance } from '../get-package-json-files/instance';
+export declare class PinnedVersionGroup {
+    _tag: string;
+    config: VersionGroupConfig.Pinned;
+    instances: Instance[];
+    constructor(config: VersionGroupConfig.Pinned);
+    canAdd(_: Instance): boolean;
+    inspect(): VersionGroupReport[];
+}