@depup/nx 22.5.4-depup.0

package/project.json

@@ -0,0 +1,188 @@
+{
+    "name": "nx",
+    "$schema": "../../node_modules/nx/schemas/project-schema.json",
+    "sourceRoot": "packages/nx",
+    "projectType": "library",
+    "implicitDependencies": ["graph-client"],
+    "release": {
+        "version": {
+            "generator": "@nx/js:release-version"
+        }
+    },
+    "targets": {
+        "build-native-wasm": {
+            "cache": true,
+            "inputs": ["native"],
+            "outputs": [
+                "{projectRoot}/src/native/*.wasm",
+                "{projectRoot}/src/native/!(index|browser).js",
+                "{projectRoot}/src/native/*.cjs",
+                "{projectRoot}/src/native/*.mjs",
+                "{projectRoot}/src/native/index.d.ts"
+            ],
+            "executor": "@monodon/rust:napi",
+            "options": {
+                "target": "wasm32-wasip1-threads",
+                "dist": "packages/nx/src/native",
+                "jsFile": "native-bindings.js",
+                "release": true
+            }
+        },
+        "build-native": {
+            "outputs": [
+                "{projectRoot}/src/native/*.node",
+                "{projectRoot}/src/native/!(index|browser).js",
+                "{projectRoot}/src/native/index.d.ts"
+            ],
+            "executor": "@monodon/rust:napi",
+            "options": {
+                "dist": "packages/nx/src/native",
+                "jsFile": "native-bindings.js",
+                "release": true
+            },
+            "configurations": {
+                "local": {
+                    "release": false
+                }
+            }
+        },
+        "copy-native-package-directories": {
+            "command": "node scripts/copy.js dist/packages/nx/native-packages/* dist/packages"
+        },
+        "artifacts": {
+            "dependsOn": ["copy-native-package-directories"],
+            "command": "pnpm napi artifacts --package-json-path dist/packages/nx/package.json -d ./artifacts --npm-dir dist/packages"
+        },
+        "echo": {
+            "command": "echo hi"
+        },
+        "long-task": {
+            "command": "node -e \"let i = 0; let interval = setInterval(() => { console.log('Long task running ' + i++ + '---------------------------------------------------------------'); }, 200); setTimeout(() => { clearInterval(interval); console.log('Long task finished'); }, 62_000);\"",
+            "dependsOn": ["echo"]
+        },
+        "build": {
+            "dependsOn": [
+                "^build-client",
+                "build-base",
+                "build-native",
+                "legacy-post-build"
+            ],
+            "inputs": [
+                "production",
+                "^production",
+                {
+                    "dependentTasksOutputFiles": "**/*.node",
+                    "transitive": true
+                },
+                "{workspaceRoot}/scripts/copy-local-native.js",
+                "{workspaceRoot}/scripts/copy-graph-client.js",
+                "{workspaceRoot}/scripts/chmod.js",
+                "{workspaceRoot}/scripts/copy-readme.js"
+            ],
+            "executor": "nx:run-commands",
+            "outputs": [
+                "{workspaceRoot}/dist/packages/nx/**/*.{node,wasm,js,mjs,cjs}",
+                "{workspaceRoot}/dist/packages/nx/src/core/graph",
+                "{workspaceRoot}/dist/packages/nx/bin/nx.js",
+                "{workspaceRoot}/dist/packages/nx/README.md"
+            ],
+            "options": {
+                "commands": [
+                    {
+                        "command": "node ./scripts/copy-local-native.js nx"
+                    },
+                    {
+                        "command": "node ./scripts/copy-graph-client.js"
+                    },
+                    {
+                        "command": "node ./scripts/chmod dist/packages/nx/bin/nx.js"
+                    },
+                    {
+                        "command": "node ./scripts/copy-readme.js nx"
+                    }
+                ],
+                "parallel": false
+            }
+        },
+        "test-native": {},
+        "format-native": {
+            "command": "cargo fmt",
+            "cache": true,
+            "inputs": ["native"],
+            "options": {
+                "cwd": "{projectRoot}/src/native",
+                "args": ["--all", "--check"]
+            },
+            "configurations": {
+                "fix": {
+                    "args": ["--all"]
+                }
+            }
+        },
+        "lint-native": {
+            "command": "cargo clippy",
+            "cache": true,
+            "inputs": ["native"],
+            "options": {
+                "cwd": "{projectRoot}/src/native",
+                "args": ["--frozen"]
+            },
+            "configurations": {
+                "fix": {
+                    "args": []
+                }
+            }
+        },
+        "legacy-post-build": {
+            "executor": "@nx/workspace-plugin:legacy-post-build",
+            "options": {
+                "main": "./bin/nx.js",
+                "types": "./bin/nx.d.ts",
+                "tsConfig": "./tsconfig.lib.json",
+                "assets": [
+                    {
+                        "input": "packages/nx",
+                        "glob": ".npmignore",
+                        "output": "/"
+                    },
+                    {
+                        "input": "packages/nx",
+                        "glob": "**/files/**",
+                        "output": "/"
+                    },
+                    {
+                        "input": "packages/nx",
+                        "glob": "**/files/**/.gitkeep",
+                        "output": "/"
+                    },
+                    {
+                        "input": "packages/nx",
+                        "glob": "**/*.json",
+                        "ignore": [
+                            "**/tsconfig*.json",
+                            "**/project.json",
+                            "**/__fixtures__/**"
+                        ],
+                        "output": "/"
+                    },
+                    {
+                        "input": "packages/nx",
+                        "glob": "**/*.{mjs,cjs,js,css,html,svg,wasm}",
+                        "ignore": ["**/jest.config.js"],
+                        "output": "/"
+                    },
+                    {
+                        "input": "packages/nx",
+                        "glob": "**/*.d.ts",
+                        "output": "/"
+                    },
+                    {
+                        "input": "",
+                        "glob": "LICENSE",
+                        "output": "/"
+                    }
+                ]
+            }
+        }
+    }
+}

