autorel 2.2.13 → 2.3.0-next.2

package/dist/semver/increment.d.ts

@@ -0,0 +1,26 @@
+import { ReleaseType, SemVer } from './types';
+export declare function incrByType(version: SemVer, releaseType: ReleaseType): SemVer;
+export declare function incrPatch(version: SemVer): SemVer;
+export declare function incrMinor(version: SemVer): SemVer;
+export declare function incrMajor(version: SemVer): SemVer;
+/**
+ * Increments the version based on the release type. The next version must
+ * be greater than the latest version except for the following case:
+ * 2. The latest version is a prerelease of a different channel. Even in this case,
+ *   the next version must be greater than the last stable/production version.
+ *
+ * Parameters:
+ * - `latestVer` is typically the current version of the package and the same as
+ *   `latestStableVer` if the last release was a stable/production release.
+ * - `latestStableVer` is the last stable/production release.
+ * - `releaseType` is the type of release to make.
+ * - `prereleaseChannel` is the name of the prerelease channel, if it's a prerelease.
+ * - `latestChannelVer` is the last version of the package on the same channel.
+ */
+export declare function incrVer(input: {
+    latestVer: SemVer;
+    latestStableVer: SemVer;
+    latestChannelVer?: SemVer;
+    releaseType: ReleaseType;
+    prereleaseChannel?: string;
+}): SemVer;

package/dist/semver/increment.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.incrVer = exports.incrMajor = exports.incrMinor = exports.incrPatch = exports.incrByType = void 0;
+const compare_1 = require("./compare");
+const parse_1 = require("./parse");
+const errors_1 = require("./errors");
+function incrByType(version, releaseType) {
+    switch (releaseType) {
+        case 'major':
+            return incrMajor(version);
+        case 'minor':
+            return incrMinor(version);
+        case 'patch':
+            return incrPatch(version);
+        default:
+            return version;
+    }
+}
+exports.incrByType = incrByType;
+function incrPatch(version) {
+    return {
+        ...version,
+        major: version.major,
+        minor: version.minor,
+        patch: version.patch + 1,
+        ...(version.build ? { build: 1 } : {}),
+    };
+}
+exports.incrPatch = incrPatch;
+function incrMinor(version) {
+    return {
+        ...version,
+        major: version.major,
+        minor: version.minor + 1,
+        patch: 0,
+        ...(version.build ? { build: 1 } : {}),
+    };
+}
+exports.incrMinor = incrMinor;
+function incrMajor(version) {
+    return {
+        ...version,
+        major: version.major + 1,
+        minor: 0,
+        patch: 0,
+        ...(version.build ? { build: 1 } : {}),
+    };
+}
+exports.incrMajor = incrMajor;
+/**
+ * Increments the version based on the release type. The next version must
+ * be greater than the latest version except for the following case:
+ * 2. The latest version is a prerelease of a different channel. Even in this case,
+ *   the next version must be greater than the last stable/production version.
+ *
+ * Parameters:
+ * - `latestVer` is typically the current version of the package and the same as
+ *   `latestStableVer` if the last release was a stable/production release.
+ * - `latestStableVer` is the last stable/production release.
+ * - `releaseType` is the type of release to make.
+ * - `prereleaseChannel` is the name of the prerelease channel, if it's a prerelease.
+ * - `latestChannelVer` is the last version of the package on the same channel.
+ */
+// eslint-disable-next-line max-lines-per-function
+function incrVer(input) {
+    const { latestStableVer, latestVer, releaseType, prereleaseChannel, latestChannelVer } = input;
+    // santiy checks and input validation
+    if (releaseType === 'none')
+        throw new Error(errors_1.errors.noReleaseErr);
+    if ((0, compare_1.compareVersions)(latestVer, latestStableVer) < 0)
+        throw new Error(errors_1.errors.outOfOrderErr);
+    if ((0, parse_1.isVerPrerelease)(latestStableVer))
+        throw new Error(errors_1.errors.stableVerNotValid);
+    if (prereleaseChannel && latestChannelVer && (0, compare_1.compareVersions)(latestChannelVer, latestVer) > 0)
+        throw new Error(errors_1.errors.lastChannelVerTooLarge);
+    if (prereleaseChannel && latestChannelVer && prereleaseChannel !== latestChannelVer.channel)
+        throw new Error(errors_1.errors.lastChannelVerNotSameChannel);
+    const isPrerelease = !!prereleaseChannel;
+    const nextRootVer = (0, compare_1.highestVersion)(incrByType(latestStableVer, releaseType), (0, parse_1.rootVersion)(latestVer));
+    if (isPrerelease) {
+        const nextVer = {
+            ...nextRootVer,
+            channel: prereleaseChannel,
+            build: 1,
+        };
+        // If no previous version exists on this channel, start a new prerelease with build 1.
+        // If the proposed next version is greater than the latest on this channel,
+        // return the next version (with build=1).
+        // Otherwise, continue the current prerelease by incrementing the build number.
+        if (!latestChannelVer || (0, compare_1.compareVersions)(nextVer, latestChannelVer) > 0) {
+            return nextVer;
+        }
+        else {
+            // Otherwise, increment the build number of the last channel version
+            return {
+                ...latestChannelVer,
+                build: (latestChannelVer.build ?? 1) + 1,
+            };
+        }
+    }
+    else {
+        return nextRootVer;
+    }
+}
+exports.incrVer = incrVer;
+//# sourceMappingURL=increment.js.map

