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

package/dist/src/command-line/release/utils/remote-release-clients/gitlab.js

@@ -1,259 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GitLabRemoteReleaseClient = exports.defaultCreateReleaseProvider = void 0;
-const tslib_1 = require("tslib");
-const pc = tslib_1.__importStar(require("picocolors"));
-const prompt_helpers_1 = require("../../../../utils/prompt-helpers");
-const node_child_process_1 = require("node:child_process");
-const output_1 = require("../../../../utils/output");
-const extract_repo_slug_1 = require("./extract-repo-slug");
-const remote_release_client_1 = require("./remote-release-client");
-exports.defaultCreateReleaseProvider = {
-    provider: 'gitlab',
-    hostname: 'gitlab.com',
-    apiBaseUrl: 'https://gitlab.com/api/v4',
-};
-class GitLabRemoteReleaseClient extends remote_release_client_1.RemoteReleaseClient {
-    constructor() {
-        super(...arguments);
-        this.remoteReleaseProviderName = 'GitLab';
-    }
-    /**
-     * Get GitLab repository data from git remote
-     */
-    static resolveRepoData(createReleaseConfig, remoteName = 'origin') {
-        try {
-            const remoteUrl = (0, node_child_process_1.execSync)(`git remote get-url ${remoteName}`, {
-                encoding: 'utf8',
-                stdio: 'pipe',
-                windowsHide: true,
-            }).trim();
-            // Use the default provider if custom one is not specified or releases are disabled
-            let hostname = exports.defaultCreateReleaseProvider.hostname;
-            let apiBaseUrl = exports.defaultCreateReleaseProvider.apiBaseUrl;
-            if (createReleaseConfig !== false &&
-                typeof createReleaseConfig !== 'string') {
-                hostname = createReleaseConfig.hostname || hostname;
-                apiBaseUrl = createReleaseConfig.apiBaseUrl;
-            }
-            const slug = (0, extract_repo_slug_1.extractGitLabRepoSlug)(remoteUrl, hostname);
-            if (slug) {
-                // Encode the project path for use in API URLs
-                const projectId = encodeURIComponent(slug);
-                return {
-                    hostname,
-                    apiBaseUrl,
-                    slug,
-                    projectId,
-                };
-            }
-            else {
-                throw new Error(`Could not extract project path data from the resolved remote URL: ${remoteUrl}`);
-            }
-        }
-        catch (err) {
-            if (process.env.NX_VERBOSE_LOGGING === 'true') {
-                console.error(err);
-            }
-            return null;
-        }
-    }
-    /**
-     * Resolve a GitLab token from various environment variables
-     */
-    static async resolveTokenData(hostname) {
-        // Try and resolve from the environment
-        const tokenFromEnv = process.env.GITLAB_TOKEN || process.env.GL_TOKEN;
-        if (tokenFromEnv) {
-            return { token: tokenFromEnv, headerName: 'PRIVATE-TOKEN' };
-        }
-        // Try and resolve from a CI environment
-        if (process.env.CI_JOB_TOKEN) {
-            return { token: process.env.CI_JOB_TOKEN, headerName: 'JOB-TOKEN' };
-        }
-        if (hostname !== 'gitlab.com') {
-            console.log(`Warning: It was not possible to automatically resolve a GitLab token from your environment for hostname ${hostname}. If you set the GITLAB_TOKEN or GL_TOKEN environment variable (or you are in GitLab CI where CI_JOB_TOKEN is set automatically), that will be used for GitLab API requests.`);
-        }
-        return null;
-    }
-    createPostGitTask(releaseVersion, changelogContents, dryRun) {
-        return async (latestCommit) => {
-            output_1.output.logSingleLine(`Creating GitLab Release`);
-            await this.createOrUpdateRelease(releaseVersion, changelogContents, latestCommit, { dryRun });
-        };
-    }
-    // Not implemented for GitLab yet, the changelog renderer should not call this method
-    async applyUsernameToAuthors() {
-        throw new Error('applyUsernameToAuthors is not implemented for GitLab yet');
-    }
-    async getReleaseByTag(tag) {
-        const gitlabRepoData = this.getRequiredRemoteRepoData();
-        return await this.makeRequest(`/projects/${gitlabRepoData.projectId}/releases/${encodeURIComponent(tag)}`);
-    }
-    async createRelease(remoteRelease) {
-        const gitlabRepoData = this.getRequiredRemoteRepoData();
-        return await this.makeRequest(`/projects/${gitlabRepoData.projectId}/releases`, {
-            method: 'POST',
-            data: remoteRelease,
-        });
-    }
-    async updateRelease(_id, remoteRelease) {
-        const gitlabRepoData = this.getRequiredRemoteRepoData();
-        return await this.makeRequest(`/projects/${gitlabRepoData.projectId}/releases/${encodeURIComponent(remoteRelease.tag_name)}`, {
-            method: 'PUT',
-            data: remoteRelease,
-        });
-    }
-    /**
-     * Generate a URL for manual release creation on GitLab. Sadly, unlike GitHub, GitLab does not
-     * seem to respect query string parameters for setting the UI form fields, so the user has to
-     * start from scratch.
-     */
-    getManualRemoteReleaseURL(_remoteReleaseOptions) {
-        const gitlabRepoData = this.getRequiredRemoteRepoData();
-        return `https://${gitlabRepoData.hostname}/${gitlabRepoData.slug}/-/releases/new`;
-    }
-    handleAuthError() {
-        output_1.output.error({
-            title: `Unable to resolve data via the GitLab API.`,
-            bodyLines: [
-                '- Set the `GITLAB_TOKEN` or `GL_TOKEN` environment variable to a valid GitLab token with `api` scope',
-                '- If running in GitLab CI, the automatically provisioned CI_JOB_TOKEN can also be used',
-            ],
-        });
-    }
-    logReleaseAction(existingRelease, gitTag, dryRun) {
-        const gitlabRepoData = this.getRequiredRemoteRepoData();
-        const logTitle = `https://${gitlabRepoData.hostname}/${gitlabRepoData.slug}/-/releases/${encodeURIComponent(gitTag)}`;
-        if (existingRelease) {
-            console.error(`${pc.white('UPDATE')} ${logTitle}${dryRun ? (0, output_1.orange)(' [dry-run]') : ''}`);
-        }
-        else {
-            console.error(`${pc.green('CREATE')} ${logTitle}${dryRun ? (0, output_1.orange)(' [dry-run]') : ''}`);
-        }
-    }
-    async handleError(error, result) {
-        if (error) {
-            process.exitCode = 1;
-            if (error.response?.data) {
-                output_1.output.error({
-                    title: `A GitLab API Error occurred when creating/updating the release`,
-                    bodyLines: [
-                        `GitLab Error: ${JSON.stringify(error.response.data)}`,
-                        `---`,
-                        `Request Data:`,
-                        `Repo: ${this.getRemoteRepoData()?.slug}`,
-                        `Token Header Data: ${this.tokenHeader}`,
-                        `Body: ${JSON.stringify(result.requestData)}`,
-                    ],
-                });
-            }
-            else {
-                console.log(error);
-                console.error(`An unknown error occurred while trying to create a release on GitLab, please report this on https://github.com/nrwl/nx (NOTE: make sure to redact your GitLab token from the error message!)`);
-            }
-        }
-        const shouldContinueInGitLab = await this.promptForContinueInGitLab();
-        if (!shouldContinueInGitLab) {
-            return;
-        }
-        const { default: open } = await new Function('return import("open")')();
-        await open(result.url)
-            .then(() => {
-            console.info(`\nFollow up in the browser to manually create the release:\n\n` +
-                pc.underline(pc.cyan(result.url)) +
-                `\n`);
-        })
-            .catch(() => {
-            console.info(`Open this link to manually create a release: \n` +
-                pc.underline(pc.cyan(result.url)) +
-                '\n');
-        });
-    }
-    async promptForContinueInGitLab() {
-        try {
-            const open = await (0, prompt_helpers_1.selectPrompt)({
-                message: 'Do you want to create the release manually in your browser?',
-                choices: [
-                    {
-                        value: 'Yes',
-                        hint: 'It will open the GitLab release page for you',
-                    },
-                    { value: 'No' },
-                ],
-                onCancel: () => process.exit(1),
-            });
-            return open === 'Yes';
-        }
-        catch {
-            process.exit(1);
-        }
-    }
-    /**
-     * Format references for the release (e.g., MRs, issues)
-     */
-    formatReferences(references) {
-        const gitlabRepoData = this.getRequiredRemoteRepoData();
-        const providerToRefSpec = {
-            gitlab: {
-                'pull-request': 'merge_requests',
-                hash: 'commit',
-                issue: 'issues',
-            },
-        };
-        const refSpec = providerToRefSpec.gitlab;
-        const formatSingleReference = (ref) => {
-            return `https://${gitlabRepoData.hostname}/${gitlabRepoData.slug}/-/${refSpec[ref.type]}/${ref.value.replace(/^[#!]/, '')}`;
-        };
-        const mr = references.filter((ref) => ref.type === 'pull-request');
-        const issue = references.filter((ref) => ref.type === 'issue');
-        if (mr.length > 0 || issue.length > 0) {
-            return (' (' +
-                [...mr, ...issue].map((ref) => formatSingleReference(ref)).join(', ') +
-                ')');
-        }
-        if (references.length > 0) {
-            return ' (' + formatSingleReference(references[0]) + ')';
-        }
-        return '';
-    }
-    async syncRelease(remoteReleaseOptions, existingRelease) {
-        const gitlabReleaseData = {
-            tag_name: remoteReleaseOptions.version,
-            name: remoteReleaseOptions.version,
-            description: remoteReleaseOptions.body,
-            prerelease: remoteReleaseOptions.prerelease,
-            ref: remoteReleaseOptions.commit,
-            released_at: new Date().toISOString(),
-            assets: { links: [] },
-            milestones: [],
-        };
-        try {
-            const newGlRelease = await (existingRelease
-                ? this.updateRelease(existingRelease.id, gitlabReleaseData)
-                : this.createRelease(gitlabReleaseData));
-            const gitlabRepoData = this.getRequiredRemoteRepoData();
-            return {
-                status: existingRelease ? 'updated' : 'created',
-                id: newGlRelease.tag_name,
-                url: `https://${gitlabRepoData.hostname}/${gitlabRepoData.slug}/-/tags/${encodeURIComponent(remoteReleaseOptions.version)}`,
-            };
-        }
-        catch (error) {
-            return {
-                status: 'manual',
-                error,
-                url: this.getManualRemoteReleaseURL(remoteReleaseOptions),
-                requestData: gitlabReleaseData,
-            };
-        }
-    }
-    getRequiredRemoteRepoData() {
-        const gitlabRepoData = this.getRemoteRepoData();
-        if (!gitlabRepoData) {
-            throw new Error(`No remote repo data could be resolved for the current workspace`);
-        }
-        return gitlabRepoData;
-    }
-}
-exports.GitLabRemoteReleaseClient = GitLabRemoteReleaseClient;

