@ohos-ports/nx 23.2.0-beta.0 → 23.2.1-beta.0

package/dist/src/command-line/release/version/resolve-current-version.d.ts

@@ -1,32 +0,0 @@
-import type { ProjectGraphProjectNode } from '../../../config/project-graph';
-import type { Tree } from '../../../generators/tree';
-import type { ReleaseGroupWithName } from '../config/filter-release-groups';
-import { getLatestGitTagForPattern } from '../utils/git';
-import { ProjectLogger } from './project-logger';
-import type { FinalConfigForProject } from '../utils/release-graph';
-import { VersionActions } from './version-actions';
-export declare function resolveCurrentVersion(tree: Tree, projectGraphNode: ProjectGraphProjectNode, releaseGroup: ReleaseGroupWithName, versionActions: VersionActions, logger: ProjectLogger, cachedCurrentVersionsPerFixedReleaseGroup: Map<string, // release group name
-{
-    currentVersion: string;
-    originatingProjectName: string;
-    logText: string;
-}>, finalConfigForProject: FinalConfigForProject, releaseTagPattern: string, latestMatchingGitTag?: Awaited<ReturnType<typeof getLatestGitTagForPattern>>): Promise<string | null>;
-/**
- * Attempt to resolve the current version from the manifest file on disk.
- *
- * Not all VersionActions implementations support a manifest file, in which case the logic will handle either thrown errors
- * or null values being returned from the readCurrentVersionFromSourceManifest method and throw a clear user-facing error.
- */
-export declare function resolveCurrentVersionFromDisk(tree: Tree, projectGraphNode: ProjectGraphProjectNode, versionActions: VersionActions, logger: ProjectLogger): Promise<string>;
-export declare function resolveCurrentVersionFromRegistry(tree: Tree, projectGraphNode: ProjectGraphProjectNode, releaseGroup: ReleaseGroupWithName, versionActions: VersionActions, logger: ProjectLogger, cachedCurrentVersionsPerFixedReleaseGroup: Map<string, // release group name
-{
-    currentVersion: string;
-    originatingProjectName: string;
-    logText?: string;
-}>, finalConfigForProject: FinalConfigForProject): Promise<string>;
-export declare function resolveCurrentVersionFromGitTag(tree: Tree, projectGraphNode: ProjectGraphProjectNode, releaseGroup: ReleaseGroupWithName, versionActions: VersionActions, logger: ProjectLogger, cachedCurrentVersionsPerFixedReleaseGroup: Map<string, // release group name
-{
-    currentVersion: string;
-    originatingProjectName: string;
-    logText: string;
-}>, finalConfigForProject: FinalConfigForProject, releaseTagPattern: string, latestMatchingGitTag?: Awaited<ReturnType<typeof getLatestGitTagForPattern>>): Promise<string>;

package/dist/src/command-line/release/version/resolve-current-version.js

