@depup/nx 22.5.4-depup.0

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

@@ -0,0 +1,342 @@
+"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 pc = 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");
+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) {
+        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.releaseTag.pattern,
+                        projectName: project,
+                        releaseGroupName: releaseGroup.name,
+                    });
+                    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.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) {
+        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 ||
+                    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 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) {
+    const projectSet = new Set(projects);
+    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);
+        for (const projectName of Object.keys(affectedGraph.nodes)) {
+            if (projectSet.has(projectName)) {
+                if (!relevantCommits.has(projectName)) {
+                    relevantCommits.set(projectName, []);
+                }
+                if (commit.scope === projectName ||
+                    commit.scope.split(',').includes(projectName) ||
+                    !commit.scope) {
+                    relevantCommits
+                        .get(projectName)
+                        ?.push({ commit, isProjectScopedCommit: true });
+                }
+                else {
+                    relevantCommits
+                        .get(projectName)
+                        ?.push({ commit, isProjectScopedCommit: false });
+                }
+            }
+        }
+    }
+    return relevantCommits;
+}

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

@@ -0,0 +1,21 @@
+export declare function createVersionConfig(): {
+    conventionalCommits: boolean;
+    groupPreVersionCommand: string;
+    preVersionCommand: string;
+    deleteVersionPlans: any;
+    manifestRootsToUpdate: any;
+    specifierSource: any;
+    currentVersionResolver: any;
+    currentVersionResolverMetadata: any;
+    preserveMatchingDependencyRanges: any;
+    preserveLocalDependencyProtocols: any;
+    fallbackCurrentVersionResolver: any;
+    firstRelease: any;
+    versionPrefix: any;
+    updateDependents: any;
+    logUnchangedProjects: any;
+    versionActions: any;
+    versionActionsOptions: any;
+    adjustSemverBumpsForZeroMajorVersion: any;
+};
+//# sourceMappingURL=test-utils.d.ts.map

package/src/command-line/release/utils/test/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/nx/src/command-line/release/utils/test/test-utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB;;;;;;;;;;;;;;;;;;;EAqBlC"}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVersionConfig = createVersionConfig;
+function createVersionConfig() {
+    return {
+        conventionalCommits: false,
+        groupPreVersionCommand: '',
+        preVersionCommand: '',
+        deleteVersionPlans: undefined,
+        manifestRootsToUpdate: undefined,
+        specifierSource: undefined,
+        currentVersionResolver: undefined,
+        currentVersionResolverMetadata: undefined,
+        preserveMatchingDependencyRanges: undefined,
+        preserveLocalDependencyProtocols: undefined,
+        fallbackCurrentVersionResolver: undefined,
+        firstRelease: undefined,
+        versionPrefix: undefined,
+        updateDependents: undefined,
+        logUnchangedProjects: undefined,
+        versionActions: undefined,
+        versionActionsOptions: undefined,
+        adjustSemverBumpsForZeroMajorVersion: undefined,
+    };
+}

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

@@ -0,0 +1,41 @@
+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[];
+//# sourceMappingURL=version-plan-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"version-plan-utils.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/release/utils/version-plan-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAChF,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAEvE;;;;;;;GAOG;AACH,wBAAgB,yCAAyC,CACvD,aAAa,EAAE,oBAAoB,EAAE,EACrC,8BAA8B,EAAE,GAAG,CAAC,oBAAoB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,GACrE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CA4ChD;AAED;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,gBAAgB,GAAG,mBAAmB,EAC5C,YAAY,EAAE,oBAAoB,GACjC,GAAG,CAAC,MAAM,CAAC,CAab;AAED;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,gBAAgB,GAAG,mBAAmB,EAC5C,YAAY,EAAE,oBAAoB,EAClC,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,SAAS,GACxC,OAAO,CAYT;AAED;;;;;;;GAOG;AACH,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,gBAAgB,GAAG,mBAAmB,EAC5C,YAAY,EAAE,oBAAoB,EAClC,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,SAAS,GACxC,MAAM,EAAE,CAUV"}

package/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/src/command-line/release/version/derive-specifier-from-conventional-commits.d.ts

@@ -0,0 +1,9 @@
+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>;
+//# sourceMappingURL=derive-specifier-from-conventional-commits.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"derive-specifier-from-conventional-commits.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/release/version/derive-specifier-from-conventional-commits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,uBAAuB,EACxB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAqB,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAGtD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,wBAAsB,sCAAsC,CAC1D,eAAe,EAAE,eAAe,EAChC,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,oBAAoB,EAClC,gBAAgB,EAAE,uBAAuB,EAMzC,YAAY,EAAE,OAAO,EACrB,oBAAoB,EAChB,OAAO,CAAC,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,GACrD,SAAS,EACb,YAAY,EAAE,YAAY,EAC1B,8BAA8B,CAAC,EAAE,MAAM,EACvC,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,cAAc,CAAC,CAyEzB"}

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

@@ -0,0 +1,56 @@
+"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, 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.`);
+    }
+    const projectToSpecifiers = await (0, resolve_semver_specifier_1.resolveSemverSpecifierFromConventionalCommits)(previousVersionRef, projectGraph, affectedProjects, nxReleaseConfig, releaseGraph);
+    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/src/command-line/release/version/deriver-specifier-from-version-plans.d.ts

@@ -0,0 +1,9 @@
+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;
+}>;
+//# sourceMappingURL=deriver-specifier-from-version-plans.d.ts.map

package/src/command-line/release/version/deriver-specifier-from-version-plans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriver-specifier-from-version-plans.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/release/version/deriver-specifier-from-version-plans.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAEvE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,wBAAsB,8BAA8B,CAClD,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,oBAAoB,EAClC,gBAAgB,EAAE,uBAAuB,EACzC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC;IACT,QAAQ,EAAE,cAAc,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC,CA6ED"}