package/dist/semver/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './compare';
+export * from './increment';
+export * from './parse';
+export * from './errors';

package/dist/semver/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./compare"), exports);
+__exportStar(require("./increment"), exports);
+__exportStar(require("./parse"), exports);
+__exportStar(require("./errors"), exports);
+//# sourceMappingURL=index.js.map

package/dist/semver/parse.d.ts

@@ -0,0 +1,25 @@
+import { SemVer } from './types';
+export declare function toTag(version: SemVer): string;
+export declare function fromTag(tag: string): SemVer | undefined;
+/**
+ * Checks if a version string is a valid SemVer tag by attempting to parse it.
+ */
+export declare function isValidTag(ver: string): boolean;
+export declare function isValidVersion(version: SemVer): boolean;
+export declare function isVerPrerelease(version: SemVer): boolean;
+/**
+ * Normalizes a SemVer object by ensuring that the channel and build properties are set.
+ */
+export declare function normalizeVer(version: SemVer): SemVer;
+/**
+ * Returns the root version of a SemVer object (ie, without the channel and build).
+ * Examples:
+ * - 1.0.0-alpha.1 => 1.0.0
+ * - 1.0.0 => 1.0.0
+ */
+export declare function rootVersion(version: SemVer): SemVer;
+export type VersionWithRaw = {
+    version: SemVer;
+    raw: string;
+};
+export declare function parseTags(tags: string[]): VersionWithRaw[];

