rman 1.0.12 → 1.2.1

package/utils/change-hash.d.ts

@@ -1,68 +0,0 @@
-import type { Package } from '../core/package.js';
-import type { GitHelper } from './git.js';
-/** `.rmanrc changelog.tagPattern` (cascaded, per-package overridable) - a glob for this package's
- *  release tags. `{name}` (if present) is replaced with the package's own name, e.g. `{name}@*`
- *  for independent per-package versioning (`@scope/pkg@1.2.3`, the same scheme lerna/changesets
- *  use - `@`/`/` are both fine in a git tag name). Without `{name}`, it's a single repo-wide tag
- *  shared by every package (e.g. the default `v*`). */
-export declare function tagPattern(pkg: Package): string;
-/** This package's most recent release tag - the `{name}`-bearing pattern looks up that package's
- *  *own* tags directly (newest by version sort); a repo-wide pattern instead finds the nearest tag
- *  HEAD actually descends from, since no single package "owns" that tag. `undefined` if never
- *  tagged at all (a fresh package, or one that's never been released). Shared by `changelog`
- *  (reading the last-documented version) and `version` (finding the boundary a bump measures
- *  "since"). */
-export declare function findLatestTag(git: GitHelper, pkg: Package): Promise<string | undefined>;
-/** The forward direction of `findLatestTag`: expands `pkg`'s (cascaded) `.rmanrc
- *  changelog.tagPattern` into the concrete tag name `version` belongs under - `{name}` becomes the
- *  package's own name, `*` becomes `version`. Shared by `version` (creating the tag),
- *  `github-release` (finding the release that tag belongs to), and `detectChangeHash`'s own npm
- *  fallback (mapping a published version back onto a tag), so all three name tags identically. */
-export declare function expandTag(pkg: Package, version: string): string;
-/** The pattern expansion `expandTag` performs, on any pattern - `{name}` becomes `name`, `*` becomes
- *  `version`. Shared with the repository's own release tag, which uses a different pattern (see
- *  `releaseTagPattern`) but names tags the same way. */
-export declare function applyTagPattern(pattern: string, name: string, version: string): string;
-/** Strips the pattern's literal prefix (everything before its first `*`) from `tag` to get just
- *  the version part - e.g. tag `@sqb/builder@1.2.3` against pattern `@sqb/builder@*` -> `1.2.3`.
- *  A pattern with no `*` is returned as its own "version" verbatim (an exact tag, nothing to strip). */
-export declare function extractVersion(tag: string, expandedPattern: string): string;
-/** Looks up `name`'s currently-published version on the npm registry, or `undefined` if it isn't
- *  published there at all (private, scoped-but-unpublished, no network, ...) - the real npm CLI
- *  call `detectChangeHash` uses by default; injectable via its `npmViewVersion` option so tests
- *  aren't making real registry calls. */
-export declare function defaultNpmViewVersion(name: string, cwd: string): Promise<string | undefined>;
-export interface DetectChangeHashOptions {
-    /** Use this commit/hash directly instead of auto-detecting - applies the same way to every
-     *  package. `"npm"` (or omitting `from` entirely) triggers auto-detection instead of being
-     *  treated as a literal ref. */
-    from?: string;
-    /** Overrides the real npm registry lookup made when auto-detecting - mainly for tests, so they
-     *  don't depend on network access or a real published package. */
-    npmViewVersion?: (name: string, cwd: string) => Promise<string | undefined>;
-    /** An existing record of what's already been documented (typically a changelog file) - only
-     *  consulted while auto-detecting (ignored when `from` is an explicit hash). Guards against a
-     *  gap: if this file's own last-modifying commit is *older* than the npm-detected tag - e.g. the
-     *  file was last updated for 1.1.0, but 1.2.0-1.5.0 were released without ever documenting them,
-     *  and npm now reports 1.5.0 - starting from the tag alone would silently skip everything the
-     *  file never recorded. The boundary becomes the merge-base of the two, so the result always
-     *  covers at least as much as the file is missing. Has no effect when the file doesn't exist. */
-    catchUpFile?: string;
-}
-/**
- * Resolves the commit/hash a package's changes should be measured "since" - the boundary
- * `changelog --from` uses, but reusable anywhere a command wants to answer "what changed for this
- * package". An explicit `options.from` (anything but `"npm"`) is returned as-is, applying the same
- * way to every package. Otherwise, it's auto-detected in order: (1) this package's own most recent
- * release tag - the same network-free `findLatestTag` lookup `version`/`changed` themselves use,
- * so all three commands agree on "since when" for any repo whose tags are the ones `rman version`
- * actually created; (2) failing that (no tag at all yet - e.g. onboarding `rman` onto a repo with
- * real npm history but no `rman`-created tags), the package's currently-published npm version -
- * looked up via `npmViewVersion`, then mapped to a git tag using `.rmanrc changelog.tagPattern`
- * (see `tagPattern`). Either way, if `catchUpFile` is given and exists, the result is widened to
- * also cover anything that file hasn't caught up on yet (see its doc comment). Returns `undefined`
- * when nothing can be resolved at all (never tagged *and* never published, no catch-up file - a
- * genuinely first-ever release) - callers should fall back to their own default in that case (e.g.
- * the whole history, since nothing has ever been released).
- */
-export declare function detectChangeHash(git: GitHelper, pkg: Package, options?: DetectChangeHashOptions): Promise<string | undefined>;