package/dist/src/command-line/release/utils/remote-release-clients/remote-release-client.d.ts

@@ -1,111 +0,0 @@
-import type { AxiosRequestConfig } from 'axios';
-import type { PostGitTask } from '../../changelog';
-import { ResolvedCreateRemoteReleaseProvider } from '../../config/config';
-import type { Reference } from '../git';
-import { type ReleaseVersion } from '../shared';
-import type { GithubRemoteReleaseClient } from './github';
-import type { GitLabRemoteReleaseClient } from './gitlab';
-export type RemoteRepoSlug = `${string}/${string}`;
-export interface RemoteRepoData {
-    hostname: string;
-    slug: RemoteRepoSlug;
-    apiBaseUrl: string;
-}
-export interface RemoteReleaseOptions {
-    version: string;
-    body: string;
-    prerelease: boolean;
-    commit: string;
-}
-export interface RemoteReleaseResult {
-    status: 'created' | 'updated' | 'manual';
-    id?: string;
-    url?: string;
-    error?: any;
-    requestData?: any;
-}
-/**
- * Abstract base class for remote release clients
- */
-export declare abstract class RemoteReleaseClient<RemoteRelease extends Record<string, any>> {
-    private remoteRepoData;
-    protected createReleaseConfig: false | ResolvedCreateRemoteReleaseProvider;
-    protected tokenData: {
-        token: string;
-        headerName: string;
-    } | null;
-    /**
-     * Used in user-facing messaging
-     */
-    abstract remoteReleaseProviderName: string;
-    protected tokenHeader: Record<string, string>;
-    constructor(remoteRepoData: RemoteRepoData | null, createReleaseConfig: false | ResolvedCreateRemoteReleaseProvider, tokenData: {
-        token: string;
-        headerName: string;
-    } | null);
-    getRemoteRepoData<T extends RemoteRepoData>(): T | null;
-    /**
-     * Create a post git task that will be executed by nx release changelog after performing any relevant
-     * git operations, if the user has opted into remote release creation.
-     */
-    abstract createPostGitTask(releaseVersion: ReleaseVersion, changelogContents: string, dryRun: boolean): PostGitTask;
-    /**
-     * Apply authors' corresponding usernames, if applicable, on the remote release provider. It is designed to be
-     * invoked by a changelog renderer implementation.
-     */
-    abstract applyUsernameToAuthors(authors: Map<string, {
-        email: Set<string>;
-        username?: string;
-    }>): Promise<void>;
-    /**
-     * Make an (optionally authenticated) API request to the remote release provider
-     */
-    protected makeRequest(url: string, opts?: AxiosRequestConfig): Promise<any>;
-    createOrUpdateRelease(releaseVersion: ReleaseVersion, changelogContents: string, latestCommit: string, { dryRun }: {
-        dryRun: boolean;
-    }): Promise<void>;
-    /**
-     * Format references for the release (e.g., PRs, issues)
-     */
-    formatReferences(_references: Reference[]): string;
-    /**
-     * Handle non-auth related errors when creating releases
-     */
-    protected abstract handleError(error: any, result: RemoteReleaseResult): Promise<void>;
-    /**
-     * Display authentication error message
-     */
-    protected abstract handleAuthError(): void;
-    /**
-     * Log the release action (create or update)
-     */
-    protected abstract logReleaseAction(existingRelease: RemoteRelease | undefined, gitTag: string, dryRun: boolean): void;
-    /**
-     * Print changelog changes
-     */
-    protected printRemoteReleaseContents(existingBody: string, newBody: string): void;
-    /**
-     * Get a release by tag
-     */
-    protected abstract getReleaseByTag(tag: string): Promise<RemoteRelease>;
-    /**
-     * Create a manual release URL used to create/edit a release in the remote release provider's UI
-     */
-    protected abstract getManualRemoteReleaseURL(remoteReleaseOptions: RemoteReleaseOptions): string;
-    /**
-     * Create a new release
-     */
-    protected abstract createRelease(body: RemoteRelease): Promise<any>;
-    /**
-     * Update an existing release
-     */
-    protected abstract updateRelease(id: string, body: RemoteRelease): Promise<any>;
-    /**
-     * Synchronize a release with the remote release provider
-     */
-    protected abstract syncRelease(remoteReleaseOptions: RemoteReleaseOptions, existingRelease?: RemoteRelease): Promise<RemoteReleaseResult>;
-}
-/**
- * Factory function to create a remote release client based on the given configuration
- */
-export declare function createRemoteReleaseClient(createReleaseConfig: false | ResolvedCreateRemoteReleaseProvider, remoteName?: string): Promise<GithubRemoteReleaseClient | GitLabRemoteReleaseClient | null>;