@@ -1,240 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveCurrentVersion = resolveCurrentVersion;
-exports.resolveCurrentVersionFromDisk = resolveCurrentVersionFromDisk;
-exports.resolveCurrentVersionFromRegistry = resolveCurrentVersionFromRegistry;
-exports.resolveCurrentVersionFromGitTag = resolveCurrentVersionFromGitTag;
-const tslib_1 = require("tslib");
-const pc = tslib_1.__importStar(require("picocolors"));
-const prompt_helpers_1 = require("../../../utils/prompt-helpers");
-const spinner_1 = require("../../../utils/spinner");
-async function resolveCurrentVersion(tree, projectGraphNode, releaseGroup, versionActions, logger, cachedCurrentVersionsPerFixedReleaseGroup, finalConfigForProject, releaseTagPattern, latestMatchingGitTag) {
-    switch (finalConfigForProject.currentVersionResolver) {
-        case 'none':
-            return null;
-        case 'disk': {
-            return resolveCurrentVersionFromDisk(tree, projectGraphNode, versionActions, logger);
-        }
-        case 'registry': {
-            return resolveCurrentVersionFromRegistry(tree, projectGraphNode, releaseGroup, versionActions, logger, cachedCurrentVersionsPerFixedReleaseGroup, finalConfigForProject);
-        }
-        case 'git-tag': {
-            return resolveCurrentVersionFromGitTag(tree, projectGraphNode, releaseGroup, versionActions, logger, cachedCurrentVersionsPerFixedReleaseGroup, finalConfigForProject, releaseTagPattern, latestMatchingGitTag);
-        }
-        default:
-            throw new Error(`Invalid value for "currentVersionResolver": ${finalConfigForProject.currentVersionResolver}`);
-    }
-}
-/**
- * Attempt to resolve the current version from the manifest file on disk.
- *
- * Not all VersionActions implementations support a manifest file, in which case the logic will handle either thrown errors
- * or null values being returned from the readCurrentVersionFromSourceManifest method and throw a clear user-facing error.
- */
-async function resolveCurrentVersionFromDisk(tree, projectGraphNode, versionActions, logger) {
-    if (!versionActions.validManifestFilenames?.length) {
-        throw new Error(`For project "${projectGraphNode.name}", the "currentVersionResolver" is set to "disk" but it is using "versionActions" of type "${versionActions.constructor.name}". This is invalid because "${versionActions.constructor.name}" does not support a manifest file. You should use a different "currentVersionResolver" or use a different "versionActions" implementation that supports a manifest file`);
-    }
-    const nullVersionError = new Error(`For project "${projectGraphNode.name}", the "currentVersionResolver" is set to "disk" and it is using "versionActions" of type "${versionActions.constructor.name}" which failed to resolve the current version from the manifest file on disk`);
-    try {
-        const res = await versionActions.readCurrentVersionFromSourceManifest(tree);
-        if (!res) {
-            throw nullVersionError;
-        }
-        const { currentVersion, manifestPath } = res;
-        logger.buffer(`📄 Resolved the current version as ${currentVersion} from manifest: ${manifestPath}`);
-        return currentVersion;
-    }
-    catch (err) {
-        if (err === nullVersionError) {
-            throw err;
-        }
-        throw new Error(`The project "${projectGraphNode.name}" does not have a ${versionActions.validManifestFilenames.join(' or ')} file available in ${projectGraphNode.data.root}
-
-To fix this you will either need to add a ${versionActions.validManifestFilenames.join(' or ')} file at that location, or configure "release" within your nx.json to use a different "currentVersionResolver" or "versionActions" implementation that supports this setup`);
-    }
-}
-async function resolveCurrentVersionFromRegistry(tree, projectGraphNode, releaseGroup, versionActions, logger, cachedCurrentVersionsPerFixedReleaseGroup, finalConfigForProject) {
-    /**
-     * In the case of fixed release groups that are configured to resolve the current version from a registry,
-     * it would be a waste of time and resources to make requests to the registry, or resolve one of the fallbacks,
-     * for each individual project, therefore we maintain a cache of the current version for each applicable release group here.
-     */
-    const cached = cachedCurrentVersionsPerFixedReleaseGroup.get(releaseGroup.name);
-    if (cached) {
-        const logText = cached.logText ? ` ${cached.logText}` : '';
-        logger.buffer(`🔄 Reusing the current version ${cached.currentVersion} already resolved for ${cached.originatingProjectName}${logText}`);
-        return cached.currentVersion;
-    }
-    let registryTxt = '';
-    // Skip non-TTY logging — the resolved version is reported through the
-    // project's batched `ProjectLogger` so the spinner step shouldn't emit an
-    // out-of-band line that would bypass the grouped output.
-    const spinner = spinner_1.globalSpinner.start(`Resolving the current version for ${projectGraphNode.name} from the configured registry...`, undefined, { skipNonTtyLogging: true });
-    try {
-        const res = await versionActions.readCurrentVersionFromRegistry(tree, finalConfigForProject.currentVersionResolverMetadata);
-        if (!res) {
-            // Not a user-facing error
-            throw new Error('Registry not applicable for this version actions implementation');
-        }
-        const { currentVersion, logText } = res;
-        spinner.stop();
-        registryTxt = logText?.length > 0 ? `: ${logText}` : '';
-        if (!currentVersion) {
-            // Not a user-facing error
-            throw new Error('No version found in the registry');
-        }
-        logger.buffer(`🔍 Resolved the current version as ${currentVersion} from the remote registry${registryTxt}`);
-        // Write to the cache if the release group is fixed
-        if (releaseGroup.projectsRelationship === 'fixed') {
-            cachedCurrentVersionsPerFixedReleaseGroup.set(releaseGroup.name, {
-                currentVersion,
-                originatingProjectName: projectGraphNode.name,
-                logText: `from the registry${registryTxt}`,
-            });
-        }
-        return currentVersion;
-    }
-    catch {
-        spinner.stop();
-        if (finalConfigForProject.fallbackCurrentVersionResolver === 'disk') {
-            if (!versionActions.validManifestFilenames?.length) {
-                throw new Error(`For project "${projectGraphNode.name}", the "currentVersionResolver" is set to "registry" with a "fallbackCurrentVersionResolver" of "disk" but it is using "versionActions" of type "${versionActions.constructor.name}". This is invalid because "${versionActions.constructor.name}" does not support a manifest file. You should use a different "fallbackCurrentVersionResolver" or use a different "versionActions" implementation that supports a manifest file`);
-            }
-            const fromDiskRes = await versionActions.readCurrentVersionFromSourceManifest(tree);
-            // Fallback on disk is available, return it directly
-            if (fromDiskRes && fromDiskRes.currentVersion) {
-                logger.buffer(`⚠️  Unable to resolve the current version from the registry${registryTxt}. Falling back to the version ${fromDiskRes.currentVersion} in manifest: ${fromDiskRes.manifestPath}`);
-                // Write to the cache if the release group is fixed
-                if (releaseGroup.projectsRelationship === 'fixed') {
-                    cachedCurrentVersionsPerFixedReleaseGroup.set(releaseGroup.name, {
-                        currentVersion: fromDiskRes.currentVersion,
-                        originatingProjectName: projectGraphNode.name,
-                        logText: `from the disk fallback`,
-                    });
-                }
-                return fromDiskRes.currentVersion;
-            }
-        }
-        // At this point the fallback on disk is also not available/configured, allow one final interactive fallback, but only when using version-plans or conventional-commits
-        if (finalConfigForProject.specifierSource === 'prompt') {
-            throw new Error(`Unable to resolve the current version from the registry${registryTxt}. Please ensure that the package exists in the registry in order to use the "registry" currentVersionResolver. Alternatively, you can use the --first-release option or set "release.version.fallbackCurrentVersionResolver" to "disk" in order to fallback to the version on disk when the registry lookup fails.`);
-        }
-        const currentVersionFromPromptFallback = await handleNoAvailableDiskFallback({
-            logger,
-            projectName: projectGraphNode.name,
-            versionActions,
-            specifierSource: finalConfigForProject.specifierSource,
-            currentVersionSourceMessage: `from the registry${registryTxt}`,
-            resolutionSuggestion: `you should publish an initial version to the registry`,
-        });
-        // Write to the cache if the release group is fixed
-        if (releaseGroup.projectsRelationship === 'fixed') {
-            cachedCurrentVersionsPerFixedReleaseGroup.set(releaseGroup.name, {
-                currentVersion: currentVersionFromPromptFallback,
-                originatingProjectName: projectGraphNode.name,
-                logText: `from the prompt fallback`,
-            });
-        }
-        return currentVersionFromPromptFallback;
-    }
-}
-async function resolveCurrentVersionFromGitTag(tree, projectGraphNode, releaseGroup, versionActions, logger, cachedCurrentVersionsPerFixedReleaseGroup, finalConfigForProject, releaseTagPattern, latestMatchingGitTag) {
-    /**
-     * In the case of fixed release groups that are configured to resolve the current version from a git tag,
-     * it would be a waste of time and resources to figure out the git tag, or resolve one of the fallbacks,
-     * for each individual project, therefore we maintain a cache of the current version for each applicable release group here.
-     */
-    const cached = cachedCurrentVersionsPerFixedReleaseGroup.get(releaseGroup.name);
-    if (cached) {
-        const logText = cached.logText ? ` ${cached.logText}` : '';
-        logger.buffer(`🔄 Reusing the current version ${cached.currentVersion} already resolved for ${cached.originatingProjectName}${logText}`);
-        return cached.currentVersion;
-    }
-    // The latest matching git tag was found in release-group-processor and has an extracted version, return it directly
-    if (latestMatchingGitTag && latestMatchingGitTag.extractedVersion) {
-        const currentVersion = latestMatchingGitTag.extractedVersion;
-        logger.buffer(`🏷️  Resolved the current version as ${currentVersion} from git tag "${latestMatchingGitTag.tag}", based on releaseTag.pattern "${releaseTagPattern}"`);
-        // Write to the cache if the release group is fixed
-        if (releaseGroup.projectsRelationship === 'fixed') {
-            cachedCurrentVersionsPerFixedReleaseGroup.set(releaseGroup.name, {
-                currentVersion,
-                originatingProjectName: projectGraphNode.name,
-                logText: `from git tag "${latestMatchingGitTag.tag}"`,
-            });
-        }
-        return currentVersion;
-    }
-    const noMatchingGitTagsError = new Error(`No git tags matching pattern "${releaseTagPattern}" for project "${projectGraphNode.name}" were found. You will need to create an initial matching tag to use as a base for determining the next version. Alternatively, you can use the --first-release option or set "release.version.fallbackCurrentVersionResolver" to "disk" in order to fallback to the version on disk when no matching git tags are found.`);
-    if (finalConfigForProject.fallbackCurrentVersionResolver !== 'disk') {
-        throw noMatchingGitTagsError;
-    }
-    const fromDiskRes = await versionActions.readCurrentVersionFromSourceManifest(tree);
-    // Fallback on disk is available, return it directly
-    if (fromDiskRes && fromDiskRes.currentVersion) {
-        logger.buffer(`⚠️  Unable to resolve the current version from git tags using pattern "${releaseTagPattern}". Falling back to the version ${fromDiskRes.currentVersion} in manifest: ${fromDiskRes.manifestPath}`);
-        // Write to the cache if the release group is fixed
-        if (releaseGroup.projectsRelationship === 'fixed') {
-            cachedCurrentVersionsPerFixedReleaseGroup.set(releaseGroup.name, {
-                currentVersion: fromDiskRes.currentVersion,
-                originatingProjectName: projectGraphNode.name,
-                logText: `from the disk fallback`,
-            });
-        }
-        return fromDiskRes.currentVersion;
-    }
-    // At this point the fallback on disk is also not available/configured, allow one final interactive fallback, but only when using version-plans or conventional-commits
-    if (finalConfigForProject.specifierSource === 'prompt') {
-        throw noMatchingGitTagsError;
-    }
-    const currentVersionFromPromptFallback = await handleNoAvailableDiskFallback({
-        logger,
-        projectName: projectGraphNode.name,
-        versionActions,
-        specifierSource: finalConfigForProject.specifierSource,
-        currentVersionSourceMessage: `from git tag using pattern "${releaseTagPattern}"`,
-        resolutionSuggestion: `you should set an initial git tag on a relevant commit`,
-    });
-    // Write to the cache if the release group is fixed
-    if (releaseGroup.projectsRelationship === 'fixed') {
-        cachedCurrentVersionsPerFixedReleaseGroup.set(releaseGroup.name, {
-            currentVersion: currentVersionFromPromptFallback,
-            originatingProjectName: projectGraphNode.name,
-            logText: `from the prompt fallback`,
-        });
-    }
-    return currentVersionFromPromptFallback;
-}
-/**
- * Allow users to be unblocked when locally running releases for the very first time with certain combinations that require an initial
- * version in order to function (e.g. a relative semver bump derived via conventional-commits or version-plans) by providing an interactive
- * prompt to let them opt into using 0.0.0 as the implied current version.
- */
-async function handleNoAvailableDiskFallback({ logger, projectName, versionActions, specifierSource, currentVersionSourceMessage, resolutionSuggestion, }) {
-    if (!versionActions.validManifestFilenames?.length) {
-        throw new Error(`Unable to resolve the current version ${currentVersionSourceMessage} and there is no version on disk to fall back to. This is invalid with ${specifierSource} because the new version is determined by relatively bumping the current version. To resolve this, ${resolutionSuggestion}, or set use a versionActions implementation that supports a manifest file`);
-    }
-    const validManifestFilenames = versionActions.validManifestFilenames.join(' or ');
-    const unresolvableCurrentVersionError = new Error(`Unable to resolve the current version ${currentVersionSourceMessage} and there is no version on disk to fall back to. This is invalid with ${specifierSource} because the new version is determined by relatively bumping the current version. To resolve this, ${resolutionSuggestion}, or set an appropriate version in a supported manifest file such as ${validManifestFilenames}`);
-    if (process.env.CI === 'true') {
-        // We can't prompt in CI, so error immediately
-        throw unresolvableCurrentVersionError;
-    }
-    try {
-        const useZero = await (0, prompt_helpers_1.confirmationPrompt)({
-            message: `\n${pc.yellow(`Warning: Unable to resolve the current version for "${projectName}" ${currentVersionSourceMessage} and there is no version on disk to fall back to. This is invalid with ${specifierSource} because the new version is determined by relatively bumping the current version.\n\nTo resolve this, ${resolutionSuggestion}, or set an appropriate version in a supported manifest file such as ${validManifestFilenames}`)}. \n\nAlternatively, would you like to continue now by using 0.0.0 as the current version?`,
-            initial: false,
-            onCancel: () => false,
-        });
-        if (!useZero) {
-            // Throw any error to skip the fallback to 0.0.0, may as well use the one we already have
-            throw unresolvableCurrentVersionError;
-        }
-        const currentVersion = '0.0.0';
-        logger.buffer(`⚠  Forcibly resolved the current version as "${currentVersion}" based on your response to the prompt above`);
-        return currentVersion;
-    }
-    catch {
-        throw unresolvableCurrentVersionError;
-    }
-}

