@nx/js 0.0.0-pr-22179-271588f

package/src/generators/library/schema.json

@@ -0,0 +1,151 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxTypescriptLibrary",
+  "cli": "nx",
+  "title": "Create a TypeScript Library",
+  "description": "Create a TypeScript Library.",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Library name.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the library?",
+      "pattern": "(?:^@[a-zA-Z0-9-*~][a-zA-Z0-9-*._~]*\\/[a-zA-Z0-9-~][a-zA-Z0-9-._~]*|^[a-zA-Z][^:]*)$"
+    },
+    "directory": {
+      "type": "string",
+      "description": "A directory where the lib is placed.",
+      "x-priority": "important"
+    },
+    "projectNameAndRootFormat": {
+      "description": "Whether to generate the project name and root directory as provided (`as-provided`) or generate them composing their values and taking the configured layout into account (`derived`).",
+      "type": "string",
+      "enum": ["as-provided", "derived"]
+    },
+    "linter": {
+      "description": "The tool to use for running lint checks.",
+      "type": "string",
+      "enum": ["eslint", "none"],
+      "default": "eslint"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["jest", "vitest", "none"],
+      "description": "Test runner to use for unit tests.",
+      "x-prompt": "Which unit test runner would you like to use?"
+    },
+    "tags": {
+      "type": "string",
+      "description": "Add tags to the library (used for linting)."
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "skipPackageJson": {
+      "description": "Do not add dependencies to `package.json`.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "skipTsConfig": {
+      "type": "boolean",
+      "description": "Do not update tsconfig.json for development experience.",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "includeBabelRc": {
+      "type": "boolean",
+      "description": "Include a .babelrc configuration to compile TypeScript files"
+    },
+    "testEnvironment": {
+      "type": "string",
+      "enum": ["jsdom", "node"],
+      "description": "The test environment to use if unitTestRunner is set to jest or vitest.",
+      "default": "node"
+    },
+    "pascalCaseFiles": {
+      "type": "boolean",
+      "description": "Use pascal case file names.",
+      "alias": "P",
+      "default": false
+    },
+    "js": {
+      "type": "boolean",
+      "description": "Generate JavaScript files rather than TypeScript files.",
+      "default": false
+    },
+    "strict": {
+      "type": "boolean",
+      "description": "Whether to enable tsconfig strict mode or not.",
+      "default": true
+    },
+    "publishable": {
+      "type": "boolean",
+      "default": false,
+      "description": "Configure the library ready for use with `nx release` (https://nx.dev/core-features/manage-releases).",
+      "x-priority": "important"
+    },
+    "importPath": {
+      "type": "string",
+      "description": "The library name used to import it, like @myorg/my-awesome-lib. Required for publishable library.",
+      "x-priority": "important"
+    },
+    "buildable": {
+      "type": "boolean",
+      "default": true,
+      "description": "Generate a buildable library.",
+      "x-deprecated": "Use the `bundler` option for greater control (swc, tsc, rollup, vite, esbuild, none)."
+    },
+    "setParserOptionsProject": {
+      "type": "boolean",
+      "description": "Whether or not to configure the ESLint `parserOptions.project` option. We do not do this by default for lint performance reasons.",
+      "default": false
+    },
+    "config": {
+      "type": "string",
+      "enum": ["workspace", "project", "npm-scripts"],
+      "default": "project",
+      "description": "Determines whether the project's executors should be configured in `workspace.json`, `project.json` or as npm scripts.",
+      "x-priority": "internal"
+    },
+    "compiler": {
+      "type": "string",
+      "enum": ["tsc", "swc"],
+      "default": "tsc",
+      "description": "The compiler used by the build and test targets",
+      "x-deprecated": "Use the `bundler` option for greater control (swc, tsc, rollup, vite, esbuild, none)."
+    },
+    "bundler": {
+      "description": "The bundler to use. Choosing 'none' means this library is not buildable.",
+      "type": "string",
+      "enum": ["swc", "tsc", "rollup", "vite", "esbuild", "none"],
+      "default": "tsc",
+      "x-prompt": "Which bundler would you like to use to build the library? Choose 'none' to skip build setup.",
+      "x-priority": "important"
+    },
+    "skipTypeCheck": {
+      "type": "boolean",
+      "description": "Whether to skip TypeScript type checking for SWC compiler.",
+      "default": false
+    },
+    "minimal": {
+      "type": "boolean",
+      "description": "Generate a library with a minimal setup. No README.md generated.",
+      "default": false
+    },
+    "simpleName": {
+      "description": "Don't include the directory in the generated file name.",
+      "type": "boolean",
+      "default": false
+    }
+  },
+  "required": ["name"],
+  "examplesFile": "../../../docs/library-examples.md"
+}