package/utils/change-hash.js

@@ -1,98 +0,0 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-/** `.rmanrc changelog.tagPattern` (cascaded, per-package overridable) - a glob for this package's
- *  release tags. `{name}` (if present) is replaced with the package's own name, e.g. `{name}@*`
- *  for independent per-package versioning (`@scope/pkg@1.2.3`, the same scheme lerna/changesets
- *  use - `@`/`/` are both fine in a git tag name). Without `{name}`, it's a single repo-wide tag
- *  shared by every package (e.g. the default `v*`). */
-export function tagPattern(pkg) {
-    const cfg = pkg.config?.changelog;
-    return typeof cfg?.tagPattern === 'string' && cfg.tagPattern ? cfg.tagPattern : DEFAULT_TAG_PATTERN;
-}
-/** This package's most recent release tag - the `{name}`-bearing pattern looks up that package's
- *  *own* tags directly (newest by version sort); a repo-wide pattern instead finds the nearest tag
- *  HEAD actually descends from, since no single package "owns" that tag. `undefined` if never
- *  tagged at all (a fresh package, or one that's never been released). Shared by `changelog`
- *  (reading the last-documented version) and `version` (finding the boundary a bump measures
- *  "since"). */
-export async function findLatestTag(git, pkg) {
-    const pattern = tagPattern(pkg);
-    const expanded = pattern.replace('{name}', pkg.name);
-    return pattern.includes('{name}') ? (await git.listTags(expanded))[0] : await git.describeTag(expanded);
-}
-/** The forward direction of `findLatestTag`: expands `pkg`'s (cascaded) `.rmanrc
- *  changelog.tagPattern` into the concrete tag name `version` belongs under - `{name}` becomes the
- *  package's own name, `*` becomes `version`. Shared by `version` (creating the tag),
- *  `github-release` (finding the release that tag belongs to), and `detectChangeHash`'s own npm
- *  fallback (mapping a published version back onto a tag), so all three name tags identically. */
-export function expandTag(pkg, version) {
-    return applyTagPattern(tagPattern(pkg), pkg.name, version);
-}
-/** The pattern expansion `expandTag` performs, on any pattern - `{name}` becomes `name`, `*` becomes
- *  `version`. Shared with the repository's own release tag, which uses a different pattern (see
- *  `releaseTagPattern`) but names tags the same way. */
-export function applyTagPattern(pattern, name, version) {
-    const expanded = pattern.replace('{name}', name);
-    const starIdx = expanded.indexOf('*');
-    return starIdx === -1 ? expanded : expanded.slice(0, starIdx) + version + expanded.slice(starIdx + 1);
-}
-/** Strips the pattern's literal prefix (everything before its first `*`) from `tag` to get just
- *  the version part - e.g. tag `@sqb/builder@1.2.3` against pattern `@sqb/builder@*` -> `1.2.3`.
- *  A pattern with no `*` is returned as its own "version" verbatim (an exact tag, nothing to strip). */
-export function extractVersion(tag, expandedPattern) {
-    const starIdx = expandedPattern.indexOf('*');
-    if (starIdx === -1)
-        return tag;
-    const prefix = expandedPattern.slice(0, starIdx);
-    return tag.startsWith(prefix) ? tag.slice(prefix.length) : tag;
-}
-/** Looks up `name`'s currently-published version on the npm registry, or `undefined` if it isn't
- *  published there at all (private, scoped-but-unpublished, no network, ...) - the real npm CLI
- *  call `detectChangeHash` uses by default; injectable via its `npmViewVersion` option so tests
- *  aren't making real registry calls. */
-export async function defaultNpmViewVersion(name, cwd) {
-    try {
-        const { stdout } = await execFileAsync('npm', ['view', name, 'version'], { cwd });
-        return stdout.trim() || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Resolves the commit/hash a package's changes should be measured "since" - the boundary
- * `changelog --from` uses, but reusable anywhere a command wants to answer "what changed for this
- * package". An explicit `options.from` (anything but `"npm"`) is returned as-is, applying the same
- * way to every package. Otherwise, it's auto-detected in order: (1) this package's own most recent
- * release tag - the same network-free `findLatestTag` lookup `version`/`changed` themselves use,
- * so all three commands agree on "since when" for any repo whose tags are the ones `rman version`
- * actually created; (2) failing that (no tag at all yet - e.g. onboarding `rman` onto a repo with
- * real npm history but no `rman`-created tags), the package's currently-published npm version -
- * looked up via `npmViewVersion`, then mapped to a git tag using `.rmanrc changelog.tagPattern`
- * (see `tagPattern`). Either way, if `catchUpFile` is given and exists, the result is widened to
- * also cover anything that file hasn't caught up on yet (see its doc comment). Returns `undefined`
- * when nothing can be resolved at all (never tagged *and* never published, no catch-up file - a
- * genuinely first-ever release) - callers should fall back to their own default in that case (e.g.
- * the whole history, since nothing has ever been released).
- */
-export async function detectChangeHash(git, pkg, options = {}) {
-    if (options.from && options.from !== 'npm')
-        return options.from;
-    let tagHash = await findLatestTag(git, pkg);
-    if (!tagHash) {
-        const npmViewVersion = options.npmViewVersion ?? defaultNpmViewVersion;
-        const publishedVersion = await npmViewVersion(pkg.name, git.cwd);
-        if (publishedVersion) {
-            const tag = expandTag(pkg, publishedVersion);
-            tagHash = (await git.tagExists(tag)) ? tag : undefined;
-        }
-    }
-    const fileHash = options.catchUpFile ? await git.lastCommitTouching(options.catchUpFile) : undefined;
-    if (!fileHash)
-        return tagHash;
-    if (!tagHash)
-        return fileHash;
-    return (await git.mergeBase(tagHash, fileHash)) ?? tagHash;
-}
-const execFileAsync = promisify(execFile);
-const DEFAULT_TAG_PATTERN = 'v*';

package/utils/conventional-commits.d.ts

@@ -1,52 +0,0 @@
-/**
- * `type(scope): description`, optionally with a `!` breaking-change marker - Conventional
- * Commits' subject-line shape. Anything that doesn't match falls into "Other Changes" as-is (for
- * changelog entries) or defaults to a patch-level change (for version bump severity) - see
- * `parseConventionalCommit`.
- */
-export declare const CONVENTIONAL_PATTERN: RegExp;
-/** A bare version-bump commit (`"6.0.1"`, `"v2.3.0-beta.1"`, ...) - many release tools commit the
- *  version bump itself with just the new version number as the message. That's a release marker,
- *  not a real change worth describing (or worth bumping a version over on its own), so it's
- *  dropped everywhere a real change is being looked for. */
-export declare const VERSION_BUMP_PATTERN: RegExp;
-/**
- * Whether `subject` is a release marker rather than a real change - dropped everywhere real
- * changes are looked for (changelog entries, and what counts as "changed" for a version bump).
- *
- * Covers the bare-version form other tools use (`VERSION_BUMP_PATTERN`) plus every message shape
- * `version` itself writes: its commit message (`commitMessageTemplate`, or the built-in
- * `"chore(release): v{version}"` when a repo doesn't override it), the multi-version form that
- * template falls back to when one commit spans several versions (`chore(release): a@1.2.0,
- * b@1.3.0`), and the monorepo root's own version-sync commit. Without this, rman's own release
- * commits show up in the changelogs it generates - visible whenever the boundary reaches back past
- * a previous release (see `detectChangeHash`'s `catchUpFile`).
- */
-export declare function isReleaseCommit(subject: string, commitMessageTemplate?: string): boolean;
-export interface ParsedCommitSubject {
-    type: string;
-    scope?: string;
-    /** A `!` right before the `:` (e.g. `feat!:`) - Conventional Commits' inline breaking-change
-     *  marker. Doesn't cover a `BREAKING CHANGE:` footer, since only the subject line is available. */
-    breaking: boolean;
-    description: string;
-}
-/** Parses a commit subject as Conventional Commits, or `undefined` if it doesn't match at all
- *  (a non-conventional message - still a real change, just with no `type` to key off of). */
-export declare function parseConventionalCommit(subject: string): ParsedCommitSubject | undefined;
-/** Whether a commit `body` carries a Conventional Commits `BREAKING CHANGE:` (or
- *  `BREAKING-CHANGE:`) footer - the other, footer-based way to mark a breaking change, alongside
- *  the inline `!` the subject line alone can carry (see `parseConventionalCommit`, whose own
- *  `breaking` only ever reflects that marker, never a footer, since it only sees the subject). */
-export declare function hasBreakingChangeFooter(body: string): boolean;
-/**
- * A `Release-As: patch|minor|major` footer in a commit `body` - lets that one commit's own
- * contribution to a detected bump severity be overridden by hand, regardless of what its subject
- * line (or a `BREAKING CHANGE:` footer) would otherwise imply. The motivating case: a `feat:`
- * commit that needs to ship right now as a patch, without waiting for the rest of a minor's worth
- * of work to land - `Release-As: patch` on just that commit ships it alone, at patch severity,
- * while a later genuine `feat:` (with no override) still correctly triggers a minor of its own.
- * Case-insensitive; the last match wins if a body somehow has more than one, matching how multiple
- * git trailers of the same key are conventionally read (later overrides earlier).
- */
-export declare function parseReleaseAs(body: string): 'patch' | 'minor' | 'major' | undefined;

package/utils/conventional-commits.js

@@ -1,90 +0,0 @@
-/**
- * `type(scope): description`, optionally with a `!` breaking-change marker - Conventional
- * Commits' subject-line shape. Anything that doesn't match falls into "Other Changes" as-is (for
- * changelog entries) or defaults to a patch-level change (for version bump severity) - see
- * `parseConventionalCommit`.
- */
-export const CONVENTIONAL_PATTERN = /^(\w+)(\(([^)]+)\))?(!)?:\s*(.+)$/;
-/** A bare version-bump commit (`"6.0.1"`, `"v2.3.0-beta.1"`, ...) - many release tools commit the
- *  version bump itself with just the new version number as the message. That's a release marker,
- *  not a real change worth describing (or worth bumping a version over on its own), so it's
- *  dropped everywhere a real change is being looked for. */
-export const VERSION_BUMP_PATTERN = /^v?\d+\.\d+\.\d+(?:[-+][\w.]+)?$/;
-/**
- * Whether `subject` is a release marker rather than a real change - dropped everywhere real
- * changes are looked for (changelog entries, and what counts as "changed" for a version bump).
- *
- * Covers the bare-version form other tools use (`VERSION_BUMP_PATTERN`) plus every message shape
- * `version` itself writes: its commit message (`commitMessageTemplate`, or the built-in
- * `"chore(release): v{version}"` when a repo doesn't override it), the multi-version form that
- * template falls back to when one commit spans several versions (`chore(release): a@1.2.0,
- * b@1.3.0`), and the monorepo root's own version-sync commit. Without this, rman's own release
- * commits show up in the changelogs it generates - visible whenever the boundary reaches back past
- * a previous release (see `detectChangeHash`'s `catchUpFile`).
- */
-export function isReleaseCommit(subject, commitMessageTemplate) {
-    if (VERSION_BUMP_PATTERN.test(subject))
-        return true;
-    if (ROOT_SYNC_PATTERN.test(subject))
-        return true;
-    if (MULTI_VERSION_RELEASE_PATTERN.test(subject))
-        return true;
-    // The built-in message is checked even when a repo overrides it: the override only applies to
-    // commits spanning a single version (see `buildCommitMessage`), and a repo that adopted one later
-    // still has older releases committed under the default.
-    if (templatePattern(DEFAULT_COMMIT_MESSAGE).test(subject))
-        return true;
-    return !!commitMessageTemplate && templatePattern(commitMessageTemplate).test(subject);
-}
-/** Parses a commit subject as Conventional Commits, or `undefined` if it doesn't match at all
- *  (a non-conventional message - still a real change, just with no `type` to key off of). */
-export function parseConventionalCommit(subject) {
-    const m = CONVENTIONAL_PATTERN.exec(subject);
-    if (!m)
-        return undefined;
-    const [, type, , scope, breakingMark, description] = m;
-    return { type: type.toLowerCase(), scope, breaking: !!breakingMark, description };
-}
-/** Whether a commit `body` carries a Conventional Commits `BREAKING CHANGE:` (or
- *  `BREAKING-CHANGE:`) footer - the other, footer-based way to mark a breaking change, alongside
- *  the inline `!` the subject line alone can carry (see `parseConventionalCommit`, whose own
- *  `breaking` only ever reflects that marker, never a footer, since it only sees the subject). */
-export function hasBreakingChangeFooter(body) {
-    return /^BREAKING[ -]CHANGE:/im.test(body);
-}
-/** A semver version, as it appears inside a commit subject - the `\d+\.\d+\.\d+` core of
- *  `VERSION_BUMP_PATTERN`, reusable inside the larger patterns below. */
-const SEMVER_SOURCE = String.raw `\d+\.\d+\.\d+(?:[-+][\w.]+)?`;
-/** Mirrors `VersionService`'s own default `version.commitMessage` - kept in sync by
- *  `version.command.ts`'s documented default, not imported, to keep this module dependency-free. */
-const DEFAULT_COMMIT_MESSAGE = 'chore(release): v{version}';
-/** `VersionService.applyPlan`'s trailing commit for a monorepo root's informational version. */
-const ROOT_SYNC_PATTERN = new RegExp(String.raw `^chore: sync root version to ${SEMVER_SOURCE}$`);
-/** What the commit-message template falls back to when one commit covers several versions at once
- *  (a cross-group ripple) - `{version}` has nothing single to substitute, so each bumped package is
- *  listed by name instead. */
-const MULTI_VERSION_RELEASE_PATTERN = new RegExp(String.raw `^chore\(release\): \S+@${SEMVER_SOURCE}(?:, \S+@${SEMVER_SOURCE})*$`);
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/** Turns a `version.commitMessage` template into a matcher for the commits it produces: every
- *  literal part escaped, each `{version}` placeholder standing in for any semver. */
-function templatePattern(template) {
-    const source = template.split('{version}').map(escapeRegExp).join(SEMVER_SOURCE);
-    return new RegExp(`^${source}$`);
-}
-/**
- * A `Release-As: patch|minor|major` footer in a commit `body` - lets that one commit's own
- * contribution to a detected bump severity be overridden by hand, regardless of what its subject
- * line (or a `BREAKING CHANGE:` footer) would otherwise imply. The motivating case: a `feat:`
- * commit that needs to ship right now as a patch, without waiting for the rest of a minor's worth
- * of work to land - `Release-As: patch` on just that commit ships it alone, at patch severity,
- * while a later genuine `feat:` (with no override) still correctly triggers a minor of its own.
- * Case-insensitive; the last match wins if a body somehow has more than one, matching how multiple
- * git trailers of the same key are conventionally read (later overrides earlier).
- */
-export function parseReleaseAs(body) {
-    const matches = [...body.matchAll(/^release-as:\s*(patch|minor|major)\s*$/gim)];
-    const last = matches.at(-1);
-    return last ? last[1].toLowerCase() : undefined;
-}

package/utils/npm-run-path.d.ts

@@ -1,67 +0,0 @@
-export interface RunPathOptions {
-    /**
-     Working directory.
-     @default process.cwd()
-     */
-    readonly cwd?: string;
-    /**
-     PATH to be appended. Default: [`PATH`](https://github.com/sindresorhus/path-key).
-     Set it to an empty string to exclude the default PATH.
-     */
-    readonly path?: string;
-    /**
-     Path to the Node.js executable to use in child processes if that is different from the current one. Its directory is pushed to the front of PATH.
-     This can be either an absolute path or a path relative to the `cwd` option.
-     @default process.execPath
-     */
-    readonly execPath?: string;
-}
-export type ProcessEnv = Record<string, string | undefined>;
-export interface EnvOptions {
-    /**
-     The working directory.
-     @default process.cwd()
-     */
-    readonly cwd?: string;
-    /**
-     Accepts an object of environment variables, like `process.env`,
-     and modifies the PATH using the correct [PATH key](https://github.com/sindresorhus/path-key).
-     Use this if you're modifying the PATH for use in the `child_process` options.
-     */
-    readonly env?: ProcessEnv;
-    /**
-     The path to the current Node.js executable. Its directory is pushed to the front of PATH.
-     This can be either an absolute path or a path relative to the `cwd` option.
-     @default process.execPath
-     */
-    readonly execPath?: string;
-}
-/**
- Get your [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) prepended with locally installed binaries.
- @returns The augmented path string.
- @example
- ```
- import childProcess from 'node:child_process';
- import {npmRunPath} from 'npm-run-path';
- console.log(process.env.PATH);
- //=> '/usr/local/bin'
- console.log(npmRunPath());
- //=> '/Users/sindresorhus/dev/foo/node_modules/.bin:/Users/sindresorhus/dev/node_modules/.bin:/Users/sindresorhus/node_modules/.bin:/Users/node_modules/.bin:/node_modules/.bin:/usr/local/bin'
- ```
- */
-export declare function npmRunPath(options?: RunPathOptions): string;
-/**
- @returns The augmented [`process.env`](https://nodejs.org/api/process.html#process_process_env) object.
- @example
- ```
- import childProcess from 'node:child_process';
- import {npmRunPathEnv} from 'npm-run-path';
- // `foo` is a locally installed binary
- childProcess.execFileSync('foo', {
- env: npmRunPathEnv()
- });
- ```
- */
-export declare function npmRunPathEnv(options?: EnvOptions): {
-    [key: string]: string | undefined;
-};

package/utils/npm-run-path.js

@@ -1,63 +0,0 @@
-/**
- * Inspired from [npm-run-path](https://github.com/sindresorhus/npm-run-path)
- */
-import path from 'path';
-import process from 'process';
-/**
- Get your [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) prepended with locally installed binaries.
- @returns The augmented path string.
- @example
- ```
- import childProcess from 'node:child_process';
- import {npmRunPath} from 'npm-run-path';
- console.log(process.env.PATH);
- //=> '/usr/local/bin'
- console.log(npmRunPath());
- //=> '/Users/sindresorhus/dev/foo/node_modules/.bin:/Users/sindresorhus/dev/node_modules/.bin:/Users/sindresorhus/node_modules/.bin:/Users/node_modules/.bin:/node_modules/.bin:/usr/local/bin'
- ```
- */
-export function npmRunPath(options = {}) {
-    const cwd = options.cwd || process.cwd();
-    const path_ = options.path || process.env[pathKey()];
-    const execPath = options.execPath || process.execPath;
-    let previous;
-    let cwdPath = path.resolve(cwd);
-    const result = [];
-    while (previous !== cwdPath) {
-        result.push(path.join(cwdPath, 'node_modules/.bin'));
-        previous = cwdPath;
-        cwdPath = path.resolve(cwdPath, '..');
-    }
-    // Ensure the running `node` binary is used.
-    result.push(path.resolve(cwd, execPath, '..'));
-    return [...result, path_].join(path.delimiter);
-}
-/**
- @returns The augmented [`process.env`](https://nodejs.org/api/process.html#process_process_env) object.
- @example
- ```
- import childProcess from 'node:child_process';
- import {npmRunPathEnv} from 'npm-run-path';
- // `foo` is a locally installed binary
- childProcess.execFileSync('foo', {
- env: npmRunPathEnv()
- });
- ```
- */
-export function npmRunPathEnv(options = {}) {
-    const env = { ...(options.env || process.env) };
-    const path_ = pathKey({ env });
-    const opts = { ...options, path: env[path_] };
-    env[path_] = npmRunPath(opts);
-    return env;
-}
-function pathKey(options) {
-    const env = options?.env || process.env;
-    const platform = options?.platform || process.platform;
-    if (platform !== 'win32') {
-        return 'PATH';
-    }
-    return (Object.keys(env)
-        .reverse()
-        .find(key => key.toUpperCase() === 'PATH') || 'Path');
-}

package/utils/workspace-range.d.ts

@@ -1,17 +0,0 @@
-export interface ParsedWorkspaceRange {
-    /** `'*'`/`'^'`/`'~'` for the bare selector forms; `'explicit'` when the protocol is followed by
-     *  a concrete semver version/range instead (e.g. `"workspace:^1.0.0"`, `"workspace:1.0.0"`). */
-    selector: '*' | '^' | '~' | 'explicit';
-    /** Only set when `selector === 'explicit'` - the literal range following `"workspace:"`. */
-    range?: string;
-}
-/** Parses a dependency range value for the pnpm/yarn `"workspace:"` protocol - `undefined` when
- *  `value` isn't a workspace range at all (a plain semver range, or not a string). */
-export declare function parseWorkspaceRange(value: unknown): ParsedWorkspaceRange | undefined;
-/**
- * Resolves a parsed workspace range against `version` (the dependency's actual current version)
- * into the real range a registry consumer would need - the same substitution pnpm/yarn's own
- * publish performs: `"*"` pins the exact version (no operator), `"^"`/`"~"` prepend themselves to
- * it, and an explicit range is used verbatim (it was already a real range, just workspace-prefixed).
- */
-export declare function resolveWorkspaceRange(parsed: ParsedWorkspaceRange, version: string): string;

package/utils/workspace-range.js

@@ -1,28 +0,0 @@
-/** Parses a dependency range value for the pnpm/yarn `"workspace:"` protocol - `undefined` when
- *  `value` isn't a workspace range at all (a plain semver range, or not a string). */
-export function parseWorkspaceRange(value) {
-    if (typeof value !== 'string' || !value.startsWith('workspace:'))
-        return undefined;
-    const rest = value.slice('workspace:'.length);
-    if (rest === '*' || rest === '^' || rest === '~')
-        return { selector: rest };
-    return { selector: 'explicit', range: rest };
-}
-/**
- * Resolves a parsed workspace range against `version` (the dependency's actual current version)
- * into the real range a registry consumer would need - the same substitution pnpm/yarn's own
- * publish performs: `"*"` pins the exact version (no operator), `"^"`/`"~"` prepend themselves to
- * it, and an explicit range is used verbatim (it was already a real range, just workspace-prefixed).
- */
-export function resolveWorkspaceRange(parsed, version) {
-    switch (parsed.selector) {
-        case '*':
-            return version;
-        case '^':
-            return `^${version}`;
-        case '~':
-            return `~${version}`;
-        case 'explicit':
-            return parsed.range;
-    }
-}