syncpack 11.2.1 → 12.0.0-alpha.0

package/dist/semver-group/ignored.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IgnoredSemverGroup = void 0;
+const effect_1 = require("effect");
+const report_1 = require("../report");
+/** Every instance in this group is ignored and nothing will be changed */
+class IgnoredSemverGroup extends effect_1.Data.TaggedClass('Ignored') {
+    constructor(config) {
+        super({
+            config,
+            instances: [],
+        });
+        this.groupType = 'semverGroup';
+    }
+    canAdd(_) {
+        return true;
+    }
+    getFixed(specifier) {
+        return effect_1.Effect.succeed(specifier);
+    }
+    inspectAll() {
+        return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
+    }
+    inspect(instance) {
+        return effect_1.Effect.succeed(new report_1.Report.Ignored({
+            instance,
+        }));
+    }
+}
+exports.IgnoredSemverGroup = IgnoredSemverGroup;

package/dist/semver-group/index.d.ts

@@ -0,0 +1,22 @@
+import { Data } from 'effect';
+import type { Union } from 'ts-toolbelt';
+import type { DisabledSemverGroup } from './disabled';
+import type { FilteredOutSemverGroup } from './filtered-out';
+import type { IgnoredSemverGroup } from './ignored';
+import type { WithRangeSemverGroup } from './with-range';
+export declare namespace SemverGroup {
+    export type Disabled = DisabledSemverGroup;
+    export type FilteredOut = FilteredOutSemverGroup;
+    export type Ignored = IgnoredSemverGroup;
+    export type WithRange = WithRangeSemverGroup;
+    export type Any = Union.Strict<Disabled | FilteredOut | Ignored | WithRange>;
+    const ConfigError_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "SemverGroupConfigError";
+    }>;
+    export class ConfigError extends ConfigError_base<{
+        readonly config: unknown;
+        readonly error: string;
+    }> {
+    }
+    export {};
+}

package/dist/semver-group/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemverGroup = void 0;
+const effect_1 = require("effect");
+var SemverGroup;
+(function (SemverGroup) {
+    class ConfigError extends effect_1.Data.TaggedClass('SemverGroupConfigError') {
+    }
+    SemverGroup.ConfigError = ConfigError;
+})(SemverGroup || (exports.SemverGroup = SemverGroup = {}));

package/dist/semver-group/with-range.d.ts

