@ohos-ports/nx 19.8.4-beta.0

package/package.json

@@ -0,0 +1,198 @@
+{
+  "name": "@ohos-ports/nx",
+  "version": "19.8.4-beta.0",
+  "private": false,
+  "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration. (ohos-ports: HarmonyOS openharmony/arm64 native binding, compiled from source)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/@nrwl/next/19.8.4"
+  },
+  "keywords": [
+    "Monorepo",
+    "Angular",
+    "React",
+    "Web",
+    "Node",
+    "Nest",
+    "Jest",
+    "Cypress",
+    "CLI",
+    "Testing",
+    "Front-end",
+    "Backend",
+    "Mobile"
+  ],
+  "bin": {
+    "nx": "./bin/nx.js",
+    "nx-cloud": "./bin/nx-cloud.js"
+  },
+  "author": "Victor Savkin",
+  "license": "MIT",
+  "homepage": "https://nx.dev",
+  "dependencies": {
+    "@napi-rs/wasm-runtime": "0.2.4",
+    "@yarnpkg/lockfile": "^1.1.0",
+    "@yarnpkg/parsers": "3.0.0-rc.46",
+    "@zkochan/js-yaml": "0.0.7",
+    "axios": "^1.7.4",
+    "chalk": "^4.1.0",
+    "cli-cursor": "3.1.0",
+    "cli-spinners": "2.6.1",
+    "cliui": "^8.0.1",
+    "dotenv": "~16.4.5",
+    "dotenv-expand": "~11.0.6",
+    "enquirer": "~2.3.6",
+    "figures": "3.2.0",
+    "flat": "^5.0.2",
+    "front-matter": "^4.0.2",
+    "ignore": "^5.0.4",
+    "jest-diff": "^29.4.1",
+    "jsonc-parser": "3.2.0",
+    "lines-and-columns": "2.0.3",
+    "minimatch": "9.0.3",
+    "npm-run-path": "^4.0.1",
+    "open": "^8.4.0",
+    "semver": "^7.5.3",
+    "string-width": "^4.2.3",
+    "strong-log-transformer": "^2.1.0",
+    "tar-stream": "~2.2.0",
+    "tmp": "~0.2.1",
+    "tsconfig-paths": "^4.1.2",
+    "tslib": "^2.3.0",
+    "yargs": "^17.6.2",
+    "yargs-parser": "21.1.1",
+    "node-machine-id": "1.1.12",
+    "ora": "5.3.0",
+    "@nrwl/tao": "19.8.4"
+  },
+  "peerDependencies": {
+    "@swc-node/register": "^1.8.0",
+    "@swc/core": "^1.3.85"
+  },
+  "peerDependenciesMeta": {
+    "@swc-node/register": {
+      "optional": true
+    },
+    "@swc/core": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "@nx/nx-darwin-x64": "19.8.4",
+    "@nx/nx-darwin-arm64": "19.8.4",
+    "@nx/nx-linux-x64-gnu": "19.8.4",
+    "@nx/nx-linux-x64-musl": "19.8.4",
+    "@nx/nx-win32-x64-msvc": "19.8.4",
+    "@nx/nx-linux-arm64-gnu": "19.8.4",
+    "@nx/nx-linux-arm64-musl": "19.8.4",
+    "@nx/nx-linux-arm-gnueabihf": "19.8.4",
+    "@nx/nx-win32-arm64-msvc": "19.8.4",
+    "@nx/nx-freebsd-x64": "19.8.4"
+  },
+  "nx-migrations": {
+    "migrations": "./migrations.json",
+    "packageGroup": [
+      "@nx/js",
+      "@nrwl/js",
+      "@nx/jest",
+      "@nrwl/jest",
+      "@nx/linter",
+      "@nx/eslint",
+      "@nrwl/linter",
+      "@nx/workspace",
+      "@nrwl/workspace",
+      "@nx/angular",
+      "@nrwl/angular",
+      "@nx/cypress",
+      "@nrwl/cypress",
+      "@nx/detox",
+      "@nrwl/detox",
+      "@nx/devkit",
+      "@nrwl/devkit",
+      "@nx/esbuild",
+      "@nrwl/esbuild",
+      "@nx/eslint-plugin",
+      "@nrwl/eslint-plugin-nx",
+      "@nx/expo",
+      "@nrwl/expo",
+      "@nx/express",
+      "@nrwl/express",
+      "@nx/gradle",
+      "@nx/nest",
+      "@nrwl/nest",
+      "@nx/next",
+      "@nrwl/next",
+      "@nx/node",
+      "@nrwl/node",
+      "@nx/nuxt",
+      "@nx/playwright",
+      "@nx/plugin",
+      "@nrwl/nx-plugin",
+      "@nx/react",
+      "@nrwl/react",
+      "@nx/react-native",
+      "@nrwl/react-native",
+      "@nx/rollup",
+      "@nrwl/rollup",
+      "@nx/remix",
+      "@nrwl/remix",
+      "@nx/storybook",
+      "@nrwl/storybook",
+      "@nrwl/tao",
+      "@nx/vite",
+      "@nrwl/vite",
+      "@nx/vue",
+      "@nx/web",
+      "@nrwl/web",
+      "@nx/webpack",
+      "@nrwl/webpack",
+      {
+        "package": "nx-cloud",
+        "version": "latest"
+      },
+      {
+        "package": "@nrwl/nx-cloud",
+        "version": "latest"
+      }
+    ]
+  },
+  "generators": "./generators.json",
+  "executors": "./executors.json",
+  "builders": "./executors.json",
+  "publishConfig": {
+    "access": "public"
+  },
+  "napi": {
+    "binaryName": "nx",
+    "packageName": "@nx/nx",
+    "wasm": {
+      "initialMemory": 1024,
+      "maximumMemory": 32768
+    },
+    "targets": [
+      "x86_64-unknown-linux-gnu",
+      "x86_64-pc-windows-msvc",
+      "x86_64-apple-darwin",
+      "aarch64-apple-darwin",
+      "aarch64-unknown-linux-gnu",
+      "aarch64-unknown-linux-musl",
+      "aarch64-pc-windows-msvc",
+      "armv7-unknown-linux-gnueabihf",
+      "x86_64-unknown-linux-musl",
+      "x86_64-unknown-freebsd"
+    ]
+  },
+  "main": "./bin/nx.js",
+  "type": "commonjs",
+  "types": "./bin/nx.d.ts",
+  "scripts": {
+    "postinstall": "node ./bin/post-install"
+  },
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "bundleDependencies": [
+    "@nrwl/tao"
+  ]
+}

