nx 20.8.4 → 22.7.7

package/src/command-line/release/utils/shared.d.ts

@@ -1,47 +0,0 @@
-import { ProjectGraph } from '../../../config/project-graph';
-import type { ReleaseGroupWithName } from '../config/filter-release-groups';
-import { GitCommit } from './git';
-export declare const noDiffInChangelogMessage: string;
-export type VersionData = Record<string, VersionDataEntry>;
-export interface VersionDataEntry {
-    currentVersion: string;
-    /**
-     * newVersion will be null in the case that no changes are detected for the project,
-     * e.g. when using conventional commits
-     */
-    newVersion: string | null;
-    /**
-     * The list of projects which depend upon the current project.
-     */
-    dependentProjects: {
-        source: string;
-        target: string;
-        type: string;
-        dependencyCollection: string;
-        rawVersionSpec: string;
-    }[];
-}
-export declare class ReleaseVersion {
-    rawVersion: string;
-    gitTag: string;
-    isPrerelease: boolean;
-    constructor({ version, // short form version string with no prefixes or patterns, e.g. 1.0.0
-    releaseTagPattern, // full pattern to interpolate, e.g. "v{version}" or "{projectName}@{version}"
-    projectName, }: {
-        version: string;
-        releaseTagPattern: string;
-        projectName?: string;
-    });
-}
-export declare function commitChanges({ changedFiles, deletedFiles, isDryRun, isVerbose, gitCommitMessages, gitCommitArgs, }: {
-    changedFiles?: string[];
-    deletedFiles?: string[];
-    isDryRun?: boolean;
-    isVerbose?: boolean;
-    gitCommitMessages?: string[];
-    gitCommitArgs?: string | string[];
-}): Promise<void>;
-export declare function createCommitMessageValues(releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>, versionData: VersionData, commitMessage: string): string[];
-export declare function createGitTagValues(releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>, versionData: VersionData): string[];
-export declare function handleDuplicateGitTags(gitTagValues: string[]): void;
-export declare function getCommitsRelevantToProjects(projectGraph: ProjectGraph, commits: GitCommit[], projects: string[]): Promise<GitCommit[]>;

package/src/command-line/release/utils/shared.js

