fireflyy 4.0.0-dev.644fea9 → 4.0.0-dev.df58d2b

package/dist/version-strategy.service-vh5KeNCA.js

@@ -0,0 +1,258 @@
+import { t as logger } from "./main.js";
+import { g as invalidError, r as FireflyOk, t as FireflyErr } from "./result.constructors-D9jmQ0uj.js";
+import { Result } from "neverthrow";
+
+//#region src/services/implementations/version-strategy.service.ts
+const TRANSITION_KEYWORDS = [
+	"general availability",
+	"promote to stable",
+	"move to stable"
+];
+const LEVEL_TO_RELEASE_TYPE = {
+	0: "major",
+	1: "minor",
+	2: "patch"
+};
+/**
+* Version type categories for organizing choices.
+*/
+const VERSION_TYPES = {
+	RELEASE: [
+		"patch",
+		"minor",
+		"major"
+	],
+	PRERELEASE: [
+		"prepatch",
+		"preminor",
+		"premajor"
+	],
+	CONTINUATION: ["prerelease"],
+	GRADUATION: ["graduate"]
+};
+/**
+* Pre-configured choice sets for different scenarios.
+*/
+const VERSION_CHOICE_SETS = {
+	latestIsPreRelease: [
+		...VERSION_TYPES.CONTINUATION,
+		...VERSION_TYPES.GRADUATION,
+		...VERSION_TYPES.RELEASE
+	],
+	preRelease: VERSION_TYPES.PRERELEASE,
+	default: [...VERSION_TYPES.RELEASE, ...VERSION_TYPES.PRERELEASE]
+};
+/**
+* Human-readable descriptions for each release type.
+*/
+const VERSION_DESCRIPTIONS = {
+	patch: "Fixes and minor enhancements without breaking compatibility. Suitable for bug fixes and small improvements.",
+	minor: "New, backward-compatible functionality. Adds features that do not break existing APIs.",
+	major: "Incompatible API changes. Introduces breaking changes or removes deprecated features.",
+	prepatch: "Unstable patch release candidate. Used for testing patch changes before a stable release.",
+	preminor: "Unstable minor release candidate. Used for previewing new features before a minor release.",
+	premajor: "Unstable major release candidate. Used for testing breaking changes before a major release.",
+	prerelease: "Unstable pre-release continuation. Increments the pre-release number or changes identifier.",
+	graduate: "Promote pre-release to stable. Removes pre-release identifiers to create a stable version."
+};
+var DefaultVersionStrategyService = class {
+	bumper;
+	constructor(bumper) {
+		this.bumper = bumper;
+	}
+	resolveVersion(options, recommendation) {
+		logger.verbose("DefaultVersionStrategyService: Deciding next version...");
+		const preReleaseContext = this.analyzePreReleaseContext(options.currentVersion, recommendation);
+		if (options.releaseType === "prerelease") {
+			logger.verbose("DefaultVersionStrategyService: Handling prerelease request...");
+			return this.handlePreReleaseRequest(options, preReleaseContext);
+		}
+		if (preReleaseContext.isCurrentPreRelease && preReleaseContext.hasStableTransition) {
+			logger.verbose("DefaultVersionStrategyService: Handling pre-release to stable transition...");
+			return this.handlePreReleaseToStableTransition(options, recommendation);
+		}
+		if (recommendation) {
+			logger.verbose("DefaultVersionStrategyService: Handling recommendation-based versioning...");
+			return this.createRecommendationBasedVersion(options, recommendation, preReleaseContext);
+		}
+		if (options.releaseType) {
+			logger.verbose("DefaultVersionStrategyService: Handling explicit release type...");
+			return this.bumper.bump({
+				currentVersion: options.currentVersion,
+				releaseType: options.releaseType,
+				prereleaseIdentifier: options.prereleaseIdentifier,
+				prereleaseBase: options.prereleaseBase
+			});
+		}
+		return FireflyErr(invalidError({ message: "Cannot determine next version: no release type or recommendation provided" }));
+	}
+	generateChoices(options) {
+		logger.verbose(`DefaultVersionStrategyService: Creating version choices for '${options.currentVersion.raw}'...`);
+		const choicesResults = this.determineAvailableVersionTypes(options.currentVersion, options.releaseType).map((releaseType) => this.createSingleChoice(options.currentVersion, releaseType, options.prereleaseIdentifier, options.prereleaseBase));
+		const combinedResult = Result.combine(choicesResults);
+		if (combinedResult.isErr()) return FireflyErr(combinedResult.error);
+		logger.verbose(`DefaultVersionStrategyService: Created ${combinedResult.value.length} version choices.`);
+		return FireflyOk(combinedResult.value);
+	}
+	/**
+	* Analyzes the current version and recommendation to determine pre-release context.
+	*
+	* @param currentVersion - The current version
+	* @param recommendation - The version recommendation
+	* @returns The pre-release context
+	*/
+	analyzePreReleaseContext(currentVersion, recommendation) {
+		return {
+			isCurrentPreRelease: currentVersion.isPrerelease,
+			prereleaseIdentifier: currentVersion.prereleaseIdentifier,
+			hasStableTransition: this.detectStableTransition(recommendation)
+		};
+	}
+	/**
+	* Detects if the recommendation indicates a transition to a stable version.
+	*
+	* @param recommendation - The version recommendation
+	* @returns True if a stable transition is detected, false otherwise
+	*/
+	detectStableTransition(recommendation) {
+		if (!recommendation) return false;
+		const reason = recommendation.reason.toLowerCase();
+		return TRANSITION_KEYWORDS.some((keyword) => reason.includes(keyword));
+	}
+	/**
+	* Handles explicit requests for pre-release versions.
+	*
+	* @param options - The version resolution options
+	* @param context - The pre-release context
+	* @returns A result containing the new pre-release version or an error
+	*/
+	handlePreReleaseRequest(options, context) {
+		logger.verbose("DefaultVersionStrategyService: Bumping to prerelease version...");
+		return this.bumper.bump({
+			currentVersion: options.currentVersion,
+			releaseType: "prerelease",
+			prereleaseIdentifier: options.prereleaseIdentifier ?? context.prereleaseIdentifier ?? "alpha",
+			prereleaseBase: options.prereleaseBase
+		});
+	}
+	/**
+	* Handles the transition from a pre-release version to a stable version.
+	*
+	* @param options - The version resolution options
+	* @param recommendation - The version recommendation
+	* @returns A result containing the new stable version or an error
+	*/
+	handlePreReleaseToStableTransition(options, recommendation) {
+		if (!recommendation) return FireflyErr(invalidError({
+			message: "Cannot transition to stable version without recommendation",
+			source: "services/version-strategy"
+		}));
+		const graduateResult = this.bumper.bump({
+			currentVersion: options.currentVersion,
+			releaseType: "graduate"
+		});
+		if (graduateResult.isErr()) return FireflyErr(graduateResult.error);
+		const stableVersion = graduateResult.value;
+		if (recommendation.level < 2) {
+			logger.verbose("DefaultVersionStrategyService: Further bumping after graduation...");
+			const releaseType = LEVEL_TO_RELEASE_TYPE[recommendation.level];
+			return this.bumper.bump({
+				currentVersion: stableVersion,
+				releaseType
+			});
+		}
+		logger.verbose("DefaultVersionStrategyService: Graduated to stable version:", stableVersion.raw);
+		return FireflyOk(stableVersion);
+	}
+	/**
+	* Creates a new version based on the provided recommendation and pre-release context.
+	*
+	* @param options - The version resolution options
+	* @param recommendation - The version recommendation
+	* @param context - The pre-release context
+	* @returns A result containing the new version or an error
+	*/
+	createRecommendationBasedVersion(options, recommendation, context) {
+		if (context.isCurrentPreRelease && !context.hasStableTransition) {
+			logger.verbose("DefaultVersionStrategyService: Continuing prerelease versioning...");
+			return this.bumper.bump({
+				currentVersion: options.currentVersion,
+				releaseType: "prerelease",
+				prereleaseIdentifier: options.prereleaseIdentifier ?? context.prereleaseIdentifier ?? "alpha",
+				prereleaseBase: options.prereleaseBase
+			});
+		}
+		const releaseType = LEVEL_TO_RELEASE_TYPE[recommendation.level];
+		logger.verbose("DefaultVersionStrategyService: Bumping version based on recommendation...");
+		return this.bumper.bump({
+			currentVersion: options.currentVersion,
+			releaseType,
+			prereleaseIdentifier: options.prereleaseIdentifier,
+			prereleaseBase: options.prereleaseBase
+		});
+	}
+	/**
+	* Determines the available version types based on current version and optional release type.
+	*
+	* @param currentVersion - The current version
+	* @param releaseType - Optional specific release type
+	* @returns An array of available release types
+	*/
+	determineAvailableVersionTypes(currentVersion, releaseType) {
+		if (releaseType !== void 0) return this.getVersionTypesForReleaseType(releaseType);
+		return currentVersion.isPrerelease ? VERSION_CHOICE_SETS.latestIsPreRelease : VERSION_CHOICE_SETS.default;
+	}
+	/**
+	* Retrieves the version types applicable for a given release type.
+	*
+	* @param releaseType - The type of release
+	* @returns An array of applicable release types
+	*/
+	getVersionTypesForReleaseType(releaseType) {
+		return releaseType === "prerelease" ? VERSION_CHOICE_SETS.preRelease : VERSION_CHOICE_SETS.default;
+	}
+	/**
+	* Retrieves the description for a given release type.
+	*
+	* @param releaseType - The type of release
+	* @returns The description string for the release type
+	*/
+	getVersionDescription(releaseType) {
+		return VERSION_DESCRIPTIONS[releaseType] ?? "";
+	}
+	/**
+	* Creates a single version choice based on the provided parameters.
+	*
+	* @param currentVersion - The current version
+	* @param releaseType - The type of release to create
+	* @param prereleaseIdentifier - Optional pre-release identifier
+	* @param prereleaseBase - Optional base for pre-release
+	* @returns A result containing the version choice or an error
+	*/
+	createSingleChoice(currentVersion, releaseType, prereleaseIdentifier, prereleaseBase) {
+		const bumpOptions = {
+			currentVersion,
+			releaseType,
+			prereleaseIdentifier,
+			prereleaseBase
+		};
+		const newVersionResult = this.bumper.bump(bumpOptions);
+		if (newVersionResult.isErr()) return FireflyErr(newVersionResult.error);
+		const newVersion = newVersionResult.value;
+		return FireflyOk({
+			label: `${releaseType} (${newVersion.raw})`,
+			hint: this.getVersionDescription(releaseType),
+			value: newVersion.raw
+		});
+	}
+};
+/**
+* Creates a version strategy service instance.
+* @param bumper - The version bumper service to use
+*/
+function createVersionStrategyService(bumper) {
+	return new DefaultVersionStrategyService(bumper);
+}
+
+//#endregion
+export { TRANSITION_KEYWORDS as n, createVersionStrategyService as r, DefaultVersionStrategyService as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fireflyy",
-  "version": "4.0.0-dev.644fea9",
+  "version": "4.0.0-dev.df58d2b",
   "description": " CLI orchestrator for automatic semantic versioning, changelog generation, and creating releases. Built for my own use cases.",
   "type": "module",
   "license": "MIT",