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

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

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

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

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

@@ -1,8 +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 { 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

@@ -1,61 +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");
-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

@@ -1,8 +0,0 @@
-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;
-}>;