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

package/dist/src/command-line/release/config/conventional-commits.d.ts

@@ -1,2 +0,0 @@
-import { NxReleaseConfig } from './config';
-export declare const DEFAULT_CONVENTIONAL_COMMITS_CONFIG: NxReleaseConfig['conventionalCommits'];

package/dist/src/command-line/release/config/conventional-commits.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CONVENTIONAL_COMMITS_CONFIG = void 0;
-exports.DEFAULT_CONVENTIONAL_COMMITS_CONFIG = {
-    useCommitScope: true,
-    types: {
-        feat: {
-            semverBump: 'minor',
-            changelog: {
-                title: '🚀 Features',
-                hidden: false,
-            },
-        },
-        fix: {
-            semverBump: 'patch',
-            changelog: {
-                title: '🩹 Fixes',
-                hidden: false,
-            },
-        },
-        perf: {
-            semverBump: 'none',
-            changelog: {
-                title: '🔥 Performance',
-                hidden: false,
-            },
-        },
-        refactor: {
-            semverBump: 'none',
-            changelog: {
-                title: '💅 Refactors',
-                hidden: true,
-            },
-        },
-        docs: {
-            semverBump: 'none',
-            changelog: {
-                title: '📖 Documentation',
-                hidden: true,
-            },
-        },
-        build: {
-            semverBump: 'none',
-            changelog: {
-                title: '📦 Build',
-                hidden: true,
-            },
-        },
-        types: {
-            semverBump: 'none',
-            changelog: {
-                title: '🌊 Types',
-                hidden: true,
-            },
-        },
-        chore: {
-            semverBump: 'none',
-            changelog: {
-                title: '🏡 Chore',
-                hidden: true,
-            },
-        },
-        examples: {
-            semverBump: 'none',
-            changelog: {
-                title: '🏀 Examples',
-                hidden: true,
-            },
-        },
-        test: {
-            semverBump: 'none',
-            changelog: {
-                title: '✅ Tests',
-                hidden: true,
-            },
-        },
-        style: {
-            semverBump: 'none',
-            changelog: {
-                title: '🎨 Styles',
-                hidden: true,
-            },
-        },
-        ci: {
-            semverBump: 'none',
-            changelog: {
-                title: '🤖 CI',
-                hidden: true,
-            },
-        },
-        revert: {
-            semverBump: 'none',
-            changelog: {
-                title: '⏪ Revert',
-                hidden: true,
-            },
-        },
-        __INVALID__: {
-            semverBump: 'none',
-            changelog: {
-                title: 'Invalid based on conventional commits specification',
-                hidden: true,
-            },
-        },
-    },
-};

package/dist/src/command-line/release/config/deep-merge-json.d.ts

@@ -1 +0,0 @@
-export declare function deepMergeJson<T extends Record<string, any>>(target: T, source: T): T;

package/dist/src/command-line/release/config/deep-merge-json.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deepMergeJson = deepMergeJson;
-function isObject(obj) {
-    return obj && typeof obj === 'object' && !Array.isArray(obj);
-}
-function deepMergeJson(target, source) {
-    try {
-        // Ensure both objects are valid JSON before attempting to merge values
-        JSON.parse(JSON.stringify(source));
-        JSON.parse(JSON.stringify(target));
-        for (const key in source) {
-            if (isObject(source[key])) {
-                if (!target[key]) {
-                    Object.assign(target, { [key]: {} });
-                }
-                deepMergeJson(target[key], source[key]);
-            }
-            else {
-                Object.assign(target, { [key]: source[key] });
-            }
-        }
-        return target;
-    }
-    catch {
-        throw new Error('Invalid JSON was provided');
-    }
-}

package/dist/src/command-line/release/config/filter-release-groups.d.ts

@@ -1,23 +0,0 @@
-import { ProjectGraph } from '../../../config/project-graph';
-import { NxReleaseConfig } from './config';
-import { GroupVersionPlan, ProjectsVersionPlan } from './version-plans';
-import { NxReleaseDockerConfiguration } from '../../../config/nx-json';
-export type ReleaseGroupWithName = Omit<NxReleaseConfig['groups'][string], 'docker'> & {
-    name: string;
-    resolvedVersionPlans: (ProjectsVersionPlan | GroupVersionPlan)[] | false;
-    docker?: NxReleaseDockerConfiguration & {
-        groupPreVersionCommand?: string;
-    };
-};
-export declare function filterReleaseGroups(projectGraph: ProjectGraph, nxReleaseConfig: NxReleaseConfig, projectsFilter?: string[], groupsFilter?: string[]): {
-    error: null | {
-        title: string;
-        bodyLines?: string[];
-    };
-    filterLog: {
-        title: string;
-        bodyLines: string[];
-    } | null;
-    releaseGroups: ReleaseGroupWithName[];
-    releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>;
-};