@@ -0,0 +1,22 @@
+import { Data, Effect } from 'effect';
+import type { SemverGroupConfig } from '../config/types';
+import type { Instance } from '../get-instances/instance';
+import { Report } from '../report';
+import { Specifier } from '../specifier';
+import type { NonSemverError } from '../specifier/lib/non-semver-error';
+declare const WithRangeSemverGroup_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "WithRange";
+}>;
+export declare class WithRangeSemverGroup extends WithRangeSemverGroup_base<{
+    config: SemverGroupConfig.WithRange;
+    instances: Instance[];
+    isCatchAll: boolean;
+}> {
+    groupType: string;
+    constructor(isCatchAll: boolean, config: SemverGroupConfig.WithRange);
+    canAdd(_: Instance): boolean;
+    getFixed(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, Specifier.Any>;
+    inspectAll(): Effect.Effect<never, never, (Report.UnsupportedMismatch | Report.SemverRangeMismatch | Report.Valid)[]>;
+    inspect(instance: Instance): Effect.Effect<never, never, Report.UnsupportedMismatch | Report.SemverRangeMismatch | Report.Valid>;
+}
+export {};

package/dist/semver-group/with-range.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithRangeSemverGroup = void 0;
+const effect_1 = require("effect");
+const set_semver_range_1 = require("../lib/set-semver-range");
+const report_1 = require("../report");
+const specifier_1 = require("../specifier");
+class WithRangeSemverGroup extends effect_1.Data.TaggedClass('WithRange') {
+    constructor(isCatchAll, config) {
+        super({
+            config,
+            instances: [],
+            isCatchAll,
+        });
+        this.groupType = 'semverGroup';
+        this.getFixed = this.getFixed.bind(this);
+    }
+    canAdd(_) {
+        return true;
+    }
+    getFixed(specifier) {
+        return (0, effect_1.pipe)(specifier.getSemver(), effect_1.Effect.map((semver) => (0, set_semver_range_1.setSemverRange)(this.config.range, semver)), effect_1.Effect.flatMap((nextSemver) => specifier.setSemver(nextSemver)));
+    }
+    inspectAll() {
+        return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
+    }
+    inspect(instance) {
+        const current = specifier_1.Specifier.create(instance, instance.rawSpecifier);
+        return (0, effect_1.pipe)(this.getFixed(current), effect_1.Effect.match({
+            // if range is fixable
+            onSuccess: (valid) => 
+            // if it is pinned and matches its pin
+            instance.versionGroup._tag === 'Pinned' &&
+                instance.rawSpecifier === instance.versionGroup.config.pinVersion
+                ? // the pinned version takes precendence and is a match
+                    new report_1.Report.Valid({
+                        specifier: current,
+                    })
+                : // if it is already like this on disk
+                    instance.rawSpecifier === valid.raw
+                        ? // it is a match
+                            new report_1.Report.Valid({
+                                specifier: current,
+                            })
+                        : // it is a mismatch and should be this one
+                            new report_1.Report.SemverRangeMismatch({
+                                fixable: valid,
+                            }),
+            // if range is NOT fixable, it is a mismatch we can't auto-fix
+            // as it seems to not be semver
+            onFailure: () => new report_1.Report.UnsupportedMismatch({
+                unfixable: instance,
+            }),
+        }));
+    }
+}
+exports.WithRangeSemverGroup = WithRangeSemverGroup;

package/dist/specifier/alias.d.ts

@@ -0,0 +1,15 @@
+import { Effect } from 'effect';
+import type { AliasResult } from 'npm-package-arg';
+import { Specifier } from '.';
+import { BaseSpecifier } from './base';
+import { NonSemverError } from './lib/non-semver-error';
+type T = AliasResult;
+/** @example "npm:imageoptim-cli@3.1.7" */
+export declare class AliasSpecifier extends BaseSpecifier<T> {
+    _tag: string;
+    /** Return the version portion if it is valid semver */
+    getSemver(): Effect.Effect<never, NonSemverError, string>;
+    /** Get a new `Specifier` from the given semver version applied to this one */
+    setSemver(version: string): Effect.Effect<never, NonSemverError, Specifier.Any>;
+}
+export {};

package/dist/specifier/alias.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AliasSpecifier = void 0;
+const effect_1 = require("effect");
+const _1 = require(".");
+const base_1 = require("./base");
+const non_semver_error_1 = require("./lib/non-semver-error");
+/** @example "npm:imageoptim-cli@3.1.7" */
+class AliasSpecifier extends base_1.BaseSpecifier {
+    constructor() {
+        super(...arguments);
+        this._tag = 'AliasSpecifier';
+    }
+    /** Return the version portion if it is valid semver */
+    getSemver() {
+        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => parsed.subSpec), effect_1.Effect.flatMap((subSpec) => ['range', 'version'].includes(subSpec.type) && subSpec.fetchSpec !== null
+            ? effect_1.Effect.succeed(subSpec.fetchSpec)
+            : non_semver_error_1.NonSemverError.asEffect(this)));
+    }
+    /** Get a new `Specifier` from the given semver version applied to this one */
+    setSemver(version) {
+        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => parsed.subSpec), effect_1.Effect.map((subSpec) => subSpec.name || ''), effect_1.Effect.map((name) => `npm:${name}@${version}`), effect_1.Effect.map((raw) => _1.Specifier.create(this.instance, raw)));
+    }
+}
+exports.AliasSpecifier = AliasSpecifier;

package/dist/specifier/base.d.ts

@@ -0,0 +1,39 @@
+import { Effect } from 'effect';
+import { Specifier } from '.';
+import type { Instance } from '../get-instances/instance';
+import { NonSemverError } from './lib/non-semver-error';
+import type { NpmPackageArgResult } from './lib/parse-specifier';
+export declare class BaseSpecifier<T extends NpmPackageArgResult | unknown> {
+    /** should be overridden by sub classes */
+    _tag: string;
+    /** The raw semver/workspace:/git etc version value */
+    raw: string;
+    /**
+     * A `Specifier` describes the version specifier (eg "^1.4.4") of a given
+     * instance.
+     *
+     * Initially there will be a `Specifier` which describes the version as it is
+     * on disk, but other `Specifier`s will need to be created which reflect what
+     * the version should be once fixed – first for the instance's version group
+     * and second for its semver group.
+     *
+     * The intermediate and final variants of `Specifier` could differ along the
+     * way and whether we're linting the current state of the monorepo or
+     * determining whether possible fixes will ultimately still have a valid
+     * version and range, each one has a reference back to the original `Instance`
+     * for writing back to it when we do finally commit our fixes once verified.
+     */
+    instance: Instance;
+    constructor(data: Pick<BaseSpecifier<T>, 'raw' | 'instance'>);
+    /**
+     * Parse the raw version specifier using
+     * https://github.com/npm/npm-package-arg
+     */
+    protected parse(): Effect.Effect<never, unknown, T>;
+    /** Return the version portion if it is valid semver */
+    getSemver(): Effect.Effect<never, NonSemverError, string>;
+    /** Get a new `Specifier` from the given semver version applied to this one */
+    setSemver(_version: string): Effect.Effect<never, NonSemverError, Specifier.Any>;
+    /** Apply the given specifier to a new one with this instance bound to it */
+    replaceWith<T extends Specifier.Any>(specifier: T): T;
+}

