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

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

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Minimal line-diff implementation for nx release output.
+ *
+ * Replaces jest-diff to eliminate transitive dependencies (pretty-format,
+ * chalk, ansi-styles@5) that cause version conflicts for supply chain
+ * hardening.
+ *
+ * Uses @jest/diff-sequences (zero deps) for the core LCS algorithm.
+ *
+ * Source algorithm: https://github.com/jestjs/jest/tree/main/packages/jest-diff
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diff = diff;
+const tslib_1 = require("tslib");
+const diff_sequences_1 = tslib_1.__importDefault(require("@jest/diff-sequences"));
+const DIFF_DELETE = -1;
+const DIFF_EQUAL = 0;
+const DIFF_INSERT = 1;
+const noColor = (s) => s;
+function diffLinesRaw(aLines, bLines) {
+    const aLength = aLines.length;
+    const bLength = bLines.length;
+    const isCommon = (aIndex, bIndex) => aLines[aIndex] === bLines[bIndex];
+    const diffs = [];
+    let aIndex = 0;
+    let bIndex = 0;
+    const foundSubsequence = (nCommon, aCommon, bCommon) => {
+        for (; aIndex !== aCommon; aIndex += 1) {
+            diffs.push([DIFF_DELETE, aLines[aIndex]]);
+        }
+        for (; bIndex !== bCommon; bIndex += 1) {
+            diffs.push([DIFF_INSERT, bLines[bIndex]]);
+        }
+        for (; nCommon !== 0; nCommon -= 1, aIndex += 1, bIndex += 1) {
+            diffs.push([DIFF_EQUAL, bLines[bIndex]]);
+        }
+    };
+    (0, diff_sequences_1.default)(aLength, bLength, isCommon, foundSubsequence);
+    for (; aIndex !== aLength; aIndex += 1) {
+        diffs.push([DIFF_DELETE, aLines[aIndex]]);
+    }
+    for (; bIndex !== bLength; bIndex += 1) {
+        diffs.push([DIFF_INSERT, bLines[bIndex]]);
+    }
+    return diffs;
+}
+function formatNoExpand(diffs, contextLines, aColor, bColor, patchColor) {
+    const lines = [];
+    let aLine = 0;
+    let bLine = 0;
+    // Group diffs into hunks with context
+    const hunks = [];
+    let currentHunk = null;
+    let trailingContext = 0;
+    for (let i = 0; i < diffs.length; i++) {
+        const [type, line] = diffs[i];
+        const isChange = type !== DIFF_EQUAL;
+        if (isChange) {
+            // Look back for leading context if starting a new hunk
+            if (!currentHunk) {
+                const contextStart = Math.max(0, i - contextLines);
+                currentHunk = {
+                    aStart: aLine - (i - contextStart),
+                    bStart: bLine - (i - contextStart),
+                    lines: [],
+                };
+                // Add leading context
+                for (let j = contextStart; j < i; j++) {
+                    const ctx = diffs[j][1];
+                    currentHunk.lines.push(ctx ? `  ${ctx}` : '');
+                }
+            }
+            else if (trailingContext > 0) {
+                // We're continuing a hunk, trailing context was already added
+            }
+            trailingContext = 0;
+            if (type === DIFF_DELETE) {
+                currentHunk.lines.push(aColor(line ? `- ${line}` : '-'));
+            }
+            else {
+                currentHunk.lines.push(bColor(line ? `+ ${line}` : '+'));
+            }
+        }
+        else {
+            if (currentHunk) {
+                trailingContext++;
+                if (trailingContext <= contextLines) {
+                    currentHunk.lines.push(line ? `  ${line}` : '');
+                }
+                // Check if we should close this hunk
+                // Look ahead to see if there's another change within contextLines
+                let nextChangeWithin = false;
+                for (let j = i + 1; j < diffs.length && j <= i + contextLines; j++) {
+                    if (diffs[j][0] !== DIFF_EQUAL) {
+                        nextChangeWithin = true;
+                        break;
+                    }
+                }
+                if (!nextChangeWithin && trailingContext >= contextLines) {
+                    hunks.push(currentHunk);
+                    currentHunk = null;
+                    trailingContext = 0;
+                }
+            }
+        }
+        if (type === DIFF_DELETE) {
+            aLine++;
+        }
+        else if (type === DIFF_INSERT) {
+            bLine++;
+        }
+        else {
+            aLine++;
+            bLine++;
+        }
+    }
+    if (currentHunk) {
+        hunks.push(currentHunk);
+    }
+    const hasEqualLines = diffs.some(([type]) => type === DIFF_EQUAL);
+    for (let i = 0; i < hunks.length; i++) {
+        if (i > 0) {
+            // Separator between hunks (matches jest-diff patch mark behavior)
+            lines.push(patchColor(`@@ @@`));
+        }
+        lines.push(...hunks[i].lines);
+    }
+    // jest-diff adds a patch mark (leading newline) only when context lines
+    // exist and are being skipped. When all lines are changes, no patch mark.
+    const prefix = hasEqualLines ? '\n' : '';
+    return prefix + lines.join('\n');
+}
+function formatExpand(diffs, aColor, bColor) {
+    const lines = [];
+    for (const [type, line] of diffs) {
+        if (type === DIFF_DELETE) {
+            lines.push(aColor(line ? `- ${line}` : '-'));
+        }
+        else if (type === DIFF_INSERT) {
+            lines.push(bColor(line ? `+ ${line}` : '+'));
+        }
+        else {
+            lines.push(line ? `  ${line}` : '');
+        }
+    }
+    return lines.join('\n');
+}
+const NO_DIFF_MESSAGE = 'Compared values have no visual difference.';
+function diff(a, b, options = {}) {
+    if (a === b) {
+        return NO_DIFF_MESSAGE;
+    }
+    const aLines = a.split('\n');
+    const bLines = b.split('\n');
+    const diffs = diffLinesRaw(a === '' ? [] : aLines, b === '' ? [] : bLines);
+    const aColor = options.aColor || noColor;
+    const bColor = options.bColor || noColor;
+    const patchColor = options.patchColor || noColor;
+    const contextLines = typeof options.contextLines === 'number' ? options.contextLines : 5;
+    const expand = options.expand ?? true;
+    if (expand) {
+        return formatExpand(diffs, aColor, bColor);
+    }
+    else {
+        return formatNoExpand(diffs, contextLines, aColor, bColor, patchColor);
+    }
+}

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

