@virmator/publish 14.23.1 → 14.25.0

package/dist/publish.d.ts

@@ -1,3 +1,4 @@
+import { type SemVer } from 'semver';
 import { type PackageJson } from 'type-fest';
 /** A virmator plugin for publishing a package to npm. */
 export declare const virmatorPublishPlugin: Readonly<Readonly<{
@@ -43,3 +44,25 @@ export declare function assertValidLicense({ license, isPrivate, displayName, }:
     isPrivate: PackageJson['private'];
     displayName: string;
 }): void;
+/** Commit message version tags that bump the published version. */
+export declare enum ChangeMarker {
+    Patch = "patch",
+    Minor = "minor",
+    Major = "major"
+}
+/**
+ * Parses the leading `[tag]` version marker from a commit message. Returns the matching
+ * {@link ChangeMarker}, or `undefined` when there is no tag or the tag is an allowed non-bumping one
+ * (e.g. `dev`). Throws a `VirmatorNoTraceError` for any tag outside the allowed set so the publish
+ * aborts.
+ */
+export declare function parseCommitChangeMarker(commitMessage: string): ChangeMarker | undefined;
+/**
+ * The next semver version to publish, derived from the highest-priority bump marker found since the
+ * last version (major > minor > patch). Returns `undefined` when no version was found or no bump
+ * marker is present, in which case the caller asks for a version manually.
+ */
+export declare function determineNextVersion({ latestVersion, changeMarkers, }: {
+    latestVersion: SemVer | undefined;
+    changeMarkers: Readonly<Record<ChangeMarker, number>>;
+}): string | undefined;

package/dist/publish.js

@@ -1,5 +1,5 @@
 import { assert, check } from '@augment-vir/assert';
-import { awaitedBlockingMap, extractErrorMessage, safeMatch } from '@augment-vir/common';
+import { awaitedBlockingMap, getObjectTypedValues, safeMatch, wrapInTry, } from '@augment-vir/common';
 import { askQuestionUntilConditionMet, readPackageJson, runShellCommand as runHiddenShellCommand, runShellCommand, } from '@augment-vir/node';
 import { defineVirmatorPlugin, parseTsConfig, VirmatorNoTraceError, } from '@virmator/core';
 import mri from 'mri';
@@ -80,23 +80,26 @@ export const virmatorPublishPlugin = defineVirmatorPlugin(import.meta.dirname, {
         return packageJson;
     }));
     const git = simpleGit(monoRepoRootPath);