package/dist/src/command-line/release/config/filter-release-groups.js

@@ -1,157 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterReleaseGroups = filterReleaseGroups;
-const find_matching_projects_1 = require("../../../utils/find-matching-projects");
-const config_1 = require("./config");
-function filterReleaseGroups(projectGraph, nxReleaseConfig, projectsFilter, groupsFilter) {
-    let filterLog = null;
-    let releaseGroups = Object.entries(nxReleaseConfig.groups).map(([name, group]) => {
-        return {
-            ...group,
-            name,
-            resolvedVersionPlans: group.versionPlans ? [] : false,
-        };
-    });
-    const filteredProjectToReleaseGroup = new Map();
-    const releaseGroupToFilteredProjects = new Map();
-    for (const releaseGroup of releaseGroups) {
-        for (const project of releaseGroup.projects) {
-            filteredProjectToReleaseGroup.set(project, releaseGroup);
-            if (!releaseGroupToFilteredProjects.has(releaseGroup)) {
-                releaseGroupToFilteredProjects.set(releaseGroup, new Set());
-            }
-            releaseGroupToFilteredProjects.get(releaseGroup).add(project);
-        }
-    }
-    /**
-     * User is filtering to a subset of projects. We need to make sure that what they have provided can be reconciled
-     * against their configuration in terms of release groups.
-     */
-    if (projectsFilter?.length) {
-        const matchingProjectsForFilter = (0, find_matching_projects_1.findMatchingProjects)(projectsFilter, projectGraph.nodes);
-        if (!matchingProjectsForFilter.length) {
-            return {
-                error: {
-                    title: `Your --projects filter "${projectsFilter}" did not match any projects in the workspace`,
-                },
-                filterLog: null,
-                releaseGroups: [],
-                releaseGroupToFilteredProjects,
-            };
-        }
-        // Remove any non-matching projects from filteredProjectToReleaseGroup
-        for (const project of filteredProjectToReleaseGroup.keys()) {
-            if (!matchingProjectsForFilter.includes(project)) {
-                filteredProjectToReleaseGroup.delete(project);
-            }
-        }
-        // Filter out any non-matching projects from the release group to filtered projects map
-        for (const releaseGroup of releaseGroups) {
-            releaseGroup.projects
-                .filter((p) => !matchingProjectsForFilter.includes(p))
-                .forEach((p) => releaseGroupToFilteredProjects.get(releaseGroup).delete(p));
-        }
-        /**
-         * If there are release groups specified, each filtered project must match at least one release
-         * group, otherwise the command + config combination is invalid.
-         */
-        if (releaseGroups.length) {
-            const unmatchedProjects = matchingProjectsForFilter.filter((p) => !filteredProjectToReleaseGroup.has(p));
-            if (unmatchedProjects.length) {
-                return {
-                    error: {
-                        title: `The following projects which match your projects filter "${projectsFilter}" did not match any configured release groups:`,
-                        bodyLines: unmatchedProjects.map((p) => `- ${p}`),
-                    },
-                    filterLog: null,
-                    releaseGroups: [],
-                    releaseGroupToFilteredProjects,
-                };
-            }
-        }
-        /**
-         * If the user is filtering to a subset of projects, we need to make sure that they are all within release groups
-         * with "independent" configured for their projectsRelationship. If not, the filtering is invalid, and they should instead
-         * be targeting the release groups directly using the --group flag, or they should update their configuration to
-         * make the projects they were trying to filter be independently releasable.
-         */
-        const releaseGroupsForFilteredProjects = Array.from(new Set(Array.from(filteredProjectToReleaseGroup.values())));
-        const releaseGroupsThatAreNotIndependent = releaseGroupsForFilteredProjects.filter((rg) => rg.projectsRelationship !== 'independent');
-        if (releaseGroupsThatAreNotIndependent.length) {
-            // Special handling for IMPLICIT_DEFAULT_RELEASE_GROUP
-            if (releaseGroupsThatAreNotIndependent.length === 1 &&
-                releaseGroupsThatAreNotIndependent[0].name ===
-                    config_1.IMPLICIT_DEFAULT_RELEASE_GROUP) {
-                return {
-                    error: {
-                        title: `In order to release specific projects independently with --projects those projects must be configured appropriately. For example, by setting \`"projectsRelationship": "independent"\` in your nx.json config.`,
-                        bodyLines: [],
-                    },
-                    filterLog: null,
-                    releaseGroups: [],
-                    releaseGroupToFilteredProjects,
-                };
-            }
-            return {
-                error: {
-                    title: `Your --projects filter "${projectsFilter}" matched projects in the following release groups which do not have "independent" configured for their "projectsRelationship":`,
-                    bodyLines: releaseGroupsThatAreNotIndependent.map((rg) => `- ${rg.name}`),
-                },
-                filterLog: null,
-                releaseGroups: [],
-                releaseGroupToFilteredProjects,
-            };
-        }
-        filterLog = {
-            title: `Your filter "${projectsFilter}" matched the following projects:`,
-            bodyLines: matchingProjectsForFilter.map((p) => {
-                const releaseGroupForProject = filteredProjectToReleaseGroup.get(p);
-                if (releaseGroupForProject.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP) {
-                    return `- ${p}`;
-                }
-                return `- ${p} (release group "${releaseGroupForProject.name}")`;
-            }),
-        };
-        // Filter the releaseGroups collection appropriately
-        for (const [releaseGroupWithName, matchingProjects,] of releaseGroupToFilteredProjects.entries()) {
-            if (matchingProjects.size === 0) {
-                releaseGroupToFilteredProjects.delete(releaseGroupWithName);
-            }
-        }
-        releaseGroups = releaseGroups.filter((rg) => releaseGroupToFilteredProjects.get(rg)?.size > 0);
-        return {
-            error: null,
-            filterLog,
-            releaseGroups,
-            releaseGroupToFilteredProjects,
-        };
-    }
-    /**
-     * The user is filtering by release group
-     */
-    if (groupsFilter?.length) {
-        releaseGroups
-            .filter((g) => !groupsFilter.includes(g.name))
-            .forEach((g) => releaseGroupToFilteredProjects.delete(g));
-        releaseGroups = releaseGroups.filter((g) => groupsFilter.includes(g.name));
-    }
-    if (!releaseGroups.length) {
-        return {
-            error: {
-                title: groupsFilter
-                    ? `Your --groups filter "${groupsFilter}" did not match any release groups in the workspace`
-                    : // Getting to this point should be impossible, as we should have explicitly handled any errors/invalid config by now
-                        `No projects could be matched for versioning, please report this case and include your nx.json config and command line arguments`,
-            },
-            filterLog: null,
-            releaseGroups: [],
-            releaseGroupToFilteredProjects,
-        };
-    }
-    return {
-        error: null,
-        filterLog,
-        releaseGroups,
-        releaseGroupToFilteredProjects,
-    };
-}