@@ -0,0 +1 @@
+export declare function execCommand(cmd: string, args: string[], options?: any): Promise<string>;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execCommand = execCommand;
+const node_child_process_1 = require("node:child_process");
+async function execCommand(cmd, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(cmd, args, {
+            ...options,
+            stdio: ['pipe', 'pipe', 'pipe'], // stdin, stdout, stderr
+            encoding: 'utf-8',
+            windowsHide: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(stderr ||
+                    `Unknown error occurred while running "${cmd} ${args.join(' ')}"`);
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}

package/dist/src/command-line/release/utils/generate-version-plan-content.d.ts

@@ -0,0 +1 @@
+export declare function generateVersionPlanContent(bumps: Record<string, string>, message: string): string;

package/dist/src/command-line/release/utils/generate-version-plan-content.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVersionPlanContent = generateVersionPlanContent;
+function generateVersionPlanContent(bumps, message) {
+    const frontMatter = `---
+${Object.entries(bumps)
+        .filter(([_, version]) => version !== 'none')
+        .map(([projectOrGroup, version]) => {
+        let key = projectOrGroup;
+        // frontmatter parsing will blow up if we don't wrap @org/package style project names in quotes
+        if (key.startsWith('@')) {
+            key = `'${key}'`;
+        }
+        return `${key}: ${version}`;
+    })
+        .join('\n')}
+---
+`;
+    return `${frontMatter}${message ? `\n${message}\n` : ''}`;
+}

package/dist/src/command-line/release/utils/get-touched-projects-for-group.d.ts

@@ -0,0 +1,7 @@
+import { FileData, ProjectGraph } from '../../../config/project-graph';
+import { NxArgs } from '../../../utils/command-line-utils';
+import { ReleaseGroupWithName } from '../config/filter-release-groups';
+/**
+ * Create a function that returns the touched projects for a given release group. Only relevant when version plans are enabled.
+ */
+export declare function createGetTouchedProjectsForGroup(nxArgs: NxArgs, projectGraph: ProjectGraph, changedFiles: string[], fileData: FileData[]): (releaseGroup: ReleaseGroupWithName, releaseGroupFilteredProjectNames: string[], hasProjectsFilter: boolean) => Promise<string[]>;

package/dist/src/command-line/release/utils/get-touched-projects-for-group.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetTouchedProjectsForGroup = createGetTouchedProjectsForGroup;
+const native_1 = require("../../../native");
+const transform_objects_1 = require("../../../native/transform-objects");
+const file_utils_1 = require("../../../project-graph/file-utils");
+const ignore_1 = require("../../../utils/ignore");
+const output_1 = require("../../../utils/output");
+const config_1 = require("../config/config");
+/**
+ * Create a function that returns the touched projects for a given release group. Only relevant when version plans are enabled.
+ */
+function createGetTouchedProjectsForGroup(nxArgs, projectGraph, changedFiles, fileData) {
+    /**
+     * Create a minimal subset of touched projects based on the configured ignore patterns, we only need
+     * to recompute when the ignorePatternsForPlanCheck differs between release groups.
+     */
+    const serializedIgnorePatternsToTouchedProjects = new Map();
+    return async function getTouchedProjectsForGroup(releaseGroup, 
+    // We don't access releaseGroups.projects directly, because we need to take the --projects filter into account
+    releaseGroupFilteredProjectNames, hasProjectsFilter) {
+        // The current release group doesn't leverage version plans
+        if (!releaseGroup.versionPlans) {
+            return [];
+        }
+        // Exclude patterns from .nxignore, .gitignore and explicit version plan config
+        let serializedIgnorePatterns = '[]';
+        const ignore = (0, ignore_1.getIgnoreObject)();
+        if (typeof releaseGroup.versionPlans !== 'boolean' &&
+            Array.isArray(releaseGroup.versionPlans.ignorePatternsForPlanCheck) &&
+            releaseGroup.versionPlans.ignorePatternsForPlanCheck.length) {
+            output_1.output.note({
+                title: `Applying configured ignore patterns to changed files${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                    ? ` for release group "${releaseGroup.name}"`
+                    : ''}`,
+                bodyLines: [
+                    ...releaseGroup.versionPlans.ignorePatternsForPlanCheck.map((pattern) => `  - ${pattern}`),
+                ],
+            });
+            ignore.add(releaseGroup.versionPlans.ignorePatternsForPlanCheck);
+            serializedIgnorePatterns = JSON.stringify(releaseGroup.versionPlans.ignorePatternsForPlanCheck);
+        }
+        let touchedProjects = {};
+        if (serializedIgnorePatternsToTouchedProjects.has(serializedIgnorePatterns)) {
+            touchedProjects = serializedIgnorePatternsToTouchedProjects.get(serializedIgnorePatterns);
+        }
+        else {
+            const touchedProjectsArr = (0, native_1.directlyTouchedProjects)((0, transform_objects_1.transformProjectGraphForLocators)(projectGraph), (0, file_utils_1.calculateFileChanges)(changedFiles, nxArgs, undefined, ignore).map((f) => f.file));
+            touchedProjects = touchedProjectsArr.reduce((acc, project) => ({ ...acc, [project]: true }), {});
+            serializedIgnorePatternsToTouchedProjects.set(serializedIgnorePatterns, touchedProjects);
+        }
+        const touchedProjectsUnderReleaseGroup = releaseGroupFilteredProjectNames.filter((project) => touchedProjects[project]);
+        if (touchedProjectsUnderReleaseGroup.length) {
+            output_1.output.log({
+                title: `Touched projects${hasProjectsFilter ? ` (after --projects filter applied)` : ''} based on changed files${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                    ? ` under release group "${releaseGroup.name}"`
+                    : ''}`,
+                bodyLines: [
+                    ...touchedProjectsUnderReleaseGroup.map((project) => `  - ${project}`),
+                    '',
+                    'NOTE: You can adjust your "versionPlans.ignorePatternsForPlanCheck" config to stop certain files from resulting in projects being classed as touched for the purposes of this command.',
+                ],
+            });
+        }
+        else {
+            output_1.output.log({
+                title: `No touched projects${hasProjectsFilter ? ` (after --projects filter applied)` : ''} found based on changed files${typeof releaseGroup.versionPlans !== 'boolean' &&
+                    Array.isArray(releaseGroup.versionPlans.ignorePatternsForPlanCheck) &&
+                    releaseGroup.versionPlans.ignorePatternsForPlanCheck.length
+                    ? ' combined with configured ignore patterns'
+                    : ''}${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                    ? ` under release group "${releaseGroup.name}"`
+                    : ''}`,
+            });
+        }
+        return touchedProjectsUnderReleaseGroup;
+    };
+}

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

@@ -0,0 +1,126 @@
+import type { CheckAllBranchesWhen, RepoGitTags } from './repository-git-tags';
+export interface GitCommitAuthor {
+    name: string;
+    email: string;
+}
+export interface RawGitCommit {
+    message: string;
+    body: string;
+    shortHash: string;
+    author: GitCommitAuthor;
+}
+export interface Reference {
+    type: 'hash' | 'issue' | 'pull-request';
+    value: string;
+}
+export interface GitTagAndVersion {
+    tag: string;
+    extractedVersion: string;
+}
+export interface GitCommit extends RawGitCommit {
+    description: string;
+    type: string;
+    scope: string;
+    references: Reference[];
+    authors: GitCommitAuthor[];
+    isBreaking: boolean;
+    affectedFiles: string[];
+    revertedHashes: string[];
+}
+export interface GetLatestGitTagForPatternOptions {
+    checkAllBranchesWhen?: CheckAllBranchesWhen;
+    preid?: string;
+    requireSemver: boolean;
+    strictPreid: boolean;
+}
+/**
+ * Sanitizes a project name to be valid for use in git tag names.
+ *
+ * Git tag names have specific restrictions per git-check-ref-format.
+ * This function handles:
+ * - Colons (:) - replaced with slashes (/) for Gradle-style module paths
+ * - Other invalid characters - replaced with hyphens (-)
+ * - Consecutive slashes - collapsed to single slash
+ * - Leading/trailing slashes - removed
+ * - Consecutive dots - replaced with single dot
+ *
+ * @param name - The project name to sanitize
+ * @returns The sanitized name suitable for git tags
+ */
+export declare function sanitizeProjectNameForGitTag(name: string): string;
+/**
+ * Extract the tag and version from a tag string
+ *
+ * @param tag - The tag string to extract the tag and version from
+ * @param tagRegexp - The regex to use to extract the tag and version from the tag string
+ *
+ * @returns The tag and version
+ */
+export declare function extractTagAndVersion(tag: string, tagRegexp: string, options: GetLatestGitTagForPatternOptions): GitTagAndVersion;
+/**
+ * Get the latest git tag for the configured release tag pattern.
+ *
+ * This function will:
+ * - Get all tags from the git repo, sorted by version
+ * - Filter the tags into a list with SEMVER-compliant tags, matching the release tag pattern
+ * - If a preid is provided, prioritise tags for that preid, then semver tags without a preid
+ * - If no preid is provided, search only for stable semver tags (i.e. no pre-release or build metadata)
+ *
+ * @param releaseTagPattern - The pattern to filter the tags list by
+ * @param additionalInterpolationData - Additional data used when interpolating the release tag pattern
+ * @param options - The options to use when getting the latest git tag for the pattern
+ *
+ * @returns The tag and version
+ */
+export declare function getLatestGitTagForPattern(releaseTagPattern: string, additionalInterpolationData: {}, resolveTags: RepoGitTags['resolveTags'], options: GetLatestGitTagForPatternOptions): Promise<GitTagAndVersion | null>;
+export declare function getGitDiff(from: string | undefined, to?: string): Promise<RawGitCommit[]>;
+export declare function gitAdd({ changedFiles, deletedFiles, dryRun, verbose, logFn, cwd, }: {
+    changedFiles?: string[];
+    deletedFiles?: string[];
+    dryRun?: boolean;
+    verbose?: boolean;
+    cwd?: string;
+    logFn?: (...messages: string[]) => void;
+}): Promise<string>;
+export declare function gitCommit({ messages, additionalArgs, dryRun, verbose, logFn, }: {
+    messages: string[];
+    additionalArgs?: string | string[];
+    dryRun?: boolean;
+    verbose?: boolean;
+    logFn?: (message: string) => void;
+}): Promise<string>;
+export declare function gitTag({ tag, message, additionalArgs, dryRun, verbose, logFn, }: {
+    tag: string;
+    message?: string;
+    additionalArgs?: string | string[];
+    dryRun?: boolean;
+    verbose?: boolean;
+    logFn?: (message: string) => void;
+}): Promise<string>;
+export declare function gitPush({ gitRemote, dryRun, verbose, additionalArgs, }: {
+    gitRemote?: string;
+    dryRun?: boolean;
+    verbose?: boolean;
+    additionalArgs?: string | string[];
+}): Promise<void>;
+export declare function parseCommits(commits: RawGitCommit[]): GitCommit[];
+export declare function parseConventionalCommitsMessage(message: string): {
+    type: string;
+    scope: string;
+    description: string;
+    breaking: boolean;
+} | null;
+export declare function extractReferencesFromCommit(commit: RawGitCommit): Reference[];
+export declare function parseVersionPlanCommit(commit: RawGitCommit): {
+    references: Reference[];
+    authors: GitCommitAuthor[];
+};
+export declare function parseGitCommit(commit: RawGitCommit): GitCommit | null;
+export declare function getCommitHash(ref: string): Promise<string>;
+export declare function getFirstGitCommit(): Promise<string>;
+/**
+ * Returns the parent of the first commit that touched the given project root,
+ * so that `from..HEAD` ranges include the project's creation commit.
+ * Falls back to getFirstGitCommit() if the project history cannot be determined.
+ */
+export declare function getFirstProjectCommit(projectRoot: string): Promise<string>;