+    /**
+     * Always read the version tags on commits since the last release so a disallowed tag (e.g.
+     * `[wip]`) aborts the publish, even when the current version needs no bump.
+     */
+    const { latestVersion, changeMarkers } = await findChangeMarkersSinceVersion(git);
     if (await isVersionPublished(version, [
         cwdValidPackageJson,
         ...monoRepoPackageJsonFiles,
     ])) {
-        let nextVersion;
-        try {
-            nextVersion = await determineNextVersion(git);
-        }
-        catch (error) {
-            log.faint(extractErrorMessage(error));
-        }
         const allPackageJsonFiles = [
             cwdValidPackageJson,
             ...monoRepoPackageJsonFiles,
         ];
-        if (!nextVersion || (await isVersionPublished(nextVersion, allPackageJsonFiles))) {
-            nextVersion = await askQuestionUntilConditionMet({
+        const autoNextVersion = determineNextVersion({
+            latestVersion,
+            changeMarkers,
+        });
+        const nextVersion = autoNextVersion && !(await isVersionPublished(autoNextVersion, allPackageJsonFiles))
+            ? autoNextVersion
+            : await askQuestionUntilConditionMet({
                 async verifyResponseCallback(response) {
                     const version = semver.coerce(response)?.raw;
                     if (!version) {
@@ -107,7 +110,6 @@ export const virmatorPublishPlugin = defineVirmatorPlugin(import.meta.dirname, {
                 invalidInputMessage: 'Invalid semver version.',
                 questionToAsk: 'Failed to automatically determine next publish version. Please enter one:',
             });
-        }
         log.info(`Publishing version ${nextVersion}...`);
         await updateVersions(nextVersion, monoRepoRootPath, monoRepoPackages, log);
         await runHiddenShellCommand('npm i');
@@ -248,12 +250,38 @@ async function isPublished({ name, version }) {
     return output.exitCode === 0;
 }
 const gitCommitFormatDelimiter = '<**..**>';
-var ChangeMarker;
+/** Commit message version tags that bump the published version. */
+export var ChangeMarker;
 (function (ChangeMarker) {
     ChangeMarker["Patch"] = "patch";
     ChangeMarker["Minor"] = "minor";
     ChangeMarker["Major"] = "major";
 })(ChangeMarker || (ChangeMarker = {}));
+/**
+ * Every commit-message version tag `virmator publish` accepts. The {@link ChangeMarker} values each
+ * bump their respective semver part; `dev` is allowed but does not bump the version. Any other tag
+ * (e.g. `wip`) aborts the publish.
+ */
+const allowedVersionTags = [
+    ...getObjectTypedValues(ChangeMarker),
+    'dev',
+];
+/**
+ * Parses the leading `[tag]` version marker from a commit message. Returns the matching
+ * {@link ChangeMarker}, or `undefined` when there is no tag or the tag is an allowed non-bumping one
+ * (e.g. `dev`). Throws a `VirmatorNoTraceError` for any tag outside the allowed set so the publish
+ * aborts.
+ */
+export function parseCommitChangeMarker(commitMessage) {
+    const [, rawChangeMarker,] = safeMatch(commitMessage.trim(), /^\[([^\]]+)]/);
+    if (!rawChangeMarker) {
+        return undefined;
+    }
+    else if (!allowedVersionTags.includes(rawChangeMarker)) {
+        throw new VirmatorNoTraceError(`${rawChangeMarker} version tag not allowed`);
+    }
+    return check.isEnumValue(rawChangeMarker, ChangeMarker) ? rawChangeMarker : undefined;
+}
 async function getGitCommitVersion(decrement, git) {
     const output = await git.raw(`show HEAD~${decrement} --pretty='%d${gitCommitFormatDelimiter}%s' -s`.split(' '));
     const [maybeTag, message,] = output.split(gitCommitFormatDelimiter);
@@ -269,16 +297,19 @@ async function getGitCommitVersion(decrement, git) {
         .filter(check.isTruthy);
     const sortedVersionTags = semver.sort(versionTags);
     const latestVersionTag = sortedVersionTags.slice(-1)[0];
-    const [, rawChangeMarker,] = message ? safeMatch(message.trim(), /^\[([^\]]+)]/) : [];
-    const changeMarker = rawChangeMarker && check.isEnumValue(rawChangeMarker, ChangeMarker)
-        ? rawChangeMarker
-        : undefined;
     return {
         version: latestVersionTag,
-        changeMarker,
+        changeMarker: message ? parseCommitChangeMarker(message) : undefined,
     };
 }
-async function determineNextVersion(git) {
+const maxCommitLookBack = 100;
+/**
+ * Walks backward from HEAD until the most recent version git-tag (or `maxCommitLookBack` commits /
+ * the start of history), tallying the bump markers found on commits since that version. Reading
+ * each commit validates its version tag, so a disallowed tag (e.g. `[wip]`) aborts here — even when
+ * the current version needs no bump.
+ */
+async function findChangeMarkersSinceVersion(git) {
     const changeMarkers = {
         [ChangeMarker.Patch]: 0,
         [ChangeMarker.Minor]: 0,
@@ -286,20 +317,42 @@ async function determineNextVersion(git) {
     };
     let decrement = 0;
     let latestVersion = undefined;
-    while (!latestVersion) {
-        if (decrement > 100) {
-            throw new Error("Couldn't find a version tag in the past 100 commits.");
+    while (!latestVersion && decrement <= maxCommitLookBack) {
+        const commitVersion = await wrapInTry(() => getGitCommitVersion(decrement, git), {
+            handleError(error) {
+                /** A disallowed version tag must abort; any other git error just ends the walk. */
+                if (error instanceof VirmatorNoTraceError) {
+                    throw error;
+                }
+                return undefined;
+            },
+        });
+        if (!commitVersion) {
+            break;
         }
-        const { changeMarker, version } = await getGitCommitVersion(decrement, git);
-        if (version) {
-            latestVersion = version;
+        else if (commitVersion.version) {
+            latestVersion = commitVersion.version;
         }
-        else if (changeMarker) {
-            changeMarkers[changeMarker]++;
+        else if (commitVersion.changeMarker) {
+            changeMarkers[commitVersion.changeMarker]++;
         }
         decrement++;
     }
-    if (changeMarkers[ChangeMarker.Major]) {
+    return {
+        latestVersion,
+        changeMarkers,
+    };
+}
+/**
+ * The next semver version to publish, derived from the highest-priority bump marker found since the
+ * last version (major > minor > patch). Returns `undefined` when no version was found or no bump
+ * marker is present, in which case the caller asks for a version manually.
+ */
+export function determineNextVersion({ latestVersion, changeMarkers, }) {
+    if (!latestVersion) {
+        return undefined;
+    }
+    else if (changeMarkers[ChangeMarker.Major]) {
         return latestVersion.inc('major').raw;
     }
     else if (changeMarkers[ChangeMarker.Minor]) {
@@ -309,7 +362,7 @@ async function determineNextVersion(git) {
         return latestVersion.inc('patch').raw;
     }
     else {
-        throw new Error('No change markers fround since last tagged version.');
+        return undefined;
     }
 }
 async function updateVersions(version, monoRepoRootPath, monoPackages, log) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@virmator/publish",
-    "version": "14.23.1",
+    "version": "14.25.0",
     "description": "Default publish plugin for virmator.",
     "keywords": [
         "virmator",
@@ -34,22 +34,22 @@
         "test:update": "npm test"
     },
     "dependencies": {
-        "@augment-vir/assert": "^31.71.3",
-        "@augment-vir/common": "^31.71.3",
-        "@augment-vir/node": "^31.71.3",
-        "@virmator/core": "^14.23.1",
+        "@augment-vir/assert": "^31.72.1",
+        "@augment-vir/common": "^31.72.1",
+        "@augment-vir/node": "^31.72.1",
+        "@virmator/core": "^14.25.0",
         "mri": "^1.2.0",
-        "semver": "^7.8.1",
+        "semver": "^7.8.3",
         "simple-git": "^3.36.0",
         "spdx-vir": "^0.0.1",
         "url-vir": "^2.1.9"
     },
     "devDependencies": {
-        "@augment-vir/test": "^31.71.3",
-        "@types/node": "^25.9.1",
+        "@augment-vir/test": "^31.72.1",
+        "@types/node": "^25.9.2",
         "@types/semver": "^7.7.1",
         "markdown-code-example-inserter": "^3.0.5",
-        "type-fest": "^5.6.0",
+        "type-fest": "^5.7.0",
         "typedoc": "^0.28.19"
     },
     "engines": {