@@ -1,219 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReleaseVersion = exports.noDiffInChangelogMessage = void 0;
-exports.commitChanges = commitChanges;
-exports.createCommitMessageValues = createCommitMessageValues;
-exports.createGitTagValues = createGitTagValues;
-exports.handleDuplicateGitTags = handleDuplicateGitTags;
-exports.getCommitsRelevantToProjects = getCommitsRelevantToProjects;
-const chalk = require("chalk");
-const semver_1 = require("semver");
-const file_map_utils_1 = require("../../../project-graph/file-map-utils");
-const utils_1 = require("../../../tasks-runner/utils");
-const output_1 = require("../../../utils/output");
-const git_1 = require("./git");
-exports.noDiffInChangelogMessage = chalk.yellow(`NOTE: There was no diff detected for the changelog entry. Maybe you intended to pass alternative git references via --from and --to?`);
-function isPrerelease(version) {
-    // prerelease returns an array of matching prerelease "components", or null if the version is not a prerelease
-    return (0, semver_1.prerelease)(version) !== null;
-}
-class ReleaseVersion {
-    constructor({ version, // short form version string with no prefixes or patterns, e.g. 1.0.0
-    releaseTagPattern, // full pattern to interpolate, e.g. "v{version}" or "{projectName}@{version}"
-    projectName, // optional project name to interpolate into the releaseTagPattern
-     }) {
-        this.rawVersion = version;
-        this.gitTag = (0, utils_1.interpolate)(releaseTagPattern, {
-            version,
-            projectName,
-        });
-        this.isPrerelease = isPrerelease(version);
-    }
-}
-exports.ReleaseVersion = ReleaseVersion;
-async function commitChanges({ changedFiles, deletedFiles, isDryRun, isVerbose, gitCommitMessages, gitCommitArgs, }) {
-    if (!changedFiles?.length && !deletedFiles?.length) {
-        throw new Error('Error: No changed files to commit');
-    }
-    output_1.output.logSingleLine(`Committing changes with git`);
-    await (0, git_1.gitAdd)({
-        changedFiles,
-        deletedFiles,
-        dryRun: isDryRun,
-        verbose: isVerbose,
-    });
-    // The extra logs need something breathing room
-    if (isVerbose) {
-        console.log('');
-    }
-    await (0, git_1.gitCommit)({
-        messages: gitCommitMessages,
-        additionalArgs: gitCommitArgs,
-        dryRun: isDryRun,
-        verbose: isVerbose,
-    });
-}
-function createCommitMessageValues(releaseGroups, releaseGroupToFilteredProjects, versionData, commitMessage) {
-    const commitMessageValues = [commitMessage];
-    if (releaseGroups.length === 0) {
-        return commitMessageValues;
-    }
-    // If we have exactly one release group, with a fixed relationship, then interpolate {version} as the new version for the release group
-    if (releaseGroups.length === 1 &&
-        releaseGroups[0].projectsRelationship === 'fixed') {
-        const releaseGroup = releaseGroups[0];
-        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
-        const projectVersionData = versionData[releaseGroupProjectNames[0]]; // all at the same version, so we can just pick the first one
-        const releaseVersion = new ReleaseVersion({
-            version: projectVersionData.newVersion,
-            releaseTagPattern: releaseGroup.releaseTagPattern,
-        });
-        commitMessageValues[0] = (0, utils_1.interpolate)(commitMessageValues[0], {
-            version: releaseVersion.rawVersion,
-        }).trim();
-        return commitMessageValues;
-    }
-    /**
-     * There is another special case for interpolation: if, after all filtering, we have a single independent release group with a single project,
-     * and the user has provided {projectName} within the custom message.
-     * In this case we will directly interpolate both {version} and {projectName} within the commit message.
-     */
-    if (releaseGroups.length === 1 &&
-        releaseGroups[0].projectsRelationship === 'independent' &&
-        commitMessage.includes('{projectName}')) {
-        const releaseGroup = releaseGroups[0];
-        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
-        if (releaseGroupProjectNames.length === 1) {
-            const projectVersionData = versionData[releaseGroupProjectNames[0]];
-            const releaseVersion = new ReleaseVersion({
-                version: projectVersionData.newVersion,
-                releaseTagPattern: releaseGroup.releaseTagPattern,
-                projectName: releaseGroupProjectNames[0],
-            });
-            commitMessageValues[0] = (0, utils_1.interpolate)(commitMessageValues[0], {
-                version: releaseVersion.rawVersion,
-                projectName: releaseGroupProjectNames[0],
-            }).trim();
-            return commitMessageValues;
-        }
-    }
-    /**
-     * At this point we have multiple release groups for a single commit, we will not interpolate an overall {version} or {projectName} because that won't be
-     * appropriate (for any {version} or {projectName} value within the string, we will replace it with an empty string so that it doesn't end up in the final output).
-     *
-     * Instead for fixed groups we will add one bullet point the release group, and for independent groups we will add one bullet point per project.
-     */
-    commitMessageValues[0] = stripPlaceholders(commitMessageValues[0], [
-        // for cleanest possible final result try and replace the common pattern of a v prefix in front of the version first
-        'v{version}',
-        '{version}',
-        '{projectName}',
-    ]);
-    for (const releaseGroup of releaseGroups) {
-        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
-        // One entry per project for independent groups
-        if (releaseGroup.projectsRelationship === 'independent') {
-            for (const project of releaseGroupProjectNames) {
-                const projectVersionData = versionData[project];
-                if (projectVersionData.newVersion !== null) {
-                    const releaseVersion = new ReleaseVersion({
-                        version: projectVersionData.newVersion,
-                        releaseTagPattern: releaseGroup.releaseTagPattern,
-                        projectName: project,
-                    });
-                    commitMessageValues.push(`- project: ${project} ${releaseVersion.rawVersion}`);
-                }
-            }
-            continue;
-        }
-        // One entry for the whole group for fixed groups
-        const projectVersionData = versionData[releaseGroupProjectNames[0]]; // all at the same version, so we can just pick the first one
-        if (projectVersionData.newVersion !== null) {
-            const releaseVersion = new ReleaseVersion({
-                version: projectVersionData.newVersion,
-                releaseTagPattern: releaseGroup.releaseTagPattern,
-            });
-            commitMessageValues.push(`- release-group: ${releaseGroup.name} ${releaseVersion.rawVersion}`);
-        }
-    }
-    return commitMessageValues;
-}
-function stripPlaceholders(str, placeholders) {
-    for (const placeholder of placeholders) {
-        // for cleanest possible final result try and replace relevant spacing around placeholders first
-        str = str
-            .replace(` ${placeholder}`, '')
-            .replace(`${placeholder} `, '')
-            .replace(placeholder, '')
-            .trim();
-    }
-    return str;
-}
-function createGitTagValues(releaseGroups, releaseGroupToFilteredProjects, versionData) {
-    const tags = [];
-    for (const releaseGroup of releaseGroups) {
-        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
-        // For independent groups we want one tag per project, not one for the overall group
-        if (releaseGroup.projectsRelationship === 'independent') {
-            for (const project of releaseGroupProjectNames) {
-                const projectVersionData = versionData[project];
-                if (projectVersionData.newVersion !== null) {
-                    tags.push((0, utils_1.interpolate)(releaseGroup.releaseTagPattern, {
-                        version: projectVersionData.newVersion,
-                        projectName: project,
-                    }));
-                }
-            }
-            continue;
-        }
-        // For fixed groups we want one tag for the overall group
-        const projectVersionData = versionData[releaseGroupProjectNames[0]]; // all at the same version, so we can just pick the first one
-        if (projectVersionData.newVersion !== null) {
-            tags.push((0, utils_1.interpolate)(releaseGroup.releaseTagPattern, {
-                version: projectVersionData.newVersion,
-                releaseGroupName: releaseGroup.name,
-            }));
-        }
-    }
-    return tags;
-}
-function findDuplicates(arr) {
-    const seen = new Set();
-    const duplicates = new Set();
-    for (const item of arr) {
-        if (seen.has(item)) {
-            duplicates.add(item);
-        }
-        else {
-            seen.add(item);
-        }
-    }
-    return Array.from(duplicates);
-}
-function handleDuplicateGitTags(gitTagValues) {
-    // If any of the gitTagValues are identical we should hard error upfront to avoid an awkward git error later
-    const duplicateGitTagValues = findDuplicates(gitTagValues);
-    if (duplicateGitTagValues.length) {
-        output_1.output.error({
-            title: `Your current configuration would generate the following duplicate git tags:`,
-            bodyLines: [
-                ...duplicateGitTagValues.map((v) => `- ${v}`),
-                '',
-                `Please ensure that for "independent" release groups the {projectName} placeholder is used so that all dynamically created project tags are unique.`,
-            ],
-        });
-        process.exit(1);
-    }
-}
-async function getCommitsRelevantToProjects(projectGraph, commits, projects) {
-    const { fileMap } = await (0, file_map_utils_1.createFileMapUsingProjectGraph)(projectGraph);
-    const filesInReleaseGroup = new Set(projects.reduce((files, p) => [...files, ...fileMap.projectFileMap[p].map((f) => f.file)], []));
-    /**
-     * The relevant commits are those that either:
-     * - touch project files which are contained within the list of projects directly
-     * - touch non-project files and the commit is not scoped
-     */
-    return commits.filter((c) => c.affectedFiles.some((f) => filesInReleaseGroup.has(f) ||
-        (!c.scope &&
-            fileMap.nonProjectFiles.some((nonProjectFile) => nonProjectFile.file === f))));
-}