package/dist/specifier/base.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSpecifier = void 0;
+const effect_1 = require("effect");
+const _1 = require(".");
+const non_semver_error_1 = require("./lib/non-semver-error");
+const parse_specifier_1 = require("./lib/parse-specifier");
+class BaseSpecifier {
+    constructor(data) {
+        /** should be overridden by sub classes */
+        this._tag = 'BaseSpecifier';
+        this.raw = data.raw;
+        this.instance = data.instance;
+    }
+    /**
+     * Parse the raw version specifier using
+     * https://github.com/npm/npm-package-arg
+     */
+    parse() {
+        const name = this.instance.name;
+        const raw = this.raw;
+        const packageJsonFile = this.instance.packageJsonFile;
+        return (0, effect_1.pipe)(effect_1.Effect.try(() => (0, parse_specifier_1.parseSpecifier)(name, raw, packageJsonFile)), effect_1.Effect.tapError(() => effect_1.Effect.logError(`parseSpecifier threw on ${name}@${raw} at ${packageJsonFile.jsonFile.shortPath}`)));
+    }
+    /** Return the version portion if it is valid semver */
+    getSemver() {
+        return non_semver_error_1.NonSemverError.asEffect(this);
+    }
+    /** Get a new `Specifier` from the given semver version applied to this one */
+    setSemver(_version) {
+        return non_semver_error_1.NonSemverError.asEffect(this);
+    }
+    /** Apply the given specifier to a new one with this instance bound to it */
+    replaceWith(specifier) {
+        return _1.Specifier.create(this.instance, specifier.raw);
+    }
+}
+exports.BaseSpecifier = BaseSpecifier;

package/dist/specifier/delete.d.ts

@@ -0,0 +1,15 @@
+import type { Instance } from '../get-instances/instance';
+import type { Delete } from '../version-group/lib/delete';
+/** A instance which should be deleted */
+export declare class DeleteSpecifier {
+    _tag: string;
+    raw: Delete;
+    instance: Instance;
+    constructor(data: {
+        raw: Delete;
+        instance: Instance;
+    });
+    getSemver: () => import("effect/Effect").Effect<never, import("./lib/non-semver-error").NonSemverError, string>;
+    setSemver: (_version: string) => import("effect/Effect").Effect<never, import("./lib/non-semver-error").NonSemverError, import(".").Specifier.Any>;
+    replaceWith: <T extends import(".").Specifier.Any>(specifier: T) => T;
+}

package/dist/specifier/delete.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteSpecifier = void 0;
+const base_1 = require("./base");
+/** A instance which should be deleted */
+class DeleteSpecifier {
+    constructor(data) {
+        this._tag = 'DeleteSpecifier';
+        this.getSemver = base_1.BaseSpecifier.prototype.getSemver;
+        this.setSemver = base_1.BaseSpecifier.prototype.setSemver;
+        this.replaceWith = base_1.BaseSpecifier.prototype.replaceWith;
+        this.raw = data.raw;
+        this.instance = data.instance;
+    }
+}
+exports.DeleteSpecifier = DeleteSpecifier;

package/dist/specifier/file.d.ts

@@ -0,0 +1,6 @@
+import type { FileResult } from 'npm-package-arg';
+import { BaseSpecifier } from './base';
+/** @example */
+export declare class FileSpecifier extends BaseSpecifier<FileResult> {
+    _tag: string;
+}