package/dist/src/command-line/release/utils/remote-release-clients/remote-release-client.js

@@ -1,138 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemoteReleaseClient = void 0;
-exports.createRemoteReleaseClient = createRemoteReleaseClient;
-const tslib_1 = require("tslib");
-const axios_1 = tslib_1.__importDefault(require("axios"));
-const handle_import_1 = require("../../../../utils/handle-import");
-const print_changes_1 = require("../print-changes");
-const shared_1 = require("../shared");
-/**
- * Abstract base class for remote release clients
- */
-class RemoteReleaseClient {
-    constructor(
-    // A workspace isn't guaranteed to have a remote
-    remoteRepoData, createReleaseConfig, tokenData) {
-        this.remoteRepoData = remoteRepoData;
-        this.createReleaseConfig = createReleaseConfig;
-        this.tokenData = tokenData;
-        this.tokenHeader = {};
-        if (tokenData) {
-            if (tokenData.headerName === 'Authorization') {
-                this.tokenHeader[tokenData.headerName] = `Bearer ${tokenData.token}`;
-            }
-            else {
-                this.tokenHeader[tokenData.headerName] = tokenData.token;
-            }
-        }
-    }
-    getRemoteRepoData() {
-        return this.remoteRepoData;
-    }
-    /**
-     * Make an (optionally authenticated) API request to the remote release provider
-     */
-    async makeRequest(url, opts = {}) {
-        const remoteRepoData = this.getRemoteRepoData();
-        if (!remoteRepoData) {
-            throw new Error(`No remote repo data could be resolved for the current workspace`);
-        }
-        const config = {
-            ...opts,
-            baseURL: remoteRepoData.apiBaseUrl,
-            headers: {
-                ...opts.headers,
-                ...this.tokenHeader,
-            },
-        };
-        return (await (0, axios_1.default)(url, config)).data;
-    }
-    async createOrUpdateRelease(releaseVersion, changelogContents, latestCommit, { dryRun }) {
-        let existingRelease;
-        try {
-            existingRelease = await this.getReleaseByTag(releaseVersion.gitTag);
-        }
-        catch (err) {
-            if (err.response?.status === 401) {
-                this.handleAuthError();
-                process.exit(1);
-            }
-            if (err.response?.status === 404) {
-                // No existing release found, this is fine
-            }
-            else {
-                // Rethrow unknown errors for now
-                throw err;
-            }
-        }
-        this.logReleaseAction(existingRelease, releaseVersion.gitTag, dryRun);
-        this.printRemoteReleaseContents(existingRelease
-            ? 'body' in existingRelease
-                ? existingRelease.body
-                : 'description' in existingRelease
-                    ? existingRelease.description
-                    : ''
-            : '', changelogContents);
-        if (!dryRun) {
-            const remoteReleaseOptions = {
-                version: releaseVersion.gitTag,
-                prerelease: releaseVersion.isPrerelease,
-                body: changelogContents,
-                commit: latestCommit,
-            };
-            const result = await this.syncRelease(remoteReleaseOptions, existingRelease);
-            if (result.status === 'manual') {
-                await this.handleError(result.error, result);
-            }
-        }
-    }
-    /**
-     * Format references for the release (e.g., PRs, issues)
-     */
-    formatReferences(_references) {
-        // Base implementation - to be overridden by specific providers
-        return '';
-    }
-    /**
-     * Print changelog changes
-     */
-    printRemoteReleaseContents(existingBody, newBody) {
-        console.log('');
-        (0, print_changes_1.printDiff)(existingBody, newBody, 3, shared_1.noDiffInChangelogMessage);
-    }
-}
-exports.RemoteReleaseClient = RemoteReleaseClient;
-/**
- * Factory function to create a remote release client based on the given configuration
- */
-async function createRemoteReleaseClient(createReleaseConfig, remoteName = 'origin') {
-    switch (true) {
-        // GitHub and GitHub Enterprise Server
-        case typeof createReleaseConfig === 'object' &&
-            (createReleaseConfig.provider === 'github-enterprise-server' ||
-                createReleaseConfig.provider === 'github'):
-        // If remote releases are disabled, assume GitHub repo data resolution (but don't attempt to resolve a token) to match existing behavior
-        case createReleaseConfig === false: {
-            const { GithubRemoteReleaseClient } = await (0, handle_import_1.handleImport)('./github.js', __dirname);
-            const repoData = GithubRemoteReleaseClient.resolveRepoData(createReleaseConfig, remoteName);
-            const token = createReleaseConfig && repoData
-                ? await GithubRemoteReleaseClient.resolveTokenData(repoData.hostname)
-                : null;
-            return new GithubRemoteReleaseClient(repoData, createReleaseConfig, token);
-        }
-        // GitLab
-        case typeof createReleaseConfig === 'object' &&
-            createReleaseConfig.provider === 'gitlab':
-            {
-                const { GitLabRemoteReleaseClient } = await (0, handle_import_1.handleImport)('./gitlab.js', __dirname);
-                const repoData = GitLabRemoteReleaseClient.resolveRepoData(createReleaseConfig, remoteName);
-                const tokenData = repoData
-                    ? await GitLabRemoteReleaseClient.resolveTokenData(repoData.hostname)
-                    : null;
-                return new GitLabRemoteReleaseClient(repoData, createReleaseConfig, tokenData);
-            }
-        default:
-            throw new Error(`Unsupported remote release configuration: ${JSON.stringify(createReleaseConfig)}`);
-    }
-}

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

@@ -1,25 +0,0 @@
-/**
- * When to check all branches for git tags instead of just merged branches.
- * - `boolean`: true = all branches, false = merged only
- * - `string[]`: Check all branches if current branch matches any pattern
- */
-export type CheckAllBranchesWhen = boolean | string[];
-/**
- * Caches git tags to avoid redundant git operations during release workflows.
- * Tags are cached per branch strategy ('single-branch' vs 'all-branches').
- */
-export declare class RepoGitTags {
-    #private;
-    /** Creates a new RepoGitTags instance with an empty cache. */
-    static create(): 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
-     */
-    resolveTags(checkAllBranchesWhen?: CheckAllBranchesWhen): Promise<string[]>;
-    /** Clears the tag cache. Useful for testing or forcing a fresh fetch. */
-    clean(): void;
-}

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

@@ -1,125 +0,0 @@
-"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

@@ -1,2 +0,0 @@
-import type ChangelogRenderer from '../../../../release/changelog-renderer';
-export declare function resolveChangelogRenderer(changelogRendererPathOrImplementation: string | typeof ChangelogRenderer): typeof ChangelogRenderer;