@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

package/dist/src/command-line/release/utils/repository-git-tags.js

@@ -0,0 +1,125 @@
+"use strict";
+var _RepoGitTags_instances, _RepoGitTags_tagsMap, _RepoGitTags_getTags, _RepoGitTags_alwaysCheckAllBranches, _RepoGitTags_getCacheKey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepoGitTags = void 0;
+const tslib_1 = require("tslib");
+const minimatch_1 = require("minimatch");
+const exec_command_1 = require("./exec-command");
+/**
+ * Caches git tags to avoid redundant git operations during release workflows.
+ * Tags are cached per branch strategy ('single-branch' vs 'all-branches').
+ */
+class RepoGitTags {
+    constructor() {
+        _RepoGitTags_instances.add(this);
+        _RepoGitTags_tagsMap.set(this, new Map());
+    }
+    /** Creates a new RepoGitTags instance with an empty cache. */
+    static create() {
+        return new RepoGitTags();
+    }
+    /**
+     * Resolves git tags with caching. Fetches from git on cache miss, returns cached tags on hit.
+     * Cache key is determined by whether to check all branches or only merged branches.
+     *
+     * @param checkAllBranchesWhen - Strategy for checking branches (boolean, array of patterns, or undefined)
+     * @returns Promise resolving to array of git tags
+     */
+    async resolveTags(checkAllBranchesWhen) {
+        const alwaysCheckAllBranches = await tslib_1.__classPrivateFieldGet(this, _RepoGitTags_instances, "m", _RepoGitTags_alwaysCheckAllBranches).call(this, checkAllBranchesWhen);
+        const cacheKey = tslib_1.__classPrivateFieldGet(this, _RepoGitTags_instances, "m", _RepoGitTags_getCacheKey).call(this, alwaysCheckAllBranches);
+        let tags = tslib_1.__classPrivateFieldGet(this, _RepoGitTags_tagsMap, "f").get(cacheKey);
+        if (!tags) {
+            tags = await tslib_1.__classPrivateFieldGet(this, _RepoGitTags_instances, "m", _RepoGitTags_getTags).call(this, checkAllBranchesWhen, alwaysCheckAllBranches);
+        }
+        tslib_1.__classPrivateFieldGet(this, _RepoGitTags_tagsMap, "f").set(cacheKey, tags);
+        return tags;
+    }
+    /** Clears the tag cache. Useful for testing or forcing a fresh fetch. */
+    clean() {
+        tslib_1.__classPrivateFieldGet(this, _RepoGitTags_tagsMap, "f").clear();
+    }
+}
+exports.RepoGitTags = RepoGitTags;
+_RepoGitTags_tagsMap = new WeakMap(), _RepoGitTags_instances = new WeakSet(), _RepoGitTags_getTags = 
+/** Fetches tags from git. Falls back to all branches if no merged tags found. */
+async function _RepoGitTags_getTags(checkAllBranchesWhen, alwaysCheckAllBranches) {
+    const defaultGitArgs = [
+        // Apply git config to take version suffixes into account when sorting, e.g. 1.0.0 is newer than 1.0.0-beta.1
+        '-c',
+        'versionsort.suffix=-',
+        'tag',
+        '--sort',
+        '-v:refname',
+    ];
+    try {
+        let tags = [];
+        tags = await (0, exec_command_1.execCommand)('git', [
+            ...defaultGitArgs,
+            ...(alwaysCheckAllBranches ? [] : ['--merged']),
+        ]).then((r) => r
+            .trim()
+            .split('\n')
+            .map((t) => t.trim())
+            .filter(Boolean));
+        if (
+        // Do not run this fallback if the user explicitly set checkAllBranchesWhen to false
+        checkAllBranchesWhen !== false &&
+            !tags.length &&
+            // There is no point in running this fallback if we already checked against all branches
+            !alwaysCheckAllBranches) {
+            // Try again with all tags instead of just --merged ones
+            tags = await (0, exec_command_1.execCommand)('git', defaultGitArgs).then((r) => r
+                .trim()
+                .split('\n')
+                .map((t) => t.trim())
+                .filter(Boolean));
+        }
+        return tags;
+    }
+    catch (e) {
+        return [];
+    }
+}, _RepoGitTags_alwaysCheckAllBranches = 
+/** Resolves checkAllBranchesWhen to a boolean by checking current branch against patterns. */
+async function _RepoGitTags_alwaysCheckAllBranches(checkAllBranchesWhen) {
+    let alwaysCheckAllBranches = false;
+    /**
+     * By default, we will try and resolve the latest match for the releaseTag.pattern from the current branch,
+     * falling back to all branches if no match is found on the current branch.
+     *
+     * - If checkAllBranchesWhen is true it will cause us to ALWAYS check all branches for the latest match.
+     * - If checkAllBranchesWhen is explicitly set to false it will cause us to ONLY check the current branch for the latest match.
+     * - If checkAllBranchesWhen is an array of strings it will cause us to check all branches WHEN the current branch is one of the strings in the array.
+     */
+    if (typeof checkAllBranchesWhen !== 'undefined') {
+        if (typeof checkAllBranchesWhen === 'boolean') {
+            alwaysCheckAllBranches = checkAllBranchesWhen;
+        }
+        else if (Array.isArray(checkAllBranchesWhen)) {
+            /**
+             * Get the current git branch and determine whether to check all branches based on the checkAllBranchesWhen parameter
+             */
+            const currentBranch = await (0, exec_command_1.execCommand)('git', [
+                'rev-parse',
+                '--abbrev-ref',
+                'HEAD',
+            ]).then((r) => r.trim());
+            // Check exact match first
+            alwaysCheckAllBranches = checkAllBranchesWhen.includes(currentBranch);
+            // Check if any glob pattern matches next
+            if (!alwaysCheckAllBranches) {
+                alwaysCheckAllBranches = checkAllBranchesWhen.some((pattern) => {
+                    const r = minimatch_1.minimatch.makeRe(pattern, { dot: true });
+                    if (!r) {
+                        return false;
+                    }
+                    return r.test(currentBranch);
+                });
+            }
+        }
+    }
+    return alwaysCheckAllBranches;
+}, _RepoGitTags_getCacheKey = function _RepoGitTags_getCacheKey(checkAllBranches) {
+    return checkAllBranches ? 'all-branches' : 'single-branch';
+};