package/dist/specifier/file.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSpecifier = void 0;
+const base_1 = require("./base");
+/** @example */
+class FileSpecifier extends base_1.BaseSpecifier {
+    constructor() {
+        super(...arguments);
+        this._tag = 'FileSpecifier';
+    }
+}
+exports.FileSpecifier = FileSpecifier;

package/dist/specifier/hosted-git.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from 'effect';
+import type { HostedGitResult } from 'npm-package-arg';
+import { Specifier } from '.';
+import { BaseSpecifier } from './base';
+import { NonSemverError } from './lib/non-semver-error';
+/** @example "git+https://github.com/user/foo" */
+export declare class HostedGitSpecifier extends BaseSpecifier<HostedGitResult> {
+    _tag: string;
+    /** Return the git tag if it is valid semver */
+    getSemver(): Effect.Effect<never, NonSemverError, string>;
+    /** Get a new `Specifier` from the given semver version applied to this one */
+    setSemver(version: string): Effect.Effect<never, NonSemverError, Specifier.Any>;
+}

package/dist/specifier/hosted-git.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostedGitSpecifier = void 0;
+const effect_1 = require("effect");
+const _1 = require(".");
+const is_semver_1 = require("../guards/is-semver");
+const base_1 = require("./base");
+const non_semver_error_1 = require("./lib/non-semver-error");
+/** @example "git+https://github.com/user/foo" */
+class HostedGitSpecifier extends base_1.BaseSpecifier {
+    constructor() {
+        super(...arguments);
+        this._tag = 'HostedGitSpecifier';
+    }
+    /** Return the git tag if it is valid semver */
+    getSemver() {
+        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => parsed.gitCommittish || ''), effect_1.Effect.flatMap((gitCommittish) => (0, is_semver_1.isSemver)(gitCommittish) ? effect_1.Effect.succeed(gitCommittish) : non_semver_error_1.NonSemverError.asEffect(this)));
+    }
+    /** Get a new `Specifier` from the given semver version applied to this one */
+    setSemver(version) {
+        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => ({
+            gitCommittish: parsed.gitCommittish || '',
+            rawSpec: parsed.rawSpec || '',
+        })), effect_1.Effect.map(({ gitCommittish, rawSpec }) => rawSpec.replace(gitCommittish, version)), effect_1.Effect.map((raw) => _1.Specifier.create(this.instance, raw)));
+    }
+}
+exports.HostedGitSpecifier = HostedGitSpecifier;

package/dist/specifier/index.d.ts

@@ -0,0 +1,27 @@
+import type { Union } from 'ts-toolbelt';
+import type { Instance } from '../get-instances/instance';
+import { type Delete } from '../version-group/lib/delete';
+import { AliasSpecifier } from './alias';
+import { DeleteSpecifier } from './delete';
+import { FileSpecifier } from './file';
+import { HostedGitSpecifier } from './hosted-git';
+import { RangeSpecifier } from './range';
+import { TagSpecifier } from './tag';
+import { UnsupportedSpecifier } from './unsupported';
+import { UrlSpecifier } from './url';
+import { VersionSpecifier } from './version';
+import { WorkspaceProtocolSpecifier } from './workspace-protocol';
+export declare namespace Specifier {
+    const Alias: typeof AliasSpecifier;
+    const Delete: typeof DeleteSpecifier;
+    const File: typeof FileSpecifier;
+    const HostedGit: typeof HostedGitSpecifier;
+    const Range: typeof RangeSpecifier;
+    const Tag: typeof TagSpecifier;
+    const Unsupported: typeof UnsupportedSpecifier;
+    const Url: typeof UrlSpecifier;
+    const Version: typeof VersionSpecifier;
+    const WorkspaceProtocol: typeof WorkspaceProtocolSpecifier;
+    type Any = Union.Strict<AliasSpecifier | DeleteSpecifier | FileSpecifier | HostedGitSpecifier | RangeSpecifier | TagSpecifier | UnsupportedSpecifier | UrlSpecifier | VersionSpecifier | WorkspaceProtocolSpecifier>;
+    function create(instance: Instance, raw: string | Delete): Specifier.Any;
+}