package/src/command-line/release/version/derive-specifier-from-conventional-commits.d.ts

@@ -1,7 +0,0 @@
-import type { ProjectGraph, ProjectGraphProjectNode } from '../../../config/project-graph';
-import { NxReleaseConfig } from '../config/config';
-import { ReleaseGroupWithName } from '../config/filter-release-groups';
-import { getLatestGitTagForPattern } from '../utils/git';
-import { ProjectLogger } from './project-logger';
-import { SemverBumpType } from './version-actions';
-export declare function deriveSpecifierFromConventionalCommits(nxReleaseConfig: NxReleaseConfig, projectGraph: ProjectGraph, projectLogger: ProjectLogger, releaseGroup: ReleaseGroupWithName, projectGraphNode: ProjectGraphProjectNode, isPrerelease: boolean, latestMatchingGitTag: Awaited<ReturnType<typeof getLatestGitTagForPattern>> | undefined, fallbackCurrentVersionResolver?: 'disk', preid?: string): Promise<SemverBumpType>;

package/src/command-line/release/version/derive-specifier-from-conventional-commits.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deriveSpecifierFromConventionalCommits = deriveSpecifierFromConventionalCommits;
-const git_1 = require("../utils/git");
-const resolve_semver_specifier_1 = require("../utils/resolve-semver-specifier");
-async function deriveSpecifierFromConventionalCommits(nxReleaseConfig, projectGraph, projectLogger, releaseGroup, projectGraphNode, 
-// NOTE: This TODO was carried over from the original version generator.
-//
-// TODO: reevaluate this prerelease logic/workflow for independent projects
-// Always assume that if the current version is a prerelease, then the next version should be a prerelease.
-// Users must manually graduate from a prerelease to a release by providing an explicit specifier.
-isPrerelease, latestMatchingGitTag, fallbackCurrentVersionResolver, preid) {
-    const affectedProjects = releaseGroup.projectsRelationship === 'independent'
-        ? [projectGraphNode.name]
-        : releaseGroup.projects;
-    // latestMatchingGitTag will be undefined if the current version was resolved from the disk fallback.
-    // In this case, we want to use the first commit as the ref to be consistent with the changelog command.
-    const previousVersionRef = latestMatchingGitTag
-        ? latestMatchingGitTag.tag
-        : fallbackCurrentVersionResolver === 'disk'
-            ? await (0, git_1.getFirstGitCommit)()
-            : undefined;
-    if (!previousVersionRef) {
-        // This should never happen since the checks above should catch if the current version couldn't be resolved
-        throw new Error(`Unable to determine previous version ref for the projects ${affectedProjects.join(', ')}. This is likely a bug in Nx.`);
-    }
-    let specifier = await (0, resolve_semver_specifier_1.resolveSemverSpecifierFromConventionalCommits)(previousVersionRef, projectGraph, affectedProjects, nxReleaseConfig.conventionalCommits);
-    if (!specifier) {
-        projectLogger.buffer(`🚫 No changes were detected using git history and the conventional commits standard`);
-        return 'none';
-    }
-    // NOTE: This TODO was carried over from the original version generator.
-    // TODO: reevaluate this prerelease logic/workflow for independent projects
-    if (isPrerelease) {
-        specifier = 'prerelease';
-        projectLogger.buffer(`📄 Resolved the specifier as "${specifier}" since the current version is a prerelease`);
-    }
-    else {
-        let extraText = '';
-        if (preid && !specifier.startsWith('pre')) {
-            specifier = `pre${specifier}`;
-            extraText = `, combined with your given preid "${preid}"`;
-        }
-        projectLogger.buffer(`📄 Resolved the specifier as "${specifier}" using git history and the conventional commits standard${extraText}`);
-    }
-    return specifier;
-}

