@ohos-ports/nx 19.8.4-beta.0

package/src/command-line/release/utils/github.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitHubRepoData = getGitHubRepoData;
+exports.createOrUpdateGithubRelease = createOrUpdateGithubRelease;
+exports.getGithubReleaseByTag = getGithubReleaseByTag;
+exports.formatReferences = formatReferences;
+const chalk = require("chalk");
+const enquirer_1 = require("enquirer");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const output_1 = require("../../../utils/output");
+const path_1 = require("../../../utils/path");
+const config_1 = require("../config/config");
+const print_changes_1 = require("./print-changes");
+const shared_1 = require("./shared");
+// axios types and values don't seem to match
+const _axios = require("axios");
+const axios = _axios;
+function getGitHubRepoData(remoteName = 'origin', createReleaseConfig) {
+    try {
+        const remoteUrl = (0, node_child_process_1.execSync)(`git remote get-url ${remoteName}`, {
+            encoding: 'utf8',
+            stdio: 'pipe',
+        }).trim();
+        // Use the default provider (github.com) if custom one is not specified or releases are disabled
+        let hostname = config_1.defaultCreateReleaseProvider.hostname;
+        let apiBaseUrl = config_1.defaultCreateReleaseProvider.apiBaseUrl;
+        if (createReleaseConfig !== false &&
+            typeof createReleaseConfig !== 'string') {
+            hostname = createReleaseConfig.hostname;
+            apiBaseUrl = createReleaseConfig.apiBaseUrl;
+        }
+        // Extract the 'user/repo' part from the URL
+        const escapedHostname = hostname.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regexString = `${escapedHostname}[/:]([\\w.-]+/[\\w.-]+)(\\.git)?`;
+        const regex = new RegExp(regexString);
+        const match = remoteUrl.match(regex);
+        if (match && match[1]) {
+            return {
+                hostname,
+                apiBaseUrl,
+                // Ensure any trailing .git is stripped
+                slug: match[1].replace(/\.git$/, ''),
+            };
+        }
+        else {
+            throw new Error(`Could not extract "user/repo" data from the resolved remote URL: ${remoteUrl}`);
+        }
+    }
+    catch (error) {
+        return null;
+    }
+}
+async function createOrUpdateGithubRelease(createReleaseConfig, releaseVersion, changelogContents, latestCommit, { dryRun }) {
+    const githubRepoData = getGitHubRepoData(undefined, createReleaseConfig);
+    if (!githubRepoData) {
+        output_1.output.error({
+            title: `Unable to create a GitHub release because the GitHub repo slug could not be determined.`,
+            bodyLines: [
+                `Please ensure you have a valid GitHub remote configured. You can run \`git remote -v\` to list your current remotes.`,
+            ],
+        });
+        process.exit(1);
+    }
+    const token = await resolveGithubToken(githubRepoData.hostname);
+    const githubRequestConfig = {
+        repo: githubRepoData.slug,
+        hostname: githubRepoData.hostname,
+        apiBaseUrl: githubRepoData.apiBaseUrl,
+        token,
+    };
+    let existingGithubReleaseForVersion;
+    try {
+        existingGithubReleaseForVersion = await getGithubReleaseByTag(githubRequestConfig, releaseVersion.gitTag);
+    }
+    catch (err) {
+        if (err.response?.status === 401) {
+            output_1.output.error({
+                title: `Unable to resolve data via the GitHub API. You can use any of the following options to resolve this:`,
+                bodyLines: [
+                    '- Set the `GITHUB_TOKEN` or `GH_TOKEN` environment variable to a valid GitHub token with `repo` scope',
+                    '- Have an active session via the official gh CLI tool (https://cli.github.com) in your current terminal',
+                ],
+            });
+            process.exit(1);
+        }
+        if (err.response?.status === 404) {
+            // No existing release found, this is fine
+        }
+        else {
+            // Rethrow unknown errors for now
+            throw err;
+        }
+    }
+    const logTitle = `https://${githubRepoData.hostname}/${githubRepoData.slug}/releases/tag/${releaseVersion.gitTag}`;
+    if (existingGithubReleaseForVersion) {
+        console.error(`${chalk.white('UPDATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+    }
+    else {
+        console.error(`${chalk.green('CREATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+    }
+    console.log('');
+    (0, print_changes_1.printDiff)(existingGithubReleaseForVersion ? existingGithubReleaseForVersion.body : '', changelogContents, 3, shared_1.noDiffInChangelogMessage);
+    if (!dryRun) {
+        await createOrUpdateGithubReleaseInternal(githubRequestConfig, {
+            version: releaseVersion.gitTag,
+            prerelease: releaseVersion.isPrerelease,
+            body: changelogContents,
+            commit: latestCommit,
+        }, existingGithubReleaseForVersion);
+    }
+}
+async function createOrUpdateGithubReleaseInternal(githubRequestConfig, release, existingGithubReleaseForVersion) {
+    const result = await syncGithubRelease(githubRequestConfig, release, existingGithubReleaseForVersion);
+    /**
+     * If something went wrong POSTing to Github we can still pre-populate the web form on github.com
+     * to allow the user to manually complete the release if they so choose.
+     */
+    if (result.status === 'manual') {
+        if (result.error) {
+            process.exitCode = 1;
+            if (result.error.response?.data) {
+                // There's a nicely formatted error from GitHub we can display to the user
+                output_1.output.error({
+                    title: `A GitHub API Error occurred when creating/updating the release`,
+                    bodyLines: [
+                        `GitHub Error: ${JSON.stringify(result.error.response.data)}`,
+                        `---`,
+                        `Request Data:`,
+                        `Repo: ${githubRequestConfig.repo}`,
+                        `Token: ${githubRequestConfig.token}`,
+                        `Body: ${JSON.stringify(result.requestData)}`,
+                    ],
+                });
+            }
+            else {
+                console.log(result.error);
+                console.error(`An unknown error occurred while trying to create a release on GitHub, please report this on https://github.com/nrwl/nx (NOTE: make sure to redact your GitHub token from the error message!)`);
+            }
+        }
+        const shouldContinueInGitHub = await promptForContinueInGitHub();
+        if (!shouldContinueInGitHub) {
+            return;
+        }
+        const open = require('open');
+        await open(result.url)
+            .then(() => {
+            console.info(`\nFollow up in the browser to manually create the release:\n\n` +
+                chalk.underline(chalk.cyan(result.url)) +
+                `\n`);
+        })
+            .catch(() => {
+            console.info(`Open this link to manually create a release: \n` +
+                chalk.underline(chalk.cyan(result.url)) +
+                '\n');
+        });
+    }
+    /**
+     * If something went wrong POSTing to Github we can still pre-populate the web form on github.com
+     * to allow the user to manually complete the release.
+     */
+    if (result.status === 'manual') {
+        if (result.error) {
+            console.error(result.error);
+            process.exitCode = 1;
+        }
+        const open = require('open');
+        await open(result.url)
+            .then(() => {
+            console.info(`Follow up in the browser to manually create the release.`);
+        })
+            .catch(() => {
+            console.info(`Open this link to manually create a release: \n` +
+                chalk.underline(chalk.cyan(result.url)) +
+                '\n');
+        });
+    }
+}
+async function promptForContinueInGitHub() {
+    try {
+        const reply = await (0, enquirer_1.prompt)([
+            {
+                name: 'open',
+                message: 'Do you want to finish creating the release manually in your browser?',
+                type: 'autocomplete',
+                choices: [
+                    {
+                        name: 'Yes',
+                        hint: 'It will pre-populate the form for you',
+                    },
+                    {
+                        name: 'No',
+                    },
+                ],
+                initial: 0,
+            },
+        ]);
+        return reply.open === 'Yes';
+    }
+    catch (e) {
+        // Handle the case where the user exits the prompt with ctrl+c
+        process.exit(1);
+    }
+}
+async function syncGithubRelease(githubRequestConfig, release, existingGithubReleaseForVersion) {
+    const ghRelease = {
+        tag_name: release.version,
+        name: release.version,
+        body: release.body,
+        prerelease: release.prerelease,
+    };
+    try {
+        const newGhRelease = await (existingGithubReleaseForVersion
+            ? updateGithubRelease(githubRequestConfig, existingGithubReleaseForVersion.id, ghRelease)
+            : createGithubRelease(githubRequestConfig, {
+                ...ghRelease,
+                target_commitish: release.commit,
+            }));
+        return {
+            status: existingGithubReleaseForVersion ? 'updated' : 'created',
+            id: newGhRelease.id,
+            url: newGhRelease.html_url,
+        };
+    }
+    catch (error) {
+        return {
+            status: 'manual',
+            error,
+            url: githubNewReleaseURL(githubRequestConfig, release),
+            requestData: ghRelease,
+        };
+    }
+}
+async function resolveGithubToken(hostname) {
+    // Try and resolve from the environment
+    const tokenFromEnv = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+    if (tokenFromEnv) {
+        return tokenFromEnv;
+    }
+    // Try and resolve from gh CLI installation
+    const ghCLIPath = (0, path_1.joinPathFragments)(process.env.XDG_CONFIG_HOME || (0, path_1.joinPathFragments)((0, node_os_1.homedir)(), '.config'), 'gh', 'hosts.yml');
+    if ((0, node_fs_1.existsSync)(ghCLIPath)) {
+        const yamlContents = await node_fs_1.promises.readFile(ghCLIPath, 'utf8');
+        const { load } = require('@zkochan/js-yaml');
+        const ghCLIConfig = load(yamlContents);
+        if (ghCLIConfig[hostname]) {
+            // Web based session (the token is already embedded in the config)
+            if (ghCLIConfig[hostname].oauth_token) {
+                return ghCLIConfig[hostname].oauth_token;
+            }
+            // SSH based session (we need to dynamically resolve a token using the CLI)
+            if (ghCLIConfig[hostname].user &&
+                ghCLIConfig[hostname].git_protocol === 'ssh') {
+                return (0, node_child_process_1.execSync)(`gh auth token`, {
+                    encoding: 'utf8',
+                    stdio: 'pipe',
+                    windowsHide: true,
+                }).trim();
+            }
+        }
+    }
+    if (hostname !== 'github.com') {
+        console.log(`Warning: It was not possible to automatically resolve a GitHub token from your environment for hostname ${hostname}. If you set the GITHUB_TOKEN or GH_TOKEN environment variable, that will be used for GitHub API requests.`);
+    }
+    return null;
+}
+async function getGithubReleaseByTag(config, tag) {
+    return await makeGithubRequest(config, `/repos/${config.repo}/releases/tags/${tag}`, {});
+}
+async function makeGithubRequest(config, url, opts = {}) {
+    return (await axios(url, {
+        ...opts,
+        baseURL: config.apiBaseUrl,
+        headers: {
+            ...opts.headers,
+            Authorization: config.token ? `Bearer ${config.token}` : undefined,
+        },
+    })).data;
+}
+async function createGithubRelease(config, body) {
+    return await makeGithubRequest(config, `/repos/${config.repo}/releases`, {
+        method: 'POST',
+        data: body,
+    });
+}
+async function updateGithubRelease(config, id, body) {
+    return await makeGithubRequest(config, `/repos/${config.repo}/releases/${id}`, {
+        method: 'PATCH',
+        data: body,
+    });
+}
+function githubNewReleaseURL(config, release) {
+    // Parameters taken from https://github.com/isaacs/github/issues/1410#issuecomment-442240267
+    let url = `https://${config.hostname}/${config.repo}/releases/new?tag=${release.version}&title=${release.version}&body=${encodeURIComponent(release.body)}&target=${release.commit}`;
+    if (release.prerelease) {
+        url += '&prerelease=true';
+    }
+    return url;
+}
+const providerToRefSpec = {
+    github: { 'pull-request': 'pull', hash: 'commit', issue: 'issues' },
+};
+function formatReference(ref, repoData) {
+    const refSpec = providerToRefSpec['github'];
+    return `[${ref.value}](https://${repoData.hostname}/${repoData.slug}/${refSpec[ref.type]}/${ref.value.replace(/^#/, '')})`;
+}
+function formatReferences(references, repoData) {
+    const pr = references.filter((ref) => ref.type === 'pull-request');
+    const issue = references.filter((ref) => ref.type === 'issue');
+    if (pr.length > 0 || issue.length > 0) {
+        return (' (' +
+            [...pr, ...issue]
+                .map((ref) => formatReference(ref, repoData))
+                .join(', ') +
+            ')');
+    }
+    if (references.length > 0) {
+        return ' (' + formatReference(references[0], repoData) + ')';
+    }
+    return '';
+}

package/src/command-line/release/utils/launch-editor.d.ts

@@ -0,0 +1 @@
+export declare function launchEditor(filePath: string): Promise<unknown>;

package/src/command-line/release/utils/launch-editor.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchEditor = launchEditor;
+const node_child_process_1 = require("node:child_process");
+async function launchEditor(filePath) {
+    // Inspired by what git does
+    const editorCommand = process.env.GIT_EDITOR ||
+        getGitConfig('core.editor') ||
+        process.env.VISUAL ||
+        process.env.EDITOR ||
+        'vi';
+    const { cmd, args } = parseCommand(editorCommand);
+    return new Promise((resolve, reject) => {
+        const editorProcess = (0, node_child_process_1.spawn)(cmd, [...args, filePath], {
+            stdio: 'inherit', // This will ensure the editor uses the current terminal
+            windowsHide: true,
+        });
+        editorProcess.on('exit', (code) => {
+            if (code === 0) {
+                resolve(undefined);
+            }
+            else {
+                reject(new Error(`Editor process exited with code ${code}`));
+            }
+        });
+    });
+}
+function getGitConfig(key) {
+    try {
+        return (0, node_child_process_1.execSync)(`git config --get ${key}`, {
+            windowsHide: true,
+        })
+            .toString()
+            .trim();
+    }
+    catch {
+        return null;
+    }
+}
+function parseCommand(commandString) {
+    const parts = commandString.split(/\s+/);
+    return {
+        cmd: parts[0],
+        args: parts.slice(1),
+    };
+}

package/src/command-line/release/utils/markdown.d.ts

@@ -0,0 +1,6 @@
+export declare function parseChangelogMarkdown(contents: string): {
+    releases: {
+        version?: string;
+        body: string;
+    }[];
+};

package/src/command-line/release/utils/markdown.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseChangelogMarkdown = parseChangelogMarkdown;
+function parseChangelogMarkdown(contents) {
+    /**
+     * The release header may include prerelease identifiers (e.g., -alpha.13),
+     * and major releases may use a single #, instead of the standard ## used
+     * for minor and patch releases. This regex matches all of these cases.
+     */
+    const CHANGELOG_RELEASE_HEAD_RE = new RegExp('^#+\\s*\\[?(\\d+\\.\\d+\\.\\d+(?:-[a-zA-Z0-9\\.]+)?)\\]?', 'gm');
+    const headings = [...contents.matchAll(CHANGELOG_RELEASE_HEAD_RE)];
+    const releases = [];
+    for (let i = 0; i < headings.length; i++) {
+        const heading = headings[i];
+        const nextHeading = headings[i + 1];
+        const version = heading[1];
+        const release = {
+            version: version,
+            body: contents
+                .slice(heading.index + heading[0].length, nextHeading ? nextHeading.index : contents.length)
+                .trim(),
+        };
+        releases.push(release);
+    }
+    return {
+        releases,
+    };
+}

package/src/command-line/release/utils/print-changes.d.ts

@@ -0,0 +1,6 @@
+import { Tree } from '../../../generators/tree';
+export declare function printDiff(before: string, after: string, contextLines?: number, noDiffMessage?: string): void;
+export declare function printAndFlushChanges(tree: Tree, isDryRun: boolean, diffContextLines?: number, shouldPrintDryRunMessage?: boolean, noDiffMessage?: string, changePredicate?: (f: {
+    path: string;
+    content?: Buffer;
+}) => boolean): void;

package/src/command-line/release/utils/print-changes.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printDiff = printDiff;
+exports.printAndFlushChanges = printAndFlushChanges;
+const chalk = require("chalk");
+const jest_diff_1 = require("jest-diff");
+const node_fs_1 = require("node:fs");
+const tree_1 = require("../../../generators/tree");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const path_1 = require("../../../utils/path");
+const logger_1 = require("../../../utils/logger");
+// jest-diff does not export this constant
+const NO_DIFF_MESSAGE = 'Compared values have no visual difference.';
+function printDiff(before, after, contextLines = 1, noDiffMessage = NO_DIFF_MESSAGE) {
+    const diffOutput = (0, jest_diff_1.diff)(before, after, {
+        omitAnnotationLines: true,
+        contextLines,
+        expand: false,
+        aColor: chalk.red,
+        bColor: chalk.green,
+        patchColor: (s) => '',
+    });
+    // It is not an exact match because of the color codes
+    if (diffOutput.includes(NO_DIFF_MESSAGE)) {
+        console.log(noDiffMessage);
+    }
+    else {
+        console.log(diffOutput);
+    }
+    console.log('');
+}
+function printAndFlushChanges(tree, isDryRun, diffContextLines = 1, shouldPrintDryRunMessage = true, noDiffMessage, changePredicate) {
+    changePredicate = changePredicate || (() => true);
+    const changes = tree.listChanges();
+    console.log('');
+    if (changes.length === 0 && noDiffMessage) {
+        console.log(noDiffMessage);
+        return;
+    }
+    // Print the changes
+    changes.filter(changePredicate).forEach((f) => {
+        if (f.type === 'CREATE') {
+            console.error(`${chalk.green('CREATE')} ${f.path}${isDryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+            printDiff('', f.content?.toString() || '', diffContextLines, noDiffMessage);
+        }
+        else if (f.type === 'UPDATE') {
+            console.error(`${chalk.white('UPDATE')} ${f.path}${isDryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+            const currentContentsOnDisk = (0, node_fs_1.readFileSync)((0, path_1.joinPathFragments)(tree.root, f.path)).toString();
+            printDiff(currentContentsOnDisk, f.content?.toString() || '', diffContextLines, noDiffMessage);
+        }
+        else if (f.type === 'DELETE') {
+            throw new Error('Unexpected DELETE change, please report this as an issue');
+        }
+    });
+    if (!isDryRun) {
+        (0, tree_1.flushChanges)(workspace_root_1.workspaceRoot, changes);
+    }
+    if (isDryRun && shouldPrintDryRunMessage) {
+        logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+    }
+}

package/src/command-line/release/utils/print-config.d.ts

@@ -0,0 +1,7 @@
+import type { NxReleaseConfiguration } from '../../../config/nx-json';
+import type { NxReleaseConfig } from '../config/config';
+export declare function printConfigAndExit({ userProvidedReleaseConfig, nxReleaseConfig, isDebug, }: {
+    userProvidedReleaseConfig: NxReleaseConfiguration;
+    nxReleaseConfig: NxReleaseConfig;
+    isDebug: boolean;
+}): any;

package/src/command-line/release/utils/print-config.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printConfigAndExit = printConfigAndExit;
+const output_1 = require("../../../utils/output");
+function printConfigAndExit({ userProvidedReleaseConfig, nxReleaseConfig, isDebug, }) {
+    if (isDebug) {
+        console.log('============================================================= START FINAL INTERNAL CONFIG');
+        console.log(JSON.stringify(nxReleaseConfig, null, 2));
+        console.log('============================================================= END FINAL INTERNAL CONFIG');
+        console.log('');
+        console.log('============================================================= START USER CONFIG');
+        console.log(JSON.stringify(userProvidedReleaseConfig, null, 2));
+        console.log('============================================================= END USER CONFIG');
+        output_1.output.log({
+            title: 'Resolved Nx Release Configuration',
+            bodyLines: [
+                'NOTE: --printConfig was set to debug, so the above output contains two different resolved configs:',
+                '',
+                '- The config immediately above is the user config, the one provided by you in nx.json and/or the programmatic API.',
+                '- The config above that is the low level resolved configuration object used internally by nx release. It can be referenced for advanced troubleshooting.',
+                '',
+                'For the user-facing configuration format, and the full list of available options, please reference https://nx.dev/reference/nx-json#release',
+            ],
+        });
+        process.exit(0);
+    }
+    console.log(JSON.stringify(userProvidedReleaseConfig, null, 2));
+    output_1.output.log({
+        title: 'Resolved Nx Release Configuration',
+        bodyLines: [
+            'The above config is the result of merging any nx release config in nx.json and/or the programmatic API.',
+            '',
+            'For details on the configuration format, and the full list of available options, please reference https://nx.dev/reference/nx-json#release',
+        ],
+    });
+}

package/src/command-line/release/utils/resolve-changelog-renderer.d.ts

@@ -0,0 +1,2 @@
+import type { ChangelogRenderer } from '../../../../release/changelog-renderer';
+export declare function resolveChangelogRenderer(changelogRendererPath: string): ChangelogRenderer;

package/src/command-line/release/utils/resolve-changelog-renderer.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveChangelogRenderer = resolveChangelogRenderer;
+const register_1 = require("../../../plugins/js/utils/register");
+const typescript_1 = require("../../../plugins/js/utils/typescript");
+const utils_1 = require("../../../tasks-runner/utils");
+const workspace_root_1 = require("../../../utils/workspace-root");
+function resolveChangelogRenderer(changelogRendererPath) {
+    const interpolatedChangelogRendererPath = (0, utils_1.interpolate)(changelogRendererPath, {
+        workspaceRoot: workspace_root_1.workspaceRoot,
+    });
+    // Try and load the provided (or default) changelog renderer
+    let changelogRenderer;
+    let cleanupTranspiler = () => { };
+    try {
+        const rootTsconfigPath = (0, typescript_1.getRootTsConfigPath)();
+        if (rootTsconfigPath) {
+            cleanupTranspiler = (0, register_1.registerTsProject)(rootTsconfigPath);
+        }
+        const r = require(interpolatedChangelogRendererPath);
+        changelogRenderer = r.default || r;
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        cleanupTranspiler();
+    }
+    return changelogRenderer;
+}

package/src/command-line/release/utils/resolve-nx-json-error-message.d.ts

@@ -0,0 +1 @@
+export declare function resolveNxJsonConfigErrorMessage(propPath: string[]): Promise<string>;

package/src/command-line/release/utils/resolve-nx-json-error-message.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNxJsonConfigErrorMessage = resolveNxJsonConfigErrorMessage;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const path_1 = require("../../../utils/path");
+const workspace_root_1 = require("../../../utils/workspace-root");
+async function resolveNxJsonConfigErrorMessage(propPath) {
+    const errorLines = await getJsonConfigLinesForErrorMessage((0, node_fs_1.readFileSync)((0, path_1.joinPathFragments)(workspace_root_1.workspaceRoot, 'nx.json'), 'utf-8'), propPath);
+    let nxJsonMessage = `The relevant config is defined here: ${(0, node_path_1.relative)(process.cwd(), (0, path_1.joinPathFragments)(workspace_root_1.workspaceRoot, 'nx.json'))}`;
+    if (errorLines) {
+        nxJsonMessage +=
+            errorLines.startLine === errorLines.endLine
+                ? `, line ${errorLines.startLine}`
+                : `, lines ${errorLines.startLine}-${errorLines.endLine}`;
+    }
+    return nxJsonMessage;
+}
+async function getJsonConfigLinesForErrorMessage(rawConfig, jsonPath) {
+    try {
+        const jsonParser = await Promise.resolve().then(() => require('jsonc-parser'));
+        const rootNode = jsonParser.parseTree(rawConfig);
+        const node = jsonParser.findNodeAtLocation(rootNode, jsonPath);
+        return computeJsonLineNumbers(rawConfig, node?.offset, node?.length);
+    }
+    catch {
+        return null;
+    }
+}
+function computeJsonLineNumbers(inputText, startOffset, characterCount) {
+    let lines = inputText.split('\n');
+    let totalChars = 0;
+    let startLine = 0;
+    let endLine = 0;
+    for (let i = 0; i < lines.length; i++) {
+        totalChars += lines[i].length + 1; // +1 for '\n' character
+        if (!startLine && totalChars >= startOffset) {
+            startLine = i + 1; // +1 because arrays are 0-based
+        }
+        if (totalChars >= startOffset + characterCount) {
+            endLine = i + 1; // +1 because arrays are 0-based
+            break;
+        }
+    }
+    if (!startLine) {
+        throw new Error('Start offset exceeds the text length');
+    }
+    if (!endLine) {
+        throw new Error('Character count exceeds the text length after start offset');
+    }
+    return { startLine, endLine };
+}

package/src/command-line/release/utils/resolve-semver-specifier.d.ts

@@ -0,0 +1,4 @@
+import { ProjectGraph } from '../../../config/project-graph';
+import { NxReleaseConfig } from '../config/config';
+export declare function resolveSemverSpecifierFromConventionalCommits(from: string, projectGraph: ProjectGraph, projectNames: string[], conventionalCommitsConfig: NxReleaseConfig['conventionalCommits']): Promise<string | null>;
+export declare function resolveSemverSpecifierFromPrompt(selectionMessage: string, customVersionMessage: string): Promise<string>;