syncpack 10.7.2 → 10.9.3

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

@@ -3,7 +3,7 @@ import * as Effect from '@effect/io/Effect';
 import type { Union } from 'ts-toolbelt';
 import type { DeprecatedTypesError } from '../config/get-enabled-types';
 import type { Ctx } from '../get-context';
-import type { Instance } from '../get-package-json-files/instance';
+import type { Instance } from '../instance';
 import { BannedVersionGroup } from './banned';
 import { FilteredOutVersionGroup } from './filtered-out';
 import { IgnoredVersionGroup } from './ignored';
@@ -16,27 +16,39 @@ export declare namespace VersionGroupReport {
     const Banned_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: "Banned";
     }>;
+    /**
+     * Every instance in this `BannedVersionGroup` matched its configuration and
+     * will be removed if fixed
+     */
     export class Banned extends Banned_base<{
         name: string;
-        instances: Instance[];
+        instances: Instance.Any[];
         readonly isValid: false;
     }> {
     }
     const FilteredOut_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: "FilteredOut";
     }>;
+    /**
+     * Every instance in this `FilteredOutVersionGroup` has name which does not
+     * match the RegExp produced by the `--filter` option.
+     */
     export class FilteredOut extends FilteredOut_base<{
         name: string;
-        instances: Instance[];
+        instances: Instance.Any[];
         readonly isValid: true;
     }> {
     }
     const HighestSemverMismatch_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: "HighestSemverMismatch";
     }>;
+    /**
+     * One or more instances has a version which is not identical to the others,
+     * to resolve this issue the highest semver version present should be used
+     */
     export class HighestSemverMismatch extends HighestSemverMismatch_base<{
         name: string;
-        instances: Instance[];
+        instances: Instance.Any[];
         readonly isValid: false;
         readonly expectedVersion: string;
     }> {
@@ -44,18 +56,25 @@ export declare namespace VersionGroupReport {
     const Ignored_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: "Ignored";
     }>;
+    /**
+     * Every instance in this `IgnoredVersionGroup` matched its configuration
+     */
     export class Ignored extends Ignored_base<{
         name: string;
-        instances: Instance[];
+        instances: Instance.Any[];
         readonly isValid: true;
     }> {
     }
     const LowestSemverMismatch_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: "LowestSemverMismatch";
     }>;
+    /**
+     * One or more instances has a version which is not identical to the others,
+     * to resolve this issue the lowest semver version present should be used
+     */
     export class LowestSemverMismatch extends LowestSemverMismatch_base<{
         name: string;
-        instances: Instance[];
+        instances: Instance.Any[];
         readonly isValid: false;
         readonly expectedVersion: string;
     }> {
@@ -63,9 +82,13 @@ export declare namespace VersionGroupReport {
     const PinnedMismatch_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: "PinnedMismatch";
     }>;
+    /**
+     * One or more instances has a version which is not identical to the
+     * `pinVersion` value set in this `PinnedVersionGroup`
+     */
     export class PinnedMismatch extends PinnedMismatch_base<{
         name: string;
-        instances: Instance[];
+        instances: Instance.Any[];
         readonly isValid: false;
         readonly expectedVersion: string;
     }> {
@@ -73,56 +96,81 @@ export declare namespace VersionGroupReport {
     const SameRangeMismatch_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: "SameRangeMismatch";
     }>;
+    /**
+     * One or more instances has a version which is not satisfied by the semver
+     * version ranges defined by every other instance of this same dependency. In
+     * a `SameRangeVersionGroup`, each version does not have to be indentical, but
+     * they do have to all satisfy the ranges set by the others.
+     */
     export class SameRangeMismatch extends SameRangeMismatch_base<{
         name: string;
-        instances: Instance[];
+        instances: Instance.Any[];
         readonly isValid: false;
     }> {
     }
     const SnappedToMismatch_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: "SnappedToMismatch";
     }>;
+    /**
+     * One or more instances has a version which does not match the version used
+     * in any of the locally developed packages whose names are set in the
+     * `snapTo` array of this `SnappedToVersionGroup`
+     */
     export class SnappedToMismatch extends SnappedToMismatch_base<{
         name: string;
-        instances: Instance[];
+        instances: Instance.Any[];
         readonly isValid: false;
         readonly expectedVersion: string;
         readonly snapTo: string[];
     }> {
     }
-    const UnsupportedMismatch_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: "UnsupportedMismatch";
+    const NonSemverMismatch_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: "NonSemverMismatch";
     }>;