package/dist/src/command-line/release/version/topological-sort.d.ts

@@ -1,9 +0,0 @@
-/**
- * Topologically sorts a directed graph, returning the sorted nodes.
- * Handles cycles by breaking them where needed.
- *
- * @param nodes All nodes in the graph
- * @param getEdges Function that returns outgoing edges for a node
- * @returns Topologically sorted list of nodes
- */
-export declare function topologicalSort<T>(nodes: T[], getEdges: (node: T) => T[]): T[];

package/dist/src/command-line/release/version/topological-sort.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.topologicalSort = topologicalSort;
-/**
- * Topologically sorts a directed graph, returning the sorted nodes.
- * Handles cycles by breaking them where needed.
- *
- * @param nodes All nodes in the graph
- * @param getEdges Function that returns outgoing edges for a node
- * @returns Topologically sorted list of nodes
- */
-function topologicalSort(nodes, getEdges) {
-    const result = [];
-    const visited = new Set();
-    const temp = new Set();
-    function visit(node) {
-        // Node is already in result
-        if (visited.has(node)) {
-            return;
-        }
-        // Cycle detected, skip this edge to break the cycle
-        if (temp.has(node)) {
-            return;
-        }
-        temp.add(node);
-        // Visit all dependencies first
-        for (const dep of getEdges(node)) {
-            visit(dep);
-        }
-        temp.delete(node);
-        visited.add(node);
-        result.push(node);
-    }
-    // Visit all nodes
-    for (const node of nodes) {
-        if (!visited.has(node)) {
-            visit(node);
-        }
-    }
-    return result;
-}

