build-strap 5.2.1 → 6.0.0-main.134

package/README.md

@@ -3,7 +3,7 @@ A suite of functions to help with writing build scripts using TypeScript (or jav
 
 This project builds itself, so take a look in the `targets/` folder for an example. Run `./bs` to build.
 
-[![CI Build](https://github.com/murrayju/build-strap/workflows/CI%20Build/badge.svg?branch=master)](https://github.com/murrayju/build-strap/actions?query=workflow%3A%22CI+Build%22)
+[![CI Build](https://github.com/murrayju/build-strap/workflows/CI%20Build/badge.svg?branch=main)](https://github.com/murrayju/build-strap/actions?query=workflow%3A%22CI+Build%22)
 [![version](https://img.shields.io/github/v/tag/murrayju/build-strap.svg?label=version&sort=semver)](https://github.com/murrayju/build-strap/releases/latest)
 [![npm](https://img.shields.io/npm/v/build-strap)](https://npmjs.org/package/build-strap)
 [![dependencies](https://img.shields.io/david/murrayju/build-strap.svg)](https://david-dm.org/murrayju/build-strap)
@@ -36,8 +36,7 @@ By default, the build tools read project-specific configuration from your `packa
     "yarnVersion": "1.22.4",
     "repoType": "git",
     "copyright": "your company",
-    "releaseBranch": "master",
-    "devBranch": "dev",
+    "mainBranch": "main",
     "npm": {
       "publish": true,
     },
@@ -50,11 +49,34 @@ By default, the build tools read project-specific configuration from your `packa
 }
 ```
 
+### mainBranch
+The name of the single long-lived branch of the repository (defaults to `main`). All work happens on short-lived branches that are merged into it via pull request.
+
 ### docker
 * **registry**: base URL for the docker registry, as needed by `docker push`.
 * **repository**: the name of the (organization's) docker repository, in which to put this project
 * **name**: the name of the project, used as the docker image name.
 
+## Branching and Release Workflow
+This project (and projects built with it) use a single long-lived branch (`main`) with short-lived work branches merged into it via pull request. There is no separate development or release branch.
+
+Releases are triggered by pushing a [semver](https://semver.org/) tag (with an optional leading `v`) to a commit on `main`:
+
+```
+git tag v1.2.3 && git push origin v1.2.3
+```
+
+The version being built is determined as follows:
+
+| Build | npm version | npm dist-tag | docker tags |
+| --- | --- | --- | --- |
+| Tag `v1.2.3` on `main` | `1.2.3` | `latest` | `latest`, `1`, `1.2`, `1.2.3` |
+| Tag `v1.2.3-rc.1` on `main` | `1.2.3-rc.1` | `rc` | `1.2.3-rc.1`, `latest-rc` |
+| Untagged commit on `main` | `1.2.3-main.42` | `next` | `latest-main` |
+| Work branch / pull request | `1.2.3-my-branch.42` | `branch` | (none) |
+
+For untagged builds, the base version comes from the `version` field in `package.json` and the build number comes from `--buildNum=` (or the `BUILD_NUMBER` environment variable). For release builds, the version comes from the git tag, and the build refuses to publish if the tagged commit is not contained in `main`.
+
 ## Write Your Build Script
 See the reference implementations (below) for a complete example of a robust build environment. The library exports many useful functions. Here are some of the most important (see source for more):
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-strap",
-  "version": "5.2.1",
+  "version": "6.0.0-main.134",
   "description": "Node scripts for building things",
   "license": "MIT",
   "author": "Justin Murray <justin@murrayju.com>",

package/src/docker.d.ts

@@ -9,12 +9,11 @@ export declare function dockerBuild(tags?: string[], buildArgs?: string[], targe
 export declare function dockerTag(imageId: string, tags?: string[], repo?: string): Promise<void>;
 /**
  * Apply the standard convention for tagging the docker image for the project,
- * based on the source control branch being built.
- * For releases, applies `latest`, `M.m.p`, `M.m`, `M`
- * For release candidates, applies `latest-rc`
- * For feature branches, applies `latest-feature`
- * For development branch, applies `latest-dev`
- * All other branches, no tag is applies
+ * based on the semver git tag (or branch) being built.
+ * For releases (a semver tag), applies `latest`, `M`, `M.m`, `M.m.p`
+ * For pre-releases (e.g. tag `v1.2.3-rc.1`), applies `1.2.3-rc.1` and `latest-rc`
+ * For untagged builds of the main branch, applies `latest-main`
+ * For all other builds, no tag is applied
  * @param {string} imageId id of the docker image to which to apply the tags
  * @param {string} repo optional override of the docker repo url to use (derived from package.json by default)
  */

package/src/docker.js

@@ -12,7 +12,7 @@ import { downloadFile } from './fetch.js';
 import { mountDmg, unmountDmg } from './macos.js';
 import { getCfg, getPkgName, getPkgScope } from './pkg.js';
 import { buildLog } from './run.js';
-import { getDevBranch, getVersion } from './version.js';
+import { getMainBranch, getVersion } from './version.js';
 export function getDockerConfig() {
     return getCfg().docker || {};
 }
@@ -37,29 +37,29 @@ export async function dockerTag(imageId, tags = ['latest'], repo = getDockerRepo
 }
 /**
  * Apply the standard convention for tagging the docker image for the project,
- * based on the source control branch being built.
- * For releases, applies `latest`, `M.m.p`, `M.m`, `M`
- * For release candidates, applies `latest-rc`
- * For feature branches, applies `latest-feature`
- * For development branch, applies `latest-dev`
- * All other branches, no tag is applies
+ * based on the semver git tag (or branch) being built.
+ * For releases (a semver tag), applies `latest`, `M`, `M.m`, `M.m.p`
+ * For pre-releases (e.g. tag `v1.2.3-rc.1`), applies `1.2.3-rc.1` and `latest-rc`
+ * For untagged builds of the main branch, applies `latest-main`
+ * For all other builds, no tag is applied
  * @param {string} imageId id of the docker image to which to apply the tags
  * @param {string} repo optional override of the docker repo url to use (derived from package.json by default)
  */
 export async function dockerTagVersion(imageId, repo = getDockerRepo()) {
-    const { branch, isRelease, major, minor, patch } = await getVersion();
+    const { branch, isRelease, major, minor, npm, patch, prerelease } = await getVersion();
     // determine what tags to apply
     if (isRelease) {
-        await dockerTag(imageId, ['latest', `${major}`, `${major}.${minor}`, `${major}.${minor}.${patch}`], repo);
+        await dockerTag(imageId, prerelease
+            ? [npm, `latest-${prerelease.split('.')[0]}`]
+            : [
+                'latest',
+                `${major}`,
+                `${major}.${minor}`,
+                `${major}.${minor}.${patch}`,
+            ], repo);
     }
-    else if (branch === (await getDevBranch())) {
-        await dockerTag(imageId, ['latest-dev'], repo);
-    }
-    else if (branch.match(/^(release|patch)-/)) {
-        await dockerTag(imageId, ['latest-rc'], repo);
-    }
-    else if (branch.match(/^feature-/)) {
-        await dockerTag(imageId, ['latest-feature'], repo);
+    else if (branch === getMainBranch()) {
+        await dockerTag(imageId, [`latest-${branch}`], repo);
     }
 }
 export async function dockerImages(repo = getDockerRepo(), filter = null) {

package/src/git.d.ts

@@ -1,10 +1,28 @@
 import { SpawnOptions } from './cp.js';
 export declare const git: (args: string[], opts?: SpawnOptions) => Promise<import("./cp.js").SpawnResult>;
 export declare const gitOutput: (args: string[], opts?: SpawnOptions) => Promise<string>;
-export declare function gitBranch(): Promise<string>;
+/**
+ * Convert a git ref name into a string that is safe to embed in a version.
+ */
+export declare function sanitizeGitRefName(refName: string): string;
+/**
+ * Name of the branch that is currently checked out, or `null` when the working
+ * copy is in a detached HEAD state (as is typical for tag and pull request
+ * builds on CI) and no branch name can be determined from the environment.
+ */
+export declare function gitBranch(): Promise<null | string>;
 export declare function gitRevId(): Promise<string>;
+/**
+ * All tags that point directly at the given commit (HEAD by default).
+ */
+export declare function gitTagsAtCommit(commitish?: string): Promise<string[]>;
+/**
+ * True when `ancestorCommitish` is reachable from `descendantCommitish`.
+ * Useful for verifying that a release tag lives on the main branch.
+ */
+export declare function gitIsAncestor(ancestorCommitish: string, descendantCommitish: string): Promise<boolean>;
 type GitInfo = {
-    branch: string;
+    branch: null | string;
     revision: string;
 };
 export declare function gitInfo(noCache?: boolean): Promise<GitInfo>;

package/src/git.js

@@ -3,16 +3,51 @@ import { userQuestion } from './prompt.js';
 import { buildLog } from './run.js';
 export const git = async (args, opts) => spawn('git', args, opts);
 export const gitOutput = async (args, opts) => (await git(args, { captureOutput: true, ...opts })).stdout.trim();
+/**
+ * Convert a git ref name into a string that is safe to embed in a version.
+ */
+export function sanitizeGitRefName(refName) {
+    return refName.replace(/[_+/]/g, '-').trim();
+}
+/**
+ * Name of the branch that is currently checked out, or `null` when the working
+ * copy is in a detached HEAD state (as is typical for tag and pull request
+ * builds on CI) and no branch name can be determined from the environment.
+ */
 export async function gitBranch() {
-    return (await gitOutput(['symbolic-ref', '--short', 'HEAD']))
-        .replace(/[_+/]/g, '-')
-        .trim();
+    const checkedOutBranch = await gitOutput(['symbolic-ref', '--short', 'HEAD'], {
+        rejectOnErrorCode: false,
+    });
+    if (checkedOutBranch) {
+        return sanitizeGitRefName(checkedOutBranch);
+    }
+    // Detached HEAD: fall back to the branch reported by the CI environment.
+    // For pull requests, GITHUB_HEAD_REF holds the source branch of the PR.
+    const { GITHUB_HEAD_REF, GITHUB_REF } = process.env;
+    const envBranch = GITHUB_HEAD_REF || GITHUB_REF?.match(/^refs\/heads\/(.+)$/)?.[1];
+    return envBranch ? sanitizeGitRefName(envBranch) : null;
 }
 export async function gitRevId() {
     return (await gitOutput(['rev-parse', '--short=12', 'HEAD']))
         .replace(/[+]/g, '')
         .trim();
 }
+/**
+ * All tags that point directly at the given commit (HEAD by default).
+ */
+export async function gitTagsAtCommit(commitish = 'HEAD') {
+    const output = await gitOutput(['tag', '--points-at', commitish], {
+        rejectOnErrorCode: false,
+    });
+    return output.split('\n').filter(Boolean);
+}
+/**
+ * True when `ancestorCommitish` is reachable from `descendantCommitish`.
+ * Useful for verifying that a release tag lives on the main branch.
+ */
+export async function gitIsAncestor(ancestorCommitish, descendantCommitish) {
+    return ((await git(['merge-base', '--is-ancestor', ancestorCommitish, descendantCommitish], { rejectOnErrorCode: false })).code === 0);
+}
 let info = null;
 export async function gitInfo(noCache = false) {
     if (!info || noCache) {

package/src/npm.js

@@ -4,7 +4,7 @@ import path from 'path';
 import { spawn } from './cp.js';
 import { getCfg, getPkgName } from './pkg.js';
 import { buildLog } from './run.js';
-import { getDevBranch, getVersion } from './version.js';
+import { getDefaultNpmDistTag, getVersion } from './version.js';
 export function getNpmConfig() {
     return getCfg().npm || {};
 }
@@ -86,7 +86,7 @@ export async function npmPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, p
         });
     }
     const existing = await npmGetVersions(name, npmPath);
-    const { branch, isRelease, npm: npmVersion } = await getVersion();
+    const { npm: npmVersion } = await getVersion();
     if (existing.includes(npmVersion)) {
         if (skipExisting) {
             buildLog('npm package with this same version already exists. Skipping publish...');
@@ -102,12 +102,7 @@ export async function npmPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, p
             'publish',
             resolvedPath,
             '--tag',
-            tag ||
-                (isRelease
-                    ? 'latest'
-                    : branch === (await getDevBranch())
-                        ? 'next'
-                        : 'branch'),
+            tag || (await getDefaultNpmDistTag()),
             ...(access ? ['--access', access] : []),
             ...(dryRun ? ['--dry-run'] : []),
             ...(provenance ? ['--provenance'] : []),

package/src/pkg.d.ts

@@ -4,10 +4,9 @@ import { NpmConfig } from './npm.js';
 export interface BuildStrapConfig {
     cert?: CertConfig;
     copyright?: string;
-    devBranch?: string;
     docker?: DockerConfig;
+    mainBranch?: string;
     npm?: NpmConfig;
-    releaseBranch?: string;
     repoType?: 'git' | 'hg';
 }
 export interface Person {

package/src/version.d.ts

@@ -1,5 +1,10 @@
 export declare function getBuild(): string;
-export declare function getReleaseBranch(): string;
+/**
+ * The one long-lived branch of the repository. All work happens on short-lived
+ * branches that are merged into it via pull request, and releases are cut by
+ * pushing a semver tag to a commit on it.
+ */
+export declare function getMainBranch(): string;
 declare enum RepoType {
     git = "git",
     hg = "hg",
@@ -7,15 +12,44 @@ declare enum RepoType {
 }
 export declare function getRepoType(): Promise<RepoType>;
 type RepoInfo = {
-    branch: string;
+    branch: null | string;
     revision: string;
 };
 export declare function getRepoInfo(): Promise<RepoInfo>;
-export declare function getDevBranch(): Promise<string>;
-export declare function getIsRelease(passedBranch?: null | string, releaseOverride?: null | boolean): Promise<boolean>;
+export interface SemverTag {
+    major: string;
+    minor: string;
+    patch: string;
+    prerelease: null | string;
+    tag: string;
+    version: string;
+}
+/**
+ * Parse a git tag as a semver release tag. Returns null if the tag is not a
+ * semver version tag (an optional leading `v` is allowed).
+ */
+export declare function parseSemverTag(tag: string): null | SemverTag;
+/**
+ * The semver tag pointing at the commit being built, if any. This is what makes
+ * a build a release build: releases are triggered by pushing a semver tag.
+ * When multiple semver tags point at the same commit, the highest one wins.
+ */
+export declare function getReleaseTag(): Promise<null | SemverTag>;
+/**
+ * Verify that the semver release tag agrees with the version in package.json, so
+ * that the published artifact always matches its source. Pre-release identifiers
+ * on the tag (e.g. `v1.2.3-rc.1` for package version `1.2.3`) are allowed.
+ */
+export declare function assertReleaseTagMatchesPackageVersion(): Promise<void>;
+/**
+ * Verify that the commit being released is contained in the main branch, so that
+ * a release can never be cut from an unmerged work branch.
+ */
+export declare function assertReleaseCommitIsOnMainBranch(mainBranch?: string): Promise<void>;
+export declare function getIsRelease(releaseOverride?: null | boolean): Promise<boolean>;
 export declare function useVersionCache(useCache?: boolean): void;
 export interface Version {
-    branch: string;
+    branch: null | string;
     build: string;
     info: string;
     isRelease: boolean;
@@ -24,10 +58,20 @@ export interface Version {
     name: string;
     npm: string;
     patch: string;
+    prerelease: null | string;
+    releaseTag: null | string;
     revision: string;
     short: string;
 }
 export declare function getVersion(logIt?: boolean, release?: null | boolean): Promise<Version>;
+/**
+ * The npm dist-tag to publish under, following the branch/tag conventions:
+ * - release tag without pre-release identifiers => `latest`
+ * - release tag with pre-release identifiers => the first identifier (`rc`, `beta`, ...)
+ * - untagged build of the main branch => `next`
+ * - anything else => `branch`
+ */
+export declare function getDefaultNpmDistTag(): Promise<string>;
 export declare function getBanner(): Promise<string>;
 export declare function getVersionCode(): Promise<string>;
 export declare function getUniqueBuildTag(): Promise<string>;

package/src/version.js

@@ -1,14 +1,19 @@
 import fs from 'fs';
-import { gitInfo } from './git.js';
+import { gitInfo, gitIsAncestor, gitTagsAtCommit } from './git.js';
 import { getCfg, getPkg } from './pkg.js';
 import { buildLog } from './run.js';
 export function getBuild() {
     const arg = process.argv.find((el) => /^--buildNum=\d+$/.test(el));
     return (arg && arg.substring(11)) || process.env.BUILD_NUMBER || '0';
 }
-export function getReleaseBranch() {
-    const { releaseBranch } = getCfg();
-    return releaseBranch || 'master';
+/**
+ * The one long-lived branch of the repository. All work happens on short-lived
+ * branches that are merged into it via pull request, and releases are cut by
+ * pushing a semver tag to a commit on it.
+ */
+export function getMainBranch() {
+    const { mainBranch } = getCfg();
+    return mainBranch || 'main';
 }
 var RepoType;
 (function (RepoType) {
@@ -31,41 +36,131 @@ export async function getRepoInfo() {
         throw new Error(`Unsupported repo type: ${repoType}`);
     }
     const { branch, revision } = await gitInfo();
-    if (!branch || !revision) {
-        throw new Error('Failed to parse branch and revision from source repo.');
+    if (!revision) {
+        throw new Error('Failed to parse revision from source repo.');
     }
     return { branch, revision };
 }
-export async function getDevBranch() {
-    const { devBranch } = getCfg();
-    return devBranch || ((await getRepoType()) === 'hg' ? 'default' : 'dev');
+const semverTagRegex = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
+/**
+ * Parse a git tag as a semver release tag. Returns null if the tag is not a
+ * semver version tag (an optional leading `v` is allowed).
+ */
+export function parseSemverTag(tag) {
+    const [, major, minor, patch, prerelease] = tag.match(semverTagRegex) || [];
+    if (!major || !minor || !patch) {
+        return null;
+    }
+    return {
+        major,
+        minor,
+        patch,
+        prerelease: prerelease || null,
+        tag,
+        version: `${major}.${minor}.${patch}${prerelease ? `-${prerelease}` : ''}`,
+    };
+}
+/**
+ * The semver tag pointing at the commit being built, if any. This is what makes
+ * a build a release build: releases are triggered by pushing a semver tag.
+ * When multiple semver tags point at the same commit, the highest one wins.
+ */
+export async function getReleaseTag() {
+    const overrideTag = process.argv
+        .find((el) => el.startsWith('--releaseTag='))
+        ?.substring('--releaseTag='.length) ||
+        process.env.RELEASE_TAG ||
+        // GitHub Actions sets this for tag builds
+        process.env.GITHUB_REF?.match(/^refs\/tags\/(.+)$/)?.[1];
+    if (overrideTag) {
+        const parsed = parseSemverTag(overrideTag);
+        if (!parsed) {
+            throw new Error(`\`${overrideTag}\` is not a valid semver release tag.`);
+        }
+        return parsed;
+    }
+    if ((await getRepoType()) !== RepoType.git) {
+        return null;
+    }
+    const semverTags = (await gitTagsAtCommit())
+        .map(parseSemverTag)
+        .filter((t) => t != null);
+    return (semverTags.sort((a, b) => a.version.localeCompare(b.version, undefined, { numeric: true }))[semverTags.length - 1] || null);
+}
+/**
+ * Verify that the semver release tag agrees with the version in package.json, so
+ * that the published artifact always matches its source. Pre-release identifiers
+ * on the tag (e.g. `v1.2.3-rc.1` for package version `1.2.3`) are allowed.
+ */
+export async function assertReleaseTagMatchesPackageVersion() {
+    const releaseTag = await getReleaseTag();
+    if (!releaseTag) {
+        return;
+    }
+    const { version: pkgVersion } = getPkg();
+    const pkgSemver = parseSemverTag(pkgVersion);
+    const tagBaseVersion = `${releaseTag.major}.${releaseTag.minor}.${releaseTag.patch}`;
+    const pkgBaseVersion = pkgSemver && `${pkgSemver.major}.${pkgSemver.minor}.${pkgSemver.patch}`;
+    if (tagBaseVersion !== pkgBaseVersion) {
+        throw new Error(`Refusing to release: tag \`${releaseTag.tag}\` does not match the version in package.json (\`${pkgVersion}\`).`);
+    }
 }
-export async function getIsRelease(passedBranch = null, releaseOverride = null) {
-    const branch = passedBranch || (await getRepoInfo()).branch;
-    return releaseOverride != null
-        ? releaseOverride
-        : process.argv.includes('--force-release-version')
-            ? true
-            : branch === getReleaseBranch();
+/**
+ * Verify that the commit being released is contained in the main branch, so that
+ * a release can never be cut from an unmerged work branch.
+ */
+export async function assertReleaseCommitIsOnMainBranch(mainBranch = getMainBranch()) {
+    const { revision } = await getRepoInfo();
+    const candidateRefs = [mainBranch, `origin/${mainBranch}`];
+    for (const ref of candidateRefs) {
+        // eslint-disable-next-line no-await-in-loop
+        if (await gitIsAncestor(revision, ref)) {
+            return;
+        }
+    }
+    throw new Error(`Refusing to release ${revision}: it is not contained in the \`${mainBranch}\` branch.`);
+}
+export async function getIsRelease(releaseOverride = null) {
+    if (releaseOverride != null) {
+        return releaseOverride;
+    }
+    if (process.argv.includes('--force-release-version')) {
+        return true;
+    }
+    return (await getReleaseTag()) != null;
 }
 let cacheVersion = true;
 export function useVersionCache(useCache = true) {
     cacheVersion = useCache;
 }
+/**
+ * Label used to identify a non-release build in its version string. Falls back
+ * to the revision when no branch name is available.
+ */
+function getBuildSourceLabel({ branch, revision }) {
+    return branch || revision;
+}
 let version = null;
 export async function getVersion(logIt = true, release = null) {
     if (!cacheVersion || version == null) {
-        const { name, version: pkgVers } = getPkg();
-        const { branch, revision } = await getRepoInfo();
-        const [, major, minor, patch] = pkgVers.match(/^(\d+)\.(\d+)\.(\d+)$/) || [];
-        if (!major || !minor || !patch) {
-            throw new Error('Invalid version format in package.json');
+        const { name, version: pkgVersion } = getPkg();
+        const repoInfo = await getRepoInfo();
+        const { branch, revision } = repoInfo;
+        const releaseTag = await getReleaseTag();
+        const isRelease = await getIsRelease(release);
+        // A release build takes its version from the git tag that triggered it;
+        // everything else is a pre-release of the version in package.json.
+        const semver = (isRelease && releaseTag) || parseSemverTag(pkgVersion.split('-')[0]);
+        if (!semver) {
+            throw new Error(`Invalid version format in package.json: \`${pkgVersion}\``);
         }
+        const { major, minor, patch, prerelease } = semver;
         const build = getBuild();
-        const isRelease = await getIsRelease(branch, release);
         const short = `${major}.${minor}.${patch}`;
-        const npm = `${short}${isRelease ? '' : `-${branch}.${build}`}`;
-        const info = `${short}${isRelease ? `+${build}.` : `-${branch}.${build}+`}${revision}`;
+        const npm = isRelease
+            ? semver.version
+            : `${short}-${getBuildSourceLabel(repoInfo)}.${build}`;
+        const info = `${npm}+${build}.${revision}`;
         version = {
             branch,
             build,
@@ -76,6 +171,8 @@ export async function getVersion(logIt = true, release = null) {
             name,
             npm,
             patch,
+            prerelease,
+            releaseTag: releaseTag?.tag || null,
             revision,
             short,
         };
@@ -85,6 +182,20 @@ export async function getVersion(logIt = true, release = null) {
     }
     return version;
 }
+/**
+ * The npm dist-tag to publish under, following the branch/tag conventions:
+ * - release tag without pre-release identifiers => `latest`
+ * - release tag with pre-release identifiers => the first identifier (`rc`, `beta`, ...)
+ * - untagged build of the main branch => `next`
+ * - anything else => `branch`
+ */
+export async function getDefaultNpmDistTag() {
+    const { branch, isRelease, prerelease } = await getVersion();
+    if (isRelease) {
+        return prerelease ? prerelease.split('.')[0] : 'latest';
+    }
+    return branch === getMainBranch() ? 'next' : 'branch';
+}
 export async function getBanner() {
     const { copyright = '' } = getCfg();
     const { info, name } = await getVersion();
@@ -96,6 +207,6 @@ export async function getVersionCode() {
 export const version = ${JSON.stringify(await getVersion(), null, 2)}`;
 }
 export async function getUniqueBuildTag() {
-    const { branch, build, revision } = await getVersion();
-    return `${branch}-${revision}-${build}`;
+    const { build, revision, ...repoInfo } = await getVersion();
+    return `${getBuildSourceLabel({ ...repoInfo, revision })}-${revision}-${build}`;
 }

package/src/yarn.js

@@ -6,7 +6,7 @@ import { envNpmCreds, getNpmConfig, npmGetVersions, npmWriteRc, } from './npm.js
 import { getPkg, getPkgName, getPkgSafeName } from './pkg.js';
 import { buildLog } from './run.js';
 import { generateFileHash } from './tgz.js';
-import { getDevBranch, getVersion } from './version.js';
+import { getDefaultNpmDistTag, getVersion } from './version.js';
 export async function yarn({ args = [], spawnOptions, } = {}) {
     const localYarn = path.join(path.dirname(process.execPath), '/node_modules/yarn/bin/yarn.js');
     const spawnOpts = {
@@ -102,7 +102,7 @@ export async function yarnPublish({ npmAuthToken, npmConfig, npmCreds, npmPath,
         });
     }
     const existing = await npmGetVersions(getPkgName(true), npmPath);
-    const { branch, isRelease, npm: npmVersion } = await getVersion();
+    const { npm: npmVersion } = await getVersion();
     if (existing.includes(npmVersion)) {
         if (skipExisting) {
             buildLog('npm package with this same version already exists. Skipping publish...');
@@ -117,12 +117,7 @@ export async function yarnPublish({ npmAuthToken, npmConfig, npmCreds, npmPath,
             '--new-version',
             npmVersion,
             '--tag',
-            tag ||
-                (isRelease
-                    ? 'latest'
-                    : branch === (await getDevBranch())
-                        ? 'next'
-                        : 'branch'),
+            tag || (await getDefaultNpmDistTag()),
             ...(access ? ['--access', access] : []),
         ],
         spawnOptions: {