@depup/nx 22.5.4-depup.0

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

@@ -0,0 +1,50 @@
+import type { NxReleaseConfiguration } from '../../config/nx-json';
+/**
+ * @public
+ */
+export declare class ReleaseClient {
+    /**
+     * Nx release configuration to use for the current release client. By default, it will be combined with any
+     * configuration in nx.json, but you can choose to use it as the sole source of truth by setting ignoreNxJsonConfig
+     * to true.
+     */
+    private nxReleaseConfig;
+    private ignoreNxJsonConfig;
+    releaseChangelog: (args: import("./command-object").ChangelogOptions) => Promise<import("./changelog").NxReleaseChangelogResult>;
+    releasePublish: (args: import("./command-object").PublishOptions) => Promise<import("./publish").PublishProjectsResult>;
+    releaseVersion: (args: import("./command-object").VersionOptions) => Promise<import("./version").NxReleaseVersionResult>;
+    release: (args: import("./command-object").ReleaseOptions) => Promise<import("./version").NxReleaseVersionResult>;
+    constructor(
+    /**
+     * Nx release configuration to use for the current release client. By default, it will be combined with any
+     * configuration in nx.json, but you can choose to use it as the sole source of truth by setting ignoreNxJsonConfig
+     * to true.
+     */
+    nxReleaseConfig: NxReleaseConfiguration, ignoreNxJsonConfig?: boolean);
+}
+declare const defaultClient: ReleaseClient;
+/**
+ * @public
+ */
+export declare const releaseChangelog: typeof defaultClient.releaseChangelog;
+/**
+ * @public
+ */
+export { PublishProjectsResult } from './publish';
+/**
+ * @public
+ */
+export declare const releasePublish: typeof defaultClient.releasePublish;
+/**
+ * @public
+ */
+export declare const releaseVersion: typeof defaultClient.releaseVersion;
+/**
+ * @public
+ */
+export declare const release: typeof defaultClient.release;
+/**
+ * @public
+ */
+export { AfterAllProjectsVersioned, VersionActions, } from './version/version-actions';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/release/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAMnE;;GAEG;AACH,qBAAa,aAAa;IAgBtB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,kBAAkB;IArB5B,gBAAgB,iHAGd;IACF,cAAc,0GAGZ;IACF,cAAc,2GAGZ;IACF,OAAO,2GAAmE;;IAGxE;;;;OAIG;IACK,eAAe,EAAE,sBAAsB,EACvC,kBAAkB,GAAE,OAAe;CAE9C;AAED,QAAA,MAAM,aAAa,eAAkD,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAExB,OAAO,aAAa,CAAC,gBAAgB,CAAC;AAE3C;;GAEG;AACH,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAClD;;GAEG;AACH,eAAO,MAAM,cAAc,EAEtB,OAAO,aAAa,CAAC,cAAc,CAAC;AAEzC;;GAEG;AACH,eAAO,MAAM,cAAc,EAEtB,OAAO,aAAa,CAAC,cAAc,CAAC;AAEzC;;GAEG;AACH,eAAO,MAAM,OAAO,EAEf,OAAO,aAAa,CAAC,OAAO,CAAC;AAElC;;GAEG;AACH,OAAO,EACL,yBAAyB,EACzB,cAAc,GACf,MAAM,2BAA2B,CAAC"}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionActions = 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(
+    /**
+     * Nx release configuration to use for the current release client. By default, it will be combined with any
+     * configuration in nx.json, but you can choose to use it as the sole source of truth by setting ignoreNxJsonConfig
+     * to true.
+     */
+    nxReleaseConfig, ignoreNxJsonConfig = false) {
+        this.nxReleaseConfig = nxReleaseConfig;
+        this.ignoreNxJsonConfig = ignoreNxJsonConfig;
+        this.releaseChangelog = (0, changelog_1.createAPI)(this.nxReleaseConfig, this.ignoreNxJsonConfig);
+        this.releasePublish = (0, publish_1.createAPI)(this.nxReleaseConfig, this.ignoreNxJsonConfig);
+        this.releaseVersion = (0, version_1.createAPI)(this.nxReleaseConfig, this.ignoreNxJsonConfig);
+        this.release = (0, release_1.createAPI)(this.nxReleaseConfig, this.ignoreNxJsonConfig);
+    }
+}
+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);
+/**
+ * @public
+ */
+var version_actions_1 = require("./version/version-actions");
+Object.defineProperty(exports, "VersionActions", { enumerable: true, get: function () { return version_actions_1.VersionActions; } });

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