package/src/command-line/release/version/project-logger.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectLogger = void 0;
-const chalk = require("chalk");
-const output_1 = require("../../../utils/output");
-const colors = [
-    { instance: chalk.green, spinnerColor: 'green' },
-    { instance: chalk.greenBright, spinnerColor: 'green' },
-    { instance: chalk.red, spinnerColor: 'red' },
-    { instance: chalk.redBright, spinnerColor: 'red' },
-    { instance: chalk.cyan, spinnerColor: 'cyan' },
-    { instance: chalk.cyanBright, spinnerColor: 'cyan' },
-    { instance: chalk.yellow, spinnerColor: 'yellow' },
-    { instance: chalk.yellowBright, spinnerColor: 'yellow' },
-    { instance: chalk.magenta, spinnerColor: 'magenta' },
-    { instance: chalk.magentaBright, spinnerColor: 'magenta' },
-];
-function getColor(projectName) {
-    let code = 0;
-    for (let i = 0; i < projectName.length; ++i) {
-        code += projectName.charCodeAt(i);
-    }
-    const colorIndex = code % colors.length;
-    return colors[colorIndex];
-}
-class ProjectLogger {
-    constructor(projectName) {
-        this.projectName = projectName;
-        this.logs = [];
-        this.color = getColor(projectName);
-    }
-    buffer(msg) {
-        this.logs.push(msg);
-    }
-    flush() {
-        if (this.logs.length === 0) {
-            return;
-        }
-        output_1.output.logSingleLine(`Running release version for project: ${this.color.instance.bold(this.projectName)}`);
-        this.logs.forEach((msg) => {
-            console.log(this.color.instance.bold(this.projectName) + ' ' + msg);
-        });
-    }
-}
-exports.ProjectLogger = ProjectLogger;