package/dist/semver/parse.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTags = exports.rootVersion = exports.normalizeVer = exports.isVerPrerelease = exports.isValidVersion = exports.isValidTag = exports.fromTag = exports.toTag = void 0;
+const typura_1 = require("typura");
+const isValidSemVer = typura_1.predicates.object({
+    major: typura_1.predicates.number(),
+    minor: typura_1.predicates.number(),
+    patch: typura_1.predicates.number(),
+    channel: typura_1.predicates.optional(typura_1.predicates.string()),
+    build: typura_1.predicates.optional(typura_1.predicates.number()),
+});
+function toTag(version) {
+    const [validationErr] = (0, typura_1.toResult)(() => isValidSemVer(version));
+    if (validationErr) {
+        throw new Error('Invalid SemVer object', { cause: validationErr });
+    }
+    let versionString = `${version.major}.${version.minor}.${version.patch}`;
+    if (version.channel) {
+        versionString += `-${version.channel}`;
+        if (version.build) {
+            versionString += `.${version.build}`;
+        }
+    }
+    return `v${versionString}`;
+}
+exports.toTag = toTag;
+function fromTag(tag) {
+    const semverRegex = /^v(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<channel>[0-9a-zA-Z-]+)(?:\.(?<build>[0-9a-zA-Z-]+))?)?(?:\+(?<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+    const match = tag.match(semverRegex);
+    if (!match || !match.groups) {
+        return undefined;
+    }
+    const { major, minor, patch, channel, build } = match.groups;
+    return normalizeVer({
+        major: parseInt(major, 10),
+        minor: parseInt(minor, 10),
+        patch: parseInt(patch, 10),
+        ...(channel ? { channel } : {}),
+        ...(build ? { build: parseInt(build, 10) } : {}),
+    });
+}
+exports.fromTag = fromTag;
+/**
+ * Checks if a version string is a valid SemVer tag by attempting to parse it.
+ */
+function isValidTag(ver) {
+    return !!fromTag(ver);
+}
+exports.isValidTag = isValidTag;
+function isValidVersion(version) {
+    const [err, tag] = (0, typura_1.toResult)(() => toTag(version));
+    if (err)
+        return false;
+    return !!fromTag(tag);
+}
+exports.isValidVersion = isValidVersion;
+function isVerPrerelease(version) {
+    return !!version.channel;
+}
+exports.isVerPrerelease = isVerPrerelease;
+/**
+ * Normalizes a SemVer object by ensuring that the channel and build properties are set.
+ */
+function normalizeVer(version) {
+    return {
+        major: version.major,
+        minor: version.minor,
+        patch: version.patch,
+        ...(version.channel ? {
+            channel: version.channel,
+            build: version.build || 1,
+        } : {}),
+    };
+}
+exports.normalizeVer = normalizeVer;
+/**
+ * Returns the root version of a SemVer object (ie, without the channel and build).
+ * Examples:
+ * - 1.0.0-alpha.1 => 1.0.0
+ * - 1.0.0 => 1.0.0
+ */
+function rootVersion(version) {
+    return {
+        major: version.major,
+        minor: version.minor,
+        patch: version.patch,
+    };
+}
+exports.rootVersion = rootVersion;
+function parseTags(tags) {
+    return tags
+        .map((raw) => {
+        const version = fromTag(raw);
+        return version ? { raw, version } : undefined;
+    })
+        .filter((entry) => !!entry);
+}
+exports.parseTags = parseTags;
+//# sourceMappingURL=parse.js.map

package/dist/semver/types.d.ts

@@ -0,0 +1,8 @@
+export type SemVer = {
+    major: number;
+    minor: number;
+    patch: number;
+    channel?: string;
+    build?: number;
+};
+export type ReleaseType = 'major' | 'minor' | 'patch' | 'none';

package/dist/semver/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/{lib → services}/git.d.ts

@@ -2,11 +2,9 @@ export type Commit = {
     hash: string;
     message: string;
 };
-export declare function gitFetchTags(): void;
+export declare function gitFetch(): void;
 export declare function createAndPushTag(tag: string): void;
-export declare function getLastChannelTag(channel: string): string | undefined;
-export declare function getHighestTag(): string | undefined;
-export declare function getLastStableTag(): string | undefined;
+export declare function getLatestTags(): string[];
 export declare function getRepo(): {
     owner: string;
     repository: string;

package/dist/{lib → services}/git.js

@@ -1,28 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCurrentBranch = exports.getCommitsFromTag = exports.getRepo = exports.getLastStableTag = exports.getHighestTag = exports.getLastChannelTag = exports.createAndPushTag = exports.gitFetchTags = void 0;
+exports.getCurrentBranch = exports.getCommitsFromTag = exports.getRepo = exports.getLatestTags = exports.createAndPushTag = exports.gitFetch = void 0;
 const sh_1 = require("./sh");
-function gitFetchTags() {
+function gitFetch() {
     (0, sh_1.$) `git fetch`;
 }
-exports.gitFetchTags = gitFetchTags;
+exports.gitFetch = gitFetch;
 function createAndPushTag(tag) {
     (0, sh_1.$) `git tag ${tag}`;
     (0, sh_1.$) `git push origin ${tag}`;
 }
 exports.createAndPushTag = createAndPushTag;
-function getLastChannelTag(channel) {
-    return (0, sh_1.$) `git tag | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+-${channel}\.[0-9]+$' | sort -V | tail -n 1` || undefined;
+function getLatestTags() {
+    const tags = (0, sh_1.$) `git tag --sort=-v:refname | head -n 100`;
+    return tags.split('\n').filter((tag) => tag.trim() !== '');
 }
-exports.getLastChannelTag = getLastChannelTag;
-function getHighestTag() {
-    return (0, sh_1.$) `git tag --sort=-v:refname | head -n1` || undefined;
-}
-exports.getHighestTag = getHighestTag;
-function getLastStableTag() {
-    return (0, sh_1.$) `git tag --sort=-v:refname | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | head -n1` || undefined;
-}
-exports.getLastStableTag = getLastStableTag;
+exports.getLatestTags = getLatestTags;
 function getRepo() {
     if (process.env.GITHUB_REPOSITORY) {
         const [owner, repository] = process.env.GITHUB_REPOSITORY.split('/');

package/dist/{lib → services}/sh.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bash = exports.$ = void 0;
 const child_process_1 = require("child_process");
-const output_1 = __importDefault(require("./output"));
+const logger_1 = __importDefault(require("../lib/logger"));
 /**
  * Executes a bash program/command and returns the output. This is a tagged template
  * literal function, so you can use it like this:
@@ -16,7 +16,7 @@ const output_1 = __importDefault(require("./output"));
  */
 function $(strings, ...values) {
     const command = strings.reduce((acc, str, i) => acc + str + (values[i] || ''), '');
-    output_1.default.debug(command);
+    logger_1.default.debug(`> ${command}`);
     const escapedCommand = command.replace(/(["$`\\])/g, '\\$1');
     const output = (0, child_process_1.execSync)(`bash -c "${escapedCommand}"`, { encoding: 'utf8' });
     return output.trim();

package/dist/updatePackageJsonVersion.js

@@ -27,7 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updatePackageJsonVersion = void 0;
-const output_1 = __importDefault(require("./lib/output"));
+const logger_1 = __importDefault(require("./lib/logger"));
 const fs_1 = require("fs");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -38,7 +38,7 @@ function readPackageJson() {
         return JSON.parse(packageJsonData);
     }
     catch (error) {
-        output_1.default.error('Unable to read or parse package.json');
+        logger_1.default.error('Unable to read or parse package.json');
         throw error;
     }
 }
@@ -51,7 +51,7 @@ function updatePackageJsonVersion(newVersion) {
         ...packageJson,
         version: newVersion.replace(/^v/, ''),
     }, null, 2));
-    output_1.default.log('Successfully updated package.json locally');
+    logger_1.default.info('Successfully updated package.json locally');
 }
 exports.updatePackageJsonVersion = updatePackageJsonVersion;
 //# sourceMappingURL=updatePackageJsonVersion.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autorel",
-  "version": "2.2.13",
+  "version": "2.3.0-next.2",
   "description": "Automate semantic releases based on conventional commits. Similar to semantic-release but much simpler.",
   "license": "MIT",
   "author": "Marc H. Weiner <mhweiner234@gmail.com> (https://mhweiner.com)",
@@ -52,11 +52,12 @@
     "c8": "^7.10.0",
     "cjs-mock": "^0.1.0",
     "eslint": "^8.4.1",
-    "hoare": "3.3.0",
+    "hoare": "3.4.4",
     "ts-node": "^10.4.0",
     "typescript": "^4.5.4"
   },
   "dependencies": {
+    "colorette": "2.0.20",
     "commander": "^12.1.0",
     "js-yaml": "^4.1.0",
     "typura": "^1.4.11"

package/dist/lib/colors.d.ts

@@ -1,8 +0,0 @@
-export declare function red(text: string): string;
-export declare function grey(text: string): string;
-export declare function yellow(text: string): string;
-export declare function green(text: string): string;
-export declare function bold(text: string): string;
-export declare function blue(text: string): string;
-export declare function white(text: string): string;
-export declare function strikethrough(text: string): string;

package/dist/lib/colors.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.strikethrough = exports.white = exports.blue = exports.bold = exports.green = exports.yellow = exports.grey = exports.red = void 0;
-function red(text) {
-    return `\x1b[91m${text}\x1b[0m`;
-}
-exports.red = red;
-function grey(text) {
-    return `\x1b[90m${text}\x1b[0m`;
-}
-exports.grey = grey;
-function yellow(text) {
-    return `\x1b[33m${text}\x1b[0m`;
-}
-exports.yellow = yellow;
-function green(text) {
-    return `\x1b[32m${text}\x1b[0m`;
-}
-exports.green = green;
-function bold(text) {
-    return `\x1b[1m${text}\x1b[0m`;
-}
-exports.bold = bold;
-function blue(text) {
-    return `\x1b[34m${text}\x1b[0m`;
-}
-exports.blue = blue;
-function white(text) {
-    return `\x1b[37m${text}\x1b[0m`;
-}
-exports.white = white;
-function strikethrough(text) {
-    return `\x1b[9m${text}\x1b[0m`;
-}
-exports.strikethrough = strikethrough;
-//# sourceMappingURL=colors.js.map

package/dist/lib/output.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const colors_1 = require("./colors");
-const prefix = '[autorel] ';
-function log(message) {
-    console.log(`${prefix}${message}`);
-}
-function debug(message) {
-    process.env.AUTOREL_DEBUG && log((0, colors_1.grey)(message));
-}
-function warn(message) {
-    log((0, colors_1.yellow)(`Warning: ${message}`));
-}
-function error(message) {
-    log((0, colors_1.red)(`Error: ${message}`));
-}
-exports.default = {
-    log,
-    debug,
-    warn,
-    error,
-};
-//# sourceMappingURL=output.js.map

package/dist/semver.d.ts

@@ -1,53 +0,0 @@
-export type SemVer = {
-    major: number;
-    minor: number;
-    patch: number;
-    channel?: string;
-    build?: number;
-};
-export type ReleaseType = 'major' | 'minor' | 'patch' | 'none';
-export declare function toTag(version: SemVer): string;
-export declare function fromTag(tag: string): SemVer | null;
-export declare function isVerPrerelease(version: SemVer): boolean;
-export declare function normalize(version: SemVer): SemVer;
-/**
- * Compares two versions and returns:
- * - 1 if version1 is greater than version2
- * - -1 if version1 is less than version2
- * - 0 if they are equal
- */
-export declare function compareVersions(version1: SemVer, version2: SemVer): number;
-export declare function rootVersion(version: SemVer): SemVer;
-export declare function highestVersion(version1: SemVer, version2: SemVer): SemVer;
-export declare function incrByType(version: SemVer, releaseType: ReleaseType): SemVer;
-export declare function incrPatch(version: SemVer): SemVer;
-export declare function incrMinor(version: SemVer): SemVer;
-export declare function incrMajor(version: SemVer): SemVer;
-export declare function isValidTag(ver: string): boolean;
-export declare function isValidVersion(version: SemVer): boolean;
-export declare const outOfOrderErr: string;
-export declare const stableVerNotValid = "The stable version cannot be a prerelease.";
-export declare const lastChannelVerNotSameChannel = "The last channel version must be a prerelease of the same channel.";
-export declare const lastChannelVerTooLarge = "The last channel version cannot be greater than the highest version.";
-/**
- * Increments the version based on the release type. The next version must
- * be greater than the highest/current version except for the following cases:
- * 1. The release type is 'none'.
- * 2. The highest version is a prerelease of a different channel. Even in this case,
- *   the next version must be greater than the last stable/production version.
- *
- * Parameters:
- * - `highestVer` is typically the current version of the package and the
- *   same as `lastStableVer` if the last release was a stable/production release.
- * - `lastStableVer` is the last stable/production release.
- * - `releaseType` is the type of release to make.
- * - `prereleaseChannel` is the name of the prerelease channel, if it's a prerelease.
- * - `lastChannelVer` is the last version of the package on the same channel.
- */
-export declare function incrVer(input: {
-    highestVer: SemVer;
-    lastStableVer: SemVer;
-    releaseType: ReleaseType;
-    prereleaseChannel?: string;
-    lastChannelVer?: SemVer;
-}): SemVer;