git-semver-tagger 2.5.0 → 2.5.2

package/kotlin/help/calculate-version.md

@@ -0,0 +1,12 @@
+Calculate the next semantic version from Git history and commit annotations.
+
+When `calculate-version` outputs a version ending in `-SNAPSHOT`, one or more conditions prevent a release version:
+
+| Reason                                                  | Remediation                                                            |
+|---------------------------------------------------------|------------------------------------------------------------------------|
+| `FORCED` — Snapshot forced via `--force-snapshot` flag  | Remove `--force-snapshot` flag when ready for release                  |
+| `DIRTY` — Uncommitted changes in working directory      | Commit or stash changes before tagging                                 |
+| `AHEAD` — Local branch ahead of remote                  | Push changes before tagging                                            |
+| `BEHIND` — Local branch behind remote                   | Pull changes before tagging                                            |
+| `NOT_RELEASE_BRANCH` — Not on configured release branch | Switch to release branch before tagging (default: main)                |
+| `NO_NEW_VERSION` — No new commits since last tag        | Add commits with version annotations (`[major]`, `[minor]`, `[patch]`) |

package/kotlin/help/tag.md

@@ -0,0 +1,12 @@
+Create and push an annotated Git tag at the specified version.
+
+Tagger uses a two-step workflow to separate version calculation from tagging:
+
+1. Run `tagger calculate-version` to compute the next version and check snapshot conditions.
+2. Review the output. If it's a release version (no -SNAPSHOT suffix), use that version here.
+
+The `--version` flag is **required**. Typically, you pass the version from calculate-version output.
+
+You can manually override the calculated version when needed (for example, to correct a versioning mistake or handle an
+exceptional release). When overriding, ensure the version adheres to semantic versioning and follows your project's
+tagging policy.

package/kotlin/help/tagger-guide.md

@@ -0,0 +1,35 @@
+Display the Tagger fit assessment and workflow guide.
+
+## Use Tagger when:
+
+- You want deterministic versioning behavior from Git history
+- You're willing to use Git tags as version source-of-truth
+- You can enforce CI prerequisites consistently (full history, tags, branch context)
+
+## Do not use Tagger when:
+
+- You want version truth from an artifact repository or build metadata instead of Git tags
+- You need multi-stream version lines as a first-class workflow
+- You want a single atomic command to orchestrate the entire release lifecycle
+- You are not willing to enforce Git/CI prerequisites
+
+## Best Practices
+
+**Do:** Keep version decisions explicit and reversible. Calculate first, review output, then tag.
+
+**Don't:** Override calculated versions casually without understanding why the calculation differs.
+
+**Don't:** Skip CI prerequisites (full history, branch context) to "make it work" in your pipeline.
+
+## Workflow Philosophy
+
+- Version numbers live on annotated Git tags.
+- Commit content determines the next version.
+- Releases should be created on a release branch.
+- Version calculation happens separately from release (`calculate-version` → review → `tag`).
+- Configuration lives in code and is governed the same way.
+
+---
+
+For more details on Tagger principles, tradeoffs, and evaluation criteria:
+<https://github.com/robertfmurdock/ze-great-tools/blob/main/docs/why-tagger.md>

package/kotlin/help/tagger.md

@@ -0,0 +1,13 @@
+Tagger calculates semantic versions from Git history and enforces the tagging policy.
+Version numbers live on Git tags. Commit content determines the next version.
+
+Typical CI/build script usage:
+
+```bash
+VERSION=$(tagger calculate-version)
+./your-build-script.sh version=$VERSION
+tagger tag --version $VERSION
+```
+
+Use `--format=json` for machine-readable output. Build with the calculated version before tagging.
+For fit assessment and philosophy: tagger guide

package/kotlin/kotlin-kotlin-stdlib.js

@@ -58,12 +58,6 @@ if (typeof Math.log10 === 'undefined') {
     return Math.log(x) * Math.LOG10E;
   };
 }