package/release/changelog-renderer/index.d.ts

@@ -0,0 +1,109 @@
+import type { ChangelogChange } from '../../src/command-line/release/changelog';
+import type { NxReleaseConfig } from '../../src/command-line/release/config/config';
+import type { RemoteReleaseClient } from '../../src/command-line/release/utils/remote-release-clients/remote-release-client';
+/**
+ * Re-export for ease of use in custom changelog renderers.
+ */
+export type { ChangelogChange };
+/**
+ * The ChangelogRenderOptions are specific to each ChangelogRenderer implementation, and are taken
+ * from the user's nx.json configuration and passed as is into the ChangelogRenderer function.
+ */
+export type ChangelogRenderOptions = Record<string, unknown>;
+/**
+ * When versioning projects independently and enabling `"updateDependents": "auto"`, there could
+ * be additional dependency bump information that is not captured in the commit data, but that nevertheless
+ * should be included in the rendered changelog.
+ */
+export type DependencyBump = {
+    dependencyName: string;
+    newVersion: string;
+};
+/**
+ * The specific options available to the default implementation of the ChangelogRenderer that nx exports
+ * for the common case.
+ */
+export interface DefaultChangelogRenderOptions extends ChangelogRenderOptions {
+    /**
+     * Whether or not the commit authors should be added to the bottom of the changelog in a "Thank You"
+     * section. Defaults to true.
+     */
+    authors?: boolean;
+    /**
+     * If authors is enabled, controls whether or not to try to map the authors to their GitHub usernames
+     * using https://ungh.cc (from https://github.com/unjs/ungh) and the email addresses found in the commits.
+     * Defaults to true.
+     */
+    applyUsernameToAuthors?: boolean;
+    /**
+     * Whether or not the commit references (such as commit and/or PR links) should be included in the changelog.
+     * Defaults to true.
+     */
+    commitReferences?: boolean;
+    /**
+     * Whether or not to include the date in the version title. It can be set to false to disable it, or true to enable
+     * with the default of (YYYY-MM-DD). Defaults to true.
+     */
+    versionTitleDate?: boolean;
+}
+export default class DefaultChangelogRenderer {
+    protected changes: ChangelogChange[];
+    protected changelogEntryVersion: string;
+    protected project: string | null;
+    protected entryWhenNoChanges: string | false;
+    protected changelogRenderOptions: DefaultChangelogRenderOptions;
+    protected isVersionPlans: boolean;
+    protected dependencyBumps?: DependencyBump[];
+    protected conventionalCommitsConfig: NxReleaseConfig['conventionalCommits'];
+    protected relevantChanges: ChangelogChange[];
+    protected breakingChanges: string[];
+    protected additionalChangesForAuthorsSection: ChangelogChange[];
+    protected remoteReleaseClient: RemoteReleaseClient<unknown>;
+    /**
+     * A ChangelogRenderer class takes in the determined changes and other relevant metadata
+     * and returns a string, or a Promise of a string of changelog contents (usually markdown).
+     *
+     * @param {Object} config The configuration object for the ChangelogRenderer
+     * @param {ChangelogChange[]} config.changes The collection of changes to show in the changelog
+     * @param {string} config.changelogEntryVersion The version for which we are rendering the current changelog entry
+     * @param {string | null} config.project The name of specific project to generate a changelog entry for, or `null` if the overall workspace changelog
+     * @param {string | false} config.entryWhenNoChanges The (already interpolated) string to use as the changelog entry when there are no changes, or `false` if no entry should be generated
+     * @param {boolean} config.isVersionPlans Whether or not Nx release version plans are the source of truth for the changelog entry
+     * @param {ChangelogRenderOptions} config.changelogRenderOptions The options specific to the ChangelogRenderer implementation
+     * @param {DependencyBump[]} config.dependencyBumps Optional list of additional dependency bumps that occurred as part of the release, outside of the change data
+     * @param {NxReleaseConfig['conventionalCommits']} config.conventionalCommitsConfig The configuration for conventional commits
+     * @param {RemoteReleaseClient} config.remoteReleaseClient The remote release client to use for formatting references
+     */
+    constructor(config: {
+        changes: ChangelogChange[];
+        changelogEntryVersion: string;
+        project: string | null;
+        entryWhenNoChanges: string | false;
+        isVersionPlans: boolean;
+        changelogRenderOptions: DefaultChangelogRenderOptions;
+        dependencyBumps?: DependencyBump[];
+        conventionalCommitsConfig: NxReleaseConfig['conventionalCommits'];
+        remoteReleaseClient: RemoteReleaseClient<unknown>;
+    });
+    protected filterChanges(changes: ChangelogChange[], project: string | null): ChangelogChange[];
+    render(): Promise<string>;
+    protected preprocessChanges(): void;
+    protected shouldRenderEmptyEntry(): boolean;
+    protected renderEmptyEntry(): string;
+    protected renderVersionTitle(): string;
+    protected renderChangesByType(): string[];
+    protected hasBreakingChanges(): boolean;
+    protected renderBreakingChanges(): string[];
+    protected hasDependencyBumps(): boolean;
+    protected renderDependencyBumps(): string[];
+    protected shouldRenderAuthors(): boolean;
+    protected renderAuthors(): Promise<string[]>;
+    protected formatChange(change: ChangelogChange): string;
+    protected formatBreakingChangeBase(change: ChangelogChange): string;
+    protected formatBreakingChange(change: ChangelogChange): string;
+    protected groupChangesByType(): Record<string, ChangelogChange[]>;
+    protected groupChangesByScope(changes: ChangelogChange[]): Record<string, ChangelogChange[]>;
+    protected extractBreakingChangeExplanation(message: string): string | null;
+    protected formatName(name?: string): string;
+}
+//# sourceMappingURL=index.d.ts.map