package/dist/src/command-line/release/version/version-actions.d.ts

@@ -1,224 +0,0 @@
-import { ReleaseType } from 'semver';
-import { NxReleaseVersionConfiguration } from '../../../config/nx-json';
-import type { ProjectGraph, ProjectGraphDependency, ProjectGraphProjectNode } from '../../../config/project-graph';
-import type { Tree } from '../../../generators/tree';
-import type { ReleaseGroupWithName } from '../config/filter-release-groups';
-import type { FinalConfigForProject } from '../utils/release-graph';
-export type SemverBumpType = ReleaseType | 'none';
-/**
- * Lazily resolves the concrete version of a dependency project that is not
- * already represented in `dependenciesToUpdate`.
- *
- * Ecosystem-specific VersionActions implementations can use this when a
- * manifest reference requires a concrete version but `dependenciesToUpdate`
- * does not contain one. The resolved value can be the dependency's new version
- * when it is part of the release, or its current version when it is not being
- * versioned.
- *
- * @public
- */
-export type ResolveVersionForDependency = (dependencyProjectName: string) => Promise<string>;
-/**
- * Implementation details of performing any actions after all projects have been versioned.
- * An example might be updating a workspace level lock file.
- *
- * NOTE: By the time this function is invoked, the tree will have been flushed back to disk,
- * so it is not accessible here.
- *
- * The function should return lists of changed and deleted files so that they can be staged
- * and committed if appropriate.
- *
- * NOTE: The versionActionsOptions passed here are the ones at the root of release.version config,
- * different values per release group or project will not be respected here because this takes
- * place after all projects have been versioned.
- */
-export type AfterAllProjectsVersioned = (cwd: string, opts: {
-    dryRun?: boolean;
-    verbose?: boolean;
-    rootVersionActionsOptions?: Record<string, unknown>;
-}) => Promise<{
-    changedFiles: string[];
-    deletedFiles: string[];
-}>;
-export declare function resolveVersionActionsForProject(tree: Tree, releaseGroup: ReleaseGroupWithName, projectGraphNode: ProjectGraphProjectNode, finalConfigForProject: FinalConfigForProject): Promise<{
-    versionActionsPath: string;
-    versionActions: VersionActions;
-    afterAllProjectsVersioned: AfterAllProjectsVersioned;
-}>;
-export declare abstract class VersionActions {
-    releaseGroup: ReleaseGroupWithName;
-    projectGraphNode: ProjectGraphProjectNode;
-    finalConfigForProject: FinalConfigForProject;
-    /**
-     * The available valid filenames of the manifest file relevant to the current versioning use-case.
-     *
-     * E.g. for JavaScript projects this would be ["package.json"], but for Gradle it would be
-     * ["build.gradle", "build.gradle.kts"].
-     *
-     * If a manifest file is not applicable to the current versioning use-case, this should be set to null.
-     */
-    abstract validManifestFilenames: string[] | null;
-    /**
-     * Whether manifests updated by this implementation should be excluded from
-     * the final Prettier pass performed by Nx Release.
-     *
-     * Custom implementations must opt in explicitly. This defaults to false so
-     * their existing formatting behavior does not change.
-     */
-    excludeManifestsFromFormatting: boolean;
-    /**
-     * The interpolated manifest paths to update, if applicable based on the user's configuration, when new
-     * versions and dependencies are determined. If no manifest files should be updated based on the user's
-     * configuration, this will be an empty array.
-     *
-     * The final value for preserveLocalDependencyProtocols will be based on the resolved config for the current
-     * project and any overrides from the user's configuration for the manifestRootsToUpdate.
-     */
-    manifestsToUpdate: {
-        manifestPath: string;
-        preserveLocalDependencyProtocols: boolean;
-    }[];
-    constructor(releaseGroup: ReleaseGroupWithName, projectGraphNode: ProjectGraphProjectNode, finalConfigForProject: FinalConfigForProject);
-    /**
-     * Asynchronous initialization of the version actions and resolution of manifest paths.
-     * Note: This does NOT validate that manifest files exist - that happens later in validate().
-     */
-    init(tree: Tree): Promise<void>;
-    /**
-     * Validates that manifest files actually exist.
-     * This will be called after all preVersionCommands have run.
-     */
-    validate(tree: Tree): Promise<void>;
-    /**
-     * The default implementation will calculate the new version based on semver. If semver is not applicable to a
-     * particular versioning use-case, this method should be overridden with custom logic.
-     *
-     * @param {string | null} currentVersion - The current version of the project, or null if the current version resolver is set to 'none'
-     * @param {string} newVersionInput - The new version input provided by the user, such as a semver relative bump type, or an explicit version
-     * @param {string} newVersionInputReason - The reason for the new version input used to inform the log message to show to the user
-     * @param {Record<string, unknown>} newVersionInputReasonData - The data to interpolate into the new version input reason
-     * @param {string} preid - The preid to use for the new version, if applicable
-     */
-    calculateNewVersion(currentVersion: string | null, newVersionInput: string, newVersionInputReason: string, newVersionInputReasonData: Record<string, unknown>, preid: string): Promise<{
-        newVersion: string;
-        logText: string;
-    }>;
-    /**
-     * Implementation details of resolving a project's current version from a valid manifest file. It should
-     * return an object with the current version and the filename of the resolved manifest path so that the
-     * logs provided to the user are as specific as possible.
-     *
-     * This method will only be called if the user has configured their currentVersionResolver to be "disk".
-     *
-     * If the version actions implementation does not support a manifest file, this method can either throw
-     * an error or return null. In this case, nx release will handle showing the user a relevant error about
-     * their currentVersionResolver configuration being fundamentally incompatible with the current version
-     * actions implementation resolved for the project being versioned and they can change it to something else
-     * (e.g. "registry" or "git-tag").
-     *
-     * NOTE: The version actions implementation does not need to provide the method for handling resolution
-     * from git tags, this is done directly by nx release.
-     */
-    abstract readCurrentVersionFromSourceManifest(tree: Tree): Promise<{
-        currentVersion: string;
-        manifestPath: string;
-    } | null>;
-    /**
-     * Implementation details of resolving a project's current version from a remote registry.
-     *
-     * The specific logText it returns will be combined with the generic remote registry log text and allows
-     * the implementation to provide more specific information to the user about what registry URL
-     * was used, what dist-tag etc.
-     *
-     * If the version actions implementation does not support resolving from a remote registry, this method
-     * can either throw an error or return null. In this case, nx release will handle showing the user a relevant
-     * error about their currentVersionResolver configuration being fundamentally incompatible with the current
-     * version actions implementation resolved for the project being versioned and they can change it to something
-     * else (e.g. "disk" or "git-tag").
-     *
-     * NOTE: The version actions implementation does not need to provide the method for handling resolution
-     * from git tags, this is done directly by nx release.
-     */
-    abstract readCurrentVersionFromRegistry(tree: Tree, currentVersionResolverMetadata: NxReleaseVersionConfiguration['currentVersionResolverMetadata']): Promise<{
-        currentVersion: string | null;
-        logText: string;
-    } | null>;
-    /**
-     * Implementation details of resolving the dependencies of a project.
-     *
-     * The default implementation will read dependencies from the Nx project graph. In many cases this will be sufficient,
-     * because the project graph will have been constructed using plugins from relevant ecosystems that should have applied
-     * any and all relevant metadata to the project nodes and dependency edges.
-     *
-     * If, however, the project graph cannot be used as the source of truth for whatever reason, then this default method
-     * can simply be overridden in the final version actions implementation.
-     */
-    readDependencies(tree: Tree, projectGraph: ProjectGraph): Promise<ProjectGraphDependency[]>;
-    /**
-     * Implementation details of resolving the current version of a specific dependency of the project.
-     *
-     * The dependency collection is the type of dependency collection to which the dependency belongs, such as 'dependencies',
-     * 'devDependencies', 'peerDependencies', 'optionalDependencies', etc. This is ecosystem and use-case specific.
-     *
-     * The currentVersion and dependencyCollection fields will be used to populate the rawVersionSpec and dependencyCollection
-     * fields on the VersionData that gets returned from the programmatic API. `null` values are accepted for these if the current
-     * version or dependencyCollection is not applicable/resolvable at all, but they should be provided if possible.
-     *
-     * The currentVersion will also be used when calculating the final versionPrefix to apply for the new dependency
-     * version, based on the user's configuration, if applicable.
-     */
-    abstract readCurrentVersionOfDependency(tree: Tree, projectGraph: ProjectGraph, dependencyProjectName: string): Promise<{
-        currentVersion: string | null;
-        dependencyCollection: string | null;
-    }>;
-    /**
-     * Implementation details of updating a newly derived version in some source of truth.
-     *
-     * For libraries/packages, this will usually involve writing to one or more manifest files
-     * (e.g. potentially both src and dist), such as a package.json/Cargo.toml/etc, but for
-     * application deployments it might involve updating something else instead, it depends on
-     * the type of application.
-     *
-     * It should return an array of log messages that will be displayed unmodified to the user
-     * after the version has been updated.
-     */
-    abstract updateProjectVersion(tree: Tree, newVersion: string): Promise<string[]>;
-    /**
-     * Implementation details of updating dependencies in some source of truth.
-     *
-     * For libraries/packages, this will usually involve writing to one or more manifest files
-     * (e.g. potentially both src and dist), such as a package.json/Cargo.toml/etc,
-     * with new dependency versions, but for application deployments it might involve
-     * updating something else instead, it depends on the type of application.
-     *
-     * `resolveVersionForDependency` is intentionally lazy: implementations
-     * decide which manifest values require a concrete version, while release core
-     * remains unaware of ecosystem-specific dependency protocols.
-     *
-     * It should return an array of log messages that will be displayed unmodified to the user
-     * after the dependencies have been updated.
-     */
-    abstract updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>, resolveVersionForDependency?: ResolveVersionForDependency): Promise<string[]>;
-}
-export declare class NOOP_VERSION_ACTIONS extends VersionActions {
-    validManifestFilenames: any;
-    validate(tree: Tree): Promise<void>;
-    readCurrentVersionFromRegistry(tree: Tree, currentVersionResolverMetadata: NxReleaseVersionConfiguration['currentVersionResolverMetadata']): Promise<{
-        currentVersion: string | null;
-        logText: string;
-    } | null>;
-    readCurrentVersionFromSourceManifest(tree: Tree): Promise<{
-        currentVersion: string;
-        manifestPath: string;
-    } | null>;
-    readCurrentVersionOfDependency(tree: Tree, projectGraph: ProjectGraph, dependencyProjectName: string): Promise<{
-        currentVersion: string | null;
-        dependencyCollection: string | null;
-    }>;
-    calculateNewVersion(currentVersion: string | null, newVersionInput: string, newVersionInputReason: string, newVersionInputReasonData: Record<string, unknown>, preid: string): Promise<{
-        newVersion: string;
-        logText: string;
-    }>;
-    updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>, resolveVersionForDependency?: ResolveVersionForDependency): Promise<string[]>;
-    updateProjectVersion(tree: Tree, newVersion: string): Promise<string[]>;
-}