@@ -0,0 +1,5 @@
+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>;
+//# sourceMappingURL=plan-check.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plan-check.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/release/plan-check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAc,MAAM,sBAAsB,CAAC;AAU1E,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAejE,eAAO,MAAM,0BAA0B,GAAI,MAAM,gBAAgB,oBACV,CAAC;AAExD,wBAAgB,SAAS,CAAC,qBAAqB,EAAE,sBAAsB,IAC9B,MAAM,WAAW,KAAG,OAAO,CAAC,MAAM,CAAC,CAyN3E"}

package/src/command-line/release/plan-check.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasePlanCheckCLIHandler = void 0;
+exports.createAPI = createAPI;
+const nx_json_1 = require("../../config/nx-json");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
+const project_graph_1 = require("../../project-graph/project-graph");
+const all_file_data_1 = require("../../utils/all-file-data");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const handle_errors_1 = require("../../utils/handle-errors");
+const output_1 = require("../../utils/output");
+const config_1 = require("./config/config");
+const deep_merge_json_1 = require("./config/deep-merge-json");
+const filter_release_groups_1 = require("./config/filter-release-groups");
+const version_plans_1 = require("./config/version-plans");
+const get_touched_projects_for_group_1 = require("./utils/get-touched-projects-for-group");
+const print_config_1 = require("./utils/print-config");
+const releasePlanCheckCLIHandler = (args) => (0, handle_errors_1.handleErrors)(args.verbose, () => createAPI({})(args));
+exports.releasePlanCheckCLIHandler = releasePlanCheckCLIHandler;
+function createAPI(overrideReleaseConfig) {
+    return async function releasePlanCheck(args) {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        const nxJson = (0, nx_json_1.readNxJson)();
+        const userProvidedReleaseConfig = (0, deep_merge_json_1.deepMergeJson)(nxJson.release ?? {}, overrideReleaseConfig ?? {});
+        // Apply default configuration to any optional user configuration
+        const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), userProvidedReleaseConfig);
+        if (configError) {
+            return await (0, config_1.handleNxReleaseConfigError)(configError);
+        }
+        // --print-config exits directly as it is not designed to be combined with any other programmatic operations
+        if (args.printConfig) {
+            return (0, print_config_1.printConfigAndExit)({
+                userProvidedReleaseConfig,
+                nxReleaseConfig,
+                isDebug: args.printConfig === 'debug',
+            });
+        }
+        // No filtering is applied here, as we want to consider all release groups for plan:check
+        const { error: filterError, releaseGroups } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig);
+        if (filterError) {
+            output_1.output.error(filterError);
+            process.exit(1);
+        }
+        // If no release groups have version plans enabled, provide an explicit error
+        if (!releaseGroups.some((group) => group.versionPlans)) {
+            output_1.output.error({
+                title: 'Version plans are not enabled',
+                bodyLines: [
+                    'Please ensure at least one release group has version plans enabled in your Nx release configuration if you want to use this command.',
+                    '',
+                    'Learn more about version plans here: https://nx.dev/recipes/nx-release/file-based-versioning-version-plans',
+                ],
+            });
+            return 1;
+        }
+        const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
+        await (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes), args.verbose);
+        // Resolve the final values for base, head etc to use when resolving the changes to consider
+        const { nxArgs } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', {
+            printWarnings: args.verbose,
+        }, nxJson);
+        const changedFiles = (0, command_line_utils_1.parseFiles)(nxArgs).files;
+        if (nxArgs.verbose) {
+            if (changedFiles.length) {
+                output_1.output.log({
+                    title: `Changed files based on resolved "base" (${nxArgs.base}) and "head" (${nxArgs.head ?? 'HEAD'})`,
+                    bodyLines: changedFiles.map((file) => `  - ${file}`),
+                });
+            }
+            else {
+                output_1.output.warn({
+                    title: 'No changed files found based on resolved "base" and "head"',
+                });
+            }
+        }
+        const resolvedAllFileData = await (0, all_file_data_1.allFileData)();
+        const getTouchedProjectsForGroup = (0, get_touched_projects_for_group_1.createGetTouchedProjectsForGroup)(nxArgs, projectGraph, changedFiles, resolvedAllFileData);
+        const NOTE_ABOUT_VERBOSE_LOGGING = 'Run with --verbose to see the full list of changed files used for the touched projects logic.';
+        let hasErrors = false;
+        for (const releaseGroup of releaseGroups) {
+            // The current release group doesn't leverage version plans
+            if (!releaseGroup.versionPlans) {
+                continue;
+            }
+            const resolvedVersionPlans = releaseGroup.resolvedVersionPlans || [];
+            // Check upfront if the release group as a whole is featured in any version plan files
+            const matchingVersionPlanFiles = resolvedVersionPlans.filter((plan) => 'groupVersionBump' in plan);
+            if (matchingVersionPlanFiles.length) {
+                output_1.output.log({
+                    title: `${releaseGroup.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? `There are`
+                        : `Release group "${releaseGroup.name}" has`} pending bumps in version plan(s)`,
+                    bodyLines: [
+                        ...matchingVersionPlanFiles.map((plan) => `  - "${plan.groupVersionBump}" in ${plan.fileName}`),
+                    ],
+                });
+                continue;
+            }
+            const touchedProjectsUnderReleaseGroup = await getTouchedProjectsForGroup(releaseGroup, 
+            // We do not take any --projects or --groups filtering into account for plan:check
+            releaseGroup.projects, false);
+            const projectsInResolvedVersionPlans = resolvedVersionPlans.reduce((acc, plan) => {
+                if ('projectVersionBumps' in plan) {
+                    for (const project in plan.projectVersionBumps) {
+                        acc[project] = acc[project] || [];
+                        acc[project].push({
+                            bump: plan.projectVersionBumps[project],
+                            fileName: plan.fileName,
+                        });
+                    }
+                }
+                return acc;
+            }, {});
+            // Ensure each touched project under this release group features in at least one version plan file
+            let touchedProjectsNotFoundInVersionPlans = [];
+            for (const touchedProject of touchedProjectsUnderReleaseGroup) {
+                if (!resolvedVersionPlans.length) {
+                    touchedProjectsNotFoundInVersionPlans.push(touchedProject);
+                    continue;
+                }
+                const matchingVersionPlanFileEntries = projectsInResolvedVersionPlans[touchedProject];
+                if (!matchingVersionPlanFileEntries?.length) {
+                    touchedProjectsNotFoundInVersionPlans.push(touchedProject);
+                    continue;
+                }
+            }
+            // Log any resolved pending bumps, regardless of whether the projects were directly touched or not
+            for (const [projectName, entries] of Object.entries(projectsInResolvedVersionPlans)) {
+                output_1.output.log({
+                    title: `Project "${projectName}" has pending bumps in version plan(s)`,
+                    bodyLines: [
+                        ...entries.map(({ bump, fileName }) => `  - "${bump}" in ${fileName}`),
+                    ],
+                });
+            }
+            if (touchedProjectsNotFoundInVersionPlans.length) {
+                const bodyLines = [
+                    `The following touched projects${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? ` under release group "${releaseGroup.name}"`
+                        : ''} do not feature in any version plan files:`,
+                    ...touchedProjectsNotFoundInVersionPlans.map((project) => `  - ${project}`),
+                    '',
+                    'Please use `nx release plan` to generate missing version plans, or adjust your "versionPlans.ignorePatternsForPlanCheck" config stop certain files from affecting the projects for the purposes of this command.',
+                ];
+                if (!nxArgs.verbose) {
+                    bodyLines.push('', NOTE_ABOUT_VERBOSE_LOGGING);
+                }
+                output_1.output.error({
+                    title: 'Touched projects missing version plans',
+                    bodyLines,
+                });
+                // At least one project in one release group has an issue
+                hasErrors = true;
+            }
+        }
+        // Do not print success message if any projects are missing version plans
+        if (hasErrors) {
+            return 1;
+        }
+        const bodyLines = [];
+        if (!nxArgs.verbose) {
+            bodyLines.push(NOTE_ABOUT_VERBOSE_LOGGING);
+        }
+        output_1.output.success({
+            title: 'All touched projects have, or do not require, version plans.',
+            bodyLines,
+        });
+        return 0;
+    };
+}

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