package/release/changelog-renderer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/release/changelog-renderer/index.ts"],"names":[],"mappings":"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"}

package/release/changelog-renderer/index.js

@@ -0,0 +1,367 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const semver_1 = require("semver");
+class DefaultChangelogRenderer {
+    /**
+     * A ChangelogRenderer class takes in the determined changes and other relevant metadata
+     * and returns a string, or a Promise of a string of changelog contents (usually markdown).
+     *
+     * @param {Object} config The configuration object for the ChangelogRenderer
+     * @param {ChangelogChange[]} config.changes The collection of changes to show in the changelog
+     * @param {string} config.changelogEntryVersion The version for which we are rendering the current changelog entry
+     * @param {string | null} config.project The name of specific project to generate a changelog entry for, or `null` if the overall workspace changelog
+     * @param {string | false} config.entryWhenNoChanges The (already interpolated) string to use as the changelog entry when there are no changes, or `false` if no entry should be generated
+     * @param {boolean} config.isVersionPlans Whether or not Nx release version plans are the source of truth for the changelog entry
+     * @param {ChangelogRenderOptions} config.changelogRenderOptions The options specific to the ChangelogRenderer implementation
+     * @param {DependencyBump[]} config.dependencyBumps Optional list of additional dependency bumps that occurred as part of the release, outside of the change data
+     * @param {NxReleaseConfig['conventionalCommits']} config.conventionalCommitsConfig The configuration for conventional commits
+     * @param {RemoteReleaseClient} config.remoteReleaseClient The remote release client to use for formatting references
+     */
+    constructor(config) {
+        this.changes = this.filterChanges(config.changes, config.project);
+        this.changelogEntryVersion = config.changelogEntryVersion;
+        this.project = config.project;
+        this.entryWhenNoChanges = config.entryWhenNoChanges;
+        this.isVersionPlans = config.isVersionPlans;
+        this.changelogRenderOptions = config.changelogRenderOptions;
+        this.dependencyBumps = config.dependencyBumps;
+        this.conventionalCommitsConfig = config.conventionalCommitsConfig;
+        this.remoteReleaseClient = config.remoteReleaseClient;
+        this.relevantChanges = [];
+        this.breakingChanges = [];
+        this.additionalChangesForAuthorsSection = [];
+    }
+    filterChanges(changes, project) {
+        if (project === null) {
+            return changes;
+        }
+        return changes.filter((c) => c.affectedProjects &&
+            (c.affectedProjects === '*' || c.affectedProjects.includes(project)));
+    }
+    async render() {
+        const sections = [];
+        this.preprocessChanges();
+        if (this.shouldRenderEmptyEntry()) {
+            return this.renderEmptyEntry();
+        }
+        sections.push([this.renderVersionTitle()]);
+        const changesByType = this.renderChangesByType();
+        if (changesByType.length > 0) {
+            sections.push(changesByType);
+        }
+        if (this.hasBreakingChanges()) {
+            sections.push(this.renderBreakingChanges());
+        }
+        if (this.hasDependencyBumps()) {
+            sections.push(this.renderDependencyBumps());
+        }
+        if (this.shouldRenderAuthors()) {
+            sections.push(await this.renderAuthors());
+        }
+        // Join sections with double newlines, and trim any extra whitespace
+        return sections
+            .filter((section) => section.length > 0)
+            .map((section) => section.join('\n').trim())
+            .join('\n\n')
+            .trim();
+    }
+    preprocessChanges() {
+        this.relevantChanges = [...this.changes];
+        this.breakingChanges = [];
+        this.additionalChangesForAuthorsSection = [];
+        // Filter out reverted changes
+        for (let i = this.relevantChanges.length - 1; i >= 0; i--) {
+            const change = this.relevantChanges[i];
+            if (change.type === 'revert' && change.revertedHashes) {
+                for (const revertedHash of change.revertedHashes) {
+                    const revertedCommitIndex = this.relevantChanges.findIndex((c) => c.shortHash && revertedHash.startsWith(c.shortHash));
+                    if (revertedCommitIndex !== -1) {
+                        this.relevantChanges.splice(revertedCommitIndex, 1);
+                        this.relevantChanges.splice(i, 1);
+                        i--;
+                        break;
+                    }
+                }
+            }
+        }
+        if (this.isVersionPlans) {
+            for (let i = this.relevantChanges.length - 1; i >= 0; i--) {
+                if (this.relevantChanges[i].isBreaking) {
+                    const change = this.relevantChanges[i];
+                    this.additionalChangesForAuthorsSection.push(change);
+                    const line = this.formatChange(change);
+                    this.breakingChanges.push(line);
+                    this.relevantChanges.splice(i, 1);
+                }
+            }
+        }
+        else {
+            for (const change of this.relevantChanges) {
+                if (change.isBreaking) {
+                    this.breakingChanges.push(this.formatBreakingChange(change));
+                }
+            }
+        }
+    }
+    shouldRenderEmptyEntry() {
+        return (this.relevantChanges.length === 0 &&
+            this.breakingChanges.length === 0 &&
+            !this.hasDependencyBumps());
+    }
+    renderEmptyEntry() {
+        if (this.hasDependencyBumps()) {
+            return [
+                this.renderVersionTitle(),
+                '',
+                ...this.renderDependencyBumps(),
+            ].join('\n');
+        }
+        else if (this.entryWhenNoChanges) {
+            return `${this.renderVersionTitle()}\n\n${this.entryWhenNoChanges}`;
+        }
+        return '';
+    }
+    renderVersionTitle() {
+        let isMajorVersion = true;
+        try {
+            isMajorVersion =
+                `${(0, semver_1.major)(this.changelogEntryVersion)}.0.0` ===
+                    this.changelogEntryVersion.replace(/^v/, '');
+        }
+        catch {
+            // Do nothing with the error
+            // Prevent non-semver versions from erroring out
+        }
+        let maybeDateStr = '';
+        if (this.changelogRenderOptions.versionTitleDate) {
+            const dateStr = new Date().toISOString().slice(0, 10);
+            maybeDateStr = ` (${dateStr})`;
+        }
+        return isMajorVersion
+            ? `# ${this.changelogEntryVersion}${maybeDateStr}`
+            : `## ${this.changelogEntryVersion}${maybeDateStr}`;
+    }
+    renderChangesByType() {
+        const markdownLines = [];
+        const typeGroups = this.groupChangesByType();
+        const changeTypes = this.conventionalCommitsConfig.types;
+        for (const type of Object.keys(changeTypes)) {
+            const group = typeGroups[type];
+            if (!group || group.length === 0) {
+                continue;
+            }
+            markdownLines.push('', `### ${changeTypes[type].changelog.title}`, '');
+            if (this.project === null) {
+                const changesGroupedByScope = this.groupChangesByScope(group);
+                const scopesSortedAlphabetically = Object.keys(changesGroupedByScope).sort();
+                for (const scope of scopesSortedAlphabetically) {
+                    const changes = changesGroupedByScope[scope];
+                    for (const change of changes.reverse()) {
+                        const line = this.formatChange(change);
+                        markdownLines.push(line);
+                        if (change.isBreaking && !this.isVersionPlans) {
+                            this.breakingChanges.push(this.formatBreakingChange(change));
+                        }
+                    }
+                }
+            }
+            else {
+                // For project-specific changelogs, maintain the original order
+                for (const change of group) {
+                    const line = this.formatChange(change);
+                    markdownLines.push(line);
+                    if (change.isBreaking && !this.isVersionPlans) {
+                        this.breakingChanges.push(this.formatBreakingChange(change));
+                    }
+                }
+            }
+        }
+        return markdownLines;
+    }
+    hasBreakingChanges() {
+        return this.breakingChanges.length > 0;
+    }
+    renderBreakingChanges() {
+        const uniqueBreakingChanges = Array.from(new Set(this.breakingChanges));
+        return ['### ⚠️  Breaking Changes', '', ...uniqueBreakingChanges];
+    }
+    hasDependencyBumps() {
+        return this.dependencyBumps && this.dependencyBumps.length > 0;
+    }
+    renderDependencyBumps() {
+        const markdownLines = ['', '### 🧱 Updated Dependencies', ''];
+        this.dependencyBumps.forEach(({ dependencyName, newVersion }) => {
+            markdownLines.push(`- Updated ${dependencyName} to ${newVersion}`);
+        });
+        return markdownLines;
+    }
+    shouldRenderAuthors() {
+        return this.changelogRenderOptions.authors;
+    }
+    async renderAuthors() {
+        const markdownLines = [];
+        const _authors = new Map();
+        for (const change of [
+            ...this.relevantChanges,
+            ...this.additionalChangesForAuthorsSection,
+        ]) {
+            if (!change.authors) {
+                continue;
+            }
+            for (const author of change.authors) {
+                const name = this.formatName(author.name);
+                if (!name || name.includes('[bot]')) {
+                    continue;
+                }
+                if (_authors.has(name)) {
+                    const entry = _authors.get(name);
+                    entry.email.add(author.email);
+                }
+                else {
+                    _authors.set(name, { email: new Set([author.email]) });
+                }
+            }
+        }
+        if (this.remoteReleaseClient.getRemoteRepoData() &&
+            this.changelogRenderOptions.applyUsernameToAuthors &&
+            // TODO: Explore if it is possible to support GitLab username resolution
+            this.remoteReleaseClient.remoteReleaseProviderName === 'GitHub') {
+            await this.remoteReleaseClient.applyUsernameToAuthors(_authors);
+        }
+        const authors = [..._authors.entries()].map((e) => ({
+            name: e[0],
+            ...e[1],
+        }));
+        if (authors.length > 0) {
+            markdownLines.push('', '### ' + '❤️ Thank You', '', ...authors
+                .sort((a, b) => a.name.localeCompare(b.name))
+                .map((i) => {
+                const username = i.username ? ` @${i.username}` : '';
+                return `- ${i.name}${username}`;
+            }));
+        }
+        return markdownLines;
+    }
+    formatChange(change) {
+        let description = change.description;
+        let extraLines = [];
+        let extraLinesStr = '';
+        if (description.includes('\n')) {
+            [description, ...extraLines] = description.split('\n');
+            const indentation = '  ';
+            extraLinesStr = (this.isVersionPlans
+                ? // Preserve newlines for version plan sources to allow author to maintain maximum control over final contents
+                    extraLines
+                : extraLines.filter((l) => l.trim().length > 0))
+                // Only add indentation to lines with content
+                .map((l) => (l.trim().length > 0 ? `${indentation}${l}` : ''))
+                .join('\n');
+        }
+        let changeLine = '- ' +
+            (!this.isVersionPlans && change.isBreaking ? '⚠️  ' : '') +
+            (!this.isVersionPlans && change.scope
+                ? `**${change.scope.trim()}:** `
+                : '') +
+            description;
+        if (this.remoteReleaseClient.getRemoteRepoData() &&
+            this.changelogRenderOptions.commitReferences &&
+            change.githubReferences) {
+            changeLine += this.remoteReleaseClient.formatReferences(change.githubReferences);
+        }
+        if (extraLinesStr) {
+            changeLine += (this.isVersionPlans ? '\n' : '\n\n') + extraLinesStr;
+        }
+        return changeLine;
+    }
+    formatBreakingChangeBase(change) {
+        let breakingLine = '- ';
+        if (change.scope) {
+            breakingLine += `**${change.scope.trim()}:** `;
+        }
+        if (change.description) {
+            breakingLine += `${change.description.trim()}`;
+        }
+        if (this.remoteReleaseClient.getRemoteRepoData() &&
+            this.changelogRenderOptions.commitReferences &&
+            change.githubReferences) {
+            breakingLine += ` ${this.remoteReleaseClient.formatReferences(change.githubReferences)}`;
+        }
+        return breakingLine;
+    }
+    formatBreakingChange(change) {
+        const explanation = this.extractBreakingChangeExplanation(change.body);
+        const baseLine = this.formatBreakingChangeBase(change);
+        if (!explanation) {
+            return baseLine;
+        }
+        const indentation = '  ';
+        let breakingLine = baseLine + `\n${indentation}`;
+        // Handle multi-line explanations
+        let explanationText = explanation;
+        let extraLines = [];
+        if (explanation.includes('\n')) {
+            [explanationText, ...extraLines] = explanation.split('\n');
+        }
+        breakingLine += explanationText;
+        // Add extra lines with indentation (matching formatChange behavior)
+        if (extraLines.length > 0) {
+            const extraLinesStr = extraLines
+                .filter((l) => l.trim().length > 0)
+                .map((l) => `${indentation}${l}`)
+                .join('\n');
+            if (extraLinesStr) {
+                breakingLine += '\n' + extraLinesStr;
+            }
+        }
+        return breakingLine;
+    }
+    groupChangesByType() {
+        const typeGroups = {};
+        for (const change of this.relevantChanges) {
+            typeGroups[change.type] = typeGroups[change.type] || [];
+            typeGroups[change.type].push(change);
+        }
+        return typeGroups;
+    }
+    groupChangesByScope(changes) {
+        const scopeGroups = {};
+        for (const change of changes) {
+            const scope = change.scope || '';
+            scopeGroups[scope] = scopeGroups[scope] || [];
+            scopeGroups[scope].push(change);
+        }
+        return scopeGroups;
+    }
+    extractBreakingChangeExplanation(message) {
+        if (!message) {
+            return null;
+        }
+        const breakingChangeIdentifier = 'BREAKING CHANGE:';
+        const startIndex = message.indexOf(breakingChangeIdentifier);
+        if (startIndex === -1) {
+            return null;
+        }
+        const startOfBreakingChange = startIndex + breakingChangeIdentifier.length;
+        // Extract all text after BREAKING CHANGE: until we hit a Co-authored-by section or git metadata
+        let endOfBreakingChange = message.length;
+        const coAuthoredBySection = message.indexOf('---------\n\nCo-authored-by:');
+        if (coAuthoredBySection !== -1) {
+            endOfBreakingChange = coAuthoredBySection;
+        }
+        else {
+            // Look for the git metadata delimiter (a line with just ")
+            const gitMetadataMarker = message.indexOf('"\n', startOfBreakingChange);
+            if (gitMetadataMarker !== -1) {
+                endOfBreakingChange = gitMetadataMarker;
+            }
+        }
+        return message.substring(startOfBreakingChange, endOfBreakingChange).trim();
+    }
+    formatName(name = '') {
+        return name
+            .split(' ')
+            .map((p) => p.trim())
+            .join(' ');
+    }
+}
+exports.default = DefaultChangelogRenderer;

package/release/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @public Programmatic API for nx release
+ */
+export { ReleaseClient, release, releaseChangelog, releasePublish, releaseVersion, VersionActions, AfterAllProjectsVersioned, } from '../src/command-line/release';
+//# sourceMappingURL=index.d.ts.map

package/release/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/nx/release/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EACL,aAAa,EACb,OAAO,EACP,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,cAAc,EACd,yBAAyB,GAC1B,MAAM,6BAA6B,CAAC"}