package/plugins/package-json.d.ts

@@ -0,0 +1 @@
+export {};

package/plugins/package-json.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const workspace_root_1 = require("../src/utils/workspace-root");
+const package_json_1 = require("../src/plugins/package-json");
+const plugin = {
+    name: 'nx-all-package-jsons-plugin',
+    createNodes: [
+        '*/**/package.json',
+        (f) => (0, package_json_1.createNodeFromPackageJson)(f, workspace_root_1.workspaceRoot),
+    ],
+};
+module.exports = plugin;

package/presets/core.json

@@ -0,0 +1 @@
+{}

package/presets/npm.json

@@ -0,0 +1,7 @@
+{
+  "pluginsConfig": {
+    "@nx/js": {
+      "analyzeSourceFiles": false
+    }
+  }
+}

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

@@ -0,0 +1,80 @@
+import { ChangelogChange } from '../../src/command-line/release/changelog';
+import { NxReleaseConfig } from '../../src/command-line/release/config/config';
+import { GitCommit } from '../../src/command-line/release/utils/git';
+import { GithubRepoData, RepoSlug } from '../../src/command-line/release/utils/github';
+import type { ProjectGraph } from '../../src/config/project-graph';
+/**
+ * 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": "always"`, 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;
+};
+/**
+ * A ChangelogRenderer function takes in the extracted commits 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 {ProjectGraph} config.projectGraph The project graph for the workspace
+ * @param {GitCommit[]} config.commits DEPRECATED [Use 'config.changes' instead] - The collection of extracted commits to generate a changelog for
+ * @param {ChangelogChange[]} config.changes The collection of changes to show in the changelog
+ * @param {string} config.releaseVersion The version that is being released
+ * @param {string | null} config.project The name of specific project to generate a changelog 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 {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 commit data
+ * @param {GithubRepoData} config.repoData Resolved data for the current GitHub repository
+ */
+export type ChangelogRenderer = (config: {
+    projectGraph: ProjectGraph;
+    commits?: GitCommit[];
+    changes?: ChangelogChange[];
+    releaseVersion: string;
+    project: string | null;
+    entryWhenNoChanges: string | false;
+    changelogRenderOptions: DefaultChangelogRenderOptions;
+    dependencyBumps?: DependencyBump[];
+    repoSlug?: RepoSlug;
+    repoData?: GithubRepoData;
+    conventionalCommitsConfig: NxReleaseConfig['conventionalCommits'] | null;
+}) => Promise<string> | 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.
+     */
+    mapAuthorsToGitHubUsernames?: 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;
+}
+/**
+ * The default ChangelogRenderer implementation that nx exports for the common case of generating markdown
+ * from the given commits and other metadata.
+ */
+declare const defaultChangelogRenderer: ChangelogRenderer;
+export default defaultChangelogRenderer;