package/src/generators/release-version/release-version.d.ts

@@ -0,0 +1,5 @@
+import { Tree } from '@nx/devkit';
+import { ReleaseVersionGeneratorResult } from 'nx/src/command-line/release/version';
+import { ReleaseVersionGeneratorSchema } from './schema';
+export declare function releaseVersionGenerator(tree: Tree, options: ReleaseVersionGeneratorSchema): Promise<ReleaseVersionGeneratorResult>;
+export default releaseVersionGenerator;

package/src/generators/release-version/release-version.js

@@ -0,0 +1,390 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseVersionGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const chalk = require("chalk");
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const config_1 = require("nx/src/command-line/release/config/config");
+const git_1 = require("nx/src/command-line/release/utils/git");
+const resolve_semver_specifier_1 = require("nx/src/command-line/release/utils/resolve-semver-specifier");
+const semver_1 = require("nx/src/command-line/release/utils/semver");
+const version_1 = require("nx/src/command-line/release/version");
+const utils_1 = require("nx/src/tasks-runner/utils");
+const ora = require("ora");
+const semver_2 = require("semver");
+const resolve_local_package_dependencies_1 = require("./utils/resolve-local-package-dependencies");
+const update_lock_file_1 = require("./utils/update-lock-file");
+async function releaseVersionGenerator(tree, options) {
+    try {
+        const versionData = {};
+        // If the user provided a specifier, validate that it is valid semver or a relative semver keyword
+        if (options.specifier) {
+            if (!(0, semver_1.isValidSemverSpecifier)(options.specifier)) {
+                throw new Error(`The given version specifier "${options.specifier}" is not valid. You provide an exact version or a valid semver keyword such as "major", "minor", "patch", etc.`);
+            }
+            // The node semver library classes a leading `v` as valid, but we want to ensure it is not present in the final version
+            options.specifier = options.specifier.replace(/^v/, '');
+        }
+        if (options.versionPrefix &&
+            version_1.validReleaseVersionPrefixes.indexOf(options.versionPrefix) === -1) {
+            throw new Error(`Invalid value for version.generatorOptions.versionPrefix: "${options.versionPrefix}"
+
+Valid values are: ${version_1.validReleaseVersionPrefixes
+                .map((s) => `"${s}"`)
+                .join(', ')}`);
+        }
+        if (options.firstRelease) {
+            // always use disk as a fallback for the first release
+            options.fallbackCurrentVersionResolver = 'disk';
+        }
+        const projects = options.projects;
+        const resolvePackageRoot = createResolvePackageRoot(options.packageRoot);
+        // Resolve any custom package roots for each project upfront as they will need to be reused during dependency resolution
+        const projectNameToPackageRootMap = new Map();
+        for (const project of projects) {
+            projectNameToPackageRootMap.set(project.name, resolvePackageRoot(project));
+        }
+        let currentVersion = undefined;
+        let currentVersionResolvedFromFallback = false;
+        // only used for options.currentVersionResolver === 'git-tag', but
+        // must be declared here in order to reuse it for additional projects
+        let latestMatchingGitTag = undefined;
+        // if specifier is undefined, then we haven't resolved it yet
+        // if specifier is null, then it has been resolved and no changes are necessary
+        let specifier = options.specifier
+            ? options.specifier
+            : undefined;
+        for (const project of projects) {
+            const projectName = project.name;
+            const packageRoot = projectNameToPackageRootMap.get(projectName);
+            if (!packageRoot) {
+                throw new Error(`The project "${projectName}" does not have a packageRoot available. Please report this issue on https://github.com/nrwl/nx`);
+            }
+            const packageJsonPath = (0, devkit_1.joinPathFragments)(packageRoot, 'package.json');
+            const workspaceRelativePackageJsonPath = (0, node_path_1.relative)(devkit_1.workspaceRoot, packageJsonPath);
+            const color = getColor(projectName);
+            const log = (msg) => {
+                console.log(color.instance.bold(projectName) + ' ' + msg);
+            };
+            if (!tree.exists(packageJsonPath)) {
+                throw new Error(`The project "${projectName}" does not have a package.json available at ${workspaceRelativePackageJsonPath}.
+
+To fix this you will either need to add a package.json file at that location, or configure "release" within your nx.json to exclude "${projectName}" from the current release group, or amend the packageRoot configuration to point to where the package.json should be.`);
+            }
+            devkit_1.output.logSingleLine(`Running release version for project: ${color.instance.bold(project.name)}`);
+            const projectPackageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
+            log(`🔍 Reading data for package "${projectPackageJson.name}" from ${workspaceRelativePackageJsonPath}`);
+            const { name: packageName, version: currentVersionFromDisk } = projectPackageJson;
+            switch (options.currentVersionResolver) {
+                case 'registry': {
+                    const metadata = options.currentVersionResolverMetadata;
+                    const registry = metadata?.registry ??
+                        (await getNpmRegistry()) ??
+                        'https://registry.npmjs.org';
+                    const tag = metadata?.tag ?? 'latest';
+                    /**
+                     * If the currentVersionResolver is set to registry, and the projects are not independent, we only want to make the request once for the whole batch of projects.
+                     * For independent projects, we need to make a request for each project individually as they will most likely have different versions.
+                     */
+                    if (!currentVersion ||
+                        options.releaseGroup.projectsRelationship === 'independent') {
+                        const spinner = ora(`${Array.from(new Array(projectName.length + 3)).join(' ')}Resolving the current version for tag "${tag}" on ${registry}`);
+                        spinner.color =
+                            color.spinnerColor;
+                        spinner.start();
+                        try {
+                            // Must be non-blocking async to allow spinner to render
+                            currentVersion = await new Promise((resolve, reject) => {
+                                (0, node_child_process_1.exec)(`npm view ${packageName} version --registry=${registry} --tag=${tag}`, (error, stdout, stderr) => {
+                                    if (error) {
+                                        return reject(error);
+                                    }
+                                    if (stderr) {
+                                        return reject(stderr);
+                                    }
+                                    return resolve(stdout.trim());
+                                });
+                            });
+                            spinner.stop();
+                            log(`📄 Resolved the current version as ${currentVersion} for tag "${tag}" from registry ${registry}`);
+                        }
+                        catch (e) {
+                            spinner.stop();
+                            if (options.fallbackCurrentVersionResolver === 'disk') {
+                                log(`📄 Unable to resolve the current version from the registry ${registry}. Falling back to the version on disk of ${currentVersionFromDisk}`);
+                                currentVersion = currentVersionFromDisk;
+                                currentVersionResolvedFromFallback = true;
+                            }
+                            else {
+                                throw new Error(`Unable to resolve the current version from the registry ${registry}. Please ensure that the package exists in the registry in order to use the "registry" currentVersionResolver. Alternatively, you can use the --first-release option or set "release.version.generatorOptions.fallbackCurrentVersionResolver" to "disk" in order to fallback to the version on disk when the registry lookup fails.`);
+                            }
+                        }
+                    }
+                    else {
+                        if (currentVersionResolvedFromFallback) {
+                            log(`📄 Using the current version ${currentVersion} already resolved from disk fallback.`);
+                        }
+                        else {
+                            log(`📄 Using the current version ${currentVersion} already resolved from the registry ${registry}`);
+                        }
+                    }
+                    break;
+                }
+                case 'disk':
+                    currentVersion = currentVersionFromDisk;
+                    log(`📄 Resolved the current version as ${currentVersion} from ${packageJsonPath}`);
+                    break;
+                case 'git-tag': {
+                    if (!currentVersion ||
+                        // We always need to independently resolve the current version from git tag per project if the projects are independent
+                        options.releaseGroup.projectsRelationship === 'independent') {
+                        const releaseTagPattern = options.releaseGroup.releaseTagPattern;
+                        latestMatchingGitTag = await (0, git_1.getLatestGitTagForPattern)(releaseTagPattern, {
+                            projectName: project.name,
+                        });
+                        if (!latestMatchingGitTag) {
+                            if (options.fallbackCurrentVersionResolver === 'disk') {
+                                log(`📄 Unable to resolve the current version from git tag using pattern "${releaseTagPattern}". Falling back to the version on disk of ${currentVersionFromDisk}`);
+                                currentVersion = currentVersionFromDisk;
+                                currentVersionResolvedFromFallback = true;
+                            }
+                            else {
+                                throw new Error(`No git tags matching pattern "${releaseTagPattern}" for project "${project.name}" were found. You will need to create an initial matching tag to use as a base for determining the next version. Alternatively, you can use the --first-release option or set "release.version.generatorOptions.fallbackCurrentVersionResolver" to "disk" in order to fallback to the version on disk when no matching git tags are found.`);
+                            }
+                        }
+                        else {
+                            currentVersion = latestMatchingGitTag.extractedVersion;
+                            log(`📄 Resolved the current version as ${currentVersion} from git tag "${latestMatchingGitTag.tag}".`);
+                        }
+                    }
+                    else {
+                        if (currentVersionResolvedFromFallback) {
+                            log(`📄 Using the current version ${currentVersion} already resolved from disk fallback.`);
+                        }
+                        else {
+                            log(
+                            // In this code path we know that latestMatchingGitTag is defined, because we are not relying on the fallbackCurrentVersionResolver, so we can safely use the non-null assertion operator
+                            `📄 Using the current version ${currentVersion} already resolved from git tag "${latestMatchingGitTag.tag}".`);
+                        }
+                    }
+                    break;
+                }
+                default:
+                    throw new Error(`Invalid value for options.currentVersionResolver: ${options.currentVersionResolver}`);
+            }
+            if (options.specifier) {
+                log(`📄 Using the provided version specifier "${options.specifier}".`);
+            }
+            /**
+             * If we are versioning independently then we always need to determine the specifier for each project individually, except
+             * for the case where the user has provided an explicit specifier on the command.
+             *
+             * Otherwise, if versioning the projects together we only need to perform this logic if the specifier is still unset from
+             * previous iterations of the loop.
+             *
+             * NOTE: In the case that we have previously determined via conventional commits that no changes are necessary, the specifier
+             * will be explicitly set to `null`, so that is why we only check for `undefined` explicitly here.
+             */
+            if (specifier === undefined ||
+                (options.releaseGroup.projectsRelationship === 'independent' &&
+                    !options.specifier)) {
+                const specifierSource = options.specifierSource;
+                switch (specifierSource) {
+                    case 'conventional-commits': {
+                        if (options.currentVersionResolver !== 'git-tag') {
+                            throw new Error(`Invalid currentVersionResolver "${options.currentVersionResolver}" provided for release group "${options.releaseGroup.name}". Must be "git-tag" when "specifierSource" is "conventional-commits"`);
+                        }
+                        const affectedProjects = options.releaseGroup.projectsRelationship === 'independent'
+                            ? [projectName]
+                            : projects.map((p) => p.name);
+                        // latestMatchingGitTag will be undefined if the current version was resolved from the disk fallback.
+                        // In this case, we want to use the first commit as the ref to be consistent with the changelog command.
+                        const previousVersionRef = latestMatchingGitTag
+                            ? latestMatchingGitTag.tag
+                            : options.fallbackCurrentVersionResolver === 'disk'
+                                ? await (0, git_1.getFirstGitCommit)()
+                                : undefined;
+                        if (!previousVersionRef) {
+                            // This should never happen since the checks above should catch if the current version couldn't be resolved
+                            throw new Error(`Unable to determine previous version ref for the projects ${affectedProjects.join(', ')}. This is likely a bug in Nx.`);
+                        }
+                        specifier = await (0, resolve_semver_specifier_1.resolveSemverSpecifierFromConventionalCommits)(previousVersionRef, options.projectGraph, affectedProjects);
+                        if (!specifier) {
+                            log(`🚫 No changes were detected using git history and the conventional commits standard.`);
+                            break;
+                        }
+                        // TODO: reevaluate this logic/workflow for independent projects
+                        //
+                        // Always assume that if the current version is a prerelease, then the next version should be a prerelease.
+                        // Users must manually graduate from a prerelease to a release by providing an explicit specifier.
+                        if ((0, semver_2.prerelease)(currentVersion ?? '')) {
+                            specifier = 'prerelease';
+                            log(`📄 Resolved the specifier as "${specifier}" since the current version is a prerelease.`);
+                        }
+                        else {
+                            log(`📄 Resolved the specifier as "${specifier}" using git history and the conventional commits standard.`);
+                        }
+                        break;
+                    }
+                    case 'prompt': {
+                        // Only add the release group name to the log if it is one set by the user, otherwise it is useless noise
+                        const maybeLogReleaseGroup = (log) => {
+                            if (options.releaseGroup.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP) {
+                                return log;
+                            }
+                            return `${log} within release group "${options.releaseGroup.name}"`;
+                        };
+                        if (options.releaseGroup.projectsRelationship === 'independent') {
+                            specifier = await (0, resolve_semver_specifier_1.resolveSemverSpecifierFromPrompt)(`${maybeLogReleaseGroup(`What kind of change is this for project "${projectName}"`)}?`, `${maybeLogReleaseGroup(`What is the exact version for project "${projectName}"`)}?`);
+                        }
+                        else {
+                            specifier = await (0, resolve_semver_specifier_1.resolveSemverSpecifierFromPrompt)(`${maybeLogReleaseGroup(`What kind of change is this for the ${projects.length} matched projects(s)`)}?`, `${maybeLogReleaseGroup(`What is the exact version for the ${projects.length} matched project(s)`)}?`);
+                        }
+                        break;
+                    }
+                    default:
+                        throw new Error(`Invalid specifierSource "${specifierSource}" provided. Must be one of "prompt" or "conventional-commits"`);
+                }
+            }
+            // Resolve any local package dependencies for this project (before applying the new version or updating the versionData)
+            const localPackageDependencies = (0, resolve_local_package_dependencies_1.resolveLocalPackageDependencies)(tree, options.projectGraph, projects, projectNameToPackageRootMap, resolvePackageRoot, 
+            // includeAll when the release group is independent, as we may be filtering to a specific subset of projects, but we still want to update their dependents
+            options.releaseGroup.projectsRelationship === 'independent');
+            const dependentProjects = Object.values(localPackageDependencies)
+                .flat()
+                .filter((localPackageDependency) => {
+                return localPackageDependency.target === project.name;
+            });
+            if (!currentVersion) {
+                throw new Error(`The current version for project "${project.name}" could not be resolved. Please report this on https://github.com/nrwl/nx`);
+            }
+            versionData[projectName] = {
+                currentVersion,
+                dependentProjects,
+                // @ts-ignore: The types will be updated in a future version of Nx
+                newVersion: null, // will stay as null in the final result in the case that no changes are detected
+            };
+            if (!specifier) {
+                log(`🚫 Skipping versioning "${projectPackageJson.name}" as no changes were detected.`);
+                continue;
+            }
+            const newVersion = (0, version_1.deriveNewSemverVersion)(currentVersion, specifier, options.preid);
+            versionData[projectName].newVersion = newVersion;
+            (0, devkit_1.writeJson)(tree, packageJsonPath, {
+                ...projectPackageJson,
+                version: newVersion,
+            });
+            log(`✍️  New version ${newVersion} written to ${workspaceRelativePackageJsonPath}`);
+            if (dependentProjects.length > 0) {
+                log(`✍️  Applying new version ${newVersion} to ${dependentProjects.length} ${dependentProjects.length > 1
+                    ? 'packages which depend'
+                    : 'package which depends'} on ${project.name}`);
+            }
+            for (const dependentProject of dependentProjects) {
+                const dependentPackageRoot = projectNameToPackageRootMap.get(dependentProject.source);
+                if (!dependentPackageRoot) {
+                    throw new Error(`The dependent project "${dependentProject.source}" does not have a packageRoot available. Please report this issue on https://github.com/nrwl/nx`);
+                }
+                (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(dependentPackageRoot, 'package.json'), (json) => {
+                    // Auto (i.e.infer existing) by default
+                    let versionPrefix = options.versionPrefix ?? 'auto';
+                    // For auto, we infer the prefix based on the current version of the dependent
+                    if (versionPrefix === 'auto') {
+                        versionPrefix = ''; // we don't want to end up printing auto
+                        const current = json[dependentProject.dependencyCollection][packageName];
+                        if (current) {
+                            const prefixMatch = current.match(/^[~^]/);
+                            if (prefixMatch) {
+                                versionPrefix = prefixMatch[0];
+                            }
+                            else {
+                                versionPrefix = '';
+                            }
+                        }
+                    }
+                    json[dependentProject.dependencyCollection][packageName] = `${versionPrefix}${newVersion}`;
+                    return json;
+                });
+            }
+        }
+        /**
+         * Ensure that formatting is applied so that version bump diffs are as minimal as possible
+         * within the context of the user's workspace.
+         */
+        await (0, devkit_1.formatFiles)(tree);
+        // Return the version data so that it can be leveraged by the overall version command
+        return {
+            data: versionData,
+            callback: async (tree, opts) => {
+                const cwd = tree.root;
+                const updatedFiles = await (0, update_lock_file_1.updateLockFile)(cwd, opts);
+                return updatedFiles;
+            },
+        };
+    }
+    catch (e) {
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            devkit_1.output.error({
+                title: e.message,
+            });
+            // Dump the full stack trace in verbose mode
+            console.error(e);
+        }
+        else {
+            devkit_1.output.error({
+                title: e.message,
+            });
+        }
+        process.exit(1);
+    }
+}
+exports.releaseVersionGenerator = releaseVersionGenerator;
+exports.default = releaseVersionGenerator;
+function createResolvePackageRoot(customPackageRoot) {
+    return (projectNode) => {
+        // Default to the project root if no custom packageRoot
+        if (!customPackageRoot) {
+            return projectNode.data.root;
+        }
+        return (0, utils_1.interpolate)(customPackageRoot, {
+            workspaceRoot: '',
+            projectRoot: projectNode.data.root,
+            projectName: projectNode.name,
+        });
+    };
+}
+const colors = [
+    { instance: chalk.green, spinnerColor: 'green' },
+    { instance: chalk.greenBright, spinnerColor: 'green' },
+    { instance: chalk.red, spinnerColor: 'red' },
+    { instance: chalk.redBright, spinnerColor: 'red' },
+    { instance: chalk.cyan, spinnerColor: 'cyan' },
+    { instance: chalk.cyanBright, spinnerColor: 'cyan' },
+    { instance: chalk.yellow, spinnerColor: 'yellow' },
+    { instance: chalk.yellowBright, spinnerColor: 'yellow' },
+    { instance: chalk.magenta, spinnerColor: 'magenta' },
+    { instance: chalk.magentaBright, spinnerColor: 'magenta' },
+];
+function getColor(projectName) {
+    let code = 0;
+    for (let i = 0; i < projectName.length; ++i) {
+        code += projectName.charCodeAt(i);
+    }
+    const colorIndex = code % colors.length;
+    return colors[colorIndex];
+}
+async function getNpmRegistry() {
+    // Must be non-blocking async to allow spinner to render
+    return await new Promise((resolve, reject) => {
+        (0, node_child_process_1.exec)('npm config get registry', (error, stdout, stderr) => {
+            if (error) {
+                return reject(error);
+            }
+            if (stderr) {
+                return reject(stderr);
+            }
+            return resolve(stdout.trim());
+        });
+    });
+}

