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

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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,240 @@
+"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

@@ -0,0 +1,9 @@
+/**
+ * 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

@@ -0,0 +1,41 @@
+"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

@@ -0,0 +1,227 @@
+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.
+ *
+ * When the project is not configured for Nx Release, the returned promise
+ * rejects with an error whose `code` is `NX_RELEASE_PROJECT_NOT_CONFIGURED`.
+ *
+ * @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[]>;
+}