package/release/changelog-renderer/index.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const semver_1 = require("semver");
+const conventional_commits_1 = require("../../src/command-line/release/config/conventional-commits");
+const github_1 = require("../../src/command-line/release/utils/github");
+// axios types and values don't seem to match
+const _axios = require("axios");
+const axios = _axios;
+/**
+ * The default ChangelogRenderer implementation that nx exports for the common case of generating markdown
+ * from the given commits and other metadata.
+ */
+const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion, project, entryWhenNoChanges, changelogRenderOptions, dependencyBumps, repoSlug, conventionalCommitsConfig, repoData, }) => {
+    const markdownLines = [];
+    // If the current range of changes contains both a commit and its revert, we strip them both from the final list. Changes from version plans are unaffected, as they have no hashes.
+    for (const change of changes) {
+        if (change.type === 'revert' && change.revertedHashes) {
+            for (const revertedHash of change.revertedHashes) {
+                const revertedCommit = changes.find((c) => c.shortHash && revertedHash.startsWith(c.shortHash));
+                if (revertedCommit) {
+                    changes.splice(changes.indexOf(revertedCommit), 1);
+                    changes.splice(changes.indexOf(change), 1);
+                }
+            }
+        }
+    }
+    let relevantChanges = changes;
+    const breakingChanges = [];
+    // For now to keep the interface of the changelog renderer non-breaking for v19 releases we have a somewhat indirect check for whether or not we are generating a changelog for version plans
+    const isVersionPlans = !conventionalCommitsConfig;
+    // Only applicable for version plans
+    const additionalChangesForAuthorsSection = [];
+    // Provide a default configuration for version plans to allow most of the subsequent logic to work in the same way it would for conventional commits
+    // NOTE: The one exception is breaking/major changes, where we do not follow the same structure and instead only show the changes once
+    if (isVersionPlans) {
+        conventionalCommitsConfig = {
+            types: {
+                feat: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.feat,
+                fix: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.fix,
+            },
+        };
+        // Trim down "relevant changes" to only include non-breaking ones so that we can render them differently under version plans,
+        // but keep track of the changes for the purposes of the authors section
+        // TODO(v20): Clean this abstraction up as part of the larger overall refactor of changelog rendering
+        for (let i = 0; i < relevantChanges.length; i++) {
+            if (relevantChanges[i].isBreaking) {
+                const change = relevantChanges[i];
+                additionalChangesForAuthorsSection.push(change);
+                const line = formatChange(change, changelogRenderOptions, isVersionPlans, repoData);
+                breakingChanges.push(line);
+                relevantChanges.splice(i, 1);
+            }
+        }
+    }
+    const changeTypes = conventionalCommitsConfig.types;
+    // workspace root level changelog
+    if (project === null) {
+        // No changes for the workspace
+        if (relevantChanges.length === 0 && breakingChanges.length === 0) {
+            if (dependencyBumps?.length) {
+                applyAdditionalDependencyBumps({
+                    markdownLines,
+                    dependencyBumps,
+                    releaseVersion,
+                    changelogRenderOptions,
+                });
+            }
+            else if (entryWhenNoChanges) {
+                markdownLines.push('', `${createVersionTitle(releaseVersion, changelogRenderOptions)}\n\n${entryWhenNoChanges}`, '');
+            }
+            return markdownLines.join('\n').trim();
+        }
+        const typeGroups = groupBy(relevantChanges, 'type');
+        markdownLines.push('', createVersionTitle(releaseVersion, changelogRenderOptions), '');
+        for (const type of Object.keys(changeTypes)) {
+            const group = typeGroups[type];
+            if (!group || group.length === 0) {
+                continue;
+            }
+            markdownLines.push('', '### ' + changeTypes[type].changelog.title, '');
+            /**
+             * In order to make the final changelog most readable, we organize changes as follows:
+             * - By scope, where scopes are in alphabetical order (changes with no scope are listed first)
+             * - Within a particular scope grouping, we list changes in chronological order
+             */
+            const changesInChronologicalOrder = group.reverse();
+            const changesGroupedByScope = groupBy(changesInChronologicalOrder, 'scope');
+            const scopesSortedAlphabetically = Object.keys(changesGroupedByScope).sort();
+            for (const scope of scopesSortedAlphabetically) {
+                const changes = changesGroupedByScope[scope];
+                for (const change of changes) {
+                    const line = formatChange(change, changelogRenderOptions, isVersionPlans, repoData);
+                    markdownLines.push(line);
+                    if (change.isBreaking) {
+                        const breakingChangeExplanation = extractBreakingChangeExplanation(change.body);
+                        breakingChanges.push(breakingChangeExplanation
+                            ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ''}${breakingChangeExplanation}`
+                            : line);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        // project level changelog
+        relevantChanges = relevantChanges.filter((c) => c.affectedProjects &&
+            (c.affectedProjects === '*' || c.affectedProjects.includes(project)));
+        // Generating for a named project, but that project has no relevant changes in the current set of commits, exit early
+        if (relevantChanges.length === 0 && breakingChanges.length === 0) {
+            if (dependencyBumps?.length) {
+                applyAdditionalDependencyBumps({
+                    markdownLines,
+                    dependencyBumps,
+                    releaseVersion,
+                    changelogRenderOptions,
+                });
+            }
+            else if (entryWhenNoChanges) {
+                markdownLines.push('', `${createVersionTitle(releaseVersion, changelogRenderOptions)}\n\n${entryWhenNoChanges}`, '');
+            }
+            return markdownLines.join('\n').trim();
+        }
+        markdownLines.push('', createVersionTitle(releaseVersion, changelogRenderOptions), '');
+        const typeGroups = groupBy(
+        // Sort the relevant changes to have the unscoped changes first, before grouping by type
+        relevantChanges.sort((a, b) => (b.scope ? 1 : 0) - (a.scope ? 1 : 0)), 'type');
+        for (const type of Object.keys(changeTypes)) {
+            const group = typeGroups[type];
+            if (!group || group.length === 0) {
+                continue;
+            }
+            markdownLines.push('', `### ${changeTypes[type].changelog.title}`, '');
+            const changesInChronologicalOrder = group.reverse();
+            for (const change of changesInChronologicalOrder) {
+                const line = formatChange(change, changelogRenderOptions, isVersionPlans, repoData);
+                markdownLines.push(line + '\n');
+                if (change.isBreaking) {
+                    const breakingChangeExplanation = extractBreakingChangeExplanation(change.body);
+                    breakingChanges.push(breakingChangeExplanation
+                        ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ''}${breakingChangeExplanation}`
+                        : line);
+                }
+            }
+        }
+    }
+    if (breakingChanges.length > 0) {
+        markdownLines.push('', '### ⚠️  Breaking Changes', '', ...breakingChanges);
+    }
+    if (dependencyBumps?.length) {
+        applyAdditionalDependencyBumps({
+            markdownLines,
+            dependencyBumps,
+            releaseVersion,
+            changelogRenderOptions,
+        });
+    }
+    if (changelogRenderOptions.authors) {
+        const _authors = new Map();
+        for (const change of [
+            ...relevantChanges,
+            ...additionalChangesForAuthorsSection,
+        ]) {
+            if (!change.author) {
+                continue;
+            }
+            const name = formatName(change.author.name);
+            if (!name || name.includes('[bot]')) {
+                continue;
+            }
+            if (_authors.has(name)) {
+                const entry = _authors.get(name);
+                entry.email.add(change.author.email);
+            }
+            else {
+                _authors.set(name, { email: new Set([change.author.email]) });
+            }
+        }
+        // Try to map authors to github usernames
+        if (repoData && changelogRenderOptions.mapAuthorsToGitHubUsernames) {
+            await Promise.all([..._authors.keys()].map(async (authorName) => {
+                const meta = _authors.get(authorName);
+                for (const email of meta.email) {
+                    // For these pseudo-anonymized emails we can just extract the Github username from before the @
+                    // It could either be in the format: username@ or github_id+username@
+                    if (email.endsWith('@users.noreply.github.com')) {
+                        const match = email.match(/^(\d+\+)?([^@]+)@users\.noreply\.github\.com$/);
+                        if (match && match[2]) {
+                            meta.github = match[2];
+                            break;
+                        }
+                    }
+                    // Look up any other emails against the ungh.cc API
+                    const { data } = await axios
+                        .get(`https://ungh.cc/users/find/${email}`)
+                        .catch(() => ({ data: { user: null } }));
+                    if (data?.user) {
+                        meta.github = data.user.username;
+                        break;
+                    }
+                }
+            }));
+        }
+        const authors = [..._authors.entries()].map((e) => ({
+            name: e[0],
+            ...e[1],
+        }));
+        if (authors.length > 0) {
+            markdownLines.push('', '### ' + '❤️  Thank You', '', ...authors
+                // Sort the contributors by name
+                .sort((a, b) => a.name.localeCompare(b.name))
+                .map((i) => {
+                // Tag the author's Github username if we were able to resolve it so that Github adds them as a contributor
+                const github = i.github ? ` @${i.github}` : '';
+                return `- ${i.name}${github}`;
+            }));
+        }
+    }
+    return markdownLines.join('\n').trim();
+};
+exports.default = defaultChangelogRenderer;
+function applyAdditionalDependencyBumps({ markdownLines, dependencyBumps, releaseVersion, changelogRenderOptions, }) {
+    if (markdownLines.length === 0) {
+        markdownLines.push('', `${createVersionTitle(releaseVersion, changelogRenderOptions)}\n`, '');
+    }
+    else {
+        markdownLines.push('');
+    }
+    markdownLines.push('### 🧱 Updated Dependencies\n');
+    dependencyBumps.forEach(({ dependencyName, newVersion }) => {
+        markdownLines.push(`- Updated ${dependencyName} to ${newVersion}`);
+    });
+    markdownLines.push('');
+}
+function formatName(name = '') {
+    return name
+        .split(' ')
+        .map((p) => p.trim())
+        .join(' ');
+}
+function groupBy(items, key) {
+    const groups = {};
+    for (const item of items) {
+        groups[item[key]] = groups[item[key]] || [];
+        groups[item[key]].push(item);
+    }
+    return groups;
+}
+function formatChange(change, changelogRenderOptions, isVersionPlans, repoData) {
+    let description = change.description;
+    let extraLines = [];
+    let extraLinesStr = '';
+    if (description.includes('\n')) {
+        [description, ...extraLines] = description.split('\n');
+        // Align the extra lines with the start of the description for better readability
+        const indentation = '  ';
+        extraLinesStr = extraLines
+            .filter((l) => l.trim().length > 0)
+            .map((l) => `${indentation}${l}`)
+            .join('\n');
+    }
+    /**
+     * In version plans changelogs:
+     * - don't repeat the breaking change icon
+     * - don't render the scope
+     */
+    let changeLine = '- ' +
+        (!isVersionPlans && change.isBreaking ? '⚠️  ' : '') +
+        (!isVersionPlans && change.scope ? `**${change.scope.trim()}:** ` : '') +
+        description;
+    if (repoData && changelogRenderOptions.commitReferences) {
+        changeLine += (0, github_1.formatReferences)(change.githubReferences, repoData);
+    }
+    if (extraLinesStr) {
+        changeLine += '\n\n' + extraLinesStr;
+    }
+    return changeLine;
+}
+/**
+ * It is common to add further information about a breaking change in the commit body,
+ * and it is naturally that information that should be included in the BREAKING CHANGES
+ * section of changelog, rather than repeating the commit title/description.
+ */
+function extractBreakingChangeExplanation(message) {
+    if (!message) {
+        return null;
+    }
+    const breakingChangeIdentifier = 'BREAKING CHANGE:';
+    const startIndex = message.indexOf(breakingChangeIdentifier);
+    if (startIndex === -1) {
+        // "BREAKING CHANGE:" not found in the message
+        return null;
+    }
+    const startOfBreakingChange = startIndex + breakingChangeIdentifier.length;
+    const endOfBreakingChange = message.indexOf('\n', startOfBreakingChange);
+    if (endOfBreakingChange === -1) {
+        // No newline character found, extract till the end of the message
+        return message.substring(startOfBreakingChange).trim();
+    }
+    // Extract and return the breaking change message
+    return message.substring(startOfBreakingChange, endOfBreakingChange).trim();
+}
+function createVersionTitle(version, changelogRenderOptions) {
+    // Normalize by removing any leading `v` during comparison
+    const isMajorVersion = `${(0, semver_1.major)(version)}.0.0` === version.replace(/^v/, '');
+    let maybeDateStr = '';
+    if (changelogRenderOptions.versionTitleDate) {
+        // YYYY-MM-DD
+        const dateStr = new Date().toISOString().slice(0, 10);
+        maybeDateStr = ` (${dateStr})`;
+    }
+    if (isMajorVersion) {
+        return `# ${version}${maybeDateStr}`;
+    }
+    return `## ${version}${maybeDateStr}`;
+}

package/release/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @public Programmatic API for nx release
+ */
+export { ReleaseClient, release, releaseChangelog, releasePublish, releaseVersion, } from '../src/command-line/release';

package/release/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseVersion = exports.releasePublish = exports.releaseChangelog = exports.release = exports.ReleaseClient = void 0;
+/**
+ * @public Programmatic API for nx release
+ */
+var release_1 = require("../src/command-line/release");
+Object.defineProperty(exports, "ReleaseClient", { enumerable: true, get: function () { return release_1.ReleaseClient; } });
+Object.defineProperty(exports, "release", { enumerable: true, get: function () { return release_1.release; } });
+Object.defineProperty(exports, "releaseChangelog", { enumerable: true, get: function () { return release_1.releaseChangelog; } });
+Object.defineProperty(exports, "releasePublish", { enumerable: true, get: function () { return release_1.releasePublish; } });
+Object.defineProperty(exports, "releaseVersion", { enumerable: true, get: function () { return release_1.releaseVersion; } });