package/src/command-line/release/version/release-group-processor.d.ts

@@ -1,251 +0,0 @@
-import { NxReleaseVersionV2Configuration } from '../../../config/nx-json';
-import { ProjectGraph } from '../../../config/project-graph';
-import { Tree } from '../../../generators/tree';
-import { type NxReleaseConfig } from '../config/config';
-import type { ReleaseGroupWithName } from '../config/filter-release-groups';
-import type { VersionData } from '../utils/shared';
-/**
- * The final configuration for a project after applying release group and project level overrides,
- * as well as default values. This will be passed to the relevant version actions implementation,
- * and referenced throughout the versioning process.
- */
-export interface FinalConfigForProject {
-    specifierSource: NxReleaseVersionV2Configuration['specifierSource'];
-    currentVersionResolver: NxReleaseVersionV2Configuration['currentVersionResolver'];
-    currentVersionResolverMetadata: NxReleaseVersionV2Configuration['currentVersionResolverMetadata'];
-    fallbackCurrentVersionResolver: NxReleaseVersionV2Configuration['fallbackCurrentVersionResolver'];
-    versionPrefix: NxReleaseVersionV2Configuration['versionPrefix'];
-    preserveLocalDependencyProtocols: NxReleaseVersionV2Configuration['preserveLocalDependencyProtocols'];
-    versionActionsOptions: NxReleaseVersionV2Configuration['versionActionsOptions'];
-    manifestRootsToUpdate: NxReleaseVersionV2Configuration['manifestRootsToUpdate'];
-}
-export declare const BUMP_TYPE_REASON_TEXT: {
-    readonly DEPENDENCY_WAS_BUMPED: ", because a dependency was bumped, ";
-    readonly USER_SPECIFIER: ", from the given specifier, ";
-    readonly PROMPTED_USER_SPECIFIER: ", from the prompted specifier, ";
-    readonly CONVENTIONAL_COMMITS: ", derived from conventional commits data, ";
-    readonly VERSION_PLANS: ", read from version plan {versionPlanPath}, ";
-    readonly DEPENDENCY_ACROSS_GROUPS_WAS_BUMPED: ", because a dependency project belonging to another release group was bumped, ";
-    readonly OTHER_PROJECT_IN_FIXED_GROUP_WAS_BUMPED_DUE_TO_DEPENDENCY: ", because of a dependency-only bump to another project in the same fixed release group, ";
-};
-interface ReleaseGroupProcessorOptions {
-    dryRun: boolean;
-    verbose: boolean;
-    firstRelease: boolean;
-    preid: string;
-    userGivenSpecifier?: string;
-    projectsToProcess?: string[];
-    /**
-     * The optional results of applying the --project or --group filters.
-     * These will be empty if there is no filtering, or contain the subset of projects or groups that
-     * are being versioned if one of the (mutually exclusive) filters is set.
-     */
-    filters: {
-        projects?: string[];
-        groups?: string[];
-    };
-}
-export declare class ReleaseGroupProcessor {
-    private tree;
-    private projectGraph;
-    private nxReleaseConfig;
-    private releaseGroups;
-    private releaseGroupToFilteredProjects;
-    private options;
-    /**
-     * Stores the relationships between release groups, including their dependencies
-     * and dependents. This is used for determining processing order and propagating
-     * version changes between related groups.
-     */
-    private groupGraph;
-    /**
-     * Tracks which release groups have already been processed to avoid
-     * processing them multiple times. Used during the group traversal.
-     */
-    private processedGroups;
-    /**
-     * Keeps track of which projects have already had their versions bumped.
-     * This is used to avoid redundant version bumping and to determine which
-     * projects need their dependencies updated.
-     */
-    private bumpedProjects;
-    /**
-     * Cache of release groups sorted in topological order to ensure dependencies
-     * are processed before dependents. Computed once and reused throughout processing.
-     */
-    private sortedReleaseGroups;
-    /**
-     * Maps each release group to its projects sorted in topological order.
-     * Ensures projects are processed after their dependencies within each group.
-     */
-    private sortedProjects;
-    /**
-     * Track the unique afterAllProjectsVersioned functions involved in the current versioning process,
-     * so that we can ensure they are only invoked once per versioning execution.
-     */
-    private uniqueAfterAllProjectsVersioned;
-    /**
-     * Track the versionActions for each project so that we can invoke certain instance methods.
-     */
-    private projectsToVersionActions;
-    /**
-     * versionData that will ultimately be returned to the nx release version handler by getVersionData()
-     */
-    private versionData;
-    /**
-     * Set of all projects that are configured in the nx release config.
-     * Used to validate dependencies and identify projects that should be updated.
-     */
-    private allProjectsConfiguredForNxRelease;
-    /**
-     * Set of projects that will be processed in the current run.
-     * This is potentially a subset of allProjectsConfiguredForNxRelease based on filters
-     * and dependency relationships.
-     */
-    private allProjectsToProcess;
-    /**
-     * If the user provided a specifier at the time of versioning we store it here so that it can take priority
-     * over any configuration.
-     */
-    private userGivenSpecifier;
-    /**
-     * Caches the current version of each project to avoid repeated disk/registry/git tag lookups.
-     * Often used during new version calculation. Will be null if the current version resolver is set to 'none'.
-     */
-    private cachedCurrentVersions;
-    /**
-     * Caches git tag information for projects that resolve their version from git tags.
-     * This avoids performing expensive git operations multiple times for the same project.
-     */
-    private cachedLatestMatchingGitTag;
-    /**
-     * Temporary storage for dependent project names while building the dependency graph.
-     * This is used as an intermediate step before creating the full dependent projects data.
-     */
-    private tmpCachedDependentProjects;
-    /**
-     * Resolve the data regarding dependent projects for each project upfront so that it remains accurate
-     * even after updates are applied to manifests.
-     */
-    private originalDependentProjectsPerProject;
-    /**
-     * In the case of fixed release groups that are configured to resolve the current version from a registry
-     * or a git tag, it would be a waste of time and resources to resolve the current version for each individual
-     * project, therefore we maintain a cache of the current version for each applicable fixed release group here.
-     */
-    private currentVersionsPerFixedReleaseGroup;
-    /**
-     * Cache of project loggers for each project.
-     */
-    private projectLoggers;
-    /**
-     * Track any version plan files that have been processed so that we can delete them after versioning is complete,
-     * while leaving any unprocessed files in place.
-     */
-    private processedVersionPlanFiles;
-    /**
-     * Certain configuration options can be overridden at the project level, and otherwise fall back to the release group level.
-     * Many also have a specific default value if nothing is set at either level. To avoid applying this hierarchy for each project
-     * every time such a configuration option is needed, we cache the result per project here.
-     */
-    private finalConfigsByProject;
-    /**
-     * Maps each project to its release group for quick O(1) lookups.
-     * This avoids having to scan through all release groups to find a project.
-     */
-    private projectToReleaseGroup;
-    /**
-     * Maps each project to its dependents (projects that depend on it).
-     * This is the inverse of the projectToDependencies map and enables
-     * efficient lookup of dependent projects for propagating version changes.
-     */
-    private projectToDependents;
-    /**
-     * Maps each project to its dependencies (projects it depends on).
-     * Used for building dependency graphs and determining processing order.
-     */
-    private projectToDependencies;
-    /**
-     * Caches the updateDependents setting for each project to avoid repeated
-     * lookups and calculations. This determines if dependent projects should
-     * be automatically updated when a dependency changes.
-     */
-    private projectToUpdateDependentsSetting;
-    constructor(tree: Tree, projectGraph: ProjectGraph, nxReleaseConfig: NxReleaseConfig, releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>, options: ReleaseGroupProcessorOptions);
-    /**
-     * Initialize the processor by building the group graph and preparing for processing.
-     * This method must be called before processGroups().
-     */
-    init(): Promise<void>;
-    /**
-     * Setup mapping from project to release group and cache updateDependents settings
-     */
-    private setupProjectReleaseGroupMapping;
-    /**
-     * Determine which projects should be processed and resolve their version actions
-     */
-    private setupProjectsToProcess;
-    /**
-     * Find all dependents that should be processed due to dependency updates
-     */
-    private findDependentsToProcess;
-    private buildGroupDependencyGraph;
-    private populateDependentProjectsData;
-    getReleaseGroupNameForProject(projectName: string): string | null;
-    getNextGroup(): string | null;
-    processGroups(): Promise<string[]>;
-    flushAllProjectLoggers(): void;
-    deleteProcessedVersionPlanFiles(): void;
-    getVersionData(): VersionData;
-    /**
-     * Invoke the afterAllProjectsVersioned functions for each unique versionActions type.
-     * This can be useful for performing actions like updating a workspace level lock file.
-     *
-     * Because the tree has already been flushed to disk at this point, each afterAllProjectsVersioned
-     * function is responsible for returning the list of changed and deleted files that it affected.
-     *
-     * The root level `release.version.versionActionsOptions` is what is passed in here because this
-     * is a one time action for the whole workspace. Release group and project level overrides are
-     * not applicable.
-     */
-    afterAllProjectsVersioned(rootVersionActionsOptions: Record<string, unknown>): Promise<{
-        changedFiles: string[];
-        deletedFiles: string[];
-    }>;
-    private processGroup;
-    private propagateChangesToDependentGroups;
-    private bumpVersions;
-    private bumpFixedVersionGroup;
-    private bumpIndependentVersionGroup;
-    private determineVersionBumpForProject;
-    private getVersionActionsForProject;
-    private getFinalConfigForProject;
-    private getProjectLoggerForProject;
-    private getCurrentCachedVersionForProject;
-    private getCachedFinalConfigForProject;
-    /**
-     * Apply project and release group precedence and default values, as well as validate the final configuration,
-     * ready to be cached.
-     */
-    private resolveFinalConfigForProject;
-    private calculateNewVersion;
-    private updateDependenciesForProject;
-    private bumpVersionForProject;
-    private updateDependenciesForDependents;
-    private getOriginalDependentProjects;
-    private propagateChanges;
-    private getFixedReleaseGroupBumpType;
-    private determineSideEffectBump;
-    private getProjectDependents;
-    private getAllNonImplicitDependents;
-    private getNonImplicitDependentsForProject;
-    private hasAutoUpdateDependents;
-    private topologicallySortReleaseGroups;
-    private topologicallySortProjects;
-    /**
-     * Precompute project -> dependents/dependencies relationships for O(1) lookups
-     */
-    private precomputeDependencyRelationships;
-    private getProjectDependencies;
-}
-export {};