package/dist/specifier/index.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Specifier = void 0;
+const delete_1 = require("../version-group/lib/delete");
+const alias_1 = require("./alias");
+const delete_2 = require("./delete");
+const file_1 = require("./file");
+const hosted_git_1 = require("./hosted-git");
+const parse_specifier_1 = require("./lib/parse-specifier");
+const range_1 = require("./range");
+const tag_1 = require("./tag");
+const unsupported_1 = require("./unsupported");
+const url_1 = require("./url");
+const version_1 = require("./version");
+const workspace_protocol_1 = require("./workspace-protocol");
+var Specifier;
+(function (Specifier) {
+    Specifier.Alias = alias_1.AliasSpecifier;
+    Specifier.Delete = delete_2.DeleteSpecifier;
+    Specifier.File = file_1.FileSpecifier;
+    Specifier.HostedGit = hosted_git_1.HostedGitSpecifier;
+    Specifier.Range = range_1.RangeSpecifier;
+    Specifier.Tag = tag_1.TagSpecifier;
+    Specifier.Unsupported = unsupported_1.UnsupportedSpecifier;
+    Specifier.Url = url_1.UrlSpecifier;
+    Specifier.Version = version_1.VersionSpecifier;
+    Specifier.WorkspaceProtocol = workspace_protocol_1.WorkspaceProtocolSpecifier;
+    function create(instance, raw) {
+        if (raw === delete_1.DELETE)
+            return new Specifier.Delete({ instance, raw });
+        if (!raw)
+            return new Specifier.Unsupported({ instance, raw });
+        try {
+            if (raw === 'latest')
+                raw = '*';
+            const parsed = (0, parse_specifier_1.parseSpecifier)(instance.name, raw, instance.packageJsonFile);
+            const type = parsed.type;
+            const data = { instance, raw };
+            if (type === 'version')
+                return new Specifier.Version(data);
+            if (type === 'range')
+                return new Specifier.Range(data);
+            if (type === 'workspaceProtocol')
+                return new Specifier.WorkspaceProtocol(data);
+            if (type === 'alias')
+                return new Specifier.Alias(data);
+            if (type === 'file' || type === 'directory')
+                return new Specifier.File(data);
+            if (type === 'remote')
+                return new Specifier.Url(data);
+            if (type === 'git')
+                return new Specifier.HostedGit(data);
+            if (type === 'tag')
+                return new Specifier.Tag(data);
+            return new Specifier.Unsupported(data);
+        }
+        catch {
+            return new Specifier.Unsupported({ instance, raw });
+        }
+    }
+    Specifier.create = create;
+})(Specifier || (exports.Specifier = Specifier = {}));

package/dist/specifier/lib/non-semver-error.d.ts