package/dist/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(changelogRendererPathOrImplementation: string | typeof ChangelogRenderer): typeof ChangelogRenderer;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveChangelogRenderer = resolveChangelogRenderer;
+const register_1 = require("../../../plugins/js/utils/register");
+const utils_1 = require("../../../tasks-runner/utils");
+const workspace_root_1 = require("../../../utils/workspace-root");
+function resolveChangelogRenderer(changelogRendererPathOrImplementation) {
+    // An implementation was provided directly via the programmatic API
+    if (typeof changelogRendererPathOrImplementation === 'function') {
+        return changelogRendererPathOrImplementation;
+    }
+    const interpolatedChangelogRendererPath = (0, utils_1.interpolate)(changelogRendererPathOrImplementation, {
+        workspaceRoot: workspace_root_1.workspaceRoot,
+    });
+    // TS renderers go through loadTsFile (native-strip -> swc/ts-node + paths).
+    // JS renderers use require() with a lazy tsconfig-paths fallback so workspace
+    // alias imports still resolve, without paying registration cost up front.
+    const r = /\.[cm]?ts$/.test(interpolatedChangelogRendererPath)
+        ? (0, register_1.loadTsFile)(interpolatedChangelogRendererPath)
+        : (0, register_1.requireWithTsconfigFallback)(interpolatedChangelogRendererPath);
+    return r.default || r;
+}

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

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

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