package/dist/src/command-line/release/config/use-legacy-versioning.d.ts

@@ -1,2 +0,0 @@
-/** @deprecated Compat shim for `@nx/js@21`. */
-export declare function shouldUseLegacyVersioning(releaseConfig: any): boolean;

package/dist/src/command-line/release/config/use-legacy-versioning.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldUseLegacyVersioning = shouldUseLegacyVersioning;
-// TODO(v23): remove — kept only so `@nx/js@21`'s library generator can load via `ensurePackage`.
-/** @deprecated Compat shim for `@nx/js@21`. */
-function shouldUseLegacyVersioning(releaseConfig) {
-    return releaseConfig?.version?.useLegacyVersioning ?? false;
-}

package/dist/src/command-line/release/config/version-plans.d.ts

@@ -1,42 +0,0 @@
-import { ReleaseType } from 'semver';
-import { RawGitCommit } from '../utils/git';
-import { ReleaseGroupWithName } from './filter-release-groups';
-export interface VersionPlanFile {
-    absolutePath: string;
-    relativePath: string;
-    fileName: string;
-    createdOnMs: number;
-}
-export interface RawVersionPlan extends VersionPlanFile {
-    content: Record<string, string>;
-    message: string;
-}
-export interface VersionPlan extends VersionPlanFile {
-    message: string;
-    /**
-     * The commit that added the version plan file, will be null if the file was never committed.
-     * For optimal performance, we don't apply it at the time of reading the raw contents, because
-     * it hasn't yet passed further validation at that point.
-     */
-    commit: RawGitCommit | null;
-}
-export interface GroupVersionPlan extends VersionPlan {
-    groupVersionBump: ReleaseType;
-    /**
-     * The commit that added the version plan file, will be null if the file was never committed.
-     * For optimal performance, we don't apply it at the time of reading the raw contents, because.
-     * it hasn't yet passed validation.
-     */
-    commit: RawGitCommit | null;
-    /**
-     * Will not be set if the group name was the trigger, otherwise will be a list of
-     * all the individual project names explicitly found in the version plan file.
-     */
-    triggeredByProjects?: string[];
-}
-export interface ProjectsVersionPlan extends VersionPlan {
-    projectVersionBumps: Record<string, ReleaseType>;
-}
-export declare function readRawVersionPlans(): Promise<RawVersionPlan[]>;
-export declare function setResolvedVersionPlansOnGroups(rawVersionPlans: RawVersionPlan[], releaseGroups: ReleaseGroupWithName[], allProjectNamesInWorkspace: string[], isVerbose: boolean): Promise<ReleaseGroupWithName[]>;
-export declare function getVersionPlansAbsolutePath(): string;