-    export class UnsupportedMismatch extends UnsupportedMismatch_base<{
+    /**
+     * One or more instances has a version which does not match the others and
+     * also, at least one of the instances has a version which is not semver.
+     * Syncpack cannot guess what any given Developer will want to do in this
+     * situation
+     */
+    export class NonSemverMismatch extends NonSemverMismatch_base<{
         name: string;
-        instances: Instance[];
+        instances: Instance.Any[];
         readonly isValid: false;
     }> {
     }
     const Valid_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: "Valid";
     }>;
+    /**
+     * Every instance satisfies the rules of the Version Group they belong to
+     */
     export class Valid extends Valid_base<{
         name: string;
-        instances: Instance[];
+        instances: Instance.Any[];
         readonly isValid: true;
     }> {
     }
-    const WorkspaceMismatch_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: "WorkspaceMismatch";
+    const LocalPackageMismatch_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: "LocalPackageMismatch";
     }>;
-    export class WorkspaceMismatch extends WorkspaceMismatch_base<{
+    /**
+     * This dependency is one of the packages developed in this monorepo and one
+     * or more of the packages in this monorepo depend on it with a version which
+     * is not identical to the `.version` property of its package.json file
+     */
+    export class LocalPackageMismatch extends LocalPackageMismatch_base<{
         name: string;
-        instances: Instance[];
+        instances: Instance.Any[];
         readonly isValid: false;
         readonly expectedVersion: string;
-        readonly workspaceInstance: Instance;
+        readonly localPackageInstance: Instance.Any;
     }> {
     }
     export type ValidCases = Union.Strict<FilteredOut | Ignored | Valid>;
-    export type InvalidCases = Union.Strict<Banned | HighestSemverMismatch | LowestSemverMismatch | PinnedMismatch | SameRangeMismatch | SnappedToMismatch | UnsupportedMismatch | WorkspaceMismatch>;
-    export type FixableCases = Union.Strict<HighestSemverMismatch | LowestSemverMismatch | PinnedMismatch | SnappedToMismatch | WorkspaceMismatch>;
-    export type UnfixableCases = Union.Strict<SameRangeMismatch | UnsupportedMismatch | WorkspaceMismatch>;
+    export type InvalidCases = Union.Strict<Banned | HighestSemverMismatch | LowestSemverMismatch | PinnedMismatch | SameRangeMismatch | SnappedToMismatch | NonSemverMismatch | LocalPackageMismatch>;
+    export type FixableCases = Union.Strict<HighestSemverMismatch | LowestSemverMismatch | PinnedMismatch | SnappedToMismatch | LocalPackageMismatch>;
+    export type UnfixableCases = Union.Strict<SameRangeMismatch | NonSemverMismatch | LocalPackageMismatch>;
     export type HighLowSemverMismatch = VersionGroupReport.HighestSemverMismatch | VersionGroupReport.LowestSemverMismatch;
     export type Any = Union.Strict<ValidCases | InvalidCases>;
     export {};

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

@@ -43,45 +43,93 @@ const snapped_to_1 = require("./snapped-to");
 const standard_1 = require("./standard");
 var VersionGroupReport;
 (function (VersionGroupReport) {
+    /**
+     * Every instance in this `BannedVersionGroup` matched its configuration and
+     * will be removed if fixed
+     */
     class Banned extends Data.TaggedClass('Banned') {
     }
     VersionGroupReport.Banned = Banned;
+    /**
+     * Every instance in this `FilteredOutVersionGroup` has name which does not
+     * match the RegExp produced by the `--filter` option.
+     */
     class FilteredOut extends Data.TaggedClass('FilteredOut') {
     }
     VersionGroupReport.FilteredOut = FilteredOut;
+    /**
+     * One or more instances has a version which is not identical to the others,
+     * to resolve this issue the highest semver version present should be used
+     */
     class HighestSemverMismatch extends Data.TaggedClass('HighestSemverMismatch') {
     }
     VersionGroupReport.HighestSemverMismatch = HighestSemverMismatch;
+    /**
+     * Every instance in this `IgnoredVersionGroup` matched its configuration
+     */
     class Ignored extends Data.TaggedClass('Ignored') {
     }
     VersionGroupReport.Ignored = Ignored;
+    /**
+     * One or more instances has a version which is not identical to the others,
+     * to resolve this issue the lowest semver version present should be used
+     */
     class LowestSemverMismatch extends Data.TaggedClass('LowestSemverMismatch') {
     }
     VersionGroupReport.LowestSemverMismatch = LowestSemverMismatch;
+    /**
+     * One or more instances has a version which is not identical to the
+     * `pinVersion` value set in this `PinnedVersionGroup`
+     */
     class PinnedMismatch extends Data.TaggedClass('PinnedMismatch') {
     }
     VersionGroupReport.PinnedMismatch = PinnedMismatch;
+    /**
+     * One or more instances has a version which is not satisfied by the semver
+     * version ranges defined by every other instance of this same dependency. In
+     * a `SameRangeVersionGroup`, each version does not have to be indentical, but
+     * they do have to all satisfy the ranges set by the others.
+     */
     class SameRangeMismatch extends Data.TaggedClass('SameRangeMismatch') {
     }
     VersionGroupReport.SameRangeMismatch = SameRangeMismatch;
+    /**
+     * One or more instances has a version which does not match the version used
+     * in any of the locally developed packages whose names are set in the
+     * `snapTo` array of this `SnappedToVersionGroup`
+     */
     class SnappedToMismatch extends Data.TaggedClass('SnappedToMismatch') {
     }
     VersionGroupReport.SnappedToMismatch = SnappedToMismatch;
-    class UnsupportedMismatch extends Data.TaggedClass('UnsupportedMismatch') {
+    /**
+     * One or more instances has a version which does not match the others and
+     * also, at least one of the instances has a version which is not semver.
+     * Syncpack cannot guess what any given Developer will want to do in this
+     * situation
+     */
+    class NonSemverMismatch extends Data.TaggedClass('NonSemverMismatch') {
     }
-    VersionGroupReport.UnsupportedMismatch = UnsupportedMismatch;
+    VersionGroupReport.NonSemverMismatch = NonSemverMismatch;
+    /**
+     * Every instance satisfies the rules of the Version Group they belong to
+     */
     class Valid extends Data.TaggedClass('Valid') {
     }
     VersionGroupReport.Valid = Valid;
-    class WorkspaceMismatch extends Data.TaggedClass('WorkspaceMismatch') {
+    /**
+     * This dependency is one of the packages developed in this monorepo and one
+     * or more of the packages in this monorepo depend on it with a version which
+     * is not identical to the `.version` property of its package.json file
+     */
+    class LocalPackageMismatch extends Data.TaggedClass('LocalPackageMismatch') {
     }
-    VersionGroupReport.WorkspaceMismatch = WorkspaceMismatch;
+    VersionGroupReport.LocalPackageMismatch = LocalPackageMismatch;
 })(VersionGroupReport || (exports.VersionGroupReport = VersionGroupReport = {}));
 class VersionGroupConfigError extends Data.TaggedClass('VersionGroupConfigError') {
 }
 exports.VersionGroupConfigError = VersionGroupConfigError;
 function getVersionGroups(ctx) {
-    return (0, Function_1.pipe)(Effect.Do(), Effect.bind('enabledTypes', () => (0, get_enabled_types_1.getEnabledTypes)(ctx.config)), Effect.bind('versionGroups', () => createVersionGroups(ctx)), Effect.flatMap(({ enabledTypes, versionGroups }) => {
+    return (0, Function_1.pipe)(Effect.Do, Effect.bind('enabledTypes', () => (0, get_enabled_types_1.getEnabledTypes)(ctx.config)), Effect.bind('versionGroups', () => createVersionGroups(ctx)), Effect.flatMap(({ enabledTypes, versionGroups }) => {
         for (const file of ctx.packageJsonFiles) {
             instances: for (const instance of file.getInstances(enabledTypes)) {
                 for (const group of versionGroups) {

package/dist/get-version-groups/lib/{sort.js → compare-semver.js}

@@ -6,17 +6,12 @@ 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_supported_1 = require("../../guards/is-supported");
 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_supported_1.isSupported)(a))
-        throw new Error(`"${a}" is not supported`);
-    if (!(0, is_supported_1.isSupported)(b))
-        throw new Error(`"${b}" is not supported`);
     if (a.startsWith('workspace:'))
         return LT;
     if (b.startsWith('workspace:'))

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

@@ -6,8 +6,8 @@ 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");
+const compare_semver_1 = require("./compare-semver");
 function getHighestVersion(versions) {
-    return (0, Function_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'));
+    return (0, Function_1.pipe)((0, from_try_1.fromTry)(() => [...versions].sort(compare_semver_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.js

@@ -6,8 +6,8 @@ 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");
+const compare_semver_1 = require("./compare-semver");
 function getLowestVersion(versions) {
-    return (0, Function_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'));
+    return (0, Function_1.pipe)((0, from_try_1.fromTry)(() => [...versions].sort(compare_semver_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-version-groups/lib/get-unique-specifiers.d.ts

@@ -0,0 +1,2 @@
+import type { Instance } from '../../instance';
+export declare function getUniqueSpecifiers(instances: Instance.Any[]): Instance.Any[];

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUniqueSpecifiers = void 0;
+function getUniqueSpecifiers(instances) {
+    const instancesBySpecifier = {};
+    instances.forEach((instance) => {
+        instancesBySpecifier[instance.specifier] = instance;
+    });
+    return Object.values(instancesBySpecifier);
+}
+exports.getUniqueSpecifiers = getUniqueSpecifiers;

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

@@ -2,16 +2,16 @@ 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';
+import type { Instance } from '../instance';
 declare const PinnedVersionGroup_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: "Pinned";
 }>;
 export declare class PinnedVersionGroup extends PinnedVersionGroup_base<{
     config: VersionGroupConfig.Pinned;
-    instances: Instance[];
+    instances: Instance.Any[];
 }> {
     constructor(config: VersionGroupConfig.Pinned);
-    canAdd(_: Instance): boolean;
+    canAdd(_: Instance.Any): boolean;
     inspect(): Effect.Effect<never, VersionGroupReport.PinnedMismatch, VersionGroupReport.Valid>[];
 }
 export {};

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

@@ -62,5 +62,5 @@ class PinnedVersionGroup extends Data.TaggedClass('Pinned') {
 }
 exports.PinnedVersionGroup = PinnedVersionGroup;
 function hasMismatch(pinVersion, instances) {
-    return instances.some((instance) => instance.version !== pinVersion);
+    return instances.some((instance) => instance.specifier !== pinVersion);
 }

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

@@ -2,16 +2,16 @@ 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';
+import type { Instance } from '../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[];
+    instances: Instance.Any[];
 }> {
     constructor(config: VersionGroupConfig.SameRange);
-    canAdd(_: Instance): boolean;
+    canAdd(_: Instance.Any): boolean;
     inspect(): Effect.Effect<never, VersionGroupReport.SameRangeMismatch, VersionGroupReport.Valid>[];
 }
 export {};

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

@@ -66,5 +66,8 @@ 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)));
+    return instances.some((a) => instances.some((b) => !(0, intersects_1.default)(aliasWorkspaceRange(a.specifier), aliasWorkspaceRange(b.specifier), loose)));
+}
+function aliasWorkspaceRange(version) {
+    return version.startsWith('workspace:*') ? '*' : version;
 }

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

@@ -2,16 +2,16 @@ 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';
+import type { Instance } from '../instance';
 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[];
+    instances: Instance.Any[];
 }> {
     constructor(config: VersionGroupConfig.SnappedTo);
-    canAdd(_: Instance): boolean;
+    canAdd(_: Instance.Any): boolean;
     inspect(): Effect.Effect<never, VersionGroupReport.SnappedToMismatch, VersionGroupReport.Valid>[];
 }
 export {};

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

@@ -64,14 +64,15 @@ class SnappedToVersionGroup extends Data.TaggedClass('SnappedTo') {
 }
 exports.SnappedToVersionGroup = SnappedToVersionGroup;
 function getExpectedVersion(snapTo, instances) {
-    const expectedVersion = instances
+    var _a;
+    const expectedVersion = (_a = instances
         .filter((i) => snapTo.includes(i.pkgName))
-        .find((i) => i.version)?.version;
+        .find((i) => i.specifier)) === null || _a === void 0 ? void 0 : _a.specifier;
     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) {
-    return instances.some((instance) => instance.version !== expectedVersion);
+    return instances.some((instance) => instance.specifier !== expectedVersion);
 }

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

@@ -2,17 +2,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';
+import type { Instance } from '../instance';
 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[];
+    instances: Instance.Any[];
     isCatchAll: boolean;
 }> {
     constructor(isCatchAll: boolean, config: VersionGroupConfig.Standard);
-    canAdd(_: Instance): boolean;
-    inspect(): Effect.Effect<never, VersionGroupReport.WorkspaceMismatch | VersionGroupReport.UnsupportedMismatch | VersionGroupReport.HighestSemverMismatch | VersionGroupReport.LowestSemverMismatch, VersionGroupReport.Valid>[];
+    canAdd(_: Instance.Any): boolean;
+    inspect(): Effect.Effect<never, VersionGroupReport.LocalPackageMismatch | VersionGroupReport.NonSemverMismatch | VersionGroupReport.HighestSemverMismatch | VersionGroupReport.LowestSemverMismatch, VersionGroupReport.Valid>[];
 }
 export {};

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

@@ -25,13 +25,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StandardVersionGroup = void 0;
 const Data = __importStar(require("@effect/data/Data"));
+const Option = __importStar(require("@effect/data/Option"));
 const Effect = __importStar(require("@effect/io/Effect"));
 const unwrap_1 = require("tightrope/result/unwrap");
 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 get_unique_specifiers_1 = require("./lib/get-unique-specifiers");
 const group_by_1 = require("./lib/group-by");
 class StandardVersionGroup extends Data.TaggedClass('Standard') {
     constructor(isCatchAll, config) {
@@ -47,6 +47,7 @@ class StandardVersionGroup extends Data.TaggedClass('Standard') {
     inspect() {
         const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
         return Object.entries(instancesByName).map(([name, instances]) => {
+            var _a;
             if (!hasMismatch(instances)) {
                 return Effect.succeed(new _1.VersionGroupReport.Valid({
                     name,
@@ -54,32 +55,24 @@ class StandardVersionGroup extends Data.TaggedClass('Standard') {
                     isValid: true,
                 }));
             }
-            const wsInstance = getWorkspaceInstance(instances);
-            const wsFile = wsInstance?.packageJsonFile;
-            const wsVersion = wsFile?.contents?.version;
-            const isWorkspacePackage = wsInstance && wsVersion;
-            if (isWorkspacePackage) {
-                const nonWsInstances = getNonWorkspaceInstances(instances);
-                if (!hasMismatch(nonWsInstances)) {
-                    return Effect.succeed(new _1.VersionGroupReport.Valid({
-                        name,
-                        instances,
-                        isValid: true,
-                    }));
-                }
-                return Effect.fail(new _1.VersionGroupReport.WorkspaceMismatch({
+            if (hasNonSemverSpecifiers(instances)) {
+                return Effect.fail(new _1.VersionGroupReport.NonSemverMismatch({
                     name,
                     instances,
                     isValid: false,
-                    expectedVersion: wsVersion,
-                    workspaceInstance: wsInstance,
                 }));
             }
-            if (hasUnsupported(instances)) {
-                return Effect.fail(new _1.VersionGroupReport.UnsupportedMismatch({
+            const localPackageInstance = getLocalPackageInstance(instances);
+            const localPackageFile = localPackageInstance === null || localPackageInstance === void 0 ? void 0 : localPackageInstance.packageJsonFile;
+            const localPackageVersion = (_a = localPackageFile === null || localPackageFile === void 0 ? void 0 : localPackageFile.contents) === null || _a === void 0 ? void 0 : _a.version;
+            const isLocalPackage = localPackageInstance && localPackageVersion;
+            if (isLocalPackage) {
+                return Effect.fail(new _1.VersionGroupReport.LocalPackageMismatch({
                     name,
                     instances,
                     isValid: false,
+                    expectedVersion: localPackageVersion,
+                    localPackageInstance,
                 }));
             }
             const preferVersion = this.config.preferVersion;
@@ -102,18 +95,15 @@ class StandardVersionGroup extends Data.TaggedClass('Standard') {
 }
 exports.StandardVersionGroup = StandardVersionGroup;
 function getExpectedVersion(preferVersion, instances) {
-    const versions = (0, get_unique_versions_1.getUniqueVersions)(instances);
+    const versions = (0, get_unique_specifiers_1.getUniqueSpecifiers)(instances).map((i) => i.specifier);
     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;
+    return (0, get_unique_specifiers_1.getUniqueSpecifiers)(instances).length > 1;
 }
-function hasUnsupported(instances) {
-    return instances.some((instance) => !(0, is_supported_1.isSupported)(instance.version));
+function hasNonSemverSpecifiers(instances) {
+    return instances.some((instance) => Option.isNone(instance.getSemverSpecifier()));
 }
-function getWorkspaceInstance(instances) {
-    return instances.find((instance) => instance.strategy.name === 'workspace');
-}
-function getNonWorkspaceInstances(instances) {
-    return instances.filter((instance) => instance.strategy.name !== 'workspace');
+function getLocalPackageInstance(instances) {
+    return instances.find((instance) => instance.strategy.name === 'localPackage');
 }

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

@@ -1,4 +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;
+import type { Instance } from '../instance';
+export declare function canAddToGroup(group: AnySemverGroup | AnyVersionGroup, instance: Instance.Any): boolean;

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

@@ -1 +1,2 @@
+/** @deprecated */
 export declare function isLooseSemver(version: unknown): boolean;

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

@@ -3,6 +3,7 @@ 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");
+/** @deprecated */
 function isLooseSemver(version) {
     return (0, is_string_1.isString)(version) && (0, is_semver_1.isSemver)(version) && version.search(/\.x(\.|$)/) !== -1;
 }

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

@@ -1 +1,2 @@
+/** @deprecated */
 export declare function isSemver(version: unknown): boolean;

package/dist/guards/is-semver.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSemver = void 0;
 const is_string_1 = require("tightrope/guard/is-string");
+/** @deprecated */
 function isSemver(version) {
     const range = '(~|\\^|>=|>|<=|<)?';
     const ints = '[0-9]+';

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

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

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isValidSemverRange = void 0;
 const constants_1 = require("../constants");
+/** @deprecated */
 function isValidSemverRange(value) {
     return (value === constants_1.RANGE.ANY ||
         value === constants_1.RANGE.EXACT ||

package/dist/instance/create.d.ts

@@ -0,0 +1,4 @@
+import { Instance } from '.';
+import type { Strategy } from '../config/get-custom-types';
+import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
+export declare function createInstance(strategy: Strategy.Any, name: string, packageJsonFile: PackageJsonFile, specifier: string): Instance.Any;