@ohos-ports/nx 17.3.2-beta.0

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

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFirstGitCommit = exports.getCommitHash = exports.parseGitCommit = exports.parseCommits = exports.gitPush = exports.gitTag = exports.gitCommit = exports.gitAdd = exports.getGitDiff = exports.getLatestGitTagForPattern = void 0;
+/**
+ * Special thanks to changelogen for the original inspiration for many of these utilities:
+ * https://github.com/unjs/changelogen
+ */
+const utils_1 = require("../../../tasks-runner/utils");
+const exec_command_1 = require("./exec-command");
+function escapeRegExp(string) {
+    return string.replace(/[/\-\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+const SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/g;
+async function getLatestGitTagForPattern(releaseTagPattern, additionalInterpolationData = {}) {
+    try {
+        const tags = await (0, exec_command_1.execCommand)('git', ['tag', '--sort', '-v:refname']).then((r) => r
+            .trim()
+            .split('\n')
+            .map((t) => t.trim())
+            .filter(Boolean));
+        if (!tags.length) {
+            return null;
+        }
+        const interpolatedTagPattern = (0, utils_1.interpolate)(releaseTagPattern, {
+            version: '%v%',
+            projectName: '%p%',
+            ...additionalInterpolationData,
+        });
+        const tagRegexp = `^${escapeRegExp(interpolatedTagPattern)
+            .replace('%v%', '(.+)')
+            .replace('%p%', '(.+)')}`;
+        const matchingSemverTags = tags.filter((tag) => 
+        // Do the match against SEMVER_REGEX to ensure that we skip tags that aren't valid semver versions
+        !!tag.match(tagRegexp) &&
+            tag.match(tagRegexp).some((r) => r.match(SEMVER_REGEX)));
+        if (!matchingSemverTags.length) {
+            return null;
+        }
+        const [latestMatchingTag, ...rest] = matchingSemverTags[0].match(tagRegexp);
+        const version = rest.filter((r) => {
+            return r.match(SEMVER_REGEX);
+        })[0];
+        return {
+            tag: latestMatchingTag,
+            extractedVersion: version,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+exports.getLatestGitTagForPattern = getLatestGitTagForPattern;
+async function getGitDiff(from, to = 'HEAD') {
+    // https://git-scm.com/docs/pretty-formats
+    const r = await (0, exec_command_1.execCommand)('git', [
+        '--no-pager',
+        'log',
+        `${from ? `${from}...` : ''}${to}`,
+        '--pretty="----%n%s|%h|%an|%ae%n%b"',
+        '--name-status',
+    ]);
+    return r
+        .split('----\n')
+        .splice(1)
+        .map((line) => {
+        const [firstLine, ..._body] = line.split('\n');
+        const [message, shortHash, authorName, authorEmail] = firstLine.split('|');
+        const r = {
+            message,
+            shortHash,
+            author: { name: authorName, email: authorEmail },
+            body: _body.join('\n'),
+        };
+        return r;
+    });
+}
+exports.getGitDiff = getGitDiff;
+async function gitAdd({ changedFiles, dryRun, verbose, logFn, }) {
+    logFn = logFn || console.log;
+    const commandArgs = ['add', ...changedFiles];
+    const message = dryRun
+        ? `Would stage files in git with the following command, but --dry-run was set:`
+        : `Staging files in git with the following command:`;
+    if (verbose) {
+        logFn(message);
+        logFn(`git ${commandArgs.join(' ')}`);
+    }
+    if (dryRun) {
+        return;
+    }
+    return (0, exec_command_1.execCommand)('git', commandArgs);
+}
+exports.gitAdd = gitAdd;
+async function gitCommit({ messages, additionalArgs, dryRun, verbose, logFn, }) {
+    logFn = logFn || console.log;
+    const commandArgs = ['commit'];
+    for (const message of messages) {
+        commandArgs.push('--message', message);
+    }
+    if (additionalArgs) {
+        commandArgs.push(...additionalArgs.split(' '));
+    }
+    if (verbose) {
+        logFn(dryRun
+            ? `Would commit all previously staged files in git with the following command, but --dry-run was set:`
+            : `Committing files in git with the following command:`);
+        logFn(`git ${commandArgs.join(' ')}`);
+    }
+    if (dryRun) {
+        return;
+    }
+    let hasStagedFiles = false;
+    try {
+        // This command will error if there are staged changes
+        await (0, exec_command_1.execCommand)('git', ['diff-index', '--quiet', 'HEAD', '--cached']);
+    }
+    catch {
+        hasStagedFiles = true;
+    }
+    if (!hasStagedFiles) {
+        logFn('\nNo staged files found. Skipping commit.');
+        return;
+    }
+    return (0, exec_command_1.execCommand)('git', commandArgs);
+}
+exports.gitCommit = gitCommit;
+async function gitTag({ tag, message, additionalArgs, dryRun, verbose, logFn, }) {
+    logFn = logFn || console.log;
+    const commandArgs = [
+        'tag',
+        // Create an annotated tag (recommended for releases here: https://git-scm.com/docs/git-tag)
+        '--annotate',
+        tag,
+        '--message',
+        message || tag,
+    ];
+    if (additionalArgs) {
+        commandArgs.push(...additionalArgs.split(' '));
+    }
+    if (verbose) {
+        logFn(dryRun
+            ? `Would tag the current commit in git with the following command, but --dry-run was set:`
+            : `Tagging the current commit in git with the following command:`);
+        logFn(`git ${commandArgs.join(' ')}`);
+    }
+    if (dryRun) {
+        return;
+    }
+    try {
+        return await (0, exec_command_1.execCommand)('git', commandArgs);
+    }
+    catch (err) {
+        throw new Error(`Unexpected error when creating tag ${tag}:\n\n${err}`);
+    }
+}
+exports.gitTag = gitTag;
+async function gitPush(gitRemote) {
+    try {
+        await (0, exec_command_1.execCommand)('git', [
+            'push',
+            // NOTE: It's important we use --follow-tags, and not --tags, so that we are precise about what we are pushing
+            '--follow-tags',
+            '--no-verify',
+            '--atomic',
+            // Set custom git remote if provided
+            ...(gitRemote ? [gitRemote] : []),
+        ]);
+    }
+    catch (err) {
+        throw new Error(`Unexpected git push error: ${err}`);
+    }
+}
+exports.gitPush = gitPush;
+function parseCommits(commits) {
+    return commits.map((commit) => parseGitCommit(commit)).filter(Boolean);
+}
+exports.parseCommits = parseCommits;
+// https://www.conventionalcommits.org/en/v1.0.0/
+// https://regex101.com/r/FSfNvA/1
+const ConventionalCommitRegex = /(?<type>[a-z]+)(\((?<scope>.+)\))?(?<breaking>!)?: (?<description>.+)/i;
+const CoAuthoredByRegex = /co-authored-by:\s*(?<name>.+)(<(?<email>.+)>)/gim;
+const PullRequestRE = /\([ a-z]*(#\d+)\s*\)/gm;
+const IssueRE = /(#\d+)/gm;
+const ChangedFileRegex = /(A|M|D|R\d*|C\d*)\t([^\t\n]*)\t?(.*)?/gm;
+const RevertHashRE = /This reverts commit (?<hash>[\da-f]{40})./gm;
+function parseGitCommit(commit) {
+    const match = commit.message.match(ConventionalCommitRegex);
+    if (!match) {
+        return null;
+    }
+    const scope = match.groups.scope || '';
+    const isBreaking = Boolean(match.groups.breaking) || commit.body.includes('BREAKING CHANGE:');
+    let description = match.groups.description;
+    // Extract references from message
+    const references = [];
+    for (const m of description.matchAll(PullRequestRE)) {
+        references.push({ type: 'pull-request', value: m[1] });
+    }
+    for (const m of description.matchAll(IssueRE)) {
+        if (!references.some((i) => i.value === m[1])) {
+            references.push({ type: 'issue', value: m[1] });
+        }
+    }
+    references.push({ value: commit.shortHash, type: 'hash' });
+    // Remove references and normalize
+    description = description.replace(PullRequestRE, '').trim();
+    let type = match.groups.type;
+    // Extract any reverted hashes, if applicable
+    const revertedHashes = [];
+    const matchedHashes = commit.body.matchAll(RevertHashRE);
+    for (const matchedHash of matchedHashes) {
+        revertedHashes.push(matchedHash.groups.hash);
+    }
+    if (revertedHashes.length) {
+        type = 'revert';
+        description = commit.message;
+    }
+    // Find all authors
+    const authors = [commit.author];
+    for (const match of commit.body.matchAll(CoAuthoredByRegex)) {
+        authors.push({
+            name: (match.groups.name || '').trim(),
+            email: (match.groups.email || '').trim(),
+        });
+    }
+    // Extract file changes from commit body
+    const affectedFiles = Array.from(commit.body.matchAll(ChangedFileRegex)).reduce((prev, [fullLine, changeType, file1, file2]) => 
+    // file2 only exists for some change types, such as renames
+    file2 ? [...prev, file1, file2] : [...prev, file1], []);
+    return {
+        ...commit,
+        authors,
+        description,
+        type,
+        scope,
+        references,
+        isBreaking,
+        revertedHashes,
+        affectedFiles,
+    };
+}
+exports.parseGitCommit = parseGitCommit;
+async function getCommitHash(ref) {
+    try {
+        return (await (0, exec_command_1.execCommand)('git', ['rev-parse', ref])).trim();
+    }
+    catch (e) {
+        throw new Error(`Unknown revision: ${ref}`);
+    }
+}
+exports.getCommitHash = getCommitHash;
+async function getFirstGitCommit() {
+    try {
+        return (await (0, exec_command_1.execCommand)('git', ['rev-list', '--max-parents=0', 'HEAD'])).trim();
+    }
+    catch (e) {
+        throw new Error(`Unable to find first commit in git history`);
+    }
+}
+exports.getFirstGitCommit = getFirstGitCommit;

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

@@ -0,0 +1,27 @@
+import { Reference } from './git';
+export type RepoSlug = `${string}/${string}`;
+export interface GithubRequestConfig {
+    repo: string;
+    token: string | null;
+}
+export interface GithubRelease {
+    id?: string;
+    tag_name: string;
+    target_commitish?: string;
+    name?: string;
+    body?: string;
+    draft?: boolean;
+    prerelease?: boolean;
+}
+export declare function getGitHubRepoSlug(remoteName?: string): RepoSlug;
+interface GithubReleaseOptions {
+    version: string;
+    body: string;
+    prerelease: boolean;
+    commit: string;
+}
+export declare function createOrUpdateGithubRelease(githubRequestConfig: GithubRequestConfig, release: GithubReleaseOptions, existingGithubReleaseForVersion?: GithubRelease): Promise<void>;
+export declare function resolveGithubToken(): Promise<string | null>;
+export declare function getGithubReleaseByTag(config: GithubRequestConfig, tag: string): Promise<GithubRelease>;
+export declare function formatReferences(references: Reference[], repoSlug: RepoSlug): string;
+export {};

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

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatReferences = exports.getGithubReleaseByTag = exports.resolveGithubToken = exports.createOrUpdateGithubRelease = exports.getGitHubRepoSlug = void 0;
+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");
+// axios types and values don't seem to match
+const _axios = require("axios");
+const axios = _axios;
+function getGitHubRepoSlug(remoteName = 'origin') {
+    try {
+        const remoteUrl = (0, node_child_process_1.execSync)(`git remote get-url ${remoteName}`, {
+            encoding: 'utf8',
+            stdio: 'pipe',
+        }).trim();
+        // Extract the 'user/repo' part from the URL
+        const regex = /github\.com[/:]([\w-]+\/[\w-]+)/;
+        const match = remoteUrl.match(regex);
+        if (match && match[1]) {
+            return match[1];
+        }
+        else {
+            throw new Error(`Could not extract "user/repo" data from the resolved remote URL: ${remoteUrl}`);
+        }
+    }
+    catch (error) {
+        return null;
+    }
+}
+exports.getGitHubRepoSlug = getGitHubRepoSlug;
+async function createOrUpdateGithubRelease(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 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,
+            },
+        ]).catch(() => {
+            return { open: 'No' };
+        });
+        if (reply.open === 'Yes') {
+            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');
+        });
+    }
+}
+exports.createOrUpdateGithubRelease = createOrUpdateGithubRelease;
+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() {
+    // 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['github.com']) {
+            // Web based session (the token is already embedded in the config)
+            if (ghCLIConfig['github.com'].oauth_token) {
+                return ghCLIConfig['github.com'].oauth_token;
+            }
+            // SSH based session (we need to dynamically resolve a token using the CLI)
+            if (ghCLIConfig['github.com'].user &&
+                ghCLIConfig['github.com'].git_protocol === 'ssh') {
+                return (0, node_child_process_1.execSync)(`gh auth token`, {
+                    encoding: 'utf8',
+                    stdio: 'pipe',
+                }).trim();
+            }
+        }
+    }
+    return null;
+}
+exports.resolveGithubToken = resolveGithubToken;
+async function getGithubReleaseByTag(config, tag) {
+    return await makeGithubRequest(config, `/repos/${config.repo}/releases/tags/${tag}`, {});
+}
+exports.getGithubReleaseByTag = getGithubReleaseByTag;
+async function makeGithubRequest(config, url, opts = {}) {
+    return (await axios(url, {
+        ...opts,
+        baseURL: 'https://api.github.com',
+        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) {
+    return `https://github.com/${config.repo}/releases/new?tag=${release.version}&title=${release.version}&body=${encodeURIComponent(release.body)}`;
+}
+const providerToRefSpec = {
+    github: { 'pull-request': 'pull', hash: 'commit', issue: 'issues' },
+};
+function formatReference(ref, repoSlug) {
+    const refSpec = providerToRefSpec['github'];
+    return `[${ref.value}](https://github.com/${repoSlug}/${refSpec[ref.type]}/${ref.value.replace(/^#/, '')})`;
+}
+function formatReferences(references, repoSlug) {
+    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, repoSlug))
+                .join(', ') +
+            ')');
+    }
+    if (references.length > 0) {
+        return ' (' + formatReference(references[0], repoSlug) + ')';
+    }
+    return '';
+}
+exports.formatReferences = formatReferences;

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,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchEditor = void 0;
+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
+        });
+        editorProcess.on('exit', (code) => {
+            if (code === 0) {
+                resolve(undefined);
+            }
+            else {
+                reject(new Error(`Editor process exited with code ${code}`));
+            }
+        });
+    });
+}
+exports.launchEditor = launchEditor;
+function getGitConfig(key) {
+    try {
+        return (0, node_child_process_1.execSync)(`git config --get ${key}`).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,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseChangelogMarkdown = void 0;
+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,
+    };
+}
+exports.parseChangelogMarkdown = parseChangelogMarkdown;

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

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+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,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printAndFlushChanges = exports.printDiff = void 0;
+const chalk = require("chalk");
+const jest_diff_1 = require("jest-diff");
+const node_fs_1 = require("node:fs");
+const devkit_exports_1 = require("../../../devkit-exports");
+const tree_1 = require("../../../generators/tree");
+// 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('');
+}
+exports.printDiff = printDiff;
+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, devkit_exports_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)(devkit_exports_1.workspaceRoot, changes);
+    }
+    if (isDryRun && shouldPrintDryRunMessage) {
+        devkit_exports_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+    }
+}
+exports.printAndFlushChanges = printAndFlushChanges;

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

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