@@ -0,0 +1,11 @@
+import { Data, Effect } from 'effect';
+import type { Specifier } from '..';
+declare const NonSemverError_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "NonSemverError";
+}>;
+export declare class NonSemverError extends NonSemverError_base<{
+    specifier: Specifier.Any;
+}> {
+    static asEffect<T>(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, T>;
+}
+export {};

package/dist/specifier/lib/non-semver-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonSemverError = void 0;
+const effect_1 = require("effect");
+class NonSemverError extends effect_1.Data.TaggedClass('NonSemverError') {
+    static asEffect(specifier) {
+        return effect_1.Effect.fail(new NonSemverError({ specifier }));
+    }
+}
+exports.NonSemverError = NonSemverError;

package/dist/specifier/lib/parse-specifier.d.ts

@@ -0,0 +1,14 @@
+import npa from 'npm-package-arg';
+import type { PackageJsonFile } from '../../get-package-json-files/package-json-file';
+/** Extends npm/npm-package-arg to support "workspace:*" */
+export interface WorkspaceProtocolResult {
+    type: 'workspaceProtocol';
+    raw: string;
+    name: string | null;
+    escapedName: string | null;
+    scope: string | null;
+    rawSpec: string;
+    saveSpec: string;
+}
+export type NpmPackageArgResult = ReturnType<typeof npa.resolve> | WorkspaceProtocolResult;
+export declare function parseSpecifier(name: string, specifier: string, packageJsonFile: PackageJsonFile): NpmPackageArgResult;

package/dist/specifier/lib/parse-specifier.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSpecifier = void 0;
+const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
+function parseSpecifier(name, specifier, packageJsonFile) {
+    if (specifier === 'workspace:*' || specifier === 'workspace:~') {
+        const parsed = npm_package_arg_1.default.resolve(name, packageJsonFile.jsonFile.dirPath, specifier.replace('workspace:', 'file:'));
+        return {
+            escapedName: parsed.escapedName,
+            name: parsed.name,
+            raw: parsed.raw.replace('file:', 'workspace:'),
+            rawSpec: parsed.rawSpec.replace('file:', 'workspace:'),
+            saveSpec: parsed.saveSpec.replace('file:', 'workspace:'),
+            scope: parsed.scope,
+            type: 'workspaceProtocol',
+        };
+    }
+    return npm_package_arg_1.default.resolve(name, specifier, packageJsonFile.jsonFile.dirPath);
+}
+exports.parseSpecifier = parseSpecifier;

package/dist/specifier/lib/specific-registry-result.d.ts

@@ -0,0 +1,9 @@
+import type { RegistryResult } from 'npm-package-arg';
+/**
+ * A helper to create specific classes for each of the possible
+ * `RegistryResult` types from npm/npm-package-arg. Instead of grouping them
+ * together we are being more specific
+ */
+export type SpecificRegistryResult<T extends RegistryResult['type'] | 'local'> = Omit<RegistryResult, 'type'> & {
+    type: T;
+};

package/dist/specifier/lib/specific-registry-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/specifier/range.d.ts

@@ -0,0 +1,18 @@
+import { Effect } from 'effect';
+import { Specifier } from '.';
+import { BaseSpecifier } from './base';
+import { NonSemverError } from './lib/non-semver-error';
+import type { SpecificRegistryResult } from './lib/specific-registry-result';
+type T = SpecificRegistryResult<'range'>;
+/**
+ * @example "*"
+ * @example "^1.2.3"
+ */
+export declare class RangeSpecifier extends BaseSpecifier<T> {
+    _tag: string;
+    /** Return the semver version including the range */
+    getSemver(): Effect.Effect<never, NonSemverError, string>;
+    /** Get a new `Specifier` from the given semver version applied to this one */
+    setSemver(version: string): Effect.Effect<never, never, Specifier.Any>;
+}
+export {};

package/dist/specifier/range.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RangeSpecifier = void 0;
+const effect_1 = require("effect");
+const _1 = require(".");
+const base_1 = require("./base");
+const non_semver_error_1 = require("./lib/non-semver-error");
+/**
+ * @example "*"
+ * @example "^1.2.3"
+ */
+class RangeSpecifier extends base_1.BaseSpecifier {
+    constructor() {
+        super(...arguments);
+        this._tag = 'RangeSpecifier';
+    }
+    /** Return the semver version including the range */
+    getSemver() {
+        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => parsed.fetchSpec));
+    }
+    /** Get a new `Specifier` from the given semver version applied to this one */
+    setSemver(version) {
+        return effect_1.Effect.succeed(_1.Specifier.create(this.instance, version));
+    }
+}
+exports.RangeSpecifier = RangeSpecifier;

package/dist/specifier/tag.d.ts

@@ -0,0 +1,9 @@
+import { BaseSpecifier } from './base';
+import type { SpecificRegistryResult } from './lib/specific-registry-result';
+/**
+ * @example "latest"
+ * @example "made-up-by-some-dev"
+ */
+export declare class TagSpecifier extends BaseSpecifier<SpecificRegistryResult<'tag'>> {
+    _tag: string;
+}

package/dist/specifier/tag.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagSpecifier = void 0;
+const base_1 = require("./base");
+/**
+ * @example "latest"
+ * @example "made-up-by-some-dev"
+ */
+class TagSpecifier extends base_1.BaseSpecifier {
+    constructor() {
+        super(...arguments);
+        this._tag = 'TagSpecifier';
+    }
+}
+exports.TagSpecifier = TagSpecifier;

package/dist/specifier/unsupported.d.ts

@@ -0,0 +1,5 @@
+import { BaseSpecifier } from './base';
+/** A specifier not supported by the `npm` package manager */
+export declare class UnsupportedSpecifier extends BaseSpecifier<unknown> {
+    _tag: string;
+}

package/dist/specifier/unsupported.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedSpecifier = void 0;
+const base_1 = require("./base");
+/** A specifier not supported by the `npm` package manager */
+class UnsupportedSpecifier extends base_1.BaseSpecifier {
+    constructor() {
+        super(...arguments);
+        this._tag = 'UnsupportedSpecifier';
+    }
+}
+exports.UnsupportedSpecifier = UnsupportedSpecifier;

package/dist/specifier/url.d.ts

@@ -0,0 +1,6 @@
+import type { URLResult } from 'npm-package-arg';
+import { BaseSpecifier } from './base';
+/** @example "http://x.com/foo.tgz" */
+export declare class UrlSpecifier extends BaseSpecifier<URLResult> {
+    _tag: string;
+}