-if (typeof String.prototype.startsWith === 'undefined') {
-  Object.defineProperty(String.prototype, 'startsWith', {value: function (searchString, position) {
-    position = position || 0;
-    return this.lastIndexOf(searchString, position) === position;
-  }});
-}
 if (typeof String.prototype.endsWith === 'undefined') {
   Object.defineProperty(String.prototype, 'endsWith', {value: function (searchString, position) {
     var subjectString = this.toString();
@@ -75,6 +69,12 @@ if (typeof String.prototype.endsWith === 'undefined') {
     return lastIndex !== -1 && lastIndex === position;
   }});
 }
+if (typeof String.prototype.startsWith === 'undefined') {
+  Object.defineProperty(String.prototype, 'startsWith', {value: function (searchString, position) {
+    position = position || 0;
+    return this.lastIndexOf(searchString, position) === position;
+  }});
+}
 //endregion
 (function (_) {
   'use strict';
@@ -100,8 +100,8 @@ if (typeof String.prototype.endsWith === 'undefined') {
   initMetadataForInterface(KtSet, 'Set', VOID, VOID, [Collection]);
   initMetadataForInterface(KtMutableMap, 'MutableMap', VOID, VOID, [KtMap]);
   initMetadataForInterface(MutableIterable, 'MutableIterable');
-  initMetadataForInterface(KtMutableList, 'MutableList', VOID, VOID, [KtList, MutableIterable, Collection]);
-  initMetadataForInterface(KtMutableSet, 'MutableSet', VOID, VOID, [KtSet, MutableIterable, Collection]);
+  initMetadataForInterface(KtMutableList, 'MutableList', VOID, VOID, [KtList, Collection, MutableIterable]);
+  initMetadataForInterface(KtMutableSet, 'MutableSet', VOID, VOID, [KtSet, Collection, MutableIterable]);
   initMetadataForCompanion(Companion_0);
   initMetadataForClass(Enum, 'Enum', VOID, VOID, [Comparable]);
   initMetadataForCompanion(Companion_1);
@@ -119,7 +119,7 @@ if (typeof String.prototype.endsWith === 'undefined') {
   initMetadataForInterface(Comparator, 'Comparator');
   initMetadataForObject(Unit, 'Unit');
   initMetadataForClass(AbstractCollection, 'AbstractCollection', VOID, VOID, [Collection]);
-  initMetadataForClass(AbstractMutableCollection, 'AbstractMutableCollection', VOID, AbstractCollection, [MutableIterable, Collection]);
+  initMetadataForClass(AbstractMutableCollection, 'AbstractMutableCollection', VOID, AbstractCollection, [Collection, MutableIterable]);
   initMetadataForClass(IteratorImpl, 'IteratorImpl');
   initMetadataForClass(ListIteratorImpl, 'ListIteratorImpl', VOID, IteratorImpl);
   initMetadataForClass(AbstractMutableList, 'AbstractMutableList', VOID, AbstractMutableCollection, [KtMutableList]);
@@ -132,7 +132,7 @@ if (typeof String.prototype.endsWith === 'undefined') {
   initMetadataForClass(ArrayList, 'ArrayList', ArrayList_init_$Create$, AbstractMutableList, [KtMutableList, RandomAccess]);
   initMetadataForClass(HashMap, 'HashMap', HashMap_init_$Create$, AbstractMutableMap, [KtMutableMap]);
   initMetadataForClass(HashMapKeys, 'HashMapKeys', VOID, AbstractMutableSet, [KtMutableSet]);
-  initMetadataForClass(HashMapValues, 'HashMapValues', VOID, AbstractMutableCollection, [MutableIterable, Collection]);
+  initMetadataForClass(HashMapValues, 'HashMapValues', VOID, AbstractMutableCollection, [Collection, MutableIterable]);
   initMetadataForClass(HashMapEntrySetBase, 'HashMapEntrySetBase', VOID, AbstractMutableSet, [KtMutableSet]);
   initMetadataForClass(HashMapEntrySet, 'HashMapEntrySet', VOID, HashMapEntrySetBase);
   initMetadataForClass(HashMapKeysDefault$iterator$1);
@@ -10215,6 +10215,29 @@ if (typeof String.prototype.endsWith === 'undefined') {
     }
     return tmp;
   }
+  function trim(_this__u8e3s4) {
+    // Inline function 'kotlin.text.trim' call
+    var startIndex = 0;
+    var endIndex = charSequenceLength(_this__u8e3s4) - 1 | 0;
+    var startFound = false;
+    $l$loop: while (startIndex <= endIndex) {
+      var index = !startFound ? startIndex : endIndex;
+      var p0 = charSequenceGet(_this__u8e3s4, index);
+      var match = isWhitespace(p0);
+      if (!startFound) {
+        if (!match)
+          startFound = true;
+        else
+          startIndex = startIndex + 1 | 0;
+      } else {
+        if (!match)
+          break $l$loop;
+        else
+          endIndex = endIndex - 1 | 0;
+      }
+    }
+    return charSequenceSubSequence(_this__u8e3s4, startIndex, endIndex + 1 | 0);
+  }
   function calcNext_1($this) {
     if ($this.og_1 < 0) {
       $this.mg_1 = 0;
@@ -10425,29 +10448,6 @@ if (typeof String.prototype.endsWith === 'undefined') {
         return null;
     }
   }
-  function trim(_this__u8e3s4) {
-    // Inline function 'kotlin.text.trim' call
-    var startIndex = 0;
-    var endIndex = charSequenceLength(_this__u8e3s4) - 1 | 0;
-    var startFound = false;
-    $l$loop: while (startIndex <= endIndex) {
-      var index = !startFound ? startIndex : endIndex;
-      var p0 = charSequenceGet(_this__u8e3s4, index);
-      var match = isWhitespace(p0);
-      if (!startFound) {
-        if (!match)
-          startFound = true;
-        else
-          startIndex = startIndex + 1 | 0;
-      } else {
-        if (!match)
-          break $l$loop;
-        else
-          endIndex = endIndex - 1 | 0;
-      }
-    }
-    return charSequenceSubSequence(_this__u8e3s4, startIndex, endIndex + 1 | 0);
-  }
   function removeSurrounding(_this__u8e3s4, prefix, suffix) {
     if (_this__u8e3s4.length >= (charSequenceLength(prefix) + charSequenceLength(suffix) | 0) && startsWith_2(_this__u8e3s4, prefix) && endsWith_1(_this__u8e3s4, suffix)) {
       return substring(_this__u8e3s4, charSequenceLength(prefix), _this__u8e3s4.length - charSequenceLength(suffix) | 0);