@@ -0,0 +1,5 @@
+import { NxReleaseConfiguration } from '../../config/nx-json';
+import { PlanOptions } from './command-object';
+export declare const releasePlanCLIHandler: (args: PlanOptions) => Promise<number>;
+export declare function createAPI(overrideReleaseConfig: NxReleaseConfiguration): (args: PlanOptions) => Promise<string | number>;
+//# sourceMappingURL=plan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/release/plan.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,sBAAsB,EAAc,MAAM,sBAAsB,CAAC;AAU1E,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAe/C,eAAO,MAAM,qBAAqB,GAAI,MAAM,WAAW,oBACA,CAAC;AAExD,wBAAgB,SAAS,CAAC,qBAAqB,EAAE,sBAAsB,IAEnE,MAAM,WAAW,KAChB,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,CA+N5B"}

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

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasePlanCLIHandler = void 0;
+exports.createAPI = createAPI;
+const enquirer_1 = require("enquirer");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const semver_1 = require("semver");
+const tmp_1 = require("tmp");
+const nx_json_1 = require("../../config/nx-json");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
+const project_graph_1 = require("../../project-graph/project-graph");
+const all_file_data_1 = require("../../utils/all-file-data");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const handle_errors_1 = require("../../utils/handle-errors");
+const output_1 = require("../../utils/output");
+const config_1 = require("./config/config");
+const deep_merge_json_1 = require("./config/deep-merge-json");
+const filter_release_groups_1 = require("./config/filter-release-groups");
+const version_plans_1 = require("./config/version-plans");
+const generate_version_plan_content_1 = require("./utils/generate-version-plan-content");
+const get_touched_projects_for_group_1 = require("./utils/get-touched-projects-for-group");
+const launch_editor_1 = require("./utils/launch-editor");
+const print_changes_1 = require("./utils/print-changes");
+const print_config_1 = require("./utils/print-config");
+const releasePlanCLIHandler = (args) => (0, handle_errors_1.handleErrors)(args.verbose, () => createAPI({})(args));
+exports.releasePlanCLIHandler = releasePlanCLIHandler;
+function createAPI(overrideReleaseConfig) {
+    return async function releasePlan(args) {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        const nxJson = (0, nx_json_1.readNxJson)();
+        const userProvidedReleaseConfig = (0, deep_merge_json_1.deepMergeJson)(nxJson.release ?? {}, overrideReleaseConfig ?? {});
+        // Apply default configuration to any optional user configuration
+        const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), userProvidedReleaseConfig);
+        if (configError) {
+            return await (0, config_1.handleNxReleaseConfigError)(configError);
+        }
+        // --print-config exits directly as it is not designed to be combined with any other programmatic operations
+        if (args.printConfig) {
+            return (0, print_config_1.printConfigAndExit)({
+                userProvidedReleaseConfig,
+                nxReleaseConfig,
+                isDebug: args.printConfig === 'debug',
+            });
+        }
+        const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
+        if (filterError) {
+            output_1.output.error(filterError);
+            process.exit(1);
+        }
+        // If no release groups have version plans enabled, it doesn't make sense to use the plan command only to set yourself up for an error at release time
+        if (!releaseGroups.some((group) => !!group.versionPlans)) {
+            if (releaseGroups.length === 1) {
+                output_1.output.warn({
+                    title: `Version plans are not enabled in your release configuration`,
+                    bodyLines: [
+                        'To enable version plans, set `"versionPlans": true` at the top level of your `"release"` configuration',
+                    ],
+                });
+                return 0;
+            }
+            output_1.output.warn({
+                title: 'No release groups have version plans enabled',
+                bodyLines: [
+                    'To enable version plans, set `"versionPlans": true` at the top level of your `"release"` configuration to apply it to all groups, otherwise set it at the release group level',
+                ],
+            });
+            return 0;
+        }
+        // Resolve the final values for base, head etc to use when resolving the changes to consider
+        const { nxArgs } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', {
+            printWarnings: args.verbose,
+        }, nxJson);
+        const versionPlanBumps = {};
+        const setBumpIfNotNone = (projectOrGroup, version) => {
+            if (version !== 'none') {
+                versionPlanBumps[projectOrGroup] = version;
+            }
+        };
+        // Changed files are only relevant if considering touched projects
+        let changedFiles = [];
+        let getProjectsToVersionForGroup;
+        if (args.onlyTouched) {
+            changedFiles = (0, command_line_utils_1.parseFiles)(nxArgs).files;
+            if (nxArgs.verbose) {
+                if (changedFiles.length) {
+                    output_1.output.log({
+                        title: `Changed files based on resolved "base" (${nxArgs.base}) and "head" (${nxArgs.head ?? 'HEAD'})`,
+                        bodyLines: changedFiles.map((file) => `  - ${file}`),
+                    });
+                }
+                else {
+                    output_1.output.warn({
+                        title: 'No changed files found based on resolved "base" and "head"',
+                    });
+                }
+            }
+            const resolvedAllFileData = await (0, all_file_data_1.allFileData)();
+            getProjectsToVersionForGroup = (0, get_touched_projects_for_group_1.createGetTouchedProjectsForGroup)(nxArgs, projectGraph, changedFiles, resolvedAllFileData);
+        }
+        if (args.projects?.length) {
+            /**
+             * Run plan for all remaining release groups and filtered projects within them
+             */
+            for (const releaseGroup of releaseGroups) {
+                const releaseGroupName = releaseGroup.name;
+                const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+                let applicableProjects = releaseGroupProjectNames;
+                if (args.onlyTouched &&
+                    typeof getProjectsToVersionForGroup === 'function') {
+                    applicableProjects = await getProjectsToVersionForGroup(releaseGroup, releaseGroupProjectNames, true);
+                }
+                if (!applicableProjects.length) {
+                    continue;
+                }
+                if (releaseGroup.projectsRelationship === 'independent') {
+                    for (const project of applicableProjects) {
+                        setBumpIfNotNone(project, args.bump ||
+                            (await promptForVersion(`How do you want to bump the version of the project "${project}"${releaseGroupName === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                                ? ''
+                                : ` within group "${releaseGroupName}"`}?`)));
+                    }
+                }
+                else {
+                    setBumpIfNotNone(releaseGroupName, args.bump ||
+                        (await promptForVersion(`How do you want to bump the versions of ${releaseGroupName === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                            ? 'all projects'
+                            : `the projects in the group "${releaseGroupName}"`}?`)));
+                }
+            }
+            // Create a version plan file if applicable
+            await createVersionPlanFileForBumps(args, versionPlanBumps);
+            return 0;
+        }
+        /**
+         * Run plan for all remaining release groups
+         */
+        for (const releaseGroup of releaseGroups) {
+            const releaseGroupName = releaseGroup.name;
+            let applicableProjects = releaseGroup.projects;
+            if (args.onlyTouched &&
+                typeof getProjectsToVersionForGroup === 'function') {
+                applicableProjects = await getProjectsToVersionForGroup(releaseGroup, releaseGroup.projects, false);
+            }
+            if (!applicableProjects.length) {
+                continue;
+            }
+            if (releaseGroup.projectsRelationship === 'independent') {
+                for (const project of applicableProjects) {
+                    setBumpIfNotNone(project, args.bump ||
+                        (await promptForVersion(`How do you want to bump the version of the project "${project}"${releaseGroupName === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                            ? ''
+                            : ` within group "${releaseGroupName}"`}?`)));
+                }
+            }
+            else {
+                setBumpIfNotNone(releaseGroupName, args.bump ||
+                    (await promptForVersion(`How do you want to bump the versions of ${releaseGroupName === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? 'all projects'
+                        : `the projects in the group "${releaseGroupName}"`}?`)));
+            }
+        }
+        // Create a version plan file if applicable
+        await createVersionPlanFileForBumps(args, versionPlanBumps);
+        return 0;
+    };
+}
+async function createVersionPlanFileForBumps(args, versionPlanBumps) {
+    if (!Object.keys(versionPlanBumps).length) {
+        let bodyLines = [];
+        if (args.onlyTouched) {
+            bodyLines = [
+                'This might be because no projects have been changed, or projects you expected to release have not been touched',
+                'To include all projects, not just those that have been changed, pass --only-touched=false',
+                'Alternatively, you can specify alternate --base and --head refs to include only changes from certain commits',
+            ];
+        }
+        output_1.output.warn({
+            title: 'No version bumps were selected so no version plan file was created.',
+            bodyLines,
+        });
+        return 0;
+    }
+    const versionPlanName = `version-plan-${new Date().getTime()}`;
+    const versionPlanMessage = args.message || (await promptForMessage(versionPlanName));
+    const versionPlanFileContent = (0, generate_version_plan_content_1.generateVersionPlanContent)(versionPlanBumps, versionPlanMessage);
+    const versionPlanFileName = `${versionPlanName}.md`;
+    if (args.dryRun) {
+        output_1.output.logSingleLine(`Would create version plan file "${versionPlanFileName}", but --dry-run was set.`);
+        (0, print_changes_1.printDiff)('', versionPlanFileContent, 1);
+    }
+    else {
+        output_1.output.logSingleLine(`Creating version plan file "${versionPlanFileName}"`);
+        (0, print_changes_1.printDiff)('', versionPlanFileContent, 1);
+        const versionPlansAbsolutePath = (0, version_plans_1.getVersionPlansAbsolutePath)();
+        await (0, promises_1.mkdir)(versionPlansAbsolutePath, { recursive: true });
+        await (0, promises_1.writeFile)((0, node_path_1.join)(versionPlansAbsolutePath, versionPlanFileName), versionPlanFileContent);
+    }
+}
+async function promptForVersion(message) {
+    try {
+        const reply = await (0, enquirer_1.prompt)([
+            {
+                name: 'version',
+                message,
+                type: 'select',
+                choices: [...semver_1.RELEASE_TYPES, 'none'],
+            },
+        ]);
+        return reply.version;
+    }
+    catch {
+        output_1.output.log({
+            title: 'Cancelled version plan creation.',
+        });
+        // Ensure the cursor is always restored before exiting
+        process.stdout.write('\u001b[?25h');
+        process.exit(0);
+    }
+}
+async function promptForMessage(versionPlanName) {
+    let message;
+    do {
+        message = await _promptForMessage(versionPlanName);
+    } while (!message);
+    return message;
+}
+async function _promptForMessage(versionPlanName) {
+    try {
+        const reply = await (0, enquirer_1.prompt)([
+            {
+                name: 'message',
+                message: 'What changelog message would you like associated with this change? (Leave blank to open an external editor for multi-line messages/easier editing)',
+                type: 'input',
+            },
+        ]);
+        let message = reply.message.trim();
+        if (!message.length) {
+            const tmpDir = (0, tmp_1.dirSync)().name;
+            const messageFilePath = (0, node_path_1.join)(tmpDir, `DRAFT_MESSAGE__${versionPlanName}.md`);
+            (0, node_fs_1.writeFileSync)(messageFilePath, '');
+            await (0, launch_editor_1.launchEditor)(messageFilePath);
+            message = (0, node_fs_1.readFileSync)(messageFilePath, 'utf-8');
+        }
+        message = message.trim();
+        if (!message) {
+            output_1.output.warn({
+                title: 'A changelog message is required in order to create the version plan file',
+                bodyLines: [],
+            });
+        }
+        return message;
+    }
+    catch (e) {
+        output_1.output.log({
+            title: 'Cancelled version plan creation.',
+        });
+        process.exit(0);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { NxReleaseConfiguration } from '../../config/nx-json';
+import { PublishOptions } from './command-object';
+export interface PublishProjectsResult {
+    [projectName: string]: {
+        code: number;
+    };
+}
+export declare const releasePublishCLIHandler: (args: PublishOptions) => Promise<number>;
+export declare function createAPI(overrideReleaseConfig: NxReleaseConfiguration, ignoreNxJsonConfig: boolean): (args: PublishOptions) => Promise<PublishProjectsResult>;
+//# sourceMappingURL=publish.d.ts.map

package/src/command-line/release/publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/release/publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,sBAAsB,EAEvB,MAAM,sBAAsB,CAAC;AAuB9B,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AASlD,MAAM,WAAW,qBAAqB;IACpC,CAAC,WAAW,EAAE,MAAM,GAAG;QACrB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAED,eAAO,MAAM,wBAAwB,GAAI,MAAM,cAAc,oBAYzD,CAAC;AAEL,wBAAgB,SAAS,CACvB,qBAAqB,EAAE,sBAAsB,EAC7C,kBAAkB,EAAE,OAAO,IAQzB,MAAM,cAAc,KACnB,OAAO,CAAC,qBAAqB,CAAC,CAuIlC"}