package/dist/src/command-line/release/config/version-plans.js

@@ -1,278 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readRawVersionPlans = readRawVersionPlans;
-exports.setResolvedVersionPlansOnGroups = setResolvedVersionPlansOnGroups;
-exports.getVersionPlansAbsolutePath = getVersionPlansAbsolutePath;
-const node_child_process_1 = require("node:child_process");
-const node_fs_1 = require("node:fs");
-const promises_1 = require("node:fs/promises");
-const path_1 = require("path");
-const semver_1 = require("semver");
-const workspace_root_1 = require("../../../utils/workspace-root");
-const config_1 = require("./config");
-const { load } = require('@zkochan/js-yaml');
-// Ported from https://github.com/jxson/front-matter/blob/master/index.js
-const fmPattern = new RegExp('^(' +
-    '\\ufeff?' +
-    '(= yaml =|---)' +
-    '$([\\s\\S]*?)' +
-    '^(?:\\2|\\.\\.\\.)\\s*' +
-    '$' +
-    (process.platform === 'win32' ? '\\r?' : '') +
-    '(?:\\n)?)', 'm');
-function parseFrontMatter(str) {
-    str = str || '';
-    const lines = str.split(/(\r?\n)/);
-    if (!lines[0] || !/= yaml =|---/.test(lines[0])) {
-        return { attributes: {}, body: str };
-    }
-    const match = fmPattern.exec(str);
-    if (!match) {
-        return { attributes: {}, body: str };
-    }
-    const yaml = match[match.length - 1].replace(/^\s+|\s+$/g, '');
-    const attributes = load(yaml) || {};
-    const body = str.replace(match[0], '');
-    return { attributes, body };
-}
-const versionPlansDirectory = (0, path_1.join)('.nx', 'version-plans');
-const allowedAttributeValues = [
-    // Stable releases (with conventional-commit style aliases)
-    '"major" (aliases: "feat!" or "fix!")',
-    '"minor" (alias: "feat")',
-    '"patch" (alias: "fix")',
-    // Prereleases
-    '"premajor"',
-    '"preminor"',
-    '"prepatch"',
-    '"prerelease"',
-];
-async function readRawVersionPlans() {
-    const versionPlansPath = getVersionPlansAbsolutePath();
-    if (!(0, node_fs_1.existsSync)(versionPlansPath)) {
-        return [];
-    }
-    const versionPlans = [];
-    const versionPlanFiles = (0, node_fs_1.readdirSync)(versionPlansPath);
-    for (const versionPlanFile of versionPlanFiles) {
-        const filePath = (0, path_1.join)(versionPlansPath, versionPlanFile);
-        const versionPlanContent = (0, node_fs_1.readFileSync)(filePath).toString();
-        const versionPlanStats = await (0, promises_1.stat)(filePath);
-        const parsedContent = parseFrontMatter(versionPlanContent);
-        /**
-         * For convenience allow:
-         * - feat to be used as an alias of minor
-         * - fix to be used as an alias of patch
-         * - Either feat! or fix! to be used as an alias of major
-         */
-        for (const [key, value] of Object.entries(parsedContent.attributes)) {
-            switch (value) {
-                case 'feat':
-                    parsedContent.attributes[key] = 'minor';
-                    break;
-                case 'fix':
-                    parsedContent.attributes[key] = 'patch';
-                    break;
-                case 'feat!':
-                case 'fix!':
-                    parsedContent.attributes[key] = 'major';
-                    break;
-            }
-        }
-        versionPlans.push({
-            absolutePath: filePath,
-            relativePath: (0, path_1.join)(versionPlansDirectory, versionPlanFile),
-            fileName: versionPlanFile,
-            content: parsedContent.attributes,
-            message: parsedContent.body,
-            createdOnMs: versionPlanStats.birthtimeMs,
-        });
-    }
-    return versionPlans;
-}
-async function setResolvedVersionPlansOnGroups(rawVersionPlans, releaseGroups, allProjectNamesInWorkspace, isVerbose) {
-    const groupsByName = releaseGroups.reduce((acc, group) => acc.set(group.name, group), new Map());
-    const isDefaultGroup = isDefault(releaseGroups);
-    for (const rawVersionPlan of rawVersionPlans) {
-        if (!rawVersionPlan.message) {
-            throw new Error(`Please add a changelog message to version plan: '${rawVersionPlan.fileName}'`);
-        }
-        for (const [key, value] of Object.entries(rawVersionPlan.content)) {
-            if (groupsByName.has(key)) {
-                const group = groupsByName.get(key);
-                if (!group.resolvedVersionPlans) {
-                    if (isDefaultGroup) {
-                        throw new Error(`Found a version bump in '${rawVersionPlan.fileName}' but version plans are not enabled.`);
-                    }
-                    else {
-                        throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' but the group does not have version plans enabled.`);
-                    }
-                }
-                if (group.projectsRelationship === 'independent') {
-                    if (isDefaultGroup) {
-                        throw new Error(`Found a version bump in '${rawVersionPlan.fileName}' but projects are configured to be independently versioned. Individual projects should be bumped instead.`);
-                    }
-                    else {
-                        throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' but the group's projects are independently versioned. Individual projects of '${key}' should be bumped instead.`);
-                    }
-                }
-                if (!isReleaseType(value)) {
-                    if (isDefaultGroup) {
-                        throw new Error(`Found a version bump in '${rawVersionPlan.fileName}' with an invalid release type. Please specify one of: ${allowedAttributeValues.join(', ')}.`);
-                    }
-                    else {
-                        throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' with an invalid release type. Please specify one of: ${allowedAttributeValues.join(', ')}.`);
-                    }
-                }
-                const existingPlan = (group.resolvedVersionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
-                if (existingPlan) {
-                    if (existingPlan.groupVersionBump !== value) {
-                        if (isDefaultGroup) {
-                            throw new Error(`Found a version bump in '${rawVersionPlan.fileName}' that conflicts with another version bump. When in fixed versioning mode, all version bumps must match.`);
-                        }
-                        else {
-                            throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' that conflicts with another version bump for this group. When the group is in fixed versioning mode, all groups' version bumps within the same version plan must match.`);
-                        }
-                    }
-                }
-                else {
-                    group.resolvedVersionPlans.push({
-                        absolutePath: rawVersionPlan.absolutePath,
-                        relativePath: rawVersionPlan.relativePath,
-                        fileName: rawVersionPlan.fileName,
-                        createdOnMs: rawVersionPlan.createdOnMs,
-                        message: rawVersionPlan.message,
-                        groupVersionBump: value,
-                        commit: await getCommitForVersionPlanFile(rawVersionPlan, isVerbose),
-                    });
-                }
-            }
-            else {
-                const groupForProject = releaseGroups.find((group) => group.projects.includes(key));
-                if (!groupForProject) {
-                    if (!allProjectNamesInWorkspace.includes(key)) {
-                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but the project does not exist in the workspace.`);
-                    }
-                    if (isDefaultGroup) {
-                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but the project is not configured for release. Ensure it is included by the 'release.projects' globs in nx.json.`);
-                    }
-                    else {
-                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but the project is not in any configured release groups.`);
-                    }
-                }
-                if (!groupForProject.resolvedVersionPlans) {
-                    if (isDefaultGroup) {
-                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but version plans are not enabled.`);
-                    }
-                    else {
-                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but the project's group '${groupForProject.name}' does not have version plans enabled.`);
-                    }
-                }
-                if (!isReleaseType(value)) {
-                    throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' with an invalid release type. Please specify one of: ${allowedAttributeValues.join(', ')}.`);
-                }
-                if (groupForProject.projectsRelationship === 'independent') {
-                    const existingPlan = (groupForProject.resolvedVersionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
-                    if (existingPlan) {
-                        existingPlan.projectVersionBumps[key] = value;
-                    }
-                    else {
-                        groupForProject.resolvedVersionPlans.push({
-                            absolutePath: rawVersionPlan.absolutePath,
-                            relativePath: rawVersionPlan.relativePath,
-                            fileName: rawVersionPlan.fileName,
-                            createdOnMs: rawVersionPlan.createdOnMs,
-                            message: rawVersionPlan.message,
-                            projectVersionBumps: {
-                                [key]: value,
-                            },
-                            commit: await getCommitForVersionPlanFile(rawVersionPlan, isVerbose),
-                        });
-                    }
-                }
-                else {
-                    const existingPlan = (groupForProject.resolvedVersionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
-                    // This can occur if the same fixed release group has multiple entries for different projects within
-                    // the same version plan file. This will be the case when users are using the default release group.
-                    if (existingPlan) {
-                        if (existingPlan.groupVersionBump !== value) {
-                            if (isDefaultGroup) {
-                                throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' that conflicts with another version bump. When in fixed versioning mode, all version bumps must match.`);
-                            }
-                            else {
-                                throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' that conflicts with another project's version bump in the same release group '${groupForProject.name}'. When the group is in fixed versioning mode, all projects' version bumps within the same group must match.`);
-                            }
-                        }
-                        else {
-                            // Avoid duplicates when releaseGraph is reused and version plans are resolved multiple times
-                            if (!existingPlan.triggeredByProjects.includes(key)) {
-                                existingPlan.triggeredByProjects.push(key);
-                            }
-                        }
-                    }
-                    else {
-                        groupForProject.resolvedVersionPlans.push({
-                            absolutePath: rawVersionPlan.absolutePath,
-                            relativePath: rawVersionPlan.relativePath,
-                            fileName: rawVersionPlan.fileName,
-                            createdOnMs: rawVersionPlan.createdOnMs,
-                            message: rawVersionPlan.message,
-                            // This is a fixed group, so the version bump is for the group, even if a project within it was specified
-                            // but we track the projects that triggered the version bump so that we can accurately produce changelog entries.
-                            groupVersionBump: value,
-                            triggeredByProjects: [key],
-                            commit: await getCommitForVersionPlanFile(rawVersionPlan, isVerbose),
-                        });
-                    }
-                }
-            }
-        }
-    }
-    // Order the plans from newest to oldest
-    releaseGroups.forEach((group) => {
-        if (group.resolvedVersionPlans) {
-            group.resolvedVersionPlans.sort((a, b) => b.createdOnMs - a.createdOnMs);
-        }
-    });
-    return releaseGroups;
-}
-function isDefault(releaseGroups) {
-    return (releaseGroups.length === 1 &&
-        releaseGroups.some((group) => group.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP));
-}
-function getVersionPlansAbsolutePath() {
-    return (0, path_1.join)(workspace_root_1.workspaceRoot, versionPlansDirectory);
-}
-function isReleaseType(value) {
-    return semver_1.RELEASE_TYPES.includes(value);
-}
-async function getCommitForVersionPlanFile(rawVersionPlan, isVerbose) {
-    return new Promise((resolve) => {
-        (0, node_child_process_1.exec)(`git log --diff-filter=A --pretty=format:"%s|%h|%an|%ae|%b" -n 1 -- ${rawVersionPlan.absolutePath}`, {
-            windowsHide: true,
-        }, (error, stdout, stderr) => {
-            if (error) {
-                if (isVerbose) {
-                    console.error(`Error executing git command for ${rawVersionPlan.relativePath}: ${error.message}`);
-                }
-                return resolve(null);
-            }
-            if (stderr) {
-                if (isVerbose) {
-                    console.error(`Git command stderr for ${rawVersionPlan.relativePath}: ${stderr}`);
-                }
-                return resolve(null);
-            }
-            const [message, shortHash, authorName, authorEmail, ...body] = stdout
-                .trim()
-                .split('|');
-            const commitDetails = {
-                message: message || '',
-                shortHash: shortHash || '',
-                author: { name: authorName || '', email: authorEmail || '' },
-                body: body.join('|') || '', // Handle case where body might be empty or contain multiple '|'
-            };
-            return resolve(commitDetails);
-        });
-    });
-}