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

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

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReleaseVersion = exports.noDiffInChangelogMessage = void 0;
+exports.isPrerelease = isPrerelease;
+exports.commitChanges = commitChanges;
+exports.createCommitMessageValues = createCommitMessageValues;
+exports.shouldPreferDockerVersionForReleaseGroup = shouldPreferDockerVersionForReleaseGroup;
+exports.shouldSkipVersionActions = shouldSkipVersionActions;
+exports.createGitTagValues = createGitTagValues;
+exports.handleDuplicateGitTags = handleDuplicateGitTags;
+exports.getCommitsRelevantToProjects = getCommitsRelevantToProjects;
+const tslib_1 = require("tslib");
+const pc = tslib_1.__importStar(require("picocolors"));
+const semver_1 = require("semver");
+const utils_1 = require("../../../tasks-runner/utils");
+const output_1 = require("../../../utils/output");
+const git_1 = require("./git");
+const find_matching_projects_1 = require("../../../utils/find-matching-projects");
+exports.noDiffInChangelogMessage = pc.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
+    try {
+        return (0, semver_1.prerelease)(version) !== null;
+    }
+    catch {
+        // If non-semver, prerelease will error. Prevent this from erroring the command
+        return false;
+    }
+}
+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
+    releaseGroupName, // optional release group name to interpolate into the releaseTagPattern
+     }) {
+        this.rawVersion = version;
+        this.gitTag = (0, utils_1.interpolate)(releaseTagPattern, {
+            version,
+            projectName: projectName
+                ? (0, git_1.sanitizeProjectNameForGitTag)(projectName)
+                : projectName,
+            releaseGroupName,
+        });
+        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.releaseTag.pattern,
+            releaseGroupName: releaseGroup.name,
+        });
+        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.releaseTag.pattern,
+                projectName: releaseGroupProjectNames[0],
+                releaseGroupName: releaseGroup.name,
+            });
+            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) {
+        // One entry per project for independent groups
+        if (releaseGroup.projectsRelationship === 'independent') {
+            // Include all projects in the release group that were actually versioned,
+            // not just the explicitly filtered ones. This ensures dependent projects
+            // that received side-effect bumps are included in the commit message.
+            const versionedProjects = releaseGroup.projects.filter((p) => versionData[p] != null && versionData[p].newVersion !== null);
+            for (const project of versionedProjects) {
+                const projectVersionData = versionData[project];
+                if (projectVersionData.newVersion !== null) {
+                    const releaseVersion = new ReleaseVersion({
+                        version: projectVersionData.newVersion,
+                        releaseTagPattern: releaseGroup.releaseTag.pattern,
+                        projectName: project,
+                        releaseGroupName: releaseGroup.name,
+                    });
+                    commitMessageValues.push(`- project: ${project} ${releaseVersion.rawVersion}`);
+                }
+            }
+            continue;
+        }
+        // One entry for the whole group for fixed groups
+        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
+        if (projectVersionData.newVersion !== null) {
+            const releaseVersion = new ReleaseVersion({
+                version: projectVersionData.newVersion,
+                releaseTagPattern: releaseGroup.releaseTag.pattern,
+                releaseGroupName: releaseGroup.name,
+            });
+            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 shouldPreferDockerVersionForReleaseGroup(releaseGroup) {
+    return releaseGroup.releaseTag.preferDockerVersion;
+}
+function shouldSkipVersionActions(dockerOptions, projectName) {
+    return (dockerOptions.skipVersionActions === true ||
+        (Array.isArray(dockerOptions.skipVersionActions) &&
+            // skipVersionActions as string[] already normalized to matching projects in config.ts
+            dockerOptions.skipVersionActions.includes(projectName)));
+}
+function createGitTagValues(releaseGroups, releaseGroupToFilteredProjects, versionData) {
+    const tags = [];
+    for (const releaseGroup of releaseGroups) {
+        // For independent groups we want one tag per project, not one for the overall group
+        if (releaseGroup.projectsRelationship === 'independent') {
+            // Include all projects in the release group that were actually versioned,
+            // not just the explicitly filtered ones. This ensures dependent projects
+            // that received side-effect bumps get their own tags.
+            const versionedProjects = releaseGroup.projects.filter((p) => versionData[p] != null &&
+                (versionData[p].newVersion !== null ||
+                    versionData[p].dockerVersion !== null));
+            for (const project of versionedProjects) {
+                const projectVersionData = versionData[project];
+                if (projectVersionData.newVersion !== null ||
+                    projectVersionData.dockerVersion !== null) {
+                    const preferDockerVersion = shouldPreferDockerVersionForReleaseGroup(releaseGroup);
+                    if (preferDockerVersion === 'both') {
+                        // Create tags for both docker and semver versions
+                        if (projectVersionData.dockerVersion) {
+                            tags.push((0, utils_1.interpolate)(releaseGroup.releaseTag.pattern, {
+                                version: projectVersionData.dockerVersion,
+                                projectName: (0, git_1.sanitizeProjectNameForGitTag)(project),
+                                releaseGroupName: releaseGroup.name,
+                            }));
+                        }
+                        if (projectVersionData.newVersion) {
+                            tags.push((0, utils_1.interpolate)(releaseGroup.releaseTag.pattern, {
+                                version: projectVersionData.newVersion,
+                                projectName: (0, git_1.sanitizeProjectNameForGitTag)(project),
+                                releaseGroupName: releaseGroup.name,
+                            }));
+                        }
+                    }
+                    else {
+                        // Use either docker version or semver version based on preference, with null fallback
+                        const version = preferDockerVersion
+                            ? (projectVersionData.dockerVersion ??
+                                projectVersionData.newVersion)
+                            : (projectVersionData.newVersion ??
+                                projectVersionData.dockerVersion);
+                        if (version) {
+                            tags.push((0, utils_1.interpolate)(releaseGroup.releaseTag.pattern, {
+                                version,
+                                projectName: (0, git_1.sanitizeProjectNameForGitTag)(project),
+                                releaseGroupName: releaseGroup.name,
+                            }));
+                        }
+                    }
+                }
+            }
+            continue;
+        }
+        // For fixed groups we want one tag for the overall group
+        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
+        if (projectVersionData.newVersion !== null ||
+            projectVersionData.dockerVersion !== null) {
+            const preferDockerVersion = shouldPreferDockerVersionForReleaseGroup(releaseGroup);
+            if (preferDockerVersion === 'both') {
+                // Create tags for both docker and semver versions
+                if (projectVersionData.dockerVersion) {
+                    tags.push((0, utils_1.interpolate)(releaseGroup.releaseTag.pattern, {
+                        version: projectVersionData.dockerVersion,
+                        releaseGroupName: releaseGroup.name,
+                    }));
+                }
+                if (projectVersionData.newVersion) {
+                    tags.push((0, utils_1.interpolate)(releaseGroup.releaseTag.pattern, {
+                        version: projectVersionData.newVersion,
+                        releaseGroupName: releaseGroup.name,
+                    }));
+                }
+            }
+            else {
+                // Use either docker version or semver version based on preference, with null fallback
+                const version = preferDockerVersion
+                    ? (projectVersionData.dockerVersion ?? projectVersionData.newVersion)
+                    : (projectVersionData.newVersion ?? projectVersionData.dockerVersion);
+                if (version) {
+                    tags.push((0, utils_1.interpolate)(releaseGroup.releaseTag.pattern, {
+                        version,
+                        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);
+    }
+}
+function isAutomatedReleaseCommit(message, nxReleaseConfig) {
+    // All possible commit message patterns based on config
+    const commitMessagePatterns = [
+        nxReleaseConfig.git.commitMessage,
+        nxReleaseConfig.version.git.commitMessage,
+        nxReleaseConfig.changelog.git.commitMessage,
+    ];
+    // Check if message matches any pattern
+    for (const pattern of commitMessagePatterns) {
+        if (!pattern)
+            continue;
+        // Split on {version}, escape each part for regex, then join with version pattern
+        const parts = pattern.split('{version}');
+        const escapedParts = parts.map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+        const regexPattern = escapedParts.join('\\S+');
+        const regex = new RegExp(`^${regexPattern}$`);
+        if (regex.test(message)) {
+            return true;
+        }
+    }
+    return false;
+}
+async function getCommitsRelevantToProjects(projectGraph, commits, projects, nxReleaseConfig, releaseGraph, 
+// The full set of projects in the active release group. For release
+// groups with `projectsRelationship: 'independent'`, `projects` only
+// contains the single project currently being processed, so the scope
+// matching/ambiguity check below would not see its sibling projects.
+// `releaseGroupProjects` lets us match scopes against the whole group
+// regardless of relationship. Defaults to `projects` for fixed groups.
+releaseGroupProjects = projects) {
+    const projectSet = new Set(projects);
+    const releaseGroupProjectSet = new Set(releaseGroupProjects);
+    const relevantCommits = new Map();
+    for (const commit of commits) {
+        // Filter out automated release commits
+        if (isAutomatedReleaseCommit(commit.message, nxReleaseConfig)) {
+            continue;
+        }
+        // Try to get the graph associated with the commit shortHash
+        // if not available, calculate it and store it in the cache
+        let affectedGraph = await releaseGraph.resolveAffectedFilesPerCommitInProjectGraph(commit, projectGraph);
+        // Resolve commit scopes using Nx matcher
+        const scopePatterns = commit.scope
+            ? commit.scope.split(',').map((s) => s.trim())
+            : [];
+        let scopedProjects = null;
+        if (scopePatterns.length > 0) {
+            const matches = (0, find_matching_projects_1.findMatchingProjects)(scopePatterns, projectGraph.nodes);
+            // Detect ambiguity, but only within the active release group's
+            // projects. A scope that resolves ambiguously against projects
+            // outside the group is irrelevant to this group — fall through
+            // to the file-affectedness path used when a commit has no scope
+            // at all. See https://github.com/nrwl/nx/issues/35744.
+            for (const pattern of scopePatterns) {
+                const perPatternMatches = (0, find_matching_projects_1.findMatchingProjects)([pattern], projectGraph.nodes);
+                const inGroupMatches = perPatternMatches.filter((p) => releaseGroupProjectSet.has(p));
+                if (inGroupMatches.length > 1) {
+                    throw new Error(`Ambiguous scope "${pattern}" in commit "${commit.message}". ` +
+                        `Matches: ${inGroupMatches.join(', ')}`);
+                }
+            }
+            // Restrict the scoped-projects set to projects in the active
+            // release group so cross-group matches don't bleed into the
+            // isProjectScopedCommit determination below.
+            scopedProjects = new Set(matches.filter((p) => releaseGroupProjectSet.has(p)));
+        }
+        for (const projectName of Object.keys(affectedGraph.nodes)) {
+            if (projectSet.has(projectName)) {
+                if (!relevantCommits.has(projectName)) {
+                    relevantCommits.set(projectName, []);
+                }
+                const isProjectScopedCommit = scopedProjects === null || scopedProjects.has(projectName);
+                relevantCommits
+                    .get(projectName)
+                    ?.push({ commit, isProjectScopedCommit });
+            }
+        }
+    }
+    return relevantCommits;
+}

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

@@ -0,0 +1,40 @@
+import { GroupVersionPlan, ProjectsVersionPlan } from '../config/version-plans';
+import { ReleaseGroupWithName } from '../config/filter-release-groups';
+/**
+ * Validates that all projects in resolved version plans are included in the filtered projects.
+ * This validation ensures that version plans don't contain projects that aren't being released.
+ *
+ * @param releaseGroups - The release groups to validate
+ * @param releaseGroupToFilteredProjects - Map of release groups to their filtered projects
+ * @returns An error object if validation fails, null otherwise
+ */
+export declare function validateResolvedVersionPlansAgainstFilter(releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>): {
+    title: string;
+    bodyLines?: string[];
+} | null;
+/**
+ * Extracts the set of projects that a version plan affects.
+ *
+ * @param plan - The version plan to analyze
+ * @param releaseGroup - The release group containing the version plan
+ * @returns Set of project names that the version plan affects
+ */
+export declare function getProjectsAffectedByVersionPlan(plan: GroupVersionPlan | ProjectsVersionPlan, releaseGroup: ReleaseGroupWithName): Set<string>;
+/**
+ * Checks if all projects affected by a version plan are included in the filtered projects set.
+ *
+ * @param plan - The version plan to check
+ * @param releaseGroup - The release group containing the version plan
+ * @param filteredProjects - Set of projects that are being released (filtered)
+ * @returns True if ALL projects in the version plan are being filtered/released
+ */
+export declare function areAllVersionPlanProjectsFiltered(plan: GroupVersionPlan | ProjectsVersionPlan, releaseGroup: ReleaseGroupWithName, filteredProjects: Set<string> | undefined): boolean;
+/**
+ * Finds projects in a version plan that are NOT included in the filtered projects set.
+ *
+ * @param plan - The version plan to check
+ * @param releaseGroup - The release group containing the version plan
+ * @param filteredProjects - Set of projects that are being released (filtered)
+ * @returns Array of project names that are in the version plan but not in the filter
+ */
+export declare function getVersionPlanProjectsOutsideFilter(plan: GroupVersionPlan | ProjectsVersionPlan, releaseGroup: ReleaseGroupWithName, filteredProjects: Set<string> | undefined): string[];

package/dist/src/command-line/release/utils/version-plan-utils.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateResolvedVersionPlansAgainstFilter = validateResolvedVersionPlansAgainstFilter;
+exports.getProjectsAffectedByVersionPlan = getProjectsAffectedByVersionPlan;
+exports.areAllVersionPlanProjectsFiltered = areAllVersionPlanProjectsFiltered;
+exports.getVersionPlanProjectsOutsideFilter = getVersionPlanProjectsOutsideFilter;
+/**
+ * Validates that all projects in resolved version plans are included in the filtered projects.
+ * This validation ensures that version plans don't contain projects that aren't being released.
+ *
+ * @param releaseGroups - The release groups to validate
+ * @param releaseGroupToFilteredProjects - Map of release groups to their filtered projects
+ * @returns An error object if validation fails, null otherwise
+ */
+function validateResolvedVersionPlansAgainstFilter(releaseGroups, releaseGroupToFilteredProjects) {
+    for (const releaseGroup of releaseGroups) {
+        if (releaseGroup.resolvedVersionPlans &&
+            releaseGroup.resolvedVersionPlans.length > 0) {
+            const filteredProjects = releaseGroupToFilteredProjects.get(releaseGroup);
+            for (const plan of releaseGroup.resolvedVersionPlans) {
+                // check if version plan applies to filtered projects
+                if (!checkVersionPlanContainsFilteredProjects(plan, releaseGroup, filteredProjects)) {
+                    continue;
+                }
+                // Check if version plan contains projects outside the filter
+                const projectsOutsideFilter = getVersionPlanProjectsOutsideFilter(plan, releaseGroup, filteredProjects);
+                if (projectsOutsideFilter.length > 0) {
+                    // Error if version plan contains projects not in the filter
+                    return {
+                        title: `Version plan contains projects not included in the release filter`,
+                        bodyLines: [
+                            `The following projects in the version plan are not being released:`,
+                            ...projectsOutsideFilter.map((p) => `  - ${p}`),
+                            '',
+                            `Either include all projects from the version plan in your release command,`,
+                            `or create separate version plans for different sets of projects.`,
+                        ],
+                    };
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Extracts the set of projects that a version plan affects.
+ *
+ * @param plan - The version plan to analyze
+ * @param releaseGroup - The release group containing the version plan
+ * @returns Set of project names that the version plan affects
+ */
+function getProjectsAffectedByVersionPlan(plan, releaseGroup) {
+    const planProjects = new Set();
+    // Collect all projects mentioned in this version plan
+    if ('groupVersionBump' in plan && plan.groupVersionBump) {
+        // Version plan applies to the entire group
+        releaseGroup.projects.forEach((p) => planProjects.add(p));
+    }
+    else if ('projectVersionBumps' in plan && plan.projectVersionBumps) {
+        // Version plan has specific project bumps
+        Object.keys(plan.projectVersionBumps).forEach((p) => planProjects.add(p));
+    }
+    return planProjects;
+}
+/**
+ * Checks if all projects affected by a version plan are included in the filtered projects set.
+ *
+ * @param plan - The version plan to check
+ * @param releaseGroup - The release group containing the version plan
+ * @param filteredProjects - Set of projects that are being released (filtered)
+ * @returns True if ALL projects in the version plan are being filtered/released
+ */
+function areAllVersionPlanProjectsFiltered(plan, releaseGroup, filteredProjects) {
+    if (!filteredProjects) {
+        return false;
+    }
+    const planProjects = getProjectsAffectedByVersionPlan(plan, releaseGroup);
+    // Only return true if the plan affects at least one project and ALL of them are filtered
+    return (planProjects.size > 0 &&
+        Array.from(planProjects).every((project) => filteredProjects.has(project)));
+}
+/**
+ * Finds projects in a version plan that are NOT included in the filtered projects set.
+ *
+ * @param plan - The version plan to check
+ * @param releaseGroup - The release group containing the version plan
+ * @param filteredProjects - Set of projects that are being released (filtered)
+ * @returns Array of project names that are in the version plan but not in the filter
+ */
+function getVersionPlanProjectsOutsideFilter(plan, releaseGroup, filteredProjects) {
+    if (!filteredProjects) {
+        return [];
+    }
+    const planProjects = getProjectsAffectedByVersionPlan(plan, releaseGroup);
+    return Array.from(planProjects).filter((project) => !filteredProjects.has(project));
+}
+/**
+ * Checks whether the version plan contains any of the filtered projects.
+ *
+ * @param plan - The version plan to check.
+ * @param releaseGroup - The release group associated with the version plan.
+ * @param filteredProjects - Set of projects that are being released (filtered).
+ * @returns Returns true if the version plan contains any of the filtered projects, or if no filtered projects are provided.
+ */
+function checkVersionPlanContainsFilteredProjects(plan, releaseGroup, filteredProjects) {
+    if (!filteredProjects) {
+        return true;
+    }
+    const planProjects = getProjectsAffectedByVersionPlan(plan, releaseGroup);
+    return Array.from(filteredProjects).some((project) => planProjects.has(project));
+}

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

@@ -0,0 +1,8 @@
+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 { ReleaseGraph } from '../utils/release-graph';
+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, releaseGraph: ReleaseGraph, fallbackCurrentVersionResolver?: 'disk', preid?: string): Promise<SemverBumpType>;

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

@@ -0,0 +1,61 @@
+"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");
+const semver_1 = require("../utils/semver");
+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, releaseGraph, 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, use the first commit that touched this project rather than the repo's first commit,
+    // to avoid scanning the entire git history for projects that were added after the repo was created.
+    const previousVersionRef = latestMatchingGitTag
+        ? latestMatchingGitTag.tag
+        : fallbackCurrentVersionResolver === 'disk'
+            ? await (0, git_1.getFirstProjectCommit)(projectGraphNode.data.root)
+            : 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.`);
+    }
+    const projectToSpecifiers = await (0, resolve_semver_specifier_1.resolveSemverSpecifierFromConventionalCommits)(previousVersionRef, projectGraph, affectedProjects, nxReleaseConfig, releaseGraph, 
+    // Always match conventional-commit scopes against the full release
+    // group, even when only a single (independent) project is being
+    // processed, so genuine intra-group ambiguity is still detected.
+    releaseGroup.projects);
+    const getHighestSemverChange = (semverSpecifiersItr) => {
+        const semverSpecifiers = Array.from(semverSpecifiersItr);
+        return semverSpecifiers.sort((a, b) => b - a)[0];
+    };
+    const semverSpecifier = releaseGroup.projectsRelationship === 'independent'
+        ? projectToSpecifiers.get(projectGraphNode.name)
+        : getHighestSemverChange(projectToSpecifiers.values());
+    let specifier = semverSpecifier === null ? null : semver_1.SemverSpecifierType[semverSpecifier];
+    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/dist/src/command-line/release/version/deriver-specifier-from-version-plans.d.ts

@@ -0,0 +1,8 @@
+import type { ProjectGraphProjectNode } from '../../../config/project-graph';
+import { ReleaseGroupWithName } from '../config/filter-release-groups';
+import { SemverBumpType } from './version-actions';
+import { ProjectLogger } from './project-logger';
+export declare function deriveSpecifierFromVersionPlan(projectLogger: ProjectLogger, releaseGroup: ReleaseGroupWithName, projectGraphNode: ProjectGraphProjectNode, currentVersion: string): Promise<{
+    bumpType: SemverBumpType;
+    versionPlanPath: string;
+}>;