@ohos-ports/nx 19.8.4-beta.0

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

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

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONVENTIONAL_COMMITS_CONFIG = void 0;
+exports.DEFAULT_CONVENTIONAL_COMMITS_CONFIG = {
+    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,
+            },
+        },
+    },
+};

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

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

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

@@ -0,0 +1,28 @@
+"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/src/command-line/release/config/filter-release-groups.d.ts

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

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

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterReleaseGroups = filterReleaseGroups;
+const find_matching_projects_1 = require("../../../utils/find-matching-projects");
+const output_1 = require("../../../utils/output");
+const config_1 = require("./config");
+function filterReleaseGroups(projectGraph, nxReleaseConfig, projectsFilter, groupsFilter) {
+    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`,
+                },
+                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}`),
+                    },
+                    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: [],
+                    },
+                    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}`),
+                },
+                releaseGroups: [],
+                releaseGroupToFilteredProjects,
+            };
+        }
+        output_1.output.note({
+            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,
+            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`,
+            },
+            releaseGroups: [],
+            releaseGroupToFilteredProjects,
+        };
+    }
+    return {
+        error: null,
+        releaseGroups,
+        releaseGroupToFilteredProjects,
+    };
+}

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

@@ -0,0 +1,42 @@
+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/src/command-line/release/config/version-plans.js

@@ -0,0 +1,220 @@
+"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 fm = require('front-matter');
+const versionPlansDirectory = (0, path_1.join)('.nx', 'version-plans');
+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 = fm(versionPlanContent);
+        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 ${semver_1.RELEASE_TYPES.join(', ')}.`);
+                    }
+                    else {
+                        throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' with an invalid release type. Please specify one of ${semver_1.RELEASE_TYPES.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 ${semver_1.RELEASE_TYPES.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 {
+                            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);
+        });
+    });
+}

package/src/command-line/release/index.d.ts

@@ -0,0 +1,30 @@
+import type { NxReleaseConfiguration } from '../../config/nx-json';
+/**
+ * @public
+ */
+export declare class ReleaseClient {
+    private overrideReleaseConfig;
+    releaseChangelog: (args: import("./command-object").ChangelogOptions) => Promise<import("./changelog").NxReleaseChangelogResult>;
+    releasePublish: (args: import("./command-object").PublishOptions, isCLI?: boolean) => Promise<number>;
+    releaseVersion: (args: import("./command-object").VersionOptions) => Promise<import("./version").NxReleaseVersionResult>;
+    release: (args: import("./command-object").ReleaseOptions) => Promise<import("./version").NxReleaseVersionResult | number>;
+    constructor(overrideReleaseConfig: NxReleaseConfiguration);
+}
+declare const defaultClient: ReleaseClient;
+/**
+ * @public
+ */
+export declare const releaseChangelog: typeof defaultClient.releaseChangelog;
+/**
+ * @public
+ */
+export declare const releasePublish: typeof defaultClient.releasePublish;
+/**
+ * @public
+ */
+export declare const releaseVersion: typeof defaultClient.releaseVersion;
+/**
+ * @public
+ */
+export declare const release: typeof defaultClient.release;
+export {};

package/src/command-line/release/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = exports.releaseVersion = exports.releasePublish = exports.releaseChangelog = exports.ReleaseClient = void 0;
+const changelog_1 = require("./changelog");
+const publish_1 = require("./publish");
+const release_1 = require("./release");
+const version_1 = require("./version");
+/**
+ * @public
+ */
+class ReleaseClient {
+    constructor(overrideReleaseConfig) {
+        this.overrideReleaseConfig = overrideReleaseConfig;
+        this.releaseChangelog = (0, changelog_1.createAPI)(this.overrideReleaseConfig);
+        this.releasePublish = (0, publish_1.createAPI)(this.overrideReleaseConfig);
+        this.releaseVersion = (0, version_1.createAPI)(this.overrideReleaseConfig);
+        this.release = (0, release_1.createAPI)(this.overrideReleaseConfig);
+    }
+}
+exports.ReleaseClient = ReleaseClient;
+const defaultClient = new ReleaseClient({});
+/**
+ * @public
+ */
+exports.releaseChangelog = defaultClient.releaseChangelog.bind(defaultClient);
+/**
+ * @public
+ */
+exports.releasePublish = defaultClient.releasePublish.bind(defaultClient);
+/**
+ * @public
+ */
+exports.releaseVersion = defaultClient.releaseVersion.bind(defaultClient);
+/**
+ * @public
+ */
+exports.release = defaultClient.release.bind(defaultClient);

package/src/command-line/release/plan-check.d.ts

@@ -0,0 +1,4 @@
+import { NxReleaseConfiguration } from '../../config/nx-json';
+import { PlanCheckOptions, PlanOptions } from './command-object';
+export declare const releasePlanCheckCLIHandler: (args: PlanCheckOptions) => Promise<number>;
+export declare function createAPI(overrideReleaseConfig: NxReleaseConfiguration): (args: PlanOptions) => Promise<number>;