package/src/generators/release-version/schema.d.ts

@@ -0,0 +1 @@
+export { ReleaseVersionGeneratorSchema } from 'nx/src/command-line/release/version';

package/src/generators/release-version/schema.json

@@ -0,0 +1,67 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxJSReleaseVersionGenerator",
+  "cli": "nx",
+  "title": "Implementation details of `nx release version`",
+  "description": "DO NOT INVOKE DIRECTLY WITH `nx generate`. Use `nx release version` instead.",
+  "type": "object",
+  "properties": {
+    "projects": {
+      "type": "array",
+      "description": "The ProjectGraphProjectNodes being versioned in the current execution.",
+      "items": {
+        "type": "object"
+      }
+    },
+    "projectGraph": {
+      "type": "object",
+      "description": "ProjectGraph instance"
+    },
+    "specifier": {
+      "type": "string",
+      "description": "Exact version or semver keyword to apply to the selected release group. Overrides specifierSource."
+    },
+    "releaseGroup": {
+      "type": "object",
+      "description": "The resolved release group configuration, including name, relevant to all projects in the current execution."
+    },
+    "specifierSource": {
+      "type": "string",
+      "default": "prompt",
+      "description": "Which approach to use to determine the semver specifier used to bump the version of the project.",
+      "enum": ["prompt", "conventional-commits"]
+    },
+    "preid": {
+      "type": "string",
+      "description": "The optional prerelease identifier to apply to the version, in the case that specifier has been set to prerelease."
+    },
+    "packageRoot": {
+      "type": "string",
+      "description": "The root directory of the directory (containing a manifest file at its root) to publish. Defaults to the project root"
+    },
+    "currentVersionResolver": {
+      "type": "string",
+      "default": "disk",
+      "description": "Which approach to use to determine the current version of the project.",
+      "enum": ["registry", "disk", "git-tag"]
+    },
+    "currentVersionResolverMetadata": {
+      "type": "object",
+      "description": "Additional metadata to pass to the current version resolver.",
+      "default": {}
+    },
+    "skipLockFileUpdate": {
+      "type": "boolean",
+      "description": "Whether to skip updating the lock file after updating the version."
+    },
+    "installArgs": {
+      "type": "string",
+      "description": "Additional arguments to pass to the package manager when updating the lock file with an install command."
+    },
+    "installIgnoreScripts": {
+      "type": "boolean",
+      "description": "Whether to ignore install lifecycle scripts when updating the lock file with an install command."
+    }
+  },
+  "required": ["projects", "projectGraph", "releaseGroup"]
+}

package/src/generators/release-version/test-utils/create-workspace-with-package-dependencies.d.ts

@@ -0,0 +1,16 @@
+import { ProjectGraph, Tree } from '@nx/devkit';
+interface ProjectAndPackageData {
+    [projectName: string]: {
+        projectRoot: string;
+        packageName: string;
+        version: string;
+        packageJsonPath: string;
+        localDependencies: {
+            projectName: string;
+            dependencyCollection: 'dependencies' | 'devDependencies' | 'optionalDependencies';
+            version: string;
+        }[];
+    };
+}
+export declare function createWorkspaceWithPackageDependencies(tree: Tree, projectAndPackageData: ProjectAndPackageData): ProjectGraph;
+export {};