@@ -0,0 +1,53 @@
+"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 handle_import_1 = require("../../../utils/handle-import");
+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 (0, handle_import_1.handleImport)('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/dist/src/command-line/release/utils/resolve-semver-specifier.d.ts

@@ -0,0 +1,7 @@
+import { ProjectGraph } from '../../../config/project-graph';
+import { NxReleaseConfig } from '../config/config';
+import { SemverBumpType } from '../version/version-actions';
+import { ReleaseGraph } from './release-graph';
+import { SemverSpecifier } from './semver';
+export declare function resolveSemverSpecifierFromConventionalCommits(from: string, projectGraph: ProjectGraph, projectNames: string[], releaseConfig: NxReleaseConfig, releaseGraph: ReleaseGraph, releaseGroupProjects?: string[]): Promise<Map<string, SemverSpecifier | null>>;
+export declare function resolveSemverSpecifierFromPrompt(selectionMessage: string, customVersionMessage: string): Promise<SemverBumpType | string>;

package/dist/src/command-line/release/utils/resolve-semver-specifier.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSemverSpecifierFromConventionalCommits = resolveSemverSpecifierFromConventionalCommits;
+exports.resolveSemverSpecifierFromPrompt = resolveSemverSpecifierFromPrompt;
+const prompt_helpers_1 = require("../../../utils/prompt-helpers");
+const semver_1 = require("semver");
+const git_1 = require("./git");
+const semver_2 = require("./semver");
+const shared_1 = require("./shared");
+async function resolveSemverSpecifierFromConventionalCommits(from, projectGraph, projectNames, releaseConfig, releaseGraph, 
+// The full set of projects in the active release group. For independent
+// release groups, `projectNames` only contains the single project being
+// processed, so this is forwarded separately to keep scope matching
+// accurate against the whole group. Defaults to `projectNames`.
+releaseGroupProjects = projectNames) {
+    const commits = await (0, git_1.getGitDiff)(from);
+    const parsedCommits = (0, git_1.parseCommits)(commits);
+    const relevantCommits = await (0, shared_1.getCommitsRelevantToProjects)(projectGraph, parsedCommits, projectNames, releaseConfig, releaseGraph, releaseGroupProjects);
+    return (0, semver_2.determineSemverChange)(relevantCommits, releaseConfig.conventionalCommits);
+}
+async function resolveSemverSpecifierFromPrompt(selectionMessage, customVersionMessage) {
+    // Cancelling exits rather than returning, so yargs never prints its help for
+    // what the user meant as an abort.
+    const abort = () => process.exit(1);
+    const specifier = await (0, prompt_helpers_1.selectPrompt)({
+        message: selectionMessage,
+        choices: [
+            ...semver_1.RELEASE_TYPES,
+            { value: 'custom', label: 'Custom exact version' },
+        ],
+        onCancel: abort,
+    });
+    if (specifier !== 'custom') {
+        return specifier;
+    }
+    return (0, prompt_helpers_1.textPrompt)({
+        message: customVersionMessage,
+        validate: (input) => (0, semver_1.valid)(input) ? undefined : 'Please enter a valid semver version',
+        onCancel: abort,
+    });
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Special thanks to changelogen for the original inspiration for many of these utilities:
+ * https://github.com/unjs/changelogen
+ */
+import { ReleaseType } from 'semver';
+import { NxReleaseConfig } from '../config/config';
+import { GitCommit } from './git';
+export declare const enum SemverSpecifier {
+    MAJOR = 3,
+    MINOR = 2,
+    PATCH = 1
+}
+export declare const SemverSpecifierType: {
+    3: string;
+    2: string;
+    1: string;
+};
+export declare function isRelativeVersionKeyword(val: string): val is ReleaseType;
+export declare function isValidSemverSpecifier(specifier: string): boolean;
+export declare function determineSemverChange(relevantCommits: Map<string, {
+    commit: GitCommit;
+    isProjectScopedCommit: boolean;
+}[]>, config: NxReleaseConfig['conventionalCommits']): Map<string, SemverSpecifier | null>;
+export declare function deriveNewSemverVersion(currentSemverVersion: string, semverSpecifier: string, preid?: string, options?: {
+    adjustSemverBumpsForZeroMajorVersion?: boolean;
+}): string;

package/dist/src/command-line/release/utils/semver.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * Special thanks to changelogen for the original inspiration for many of these utilities:
+ * https://github.com/unjs/changelogen
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemverSpecifierType = void 0;
+exports.isRelativeVersionKeyword = isRelativeVersionKeyword;
+exports.isValidSemverSpecifier = isValidSemverSpecifier;
+exports.determineSemverChange = determineSemverChange;
+exports.deriveNewSemverVersion = deriveNewSemverVersion;
+const semver_1 = require("semver");
+exports.SemverSpecifierType = {
+    3: 'major',
+    2: 'minor',
+    1: 'patch',
+};
+function isRelativeVersionKeyword(val) {
+    return semver_1.RELEASE_TYPES.includes(val);
+}
+function isValidSemverSpecifier(specifier) {
+    return (specifier && !!((0, semver_1.valid)(specifier) || isRelativeVersionKeyword(specifier)));
+}
+function determineSemverChange(relevantCommits, config) {
+    const semverChangePerProject = new Map();
+    for (const [projectName, relevantCommit] of relevantCommits) {
+        let highestChange = null;
+        for (const { commit, isProjectScopedCommit } of relevantCommit) {
+            if (config.useCommitScope && !isProjectScopedCommit) {
+                // commit is relevant to the project, but not directly, report patch change to match side-effectful bump behavior in update dependents in release-group-processor
+                const indirectSemverType = config.types[commit.type]?.semverBump;
+                // If the commit type has semverBump 'none' and the commit is not breaking,
+                // skip the indirect patch bump as the dependency itself won't be bumped
+                if (indirectSemverType === 'none' && !commit.isBreaking) {
+                    continue;
+                }
+                highestChange = Math.max(1 /* SemverSpecifier.PATCH */, highestChange ?? 0);
+                continue;
+            }
+            const semverType = config.types[commit.type]?.semverBump;
+            if (semverType === 'major' || commit.isBreaking) {
+                highestChange = Math.max(3 /* SemverSpecifier.MAJOR */, highestChange ?? 0);
+                break; // Major is highest priority, no need to check more commits
+            }
+            else if (semverType === 'minor') {
+                highestChange = Math.max(2 /* SemverSpecifier.MINOR */, highestChange ?? 0);
+            }
+            else if (semverType === 'patch') {
+                highestChange = Math.max(1 /* SemverSpecifier.PATCH */, highestChange ?? 0);
+            }
+        }
+        semverChangePerProject.set(projectName, highestChange);
+    }
+    return semverChangePerProject;
+}
+/**
+ * For 0.x versions, shifts semver bump types down to follow
+ * the common convention where breaking changes bump minor, and
+ * new features bump patch.
+ *
+ * - 'major' -> 'minor'
+ * - 'premajor' -> 'preminor'
+ * - 'minor' -> 'patch'
+ * - 'preminor' -> 'prepatch'
+ * - 'patch' -> 'patch' (unchanged)
+ * - 'prepatch' -> 'prepatch' (unchanged)
+ * - 'prerelease' -> 'prerelease' (unchanged)
+ */
+function adjustSpecifierForZeroMajorVersion(specifier, currentVersion) {
+    // Only adjust for 0.x versions
+    if ((0, semver_1.major)(currentVersion) !== 0) {
+        return specifier;
+    }
+    switch (specifier) {
+        case 'major':
+            return 'minor';
+        case 'premajor':
+            return 'preminor';
+        case 'minor':
+            return 'patch';
+        case 'preminor':
+            return 'prepatch';
+        default:
+            return specifier;
+    }
+}
+function deriveNewSemverVersion(currentSemverVersion, semverSpecifier, preid, options) {
+    if (!(0, semver_1.valid)(currentSemverVersion)) {
+        throw new Error(`Invalid semver version "${currentSemverVersion}" provided.`);
+    }
+    let newVersion = semverSpecifier;
+    if (isRelativeVersionKeyword(semverSpecifier)) {
+        // Adjust for 0.x versions if explicitly enabled
+        const adjustedSpecifier = options?.adjustSemverBumpsForZeroMajorVersion
+            ? adjustSpecifierForZeroMajorVersion(semverSpecifier, currentSemverVersion)
+            : semverSpecifier;
+        // Derive the new version from the current version combined with the adjusted version specifier.
+        const derivedVersion = (0, semver_1.inc)(currentSemverVersion, adjustedSpecifier, preid);
+        if (!derivedVersion) {
+            throw new Error(`Unable to derive new version from current version "${currentSemverVersion}" and version specifier "${semverSpecifier}"`);
+        }
+        newVersion = derivedVersion;
+    }
+    else {
+        // Ensure the new version specifier is a valid semver version, given it is not a valid semver keyword
+        if (!(0, semver_1.valid)(semverSpecifier)) {
+            throw new Error(`Invalid semver version specifier "${semverSpecifier}" provided. Please provide either a valid semver version or a valid semver version keyword.`);
+        }
+    }
+    return newVersion;
+}

package/dist/src/command-line/release/utils/shared-legacy.d.ts

@@ -0,0 +1,25 @@
+import { Tree } from '../../../generators/tree';
+export type ReleaseVersionGeneratorResult = {
+    data: VersionData;
+    callback: (tree: Tree, opts: {
+        dryRun?: boolean;
+        verbose?: boolean;
+        generatorOptions?: Record<string, unknown>;
+    }) => Promise<string[] | {
+        changedFiles: string[];
+        deletedFiles: string[];
+    }>;
+};
+export type VersionData = Record<string, {
+    /**
+     * newVersion will be null in the case that no changes are detected for the project,
+     * e.g. when using conventional commits
+     */
+    newVersion: string | null;
+    currentVersion: string;
+    /**
+     * The list of projects which depend upon the current project.
+     * NOTE: This is more strictly typed in versioning v2.
+     */
+    dependentProjects: any[];
+}>;

package/dist/src/command-line/release/utils/shared-legacy.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/command-line/release/utils/shared.d.ts

@@ -0,0 +1,64 @@
+import { ProjectGraph } from '../../../config/project-graph';
+import { NxReleaseConfig } from '../config/config';
+import type { ReleaseGroupWithName } from '../config/filter-release-groups';
+import { GitCommit } from './git';
+import { ReleaseGraph } from './release-graph';
+export declare const noDiffInChangelogMessage: string;
+export type VersionData = Record<string, VersionDataEntry>;
+export interface VersionDataEntry {
+    currentVersion: string;
+    /**
+     * newVersion will be null in the case that no changes are detected for the project,
+     * e.g. when using conventional commits
+     */
+    newVersion: string | null;
+    /**
+     * dockerVersion will be populated if the project is a docker project and has been
+     * included within this release.
+     */
+    dockerVersion?: string | null;
+    /**
+     * The list of projects which depend upon the current project.
+     */
+    dependentProjects: {
+        source: string;
+        target: string;
+        type: string;
+        dependencyCollection: string | null;
+        rawVersionSpec: string | null;
+    }[];
+}
+export declare function isPrerelease(version: string): boolean;
+export declare class ReleaseVersion {
+    rawVersion: string;
+    gitTag: string;
+    isPrerelease: boolean;
+    constructor({ version, // short form version string with no prefixes or patterns, e.g. 1.0.0
+    releaseTagPattern, // full pattern to interpolate, e.g. "v{version}" or "{projectName}@{version}"
+    projectName, // optional project name to interpolate into the releaseTagPattern
+    releaseGroupName, }: {
+        version: string;
+        releaseTagPattern: string;
+        projectName?: string;
+        releaseGroupName?: string;
+    });
+}
+export declare function commitChanges({ changedFiles, deletedFiles, isDryRun, isVerbose, gitCommitMessages, gitCommitArgs, }: {
+    changedFiles?: string[];
+    deletedFiles?: string[];
+    isDryRun?: boolean;
+    isVerbose?: boolean;
+    gitCommitMessages?: string[];
+    gitCommitArgs?: string | string[];
+}): Promise<void>;
+export declare function createCommitMessageValues(releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>, versionData: VersionData, commitMessage: string): string[];
+export declare function shouldPreferDockerVersionForReleaseGroup(releaseGroup: ReleaseGroupWithName): boolean | 'both';
+export declare function shouldSkipVersionActions(dockerOptions: {
+    skipVersionActions?: string[] | boolean;
+}, projectName: string): boolean;
+export declare function createGitTagValues(releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>, versionData: VersionData): string[];
+export declare function handleDuplicateGitTags(gitTagValues: string[]): void;
+export declare function getCommitsRelevantToProjects(projectGraph: ProjectGraph, commits: GitCommit[], projects: string[], nxReleaseConfig: NxReleaseConfig, releaseGraph: ReleaseGraph, releaseGroupProjects?: string[]): Promise<Map<string, {
+    commit: GitCommit;
+    isProjectScopedCommit: boolean;
+}[]>>;