nx 20.8.4 → 22.7.7

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

@@ -0,0 +1,268 @@
+"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 enquirer_1 = require("enquirer");
+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 open = require('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 reply = await (0, enquirer_1.prompt)([
+                {
+                    name: 'open',
+                    message: 'Do you want to create the release manually in your browser?',
+                    type: 'autocomplete',
+                    choices: [
+                        {
+                            name: 'Yes',
+                            hint: 'It will open the GitLab release page for you',
+                        },
+                        {
+                            name: 'No',
+                        },
+                    ],
+                    initial: 0,
+                },
+            ]);
+            return reply.open === 'Yes';
+        }
+        catch {
+            // Ensure the cursor is always restored before exiting
+            process.stdout.write('\u001b[?25h');
+            // Handle the case where the user exits the prompt with ctrl+c
+            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

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

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

@@ -0,0 +1,25 @@
+/**
+ * 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

@@ -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 releaseTagPattern 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;