autorel 2.2.13 → 2.3.0-next.2

package/dist/cli.js

@@ -1,18 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
-const colors_1 = require("./lib/colors");
+const colorette_1 = require("colorette");
 const _1 = require(".");
-const output_1 = __importDefault(require("./lib/output"));
 const config_1 = require("./config");
 // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
 const packageJson = require('../package.json');
 const program = new commander_1.Command();
 console.log('------------------------------');
-console.log(`${(0, colors_1.bold)('autorel')} ${(0, colors_1.grey)(`v${packageJson.version}`)}`);
+console.log(`${(0, colorette_1.bold)((0, colorette_1.white)('autorel'))} ${(0, colorette_1.dim)(`v${packageJson.version}`)}`);
 console.log('------------------------------');
 program
     .version(packageJson.version, '-v, --version')
@@ -35,7 +31,6 @@ const cliOptions = {
     publish: options.publish,
     skipRelease: options.skipRelease,
 };
-output_1.default.debug(`CLI Options: ${JSON.stringify(cliOptions, null, 2)}`);
 // remove falsy values from the overrides
 if (cliOptions) {
     Object.keys(cliOptions).forEach((key) => (
@@ -43,6 +38,5 @@ if (cliOptions) {
     !cliOptions[key] && delete cliOptions[key]));
 }
 const config = (0, config_1.getConfig)(cliOptions);
-output_1.default.debug(`Config: ${JSON.stringify(config, null, 2)}`);
 (0, _1.autorel)(config);
 //# sourceMappingURL=cli.js.map

package/dist/config.js

@@ -31,7 +31,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const yaml = __importStar(require("js-yaml"));
 const typura_1 = require("typura");
-const output_1 = __importDefault(require("./lib/output"));
+const logger_1 = __importDefault(require("./lib/logger"));
 const defaults_1 = require("./defaults");
 const validateConfig = typura_1.predicates.object({
     dryRun: typura_1.predicates.optional(typura_1.predicates.boolean()),
@@ -62,37 +62,42 @@ function readAutorelYaml(filePath = '.autorel.yaml') {
     const absolutePath = path.resolve(filePath);
     // Check if the file exists
     if (!fs.existsSync(absolutePath)) {
-        output_1.default.log('.autorel.yaml not found, using default configuration');
+        logger_1.default.info('.autorel.yaml not found, using default configuration');
         return {};
     }
     else {
-        output_1.default.log('Using .autorel.yaml configuration');
+        logger_1.default.info('Using .autorel.yaml configuration');
     }
     const [readErr, fileContents] = (0, typura_1.toResult)(() => fs.readFileSync(absolutePath, 'utf8'));
     if (readErr) {
-        output_1.default.error('Error reading .autorel.yaml file:');
+        logger_1.default.error('Error reading .autorel.yaml file:');
         throw readErr;
     }
     const [parseErr, parsedData] = (0, typura_1.toResult)(() => yaml.load(fileContents));
     if (parseErr) {
-        output_1.default.error('Error parsing .autorel.yaml file:');
+        logger_1.default.error('Error parsing .autorel.yaml file:');
         throw parseErr;
     }
-    const [validationErr] = (0, typura_1.toResult)(() => validateConfig(parsedData));
-    if (validationErr instanceof typura_1.ValidationError) {
-        output_1.default.error('Invalid configuration:');
-        throw validationErr;
-    }
     return parsedData;
 }
 function getConfig(overrides) {
     const yamlConfig = readAutorelYaml();
-    output_1.default.debug(`Yaml: ${JSON.stringify(yamlConfig, null, 2)}`);
-    return {
+    const mergedConfig = {
         ...defaults_1.defaultConfig,
         ...yamlConfig,
-        ...overrides,
+        ...overrides ?? {},
     };
+    logger_1.default.debug('---\nConfig:');
+    logger_1.default.debug(`Default: ${JSON.stringify(defaults_1.defaultConfig, null, 2)}`);
+    logger_1.default.debug(`Yaml: ${JSON.stringify(yamlConfig, null, 2)}`);
+    logger_1.default.debug(`Overrides: ${JSON.stringify(overrides, null, 2)}`);
+    logger_1.default.debug('---');
+    const [validationErr] = (0, typura_1.toResult)(() => validateConfig(mergedConfig));
+    if (validationErr instanceof typura_1.ValidationError) {
+        logger_1.default.error('Invalid configuration:');
+        throw validationErr;
+    }
+    return mergedConfig;
 }
 exports.getConfig = getConfig;
 //# sourceMappingURL=config.js.map

package/dist/conventionalcommits.js

@@ -1,35 +1,12 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterBreakingCommits = exports.groupCommits = exports.determineReleaseType = exports.parseConventionalCommit = void 0;
 const node_util_1 = require("node:util");
-const color = __importStar(require("./lib/colors"));
-const output_1 = __importDefault(require("./lib/output"));
+const logger_1 = __importDefault(require("./lib/logger"));
+const colorette_1 = require("colorette");
 // eslint-disable-next-line max-lines-per-function
 function parseConventionalCommit(commitMessage, hash) {
     const lines = commitMessage.split('\n');
@@ -84,17 +61,17 @@ function determineCommitReleaseType(commit, commitTypeMap) {
 }
 function determineReleaseType(commits, commitTypeMap) {
     const releaseTypes = commits.map((commit) => {
-        output_1.default.debug('Analyzing commit:');
-        output_1.default.debug((0, node_util_1.inspect)(commit, {
+        logger_1.default.debug('Analyzing commit:');
+        logger_1.default.debug((0, node_util_1.inspect)(commit, {
             depth: null,
             colors: false,
         }));
         const releaseType = determineCommitReleaseType(commit, commitTypeMap);
-        const releaseTypeStr = (releaseType === 'none' && color.grey('none'))
-            || (releaseType === 'major' && color.red('major'))
-            || (releaseType === 'minor' && color.yellow('minor'))
-            || (releaseType === 'patch' && color.green('patch'));
-        output_1.default.debug(`Release type: ${releaseTypeStr}`);
+        const releaseTypeStr = (releaseType === 'none' && (0, colorette_1.dim)('none'))
+            || (releaseType === 'major' && (0, colorette_1.redBright)('major'))
+            || (releaseType === 'minor' && (0, colorette_1.yellowBright)('minor'))
+            || (releaseType === 'patch' && (0, colorette_1.greenBright)('patch'));
+        logger_1.default.debug(`Release type: ${releaseTypeStr}`);
         return releaseType;
     });
     if (releaseTypes.includes('major'))

package/dist/getPrereleaseChannel.d.ts

@@ -0,0 +1,18 @@
+import { Config } from '.';
+/**
+ * Determines the prerelease channel to use for the current release.
+ *
+ * It follows this order of precedence:
+ * 1. Use `config.prereleaseChannel` if explicitly defined.
+ * 2. Otherwise, detect the current git branch and look for a matching entry
+ *    in `config.branches` to infer the prerelease channel.
+ *
+ * Returns:
+ * - A string representing the prerelease channel (e.g. "alpha", "beta"), or
+ * - `undefined` if no channel is configured or matched.
+ *
+ * Throws:
+ * - If the current branch cannot be determined.
+ * - If `config.branches` is undefined or empty.
+ */
+export declare function getPrereleaseChannel(config: Config): string | undefined;

package/dist/getPrereleaseChannel.js

@@ -0,0 +1,58 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrereleaseChannel = void 0;
+const git = __importStar(require("./services/git"));
+/**
+ * Determines the prerelease channel to use for the current release.
+ *
+ * It follows this order of precedence:
+ * 1. Use `config.prereleaseChannel` if explicitly defined.
+ * 2. Otherwise, detect the current git branch and look for a matching entry
+ *    in `config.branches` to infer the prerelease channel.
+ *
+ * Returns:
+ * - A string representing the prerelease channel (e.g. "alpha", "beta"), or
+ * - `undefined` if no channel is configured or matched.
+ *
+ * Throws:
+ * - If the current branch cannot be determined.
+ * - If `config.branches` is undefined or empty.
+ */
+function getPrereleaseChannel(config) {
+    if (config.prereleaseChannel)
+        return config.prereleaseChannel;
+    const branch = git.getCurrentBranch();
+    if (!branch)
+        throw new Error('Could not get the current branch. Please make sure you are in a git repository.');
+    if (!config.branches.length)
+        throw new Error('Branches are not defined in the configuration. See https://github.com/mhweiner/autorel?tab=readme-ov-file#configuration');
+    const matchingBranch = config.branches.find((b) => b.name === branch);
+    if (!matchingBranch)
+        return undefined;
+    return matchingBranch.prereleaseChannel || undefined;
+}
+exports.getPrereleaseChannel = getPrereleaseChannel;
+//# sourceMappingURL=getPrereleaseChannel.js.map

package/dist/index.d.ts

@@ -20,5 +20,4 @@ export type Config = {
     commitTypes: CommitType[];
     branches: ReleaseBranch[];
 };
-export declare function getPrereleaseChannel(config: Config): string | undefined;
 export declare function autorel(args: Config): Promise<string | undefined>;

package/dist/index.js

@@ -26,110 +26,92 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.autorel = exports.getPrereleaseChannel = void 0;
+exports.autorel = void 0;
 /* eslint-disable max-lines-per-function */
 const semver = __importStar(require("./semver"));
 const convCom = __importStar(require("./conventionalcommits"));
-const git = __importStar(require("./lib/git"));
-const npm = __importStar(require("./lib/npm"));
-const color = __importStar(require("./lib/colors"));
+const git = __importStar(require("./services/git"));
+const npm = __importStar(require("./services/npm"));
 const changelog_1 = require("./changelog");
 const github = __importStar(require("./services/github"));
-const output_1 = __importDefault(require("./lib/output"));
+const logger_1 = __importDefault(require("./lib/logger"));
 const updatePackageJsonVersion_1 = require("./updatePackageJsonVersion");
-const sh_1 = require("./lib/sh");
-function getPrereleaseChannel(config) {
-    if (config.prereleaseChannel)
-        return config.prereleaseChannel;
-    const branch = git.getCurrentBranch();
-    if (!branch)
-        throw new Error('Could not get the current branch. Please make sure you are in a git repository.');
-    if (!config.branches || !config.branches.length)
-        throw new Error('Branches are not defined in the configuration. See https://github.com/mhweiner/autorel?tab=readme-ov-file#configuration');
-    const matchingBranch = config.branches.find((b) => b.name === branch);
-    if (!matchingBranch)
-        return undefined;
-    return matchingBranch.prereleaseChannel || undefined;
-}
-exports.getPrereleaseChannel = getPrereleaseChannel;
+const sh_1 = require("./services/sh");
+const colorette_1 = require("colorette");
+const getPrereleaseChannel_1 = require("./getPrereleaseChannel");
 async function autorel(args) {
-    const prereleaseChannel = getPrereleaseChannel(args);
+    const prereleaseChannel = (0, getPrereleaseChannel_1.getPrereleaseChannel)(args);
     if (args.dryRun) {
-        output_1.default.warn('Running in dry-run mode. No changes will be made.');
+        logger_1.default.warn('Running in dry-run mode. No changes will be made.');
     }
     if (prereleaseChannel && !args.useVersion) {
-        const stmt = `Using prerelease channel: ${color.bold(prereleaseChannel)}`;
-        output_1.default.log(!args.useVersion ? stmt : color.strikethrough(stmt));
+        const stmt = `Using prerelease channel: ${(0, colorette_1.bold)(prereleaseChannel)}`;
+        logger_1.default.info(!args.useVersion ? stmt : (0, colorette_1.strikethrough)(stmt));
     }
     else {
         const stmt = 'This is a production release.';
-        output_1.default.log(!args.useVersion ? stmt : color.strikethrough(stmt));
+        logger_1.default.info(!args.useVersion ? stmt : (0, colorette_1.strikethrough)(stmt));
     }
     const commitTypeMap = new Map(args.commitTypes.map((type) => [type.type, type]));
-    git.gitFetchTags(); // fetch latest tags from remote
-    const lastChannelTag = prereleaseChannel ? git.getLastChannelTag(prereleaseChannel) : undefined;
-    const lastStableTag = git.getLastStableTag();
-    const highestTag = git.getHighestTag();
-    // validate tags if they exist
-    if (lastChannelTag && !semver.isValidTag(lastChannelTag))
-        throw new Error(`Invalid last channel tag: ${lastChannelTag}`);
-    if (lastStableTag && !semver.isValidTag(lastStableTag))
-        throw new Error(`Invalid last stable tag: ${lastStableTag}`);
-    if (highestTag && !semver.isValidTag(highestTag))
-        throw new Error(`Invalid highest tag: ${highestTag}`);
-    if (lastChannelTag && !highestTag)
-        throw new Error('Last channel tag exists, but highest tag does not.');
-    const tagFromWhichToFindCommits = prereleaseChannel && lastChannelTag
-        ? semver.toTag(semver.highestVersion(semver.fromTag(lastChannelTag), semver.fromTag(lastStableTag ?? 'v0.0.0')))
-        : lastStableTag;
-    !!lastChannelTag && output_1.default.log(`The last pre-release channel version (${prereleaseChannel}) is: ${color.bold(lastChannelTag)}`);
-    output_1.default.log(`The last stable/production version is: ${lastStableTag ? color.bold(lastStableTag) : color.grey('none')}`);
-    output_1.default.log(`The current/highest version is: ${highestTag ? color.bold(highestTag) : color.grey('none')}`);
-    output_1.default.log(`Fetching commits since ${tagFromWhichToFindCommits ?? 'the beginning of the repository'}...`);
+    git.gitFetch();
+    const latestTags = git.getLatestTags();
+    const latestTag = semver.latestTag(latestTags);
+    const lastStableTag = semver.latestStableTag(latestTags);
+    const lastChannelTag = prereleaseChannel
+        ? semver.latestChannelTag(latestTags, prereleaseChannel)
+        : undefined;
+    // Determine the starting Git tag to compare against when generating
+    // release notes or changelogs (i.e. the point “since” which to find commits).
+    // If a pre-release channel is specified and a last channel tag exists,
+    // use the last channel tag. Otherwise, use the last stable tag.
+    const tagFromWhichToFindCommits = lastChannelTag ?? lastStableTag;
+    !!lastChannelTag && logger_1.default.info(`The last pre-release channel version (${prereleaseChannel}) is: ${(0, colorette_1.bold)(lastChannelTag)}`);
+    logger_1.default.info(`The last stable/production version is: ${lastStableTag ? (0, colorette_1.bold)(lastStableTag) : (0, colorette_1.dim)('none')}`);
+    logger_1.default.info(`The current/highest version is: ${latestTag ? (0, colorette_1.bold)(latestTag) : (0, colorette_1.dim)('none')}`);
+    logger_1.default.info(`Fetching commits since ${tagFromWhichToFindCommits ?? 'the beginning of the repository'}...`);
     const commits = git.getCommitsFromTag(tagFromWhichToFindCommits);
-    output_1.default.log(`Found ${color.bold(commits.length.toString())} commit(s).`);
+    logger_1.default.info(`Found ${(0, colorette_1.bold)(commits.length.toString())} commit(s).`);
     const parsedCommits = commits.map((commit) => convCom.parseConventionalCommit(commit.message, commit.hash))
         .filter((commit) => !!commit);
     const releaseType = convCom.determineReleaseType(parsedCommits, commitTypeMap);
-    const releaseTypeStr = (releaseType === 'none' && color.grey('none'))
-        || (releaseType === 'major' && color.red('major'))
-        || (releaseType === 'minor' && color.yellow('minor'))
-        || (releaseType === 'patch' && color.green('patch'));
-    output_1.default.log(`The release type is: ${releaseTypeStr}`);
+    const releaseTypeStr = (releaseType === 'none' && (0, colorette_1.dim)('none'))
+        || (releaseType === 'major' && (0, colorette_1.redBright)('major'))
+        || (releaseType === 'minor' && (0, colorette_1.yellowBright)('minor'))
+        || (releaseType === 'patch' && (0, colorette_1.greenBright)('patch'));
+    logger_1.default.info(`The release type is: ${releaseTypeStr}`);
     if (releaseType === 'none' && !args.useVersion) {
-        output_1.default.log('No release is needed. Have a nice day (^_^)/');
+        logger_1.default.info('No release is needed. Have a nice day (^_^)/');
         return;
     }
-    let nextTagCalculated = '';
+    // Validate useVersion & log warnings
     if (args.useVersion) {
         if (/^v(.+)$/.test(args.useVersion))
             throw new Error('useVersion should not start with a "v".');
         if (!semver.isValidTag(args.useVersion))
             throw new Error('useVersion must be a valid SemVer version');
         if (releaseType === 'none') {
-            output_1.default.warn(`We didn't find any commmits that would create a release, but you have set 'useVersion', which will force a release as: ${color.bold(args.useVersion)}.`);
+            logger_1.default.warn(`We didn't find any commmits that would create a release, but you have set 'useVersion', which will force a release as: ${(0, colorette_1.bold)(args.useVersion)}.`);
         }
         else {
-            output_1.default.warn(`The next version was set by useVersion to be: ${color.bold(args.useVersion)}.`);
+            logger_1.default.warn(`The next version was explicitly set by useVersion to be: ${(0, colorette_1.bold)(args.useVersion)}.`);
         }
     }
-    else {
-        nextTagCalculated = semver.toTag(semver.incrVer({
-            highestVer: semver.fromTag(highestTag || 'v0.0.0'),
-            lastStableVer: semver.fromTag(lastStableTag || 'v0.0.0'),
+    const nextTag = args.useVersion
+        ? `v${args.useVersion}`
+        : semver.toTag(semver.incrVer({
+            latestVer: semver.fromTag(latestTag || 'v0.0.0'),
+            latestStableVer: semver.fromTag(lastStableTag || 'v0.0.0'),
             releaseType,
             prereleaseChannel,
-            lastChannelVer: lastChannelTag ? semver.fromTag(lastChannelTag) ?? undefined : undefined,
+            latestChannelVer: lastChannelTag ? semver.fromTag(lastChannelTag) ?? undefined : undefined,
         }));
-        output_1.default.log(`The next version is: ${color.bold(nextTagCalculated)}`);
-    }
-    const nextTag = args.useVersion ? `v${args.useVersion}` : nextTagCalculated;
     const changelog = (0, changelog_1.generateChangelog)(parsedCommits, commitTypeMap, args.breakingChangeTitle);
-    output_1.default.debug(`The changelog is:\n${changelog}`);
+    logger_1.default.info(`The next version is: ${(0, colorette_1.bold)(nextTag)}`);
+    logger_1.default.debug(`The changelog is:\n${changelog}`);
     if (args.dryRun)
         return;
     if (args.preRun) {
-        output_1.default.log('Running pre-release bash script...');
+        logger_1.default.info('Running pre-release bash script...');
         (0, sh_1.bash)(args.preRun);
     }
     git.createAndPushTag(nextTag);
@@ -151,16 +133,16 @@ async function autorel(args) {
     process.env.NEXT_TAG = nextTag;
     // run post-release bash script
     if (args.run) {
-        output_1.default.log('Running post-release bash script...');
+        logger_1.default.info('Running post-release bash script...');
         (0, sh_1.bash)(args.run);
     }
     else if (args.runScript) {
         // TODO: delete this block in the next major version
-        output_1.default.warn('----------------------------');
-        output_1.default.warn('🚨 The "runScript" option is deprecated. Please use "run" instead. 🚨');
-        output_1.default.warn('🚨 The "runScript" option will be removed in the next major version. 🚨');
-        output_1.default.warn('----------------------------');
-        output_1.default.log('Running post-release bash script...');
+        logger_1.default.warn('----------------------------');
+        logger_1.default.warn('🚨 The "runScript" option is deprecated. Please use "run" instead. 🚨');
+        logger_1.default.warn('🚨 The "runScript" option will be removed in the next major version. 🚨');
+        logger_1.default.warn('----------------------------');
+        logger_1.default.info('Running post-release bash script...');
         (0, sh_1.bash)(args.runScript);
     }
     return nextTag.replace('v', '');

package/dist/lib/{output.d.ts → logger.d.ts}

@@ -1,9 +1,9 @@
-declare function log(message: string): void;
+declare function info(message: string): void;
 declare function debug(message: string): void;
 declare function warn(message: string): void;
 declare function error(message: string): void;
 declare const _default: {
-    log: typeof log;
+    info: typeof info;
     debug: typeof debug;
     warn: typeof warn;
     error: typeof error;

package/dist/lib/logger.js

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

package/dist/{test_fixtures/fakeLog.d.ts → lib/mockLogger.d.ts}

@@ -1,5 +1,5 @@
-export declare const fakeLogger: {
-    log: () => undefined;
+export declare const mockLogger: {
+    info: () => undefined;
     debug: () => undefined;
     warn: () => undefined;
     error: () => undefined;

package/dist/{test_fixtures/fakeLog.js → lib/mockLogger.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fakeLogger = void 0;
-exports.fakeLogger = {
-    log: () => undefined,
+exports.mockLogger = void 0;
+exports.mockLogger = {
+    info: () => undefined,
     debug: () => undefined,
     warn: () => undefined,
     error: () => undefined,
 };
-//# sourceMappingURL=fakeLog.js.map
+//# sourceMappingURL=mockLogger.js.map

package/dist/semver/compare.d.ts

@@ -0,0 +1,20 @@
+import { VersionWithRaw } from './parse';
+import { SemVer } from './types';
+/**
+ * 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;
+/**
+ * Returns the highest version of two SemVer objects (nomalized).
+ */
+export declare function highestVersion(version1: SemVer, version2: SemVer): SemVer;
+export declare function latestTag(tags: string[]): string | undefined;
+export declare function latestChannelTag(tags: string[], channel: string): string | undefined;
+export declare function latestStableTag(tags: string[]): string | undefined;
+/**
+ * Returns the raw tag string with the highest version.
+ */
+export declare function highest(parsed: VersionWithRaw[]): VersionWithRaw;

package/dist/semver/compare.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.highest = exports.latestStableTag = exports.latestChannelTag = exports.latestTag = exports.highestVersion = exports.compareVersions = void 0;
+const parse_1 = require("./parse");
+/**
+ * Compares two versions and returns:
+ * - 1 if version1 is greater than version2
+ * - -1 if version1 is less than version2
+ * - 0 if they are equal
+ */
+function compareVersions(version1, version2) {
+    const version1n = (0, parse_1.normalizeVer)(version1);
+    const version2n = (0, parse_1.normalizeVer)(version2);
+    if (version1n.major > version2n.major)
+        return 1;
+    if (version1n.major < version2n.major)
+        return -1;
+    if (version1n.minor > version2n.minor)
+        return 1;
+    if (version1n.minor < version2n.minor)
+        return -1;
+    if (version1n.patch > version2n.patch)
+        return 1;
+    if (version1n.patch < version2n.patch)
+        return -1;
+    if (!version1n.channel && !!version2n.channel)
+        return 1;
+    if (!!version1n.channel && !version2n.channel)
+        return -1;
+    // compare channel
+    if (version1n.channel && version2n.channel) {
+        if (version1n.channel > version2n.channel)
+            return 1;
+        if (version1n.channel < version2n.channel)
+            return -1;
+        // compare build
+        if (version1n.build && version2n.build) {
+            if (version1n.build > version2n.build)
+                return 1;
+            if (version1n.build < version2n.build)
+                return -1;
+        }
+    }
+    return 0;
+}
+exports.compareVersions = compareVersions;
+/**
+ * Returns the highest version of two SemVer objects (nomalized).
+ */
+function highestVersion(version1, version2) {
+    const comparison = compareVersions(version1, version2);
+    return (0, parse_1.normalizeVer)(comparison > 0 ? version1 : version2);
+}
+exports.highestVersion = highestVersion;
+function latestTag(tags) {
+    const parsed = (0, parse_1.parseTags)(tags);
+    if (parsed.length === 0)
+        return undefined;
+    return highest(parsed).raw;
+}
+exports.latestTag = latestTag;
+function latestChannelTag(tags, channel) {
+    const parsed = (0, parse_1.parseTags)(tags)
+        .filter((entry) => entry.version.channel === channel);
+    if (parsed.length === 0)
+        return undefined;
+    return highest(parsed).raw;
+}
+exports.latestChannelTag = latestChannelTag;
+function latestStableTag(tags) {
+    const parsed = (0, parse_1.parseTags)(tags)
+        .filter((entry) => !entry.version.channel);
+    if (parsed.length === 0)
+        return undefined;
+    return highest(parsed).raw;
+}
+exports.latestStableTag = latestStableTag;
+/**
+ * Returns the raw tag string with the highest version.
+ */
+function highest(parsed) {
+    return parsed.reduce((a, b) => compareVersions(a.version, b.version) >= 0 ? a : b);
+}
+exports.highest = highest;
+//# sourceMappingURL=compare.js.map

package/dist/semver/errors.d.ts

@@ -0,0 +1,7 @@
+export declare const errors: {
+    noReleaseErr: string;
+    outOfOrderErr: string;
+    stableVerNotValid: string;
+    lastChannelVerNotSameChannel: string;
+    lastChannelVerTooLarge: string;
+};

package/dist/semver/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errors = void 0;
+const noReleaseErr = 'Release type is set to "none"';
+const outOfOrderErr = 'The latest version cannot be less than the last stable/production version (following SemVer).'
+    + '\n\nTo fix this, we recommend using the --use-version flag to specify the version you want to use.';
+const stableVerNotValid = 'The stable version cannot be a prerelease.';
+const lastChannelVerNotSameChannel = 'The last channel version must be a prerelease of the same channel.';
+const lastChannelVerTooLarge = 'The latest channel version cannot be greater than the latest version.';
+exports.errors = {
+    noReleaseErr,
+    outOfOrderErr,
+    stableVerNotValid,
+    lastChannelVerNotSameChannel,
+    lastChannelVerTooLarge,
+};
+//# sourceMappingURL=errors.js.map